Fix Java codegen and build failures after @github/copilot update

The new @github/copilot schemas introduced cross-schema $ref references
in api.schema.json pointing to session-events.schema.json definitions:
- session-events.schema.json#/definitions/SessionEvent
- session-events.schema.json#/definitions/PermissionPromptRequest

The code generator only handled local #/definitions/ refs, causing invalid
Java type names to be emitted (the raw $ref string), which produced
compilation errors:
  PendingPermissionRequest.java: illegal character '#'
  SessionEventLogReadResult.java: '<identifier> expected', etc.

Fix in java/scripts/codegen/java.ts:
- Track generated session-events type names in generatedSessionEventsTypes
- Store session-events definitions in sessionEventsDefinitions
- In schemaTypeToJava, detect cross-schema refs and resolve them:
  - If the type is already generated in the session-events package
    (e.g. SessionEvent), emit it with the correct import
  - Otherwise resolve inline using the external definitions
    (anyOf unions like PermissionPromptRequest fall back to Object)

Regenerated affected files:
  PendingPermissionRequest.java: request field now typed as Object
  SessionEventLogReadResult.java: events field now typed as List<SessionEvent>

Automated fix applied by java-codegen-fix workflow.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

java/scripts/codegen/java.ts

@@ -102,6 +102,13 @@ interface JavaTypeResult {
 let currentDefinitions: Record<string, JSONSchema7> = {};
 const pendingStandaloneTypes = new Map<string, JSONSchema7>();
 
+// Definitions and generated type names from the session-events schema, populated
+// during generateSessionEvents so that cross-schema $ref resolution in generateRpcTypes
+// can look up types like SessionEvent and PermissionPromptRequest.
+let sessionEventsDefinitions: Record<string, JSONSchema7> = {};
+const generatedSessionEventsTypes = new Set<string>();
+const SESSION_EVENTS_PACKAGE = "com.github.copilot.sdk.generated";
+
 /**
  * Resolve a $ref in a JSON Schema against the current definitions.
  * Returns the resolved schema, or the original if no $ref is present.
@@ -131,6 +138,28 @@ function schemaTypeToJava(
 
     // Resolve $ref first — register standalone types for generation
     if (schema.$ref) {
+        // Handle cross-schema refs (e.g. "session-events.schema.json#/definitions/X")
+        if (!schema.$ref.startsWith("#")) {
+            const hashIdx = schema.$ref.indexOf("#");
+            const schemaFile = hashIdx >= 0 ? schema.$ref.substring(0, hashIdx) : schema.$ref;
+            const pointer = hashIdx >= 0 ? schema.$ref.substring(hashIdx + 1) : "";
+            const typeName = pointer.replace(/^\/definitions\//, "");
+            if (schemaFile === "session-events.schema.json" && typeName) {
+                if (generatedSessionEventsTypes.has(typeName)) {
+                    // Already generated in the session-events package — use with import
+                    imports.add(`${SESSION_EVENTS_PACKAGE}.${typeName}`);
+                    return { javaType: typeName, imports };
+                }
+                // Not a pre-generated standalone type; resolve inline from session-events defs
+                const extDef = sessionEventsDefinitions[typeName];
+                if (extDef) {
+                    return schemaTypeToJava(extDef, required, context, propName, nestedTypes);
+                }
+            }
+            console.warn(`[codegen] Unresolved cross-schema $ref: ${schema.$ref}`);
+            return { javaType: "Object", imports };
+        }
+
         const name = schema.$ref.replace(/^#\/definitions\//, "");
         const resolved = currentDefinitions[name];
         if (resolved) {
@@ -314,20 +343,30 @@ async function generateSessionEvents(schemaPath: string): Promise<void> {
     currentDefinitions = (schema.definitions ?? {}) as Record<string, JSONSchema7>;
     pendingStandaloneTypes.clear();
 
+    // Store session-events definitions for cross-schema $ref resolution during RPC generation
+    sessionEventsDefinitions = currentDefinitions;
+    generatedSessionEventsTypes.clear();
+
     const variants = extractEventVariants(schema);
     const packageName = "com.github.copilot.sdk.generated";
     const packageDir = `src/generated/java/com/github/copilot/sdk/generated`;
 
     // Generate base SessionEvent class
     await generateSessionEventBaseClass(variants, packageName, packageDir);
+    generatedSessionEventsTypes.add("SessionEvent");
+    generatedSessionEventsTypes.add("UnknownSessionEvent");
 
     // Generate one class file per event variant
     for (const variant of variants) {
         await generateEventVariantClass(variant, packageName, packageDir);
+        generatedSessionEventsTypes.add(variant.className);
     }
 
     // Generate standalone types discovered via $ref resolution
     await generatePendingStandaloneTypes(packageName, packageDir, GENERATED_FROM_SESSION_EVENTS);
+    for (const typeName of pendingStandaloneTypes.keys()) {
+        generatedSessionEventsTypes.add(typeName);
+    }
 
     console.log(`✅ Generated ${variants.length + 1} session event files`);
 }

java/src/generated/java/com/github/copilot/sdk/generated/rpc/PendingPermissionRequest.java

@@ -24,6 +24,6 @@ public record PendingPermissionRequest(
     /** Unique identifier for the pending permission request */
     @JsonProperty("requestId") String requestId,
     /** The user-facing permission prompt details (commands, write, read, mcp, url, memory, custom-tool, path, hook) */
-    @JsonProperty("request") session-events.schema.json#/definitions/PermissionPromptRequest request
+    @JsonProperty("request") Object request
 ) {
 }

java/src/generated/java/com/github/copilot/sdk/generated/rpc/SessionEventLogReadResult.java

@@ -10,6 +10,7 @@
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.github.copilot.sdk.generated.SessionEvent;
 import java.util.List;
 import javax.annotation.processing.Generated;
 
@@ -23,7 +24,7 @@
 @JsonIgnoreProperties(ignoreUnknown = true)
 public record SessionEventLogReadResult(
     /** Events are delivered in two batches per read: persisted events first (in append order), then ephemeral events (in seq order). When `waitMs > 0` and the catch-up batches were empty, post-wait events follow the same two-batch ordering. Persisted and ephemeral events do not interleave within a single read. */
-    @JsonProperty("events") List<session-events.schema.json#/definitions/SessionEvent> events,
+    @JsonProperty("events") List<SessionEvent> events,
     /** Opaque cursor for the next read. Pass back unchanged in the next read.cursor to continue from where this read left off. Always present, even when no events were returned. */
     @JsonProperty("cursor") String cursor,
     /** True when the read returned `max` events and more events are available immediately. When false, the next read with a non-zero `waitMs` will block until a new event arrives or the wait expires. */