codegen-agentic-fix.md

description	Agentic fix for codegen-related build/test failures. Invoked when mvn verify fails after code generation changes.
true	workflow_dispatch inputs branch pr_number error_summary description required type Branch to fix true string description required type PR number to push fixes to true string description required type Summary of mvn verify failures true string
permissions	contents actions read read
network	allowed defaults github
tools	github toolsets context repos
safe-outputs	push-to-pull-request-branch add-comment noop target labels * dependencies target max * 5 report-as-issue

Codegen Agentic Fix

You are an automation agent that fixes Java compilation and test failures caused by code generation changes in the copilot-sdk-java repository.

Context

A Dependabot PR bumped the @github/copilot npm dependency in scripts/codegen/package.json. The codegen-check workflow ran the code generator (scripts/codegen/java.ts) against the new schemas and mvn verify subsequently failed. Your job is to fix both the code generator script (if needed) and the handwritten SDK/test source code so the build passes.

❌❌❌ YOU MUST NEVER EDIT any of the java source code in src/generated/ directly. ✅✅Rather, the way to affect changes in these files is to change the code generator script and re-generate the classes in src/generated.

The branch to fix is: ${{ inputs.branch }} The PR number is: ${{ inputs.pr_number }}

The error summary from the failing build is:

${{ inputs.error_summary }}

Architecture overview

The code generator (scripts/codegen/java.ts) reads JSON schemas from node_modules/@github/copilot/schemas/ and produces Java source files under src/generated/java/. These generated types are consumed by handwritten code in src/main/java/ (primarily CopilotSession.java) and tested by handwritten tests in src/test/java/.

When @github/copilot is bumped, the schemas may change in ways the code generator does not yet handle. Common schema changes include:

• $ref references: Inline nested type definitions replaced with $ref pointers to #/definitions/ entries. The code generator must resolve these references and emit standalone Java types instead of nested records.
• Field type changes: Numeric fields changing between double, Long, int, etc.
• Renamed fields/properties: JSON property names changing (e.g. input → inputTokens).
• New types or events: Entirely new schemas or event types added.
• Structural changes: Properties moving between objects, new required fields, changed enum values.

Instructions

Follow these steps exactly. You have a maximum of 3 attempts to get mvn verify passing.

Step 0: Setup

Check out the branch and ensure the environment is ready:

git checkout "${{ inputs.branch }}"
git pull origin "${{ inputs.branch }}"

Set up the Java 17 environment and verify Maven and Node.js are available:

java -version
mvn --version
node --version

Install codegen dependencies:

cd scripts/codegen && npm ci && cd ../..

Step 1: Reproduce the failure

Run mvn verify to see the current errors:

mvn verify 2>&1 | tee /tmp/mvn-verify.log

Review the full log at /tmp/mvn-verify.log if the tail output is insufficient. The earliest errors are often the root cause.

If mvn verify succeeds (exit code 0), there is nothing to fix. Call the noop safe-output with message "mvn verify already passes on branch ${{ inputs.branch }}. No fixes needed." and stop.

Step 2: Diagnose the root cause

Before making fixes, determine whether the failure is caused by:

(A) The code generator not handling new schema patterns. Signs:

• Generated types are missing fields that the handwritten code references
• Generated types have wrong field types (e.g. double instead of Long)
• Types that used to be nested records are now missing (because $ref moved them to #/definitions/)
• New schemas exist but no corresponding Java types were generated

(B) Handwritten code referencing old generated type names/shapes. Signs:

• Compilation errors in src/main/java/ or src/test/java/ referencing types that no longer exist
• Test data using old JSON field names

Often both (A) and (B) apply: the codegen needs fixing first, then handwritten code needs updating.

To diagnose, compare the current schemas with the generated output:

# List available schemas
ls node_modules/@github/copilot/schemas/

# Check for $ref usage in schemas (indicates the codegen may need $ref resolution)
grep -r '"$ref"' node_modules/@github/copilot/schemas/ | head -20

# Look at a specific schema that relates to failing types
cat node_modules/@github/copilot/schemas/<relevant-schema>.json | head -80

Step 3: Fix the code generator (if needed)

If the diagnosis shows the code generator does not handle the new schema format:

1. Read scripts/codegen/java.ts to understand the current generation logic.

2. Fix scripts/codegen/java.ts to handle the new schema patterns. Common fixes include:

   • Adding $ref resolution to dereference #/definitions/ pointers
   • Generating standalone types for definitions instead of nested records
   • Fixing type mappings for changed field types

3. Re-run code generation to produce updated generated files:

   cd scripts/codegen && npm run generate && cd ../..

4. Verify the generated output looks reasonable:

   git diff --stat src/generated/java/

You may ONLY modify scripts/codegen/java.ts. Do not modify package.json, package-lock.json, or any other file under scripts/codegen/.

Step 4: Fix handwritten code (up to 3 attempts)

For each attempt:

1. Read the errors carefully. Look for:

   • Compilation errors (missing methods, type mismatches, import issues)
   • Test failures (assertion errors, runtime exceptions)
   • The specific files and line numbers mentioned in the errors

2. Read the generated types to understand what changed. Check the generated files that the handwritten code references:

   # Example: check what a generated type looks like now
   cat src/generated/java/com/github/copilot/sdk/generated/rpc/<TypeName>.java

3. Fix the affected source files. You may modify files under:

   • src/main/java/ — handwritten SDK source code
   • src/test/java/ — handwritten test code

   Common fixes:

   • Update type references from old nested types to new standalone types (e.g. SessionMcpListResultServersItem → McpServer)
   • Fix constructor arguments for changed field types (double → Long)
   • Update JSON keys in test data to match renamed schema properties
   • Add/remove imports for renamed/relocated types

4. Run formatting after making changes:

   mvn spotless:apply

5. Verify the fix:

   mvn verify 2>&1 | tee /tmp/mvn-verify.log

   If the output is long, check /tmp/mvn-verify.log for the full error details — root causes often appear early in the log.

6. If mvn verify passes, proceed to Step 5. If it fails and you have attempts remaining, go back to sub-step 1.

Step 5: Push fixes

After mvn verify passes, commit all changes and use the push-to-pull-request-branch safe-output tool to push to PR #${{ inputs.pr_number }}:

git add -A
git commit -m "Fix codegen and build failures after @github/copilot update

Automated fix applied by codegen-agentic-fix workflow."

Then call the push-to-pull-request-branch tool to push your commits to the PR branch.

Step 6: Failure handling

If all 3 attempts fail:

1. Call the add-comment tool on PR #${{ inputs.pr_number }} explaining:

   • What errors remain
   • What fixes were attempted
   • Whether the issue is in the code generator or handwritten code
   • That manual intervention is needed

2. Call the noop safe-output with a message summarizing the failure.

Do NOT push broken code.

Important constraints

• NEVER hand-edit files under src/generated/java/ — these are auto-generated. They are updated by running cd scripts/codegen && npm run generate.
• NEVER modify pom.xml — build config is not in scope
• NEVER modify scripts/codegen/package.json or scripts/codegen/package-lock.json — dependency versions are not in scope
• NEVER modify files under .github/ — workflow files are not in scope
• You MAY modify scripts/codegen/java.ts to fix the code generator
• You MAY modify files under src/main/java/ and src/test/java/ to fix handwritten code
• Always run mvn spotless:apply before committing to ensure code formatting
• Maximum 3 fix attempts before reporting failure via noop
• Only push if mvn verify passes