Add classical code generation workflow for Java SDK and migrate to generated event types

[Copilot]

Resolves #69

---

Before the change?

• All Java event and RPC types were hand-authored and manually kept in sync with upstream schema changes — no automated generation or drift detection.
• The hand-written com.github.copilot.sdk.events package (59 files) required manual updates for every schema change, used a bespoke SessionEventParser type-map for polymorphic deserialization, and was missing ~18 event types present in the latest schema.

After the change?

Codegen script (scripts/codegen/java.ts)

• Reads session-events.schema.json → generates com.github.copilot.sdk.generated (75 files): SessionEvent abstract sealed base class with full @JsonTypeInfo/@JsonSubTypes polymorphism, one public final typed event class per variant with @Override getType(), UnknownSessionEvent fallback as last permits entry
• Reads api.schema.json → generates com.github.copilot.sdk.generated.rpc (111 files): params/result DTOs for all RPC methods
• All event Data inner classes and RPC Params/Result classes are Java records (immutable, no getters/setters)
• "integer" schema type maps to Long; "number" maps to Double (previously both mapped to Double)
• Generated enums include @JsonCreator static fromValue(String) factory for correct deserialization
• All generated types carry Javadoc with @since 1.0.0 and @JsonInclude(JsonInclude.Include.NON_NULL)
• Dead function generateDataClass removed; every Object fallback emits a console.warn() with schema path
• anyOf unions of exactly two non-null types where one is string resolve to String instead of Object
• All generated files carry // AUTO-GENERATED FILE - DO NOT EDIT, schema-source comment, and @javax.annotation.processing.Generated("copilot-sdk-codegen")

Migration: com.github.copilot.sdk.events → com.github.copilot.sdk.generated

• All 5 main source files updated (CopilotSession, RpcHandlerDispatcher, EventErrorHandler, SessionConfig, ResumeSessionConfig): AbstractSessionEvent → SessionEvent, all event imports redirected to generated package
• RpcHandlerDispatcher now uses Jackson-native MAPPER.treeToValue(eventNode, SessionEvent.class) instead of the manual SessionEventParser type-map — polymorphism is handled by @JsonTypeInfo/@JsonSubTypes on the generated base class
• SessionEventParser.java deleted — no longer needed
• All 17 test files updated to import from com.github.copilot.sdk.generated; SessionEventParserTest rewritten as SessionEventDeserializationTest using Jackson-native deserialization
• Old com.github.copilot.sdk.events package (59 files) deleted entirely
• Zero remaining references to com.github.copilot.sdk.events in src/main/ or src/test/
• Generated package covers all 57 original event types plus ~18 new event types from the latest schema

Maven (pom.xml)

• build-helper-maven-plugin adds src/generated/java as a source root
• Spotless excludes src/generated/java/**

Infrastructure

• config/checkstyle/checkstyle.xml — excludes generated and rpc packages from Javadoc enforcement
• .gitattributes — src/generated/java/** eol=lf linguist-generated=true
• .github/workflows/codegen-check.yml — installs deps, re-runs npm run generate, fails on any diff (runs on push/pull_request paths that touch codegen or generated files)
• .github/workflows/update-copilot-dependency.yml — workflow_dispatch with version input; updates @github/copilot in scripts/codegen (via npm install to update package.json and lock file, then npm ci for a clean reproducible install), regenerates, opens a PR automatically

Pull request checklist

• Tests for the changes have been added (for bug fixes / features)
• Docs have been reviewed and added / updated if needed (for bug fixes / features)
• mvn spotless:apply has been run to format the code
• mvn clean verify passes locally

Does this introduce a breaking change?

• Yes
• No

---

[edburns]

@copilot add a comment explaining the necessity of the unusual step of running npm install before npm ci

[Copilot]

Added a comment in 6e3c50c explaining the two-step approach: npm install updates package.json and package-lock.json to pin the new version, then npm ci does a clean reproducible install from the updated lock file. Running npm ci alone would fail because it cannot change a pinned version, and npm install alone leaves behind stale packages.

[edburns]

@copilot

Epic #69: Improve Quality of Java Code Generator

Context

The file scripts/codegen/java.ts is a TypeScript code generator that reads JSON Schema files from the @github/copilot npm dependency and emits Java source files under src/generated/java/. Its purpose is to replace hand-written Java classes in src/main/java/com/github/copilot/sdk/events/ and src/main/java/com/github/copilot/sdk/json/ with auto-generated equivalents.

The current generator produces Java code that is significantly less idiomatic than the hand-written classes it is meant to replace. This prompt describes the required improvements.

Reference files

Before making any changes, read and understand these files:

• scripts/codegen/java.ts — the generator to modify
• src/main/java/com/github/copilot/sdk/events/AbstractSessionEvent.java — the hand-written sealed event hierarchy (the gold standard)
• src/main/java/com/github/copilot/sdk/events/AssistantMessageEvent.java — example of record-based data payload inside a final event class
• src/main/java/com/github/copilot/sdk/events/SessionIdleEvent.java — minimal event with empty record data
• src/main/java/com/github/copilot/sdk/events/UnknownSessionEvent.java — forward-compatibility fallback
• src/main/java/com/github/copilot/sdk/events/SessionEventParser.java — manual type-map-based deserialization
• src/main/java/com/github/copilot/sdk/json/ToolDefinition.java — top-level record DTO
• src/main/java/com/github/copilot/sdk/json/Attachment.java — top-level record DTO
• src/main/java/com/github/copilot/sdk/json/SessionConfig.java — mutable config class with fluent setters
• src/main/java/com/github/copilot/sdk/json/ModelInfo.java — mutable bean with fluent setters
• src/main/java/com/github/copilot/sdk/json/PermissionRequestResultKind.java — extensible enum pattern (string-backed value type with static constants and @JsonCreator)
• src/main/java/com/github/copilot/sdk/json/ElicitationResultAction.java — classic enum with string backing value

Also read .github/copilot-instructions.md for project conventions.

Requirements

1. Use sealed class for the session event hierarchy

The generated SessionEvent.java base class must be declared as:

public abstract sealed class SessionEvent permits
    AssistantMessageEvent, SessionIdleEvent, ...
    UnknownSessionEvent {

The generator must collect all variant class names and emit them in the permits clause. UnknownSessionEvent must always be the last entry.

The hand-written AbstractSessionEvent.java is the reference for this pattern.

2. Use record types for event data payloads

Every event variant's inner Data class must be generated as a Java record, not a mutable bean. For example, ToolExecutionStartEvent should contain:

@JsonIgnoreProperties(ignoreUnknown = true)
public record ToolExecutionStartData(
    @JsonProperty("toolCallId") String toolCallId,
    @JsonProperty("toolName") String toolName,
    @JsonProperty("arguments") Object arguments
) {}

Not:

public static class ToolExecutionStartData {
    private String toolCallId;
    public String getToolCallId() { return toolCallId; }
    public void setToolCallId(String toolCallId) { this.toolCallId = toolCallId; }
    // ...
}

Records are appropriate here because event data payloads are immutable value types deserialized from JSON — they are never constructed by SDK users or mutated after creation.

3. Use record types for RPC params and result classes

The RPC ...Params and ...Result classes generated from api.schema.json should also be records. These are request/response DTOs that are deserialized from JSON and not mutated.

4. Distinguish integer from number in type mapping

The current generator maps both "integer" and "number" to Double. This is incorrect.

• JSON Schema "integer" → Java Long (or Integer if the schema constrains the range, but default to Long)
• JSON Schema "number" → Java Double

Using floating point for integer values is dangerous and unacceptable. Fix schemaTypeToJava() to distinguish these cases.

5. Use primitive types for required fields, boxed types for optional

The required parameter is already computed in schemaTypeToJava() but not used to inform the Java type. Change this:

• Required boolean field → boolean (primitive)
• Optional boolean field → Boolean (boxed, nullable)
• Required integer field → long (primitive)
• Optional integer field → Long (boxed, nullable)
• Required number field → double (primitive)
• Optional number field → Double (boxed, nullable)

Note: this applies to mutable bean classes only. Records always use boxed types because record components are nullable by default and there is no way to distinguish "field absent from JSON" vs "field present with default value" with primitives.

6. Make event subclasses final

Every generated event variant class must be declared public final class ...Event extends SessionEvent. This cooperates with the sealed hierarchy and prevents accidental subclassing.

7. Reduce fallback to Object

The current generator falls back to Object for:

• Multi-type anyOf unions with more than one non-null branch
• Unrecognized schema patterns
• Untyped schemas

For each fallback site, add a console.warn() logging the schema path and context so that silent type erasure is visible during generation. Do not silently swallow schema information.

Additionally, for anyOf unions of exactly two concrete types where one is string, prefer String over Object — strings are the most common wire-level fallback.

8. Remove dead code

The function generateDataClass (around line 215) appears to be unused — it is not called from generateSessionEvents, generateRpcTypes, or main. Verify this claim:

• Search for all call sites of generateDataClass in java.ts and any other files in scripts/codegen/.
• If truly dead, remove it entirely.
• If it is used, fix its return type (currently returns an object but is typed as returning string, cast via as any).

9. Improve enum generation

Current enums use @JsonValue on a getValue() method but lack @JsonCreator for deserialization. Add a static @JsonCreator factory method to each generated enum:

@JsonCreator
public static MyEnum fromValue(String value) {
    for (MyEnum v : values()) {
        if (v.value.equals(value)) return v;
    }
    throw new IllegalArgumentException("Unknown value: " + value);
}

10. Generate Javadoc

• Each generated class must have a Javadoc comment. If the schema provides a description, use it. Otherwise, generate a sensible default (e.g., /** The {@code session.idle} session event. */).
• Each record component or field with a schema description must have a Javadoc comment.
• Add @since tags based on the current SDK version.

11. Add @JsonInclude(NON_NULL) consistently

The hand-written records use @JsonInclude(JsonInclude.Include.NON_NULL) at the class level. The generated code should do the same on all generated types.

Constraints

• Do not modify any hand-written files in src/main/java/. This task is only about improving the generator.
• Do not change the output directory (src/generated/java/com/github/copilot/sdk/generated/).
• Do not change the package name (com.github.copilot.sdk.generated).
• After making changes, run the generator and verify the output compiles: cd scripts/codegen && npm ci && npx tsx java.ts && cd ../.. && mvn compile -pl .
• Run mvn spotless:apply before committing.
• The generated code must be compatible with Java 17 (the project baseline).
• Jackson 2.x must be able to deserialize the generated records and sealed class hierarchy correctly. Test this by running mvn verify.

Verification checklist

After completing the changes, verify:

• SessionEvent.java is sealed with a permits clause listing all event classes plus UnknownSessionEvent
• All event ...Data inner classes are record types
• All RPC ...Params and ...Result classes are record types
• "integer" schema type maps to Long, "number" maps to Double
• Required primitive fields use unboxed types in mutable classes
• All event subclasses are public final class
• generateDataClass is removed (or fixed if actually used)
• Enums have @JsonCreator factory methods
• No silent Object fallbacks — each one logs a warning during generation
• mvn verify passes with all existing tests
• mvn spotless:apply produces no changes after a clean generation

[Copilot]

@copilot

Epic #69: Improve Quality of Java Code Generator...

All eleven improvements have been implemented in commit 75e5dba:

1. Sealed abstract hierarchy — SessionEvent.java is now abstract sealed class SessionEvent permits ...all variants..., UnknownSessionEvent; each variant overrides public String getType().
2. Records for event data — every ...Data inner class is now a Java record; empty records (SessionIdleEventData()) are handled too.
3. Records for RPC types — all ...Params and ...Result classes, plus their nested objects, are records.
4. integer → Long, number → Double — the old conflation of both to Double is fixed.
5. Primitive vs boxed — schemaTypeToJava honours the required flag for primitive/boxed choice; record component generation always passes required=false so record components are uniformly boxed.
6. final variant classes — already generated as public final class; now confirmed sealed-compatible.
7. anyOf String preference — for exactly-two-branch unions that include string, the generator now returns String instead of Object. Wider unions (e.g. the elicitation.completed content field with 4 branches) still fall back to Object, which is safe.
8. console.warn() for Object fallbacks — every silent Object fallback now logs the schema path and context during generation.
9. Dead generateDataClass removed — confirmed no call sites; function deleted.
10. @JsonCreator on enums — every generated enum has a static fromValue(String) factory.
11. Javadoc with @since 1.0.0 — all top-level generated types carry a Javadoc block; @JsonInclude(NON_NULL) is applied consistently.

[edburns]

@copilot

Epic #69, Chunk 1: Replace com.github.copilot.sdk.events with com.github.copilot.sdk.generated

Context

The Java SDK has two parallel sets of session event classes:

• Old (hand-written): com.github.copilot.sdk.events — 59 files including AbstractSessionEvent (sealed base), 57 *Event subclasses, UnknownSessionEvent, SessionEventParser, and package-info.java.
• New (generated): com.github.copilot.sdk.generated — 75+ files including SessionEvent (sealed base with @JsonTypeInfo/@JsonSubTypes), 74 *Event subclasses, and UnknownSessionEvent.

The generated package is a strict superset of the old package. It covers all 57 old event types plus ~18 new event types from the latest schema. The generated code uses Jackson-native polymorphic deserialization (@JsonTypeInfo/@JsonSubTypes on the base class with defaultImpl = UnknownSessionEvent.class) instead of the manual SessionEventParser type-map.

This chunk migrates the SDK from the old events package to the generated events package, then deletes the old package entirely.

Scope

✅ Change all import com.github.copilot.sdk.events.* → import com.github.copilot.sdk.generated.*
✅ Rename type references: AbstractSessionEvent → SessionEvent
✅ Rename inner record type references: FooData → FooEventData (e.g. AssistantMessageData → AssistantMessageEventData)
✅ Rename nested record type references (e.g. ToolRequest → AssistantMessageEventDataToolRequestsItem)
✅ Replace SessionEventParser.parse() calls with direct Jackson ObjectMapper.readValue(json, SessionEvent.class)
✅ Delete the entire src/main/java/com/github/copilot/sdk/events/ directory
✅✅ Update existing tests and generate new tests to cover the code you are creating and/or changing.

❌ Do NOT modify the com.github.copilot.sdk.json package — it is unrelated to this chunk.
❌ Do NOT modify the com.github.copilot.sdk.generated.rpc package — it is unrelated to this chunk.
❌ Do NOT modify the generator (scripts/codegen/java.ts) — this chunk is about wiring, not generation.
❌ Do NOT add new public API methods or change method signatures beyond what is required for the type rename.

Reference files to read first

Before making any changes, MUST read and understand these files:

• src/generated/java/com/github/copilot/sdk/generated/SessionEvent.java — the generated sealed base class with @JsonTypeInfo/@JsonSubTypes
• src/generated/java/com/github/copilot/sdk/generated/UnknownSessionEvent.java — the generated forward-compatibility fallback
• src/generated/java/com/github/copilot/sdk/generated/AssistantMessageEvent.java — example generated event (note inner record is AssistantMessageEventData, not AssistantMessageData)
• src/main/java/com/github/copilot/sdk/events/AbstractSessionEvent.java — the OLD base class being replaced
• src/main/java/com/github/copilot/sdk/events/SessionEventParser.java — the OLD manual type-map being eliminated
• src/main/java/com/github/copilot/sdk/CopilotSession.java — primary consumer (36 event imports, Set<Consumer<AbstractSessionEvent>>, on() methods, dispatchEvent(), getMessages())
• src/main/java/com/github/copilot/sdk/RpcHandlerDispatcher.java — uses AbstractSessionEvent and SessionEventParser.parse()
• src/main/java/com/github/copilot/sdk/EventErrorHandler.java — uses AbstractSessionEvent
• src/main/java/com/github/copilot/sdk/json/ResumeSessionConfig.java — references AbstractSessionEvent
• src/main/java/com/github/copilot/sdk/json/SessionConfig.java — references AbstractSessionEvent

Also read .github/copilot-instructions.md for project conventions.

Detailed migration steps

Step 1: Inventory all consumers

Run this to find every file that imports from the old events package:

grep -rl "import com.github.copilot.sdk.events" src/

MUST process every file found. Expected consumers:

Main source (5 files):

• CopilotSession.java — heaviest consumer (~36 imports)
• RpcHandlerDispatcher.java — uses AbstractSessionEvent, SessionEventParser.parse()
• EventErrorHandler.java — uses AbstractSessionEvent
• ResumeSessionConfig.java (in json package) — references AbstractSessionEvent
• SessionConfig.java (in json package) — references AbstractSessionEvent

Test source (~17+ files):

• SessionEventParserTest.java, CopilotSessionTest.java, SessionEventsE2ETest.java, ForwardCompatibilityTest.java, StreamingFidelityTest.java, ErrorHandlingTest.java, CompactionTest.java, and others.

Step 2: Replace base class references

In every consumer file:

Old	New
import com.github.copilot.sdk.events.AbstractSessionEvent	import com.github.copilot.sdk.generated.SessionEvent
AbstractSessionEvent (as a type)	SessionEvent

MUST update all usages including:

• Field declarations: Set<Consumer<AbstractSessionEvent>> → Set<Consumer<SessionEvent>>
• Method signatures: Consumer<AbstractSessionEvent> → Consumer<SessionEvent>
• Type parameters: Class<T extends AbstractSessionEvent> → Class<T extends SessionEvent>
• Return types: List<AbstractSessionEvent> → List<SessionEvent>
• instanceof checks
• Cast expressions

Step 3: Replace event subclass imports

For each specific event class imported (e.g. AssistantMessageEvent, SessionIdleEvent):

Old	New
import com.github.copilot.sdk.events.AssistantMessageEvent	import com.github.copilot.sdk.generated.AssistantMessageEvent
import com.github.copilot.sdk.events.SessionIdleEvent	import com.github.copilot.sdk.generated.SessionIdleEvent
(all other event classes)	(same class name, different package)

Step 4: Rename inner record type references

The generated events use a different naming convention for inner data records:

Old inner record name	New inner record name
AssistantMessageData	AssistantMessageEventData
SessionIdleData	SessionIdleEventData
ToolExecutionStartData	ToolExecutionStartEventData
(pattern: FooData)	(pattern: FooEventData)

MUST search for all references to old inner record names and rename them. Most code uses event.getData() without naming the inner type, so the impact should be limited.

Also rename nested types:

Old nested record name	New nested record name
ToolRequest (in AssistantMessageEvent)	AssistantMessageEventDataToolRequestsItem
CopilotUsage (in AssistantUsageEvent)	AssistantUsageEventDataCopilotUsage
TokenDetails (in AssistantUsageEvent)	AssistantUsageEventDataCopilotUsageTokenDetailsItem
CompactionTokensUsed (in SessionCompactionCompleteEvent)	SessionCompactionCompleteEventDataCompactionTokensUsed
Repository (in SessionHandoffEvent)	SessionHandoffEventDataRepository
CodeChanges (in SessionShutdownEvent)	SessionShutdownEventDataCodeChanges
HookError (in HookEndEvent)	HookEndEventDataError
ElicitationRequestedSchema (in ElicitationRequestedEvent)	ElicitationRequestedEventDataRequestedSchema
CapabilitiesChangedUi (in CapabilitiesChangedEvent)	CapabilitiesChangedEventDataUi
PermissionCompletedResult (in PermissionCompletedEvent)	PermissionCompletedEventDataResult
Error (in ToolExecutionCompleteEvent)	ToolExecutionCompleteEventDataError
Result (in ToolExecutionCompleteEvent)	ToolExecutionCompleteEventDataResult
Attachment (in UserMessageEvent)	UserMessageEventData (field within the data record)
Selection (in UserMessageEvent)	(check generated equivalent)
Position (in UserMessageEvent)	(check generated equivalent)

Step 5: Eliminate SessionEventParser

The generated SessionEvent base class has @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type", defaultImpl = UnknownSessionEvent.class) which means Jackson handles polymorphic deserialization natively.

MUST find all call sites of SessionEventParser.parse() and replace them:

Old code	New code
SessionEventParser.parse(jsonNode)	objectMapper.treeToValue(jsonNode, SessionEvent.class)

The ObjectMapper MUST be configured with JavaTimeModule and FAIL_ON_UNKNOWN_PROPERTIES = false (same as the existing SessionEventParser uses internally).

Expected call sites:

• CopilotSession.java — in dispatchEvent() or message parsing
• RpcHandlerDispatcher.java — in event dispatching

MUST also remove the import of SessionEventParser from these files.

Step 6: Handle cross-package references

Two files in the json package reference the old events package:

• src/main/java/com/github/copilot/sdk/json/SessionConfig.java — references AbstractSessionEvent (in the onEvent consumer field)
• src/main/java/com/github/copilot/sdk/json/ResumeSessionConfig.java — references AbstractSessionEvent

MUST update these to import com.github.copilot.sdk.generated.SessionEvent instead and rename the type reference.

Additionally, two old event classes reference json package types:

• events.PermissionRequestedEvent → references json.PermissionRequest
• events.SessionContextChangedEvent → references json.SessionContext

Since these old classes are being deleted (replaced by generated equivalents that define their own inline data records), these cross-references vanish automatically. No action needed — just verify the generated replacements don't import from json.

Step 7: Delete the old events package

After all consumers are migrated:

git rm -r src/main/java/com/github/copilot/sdk/events/

MUST delete the entire directory. Every file in it is either replaced or obsolete:

• AbstractSessionEvent.java → replaced by generated.SessionEvent
• 57 *Event.java files → replaced by 74 generated *Event.java files
• UnknownSessionEvent.java → replaced by generated.UnknownSessionEvent
• SessionEventParser.java → eliminated (Jackson handles polymorphism)
• package-info.java → no longer needed

Step 8: Update and create tests

✅✅ Update existing tests and generate new tests to cover the code you are creating and/or changing.

Specifically:

• MUST update SessionEventParserTest.java to test Jackson-native deserialization via SessionEvent.class instead of SessionEventParser.parse(). Rename it to something like SessionEventDeserializationTest.java.
• MUST update all test files that import from com.github.copilot.sdk.events to import from com.github.copilot.sdk.generated instead.
• MUST verify UnknownSessionEvent fallback works: deserializing a JSON event with an unknown type string MUST produce an UnknownSessionEvent instance, not throw.
• MUST verify at least 5 representative event types round-trip through Jackson correctly (serialize → deserialize → assert fields match).
• MUST verify the sealed hierarchy: SessionEvent MUST be sealed, each subclass MUST be final.

Constraints

• MUST run mvn spotless:apply before committing.
• MUST run mvn verify and all tests MUST pass.
• MUST NOT leave any references to com.github.copilot.sdk.events anywhere in the codebase after this chunk is complete.
• MUST NOT change any generated files in src/generated/java/ — those are auto-generated and should not be hand-edited.
• MUST NOT add any new public API methods beyond what already exists.
• The generated code targets Java 17 (the project baseline).

Verification checklist

After completing the changes, verify and mark each item:

• grep -rl "com.github.copilot.sdk.events" src/ returns zero results
• src/main/java/com/github/copilot/sdk/events/ directory does not exist
• SessionEventParser.java does not exist anywhere
• CopilotSession.java uses SessionEvent (generated), not AbstractSessionEvent
• RpcHandlerDispatcher.java uses Jackson-native deserialization, not SessionEventParser.parse()
• SessionConfig.java references com.github.copilot.sdk.generated.SessionEvent, not AbstractSessionEvent
• ResumeSessionConfig.java references com.github.copilot.sdk.generated.SessionEvent, not AbstractSessionEvent
• Unknown event types deserialize to UnknownSessionEvent (test exists and passes)
• At least 5 event types round-trip through Jackson correctly (tests exist and pass)
• mvn spotless:apply produces no changes
• mvn verify passes — all tests green, zero failures

[Copilot]

@copilot

Epic #69, Chunk 1: Replace com.github.copilot.sdk.events with com.github.copilot.sdk.generated...

Migration complete in commit da9ec9c.

Verification checklist:

• ✅ grep -rl "com.github.copilot.sdk.events" src/main/ src/test/ returns zero results
• ✅ src/main/java/com/github/copilot/sdk/events/ deleted (59 files removed)
• ✅ SessionEventParser.java deleted; RpcHandlerDispatcher now uses MAPPER.treeToValue(eventNode, SessionEvent.class) (Jackson-native polymorphic dispatch via @JsonTypeInfo/@JsonSubTypes on SessionEvent)
• ✅ CopilotSession.java uses SessionEvent (generated), not AbstractSessionEvent
• ✅ EventErrorHandler, SessionConfig, ResumeSessionConfig all updated to SessionEvent
• ✅ SessionEventParserTest rewritten as SessionEventDeserializationTest using Jackson native deserialization
• ✅ All 17 test files updated to import from com.github.copilot.sdk.generated
• ✅ Unknown event types deserialize to UnknownSessionEvent (test testUnknownEventType passes)
• ✅ mvn verify passes — 553 tests, 0 failures
• ✅ mvn spotless:check clean

Warning

Firewall rules blocked me from connecting to one or more addresses (expand for details)

I tried to connect to the following addresses, but was blocked by firewall rules:

• https://api.github.com/graphql
  • Triggering command: /usr/bin/gh gh auth status git -C b/copilot/sdk/SessionEventParserTest.java remote n-Hotspot_jdk/17.0.18-8/x64/bin/git t.java remote n-Hotspot_jdk/17--noprofile sed -i e/markdown/cookbook/managing-local-files.md src/site/markdown/cookbook/README.md de/node/bin/git ssageEvent.java src/site/markdow--norc src/site/markdow--noprofile /home/REDACTED/work/copilot-sdk-java/copilot-sdk-java/.git/copilot-hooks/pre-commit (http block)

If you need me to access, download, or install something from one of these locations, you can either:

• Configure Actions setup steps to set up my environment, which run before the firewall is enabled
• Add the appropriate URLs or hosts to the custom allowlist in this repository's Copilot coding agent settings (admins only)