Fix CI breaks from the CLI 1.0.78-2 schema update

The dependency bump regenerated types but left hand-written code and tests
behind, breaking every language job. Five independent fixes:

- Go: the CLI added a `factory` permission-request kind, so
  `PermissionRequestFactory` needed a `RequiresManagedApproval()` impl.
  Added it, and registered the new variant in the codegen shim
  (`PERMISSION_REQUEST_DEFINITION_NAMES`) so Go/Python/Rust all carry the
  `managedApprovalRequired` field consistently.

- .NET: `session.start` gained `githubMcpToolConfig`, so codegen emitted a
  `GitHubMcpToolConfig` class colliding with the hand-written one in
  `dotnet/src/Types.cs` (15 CS0260/CS0102 errors). Taught the C# generator to
  skip nested classes whose names already exist hand-written under
  `dotnet/src`, mirroring the existing behavior in the Go generator. The
  `[JsonSerializable]` registrations are preserved.

- Java: `SessionEventHandlingTest` calls generated record constructors
  positionally; `SessionStartEventData` gained `githubMcpToolConfig` and
  `AssistantMessageEventData` gained `chunkIndex`/`chunkCount`. Padded the
  three call sites. This also unblocks CodeQL's java-kotlin analysis.

- Rust: `EventLogReadRequest` gained `agent_ids` and `direction`; added them
  to the three exhaustive struct literals in `tests/e2e/rpc_event_log.rs`.

- Node.js: the CLI can now answer `session.factory.run`/`resume` before the
  run settles, so the e2e test saw `status: "running"`. `SessionFactoryApi`
  documents these as resolving with a terminal envelope, so both now route
  through a `settleFactoryRun` helper that waits for terminal state when the
  initial envelope is non-terminal. Correct under both old and new CLI
  behavior.

Validated locally: go build/vet, dotnet build (src + test), mvn test-compile
+ spotless:check + SessionEventHandlingTest (29/29), cargo check --tests +
cargo fmt --check, npm run typecheck/lint, and the full Node unit suite
(363 tests).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 820d6939-ba01-4044-8ee3-c5f5b4d3f443

Author: stephentoub

dotnet/src/Generated/SessionEvents.cs

@@ -26,6 +26,12 @@ func (r PermissionRequestExtensionPermissionAccess) RequiresManagedApproval() bo
 	return managedApprovalRequired(r.ManagedApprovalRequired)
 }
 
+// RequiresManagedApproval reports whether managed policy requires an explicit
+// human decision for this request.
+func (r PermissionRequestFactory) RequiresManagedApproval() bool {
+	return managedApprovalRequired(r.ManagedApprovalRequired)
+}
+
 // RequiresManagedApproval reports whether managed policy requires an explicit
 // human decision for this request.
 func (r PermissionRequestHook) RequiresManagedApproval() bool {

go/rpc/permission_request_managed_approval.go

@@ -180,7 +180,7 @@ void testHandlerReceivesCorrectEventData() {
 
         SessionStartEvent startEvent = createSessionStartEvent();
         startEvent.setData(new SessionStartEvent.SessionStartEventData("my-session-123", null, null, null, null, null,
-                null, null, null, null, null, null, null, null, null));
+                null, null, null, null, null, null, null, null, null, null));
         dispatchEvent(startEvent);
 
         AssistantMessageEvent msgEvent = createAssistantMessageEvent("Test content");
@@ -857,15 +857,15 @@ private SessionStartEvent createSessionStartEvent() {
     private SessionStartEvent createSessionStartEvent(String sessionId) {
         var event = new SessionStartEvent();
         var data = new SessionStartEvent.SessionStartEventData(sessionId, null, null, null, null, null, null, null,
-                null, null, null, null, null, null, null);
+                null, null, null, null, null, null, null, null);
         event.setData(data);
         return event;
     }
 
     private AssistantMessageEvent createAssistantMessageEvent(String content) {
         var event = new AssistantMessageEvent();
         var data = new AssistantMessageEvent.AssistantMessageEventData(null, null, content, null, null, null, null,
-                null, null, null, null, null, null, null, null, null, null, null, null, null);
+                null, null, null, null, null, null, null, null, null, null, null, null, null, null, null);
         event.setData(data);
         return event;
     }

go/rpc/zsession_events.go

@@ -461,7 +461,7 @@ export class CopilotSession {
                 },
             });
 
-            return toPublicFactoryRunResult(envelope);
+            return this.settleFactoryRun(envelope);
         }) as SessionFactoryApi["run"],
         resume: (async (runId: string, options?: Parameters<SessionFactoryApi["resume"]>[1]) => {
             let response;
@@ -483,7 +483,7 @@ export class CopilotSession {
                 }
                 throw error;
             }
-            return toPublicFactoryRunResult(response.run);
+            return this.settleFactoryRun(response.run);
         }) as SessionFactoryApi["resume"],
         getRun: async (runId) => toPublicFactoryRunResult(await this.rpc.factory.getRun({ runId })),
         waitForRun: (runId, options) => this.waitForFactoryRun(runId, options?.signal),
@@ -494,6 +494,20 @@ export class CopilotSession {
         cancel: async (runId) => toPublicFactoryRunResult(await this.rpc.factory.cancel({ runId })),
     };
 
+    /**
+     * Resolve a start/resume envelope into the terminal envelope callers expect.
+     *
+     * The CLI may answer `session.factory.run` and `session.factory.resume`
+     * before the run settles, so a non-terminal envelope is followed by a wait
+     * on the run's terminal state.
+     */
+    private settleFactoryRun(envelope: WireFactoryRunResult): Promise<FactoryRunResult> {
+        if (isFactoryRunTerminal(envelope.status)) {
+            return Promise.resolve(toPublicFactoryRunResult(envelope));
+        }
+        return this.waitForFactoryRun(envelope.runId);
+    }
+
     /**
      * Resolve when a factory run reaches a terminal status.
      *

java/src/test/java/com/github/copilot/SessionEventHandlingTest.java

@@ -3322,6 +3322,9 @@ pub struct PermissionRequestFactory {
     pub description: String,
     /// Permission kind discriminator
     pub kind: PermissionRequestFactoryKind,
+    /// When true, managed policy requires an explicit user decision and automatic approval must be bypassed.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub managed_approval_required: Option<bool>,
     /// Effective AI-credit limit; omitted means unlimited
     #[serde(skip_serializing_if = "Option::is_none")]
     pub max_ai_credits: Option<f64>,

nodejs/src/session.ts

@@ -43,8 +43,10 @@ async fn should_read_persisted_events_from_beginning() {
                     .rpc()
                     .event_log()
                     .read(EventLogReadRequest {
+                        agent_ids: None,
                         agent_scope: None,
                         cursor: None,
+                        direction: None,
                         include_ephemeral: None,
                         max: Some(100),
                         types: Some(json!("*")),
@@ -89,8 +91,10 @@ async fn should_return_tail_cursor_and_read_empty_when_no_new_events() {
                     .rpc()
                     .event_log()
                     .read(EventLogReadRequest {
+                        agent_ids: None,
                         agent_scope: None,
                         cursor: Some(tail.cursor),
+                        direction: None,
                         include_ephemeral: None,
                         max: Some(10),
                         types: Some(json!("*")),
@@ -172,8 +176,10 @@ async fn should_longpoll_with_types_filter_for_titlechanged_event() {
                 let tail = session.rpc().event_log().tail().await.expect("tail");
                 let event_log = session.rpc().event_log();
                 let read_future = event_log.read(EventLogReadRequest {
+                    agent_ids: None,
                     agent_scope: None,
                     cursor: Some(tail.cursor),
+                    direction: None,
                     include_ephemeral: None,
                     max: Some(10),
                     types: Some(json!(["session.title_changed"])),

python/copilot/generated/session_events.py

@@ -70,6 +70,51 @@ const POLYMORPHIC_BASE_PROPERTIES: Record<string, readonly string[]> = {
     PermissionRequest: ["managedApprovalRequired"],
 };
 
+/**
+ * Public type names declared by hand-written C# sources under `dotnet/src`
+ * (excluding `dotnet/src/Generated`). Generated session-event types share the
+ * `GitHub.Copilot` namespace with those sources, so a schema definition whose
+ * name collides with a hand-written declaration must reuse it — emitting a
+ * second class of the same name fails the build (CS0260/CS0102).
+ *
+ * Populated by {@link collectHandWrittenCSharpTypeNames} before generation.
+ */
+let handWrittenCSharpTypeNames = new Set<string>();
+
+/**
+ * Scan hand-written `.cs` files under `dotnet/src` for top-level public type
+ * declarations. The `Generated` directory is skipped so this scanner never
+ * reads (or depends on the output of) its own emit.
+ */
+async function collectHandWrittenCSharpTypeNames(): Promise<Set<string>> {
+    const names = new Set<string>();
+    const srcDir = path.join(REPO_ROOT, "dotnet", "src");
+    const declaration = /^\s*(?:public|internal)\s+(?:(?:abstract|sealed|static|partial|readonly|ref)\s+)*(?:class|record|struct|interface|enum)\s+([A-Za-z_]\w*)/gm;
+
+    const walk = async (dir: string): Promise<void> => {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+            return;
+        }
+        for (const entry of entries) {
+            const entryPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === "Generated" || entry.name === "bin" || entry.name === "obj") continue;
+                await walk(entryPath);
+                continue;
+            }
+            if (!entry.name.endsWith(".cs")) continue;
+            const content = await fs.readFile(entryPath, "utf-8");
+            for (const match of content.matchAll(declaration)) names.add(match[1]);
+        }
+    };
+
+    await walk(srcDir);
+    return names;
+}
+
 /** Apply rename to a generated class name, checking both exact match and prefix replacement for derived types. */
 function applyTypeRename(className: string): string {
     if (TYPE_RENAMES[className]) return TYPE_RENAMES[className];
@@ -1456,8 +1501,13 @@ namespace GitHub.Copilot;
         lines.push(generateDataClass(variant, knownTypes, nestedClasses, enumOutput), "");
     }
 
-    // Nested classes
-    for (const [, code] of nestedClasses) lines.push(code, "");
+    // Nested classes. A name already declared by a hand-written source is skipped:
+    // that declaration is the one the namespace keeps, and the generated property
+    // simply binds to it.
+    for (const [name, code] of nestedClasses) {
+        if (handWrittenCSharpTypeNames.has(name)) continue;
+        lines.push(code, "");
+    }
 
     // Enums
     for (const code of enumOutput) lines.push(code);
@@ -1477,6 +1527,7 @@ export async function generateSessionEvents(schemaPath?: string): Promise<void>
     const resolvedPath = schemaPath ?? (await getSessionEventsSchemaPath());
     const schema = cloneSchemaForCodegen((await loadSchemaJson(resolvedPath)) as JSONSchema7);
     const processed = propagateInternalVisibility(postProcessSchema(schema));
+    handWrittenCSharpTypeNames = await collectHandWrittenCSharpTypeNames();
     const code = generateSessionEventsCode(processed);
     const outPath = await writeGeneratedFile("dotnet/src/Generated/SessionEvents.cs", code);
     console.log(`  ✓ ${outPath}`);
@@ -2629,6 +2680,7 @@ namespace GitHub.Copilot.Rpc;
 export async function generateRpc(schemaPath?: string, sessionEventsSchema?: JSONSchema7): Promise<void> {
     console.log("C#: generating RPC types...");
     const resolvedPath = schemaPath ?? (await getApiSchemaPath());
+    handWrittenCSharpTypeNames = await collectHandWrittenCSharpTypeNames();
     let schema = fixNullableRequiredRefsInApiSchema(cloneSchemaForCodegen((await loadSchemaJson(resolvedPath)) as ApiSchema));
     if (sessionEventsSchema) {
         const sharedDefinitions = findSharedSchemaDefinitions(
@@ -2658,7 +2710,9 @@ export async function generateRpc(schemaPath?: string, sessionEventsSchema?: JSO
             for (const name of reachableDefinitions) {
                 const typeName = typeToClassName(name);
                 const declarationPattern = new RegExp(`\\bpublic\\s+(?:(?:sealed|abstract|partial|readonly)\\s+)*(?:class|struct)\\s+${typeName}\\b`);
-                if (declarationPattern.test(sessionEventsCode)) {
+                // A hand-written declaration also lives in `GitHub.Copilot`, so the
+                // reference resolves even though the generated file skipped it.
+                if (declarationPattern.test(sessionEventsCode) || handWrittenCSharpTypeNames.has(typeName)) {
                     emittedDefinitions.add(name);
                 }
                 const valueTypeDeclarationPattern = new RegExp(`\\bpublic\\s+(?:(?:readonly)\\s+)?struct\\s+${typeName}\\b`);

rust/src/generated/session_events.rs

@@ -457,6 +457,7 @@ const PERMISSION_REQUEST_DEFINITION_NAMES = [
     "PermissionRequestCustomTool",
     "PermissionRequestExtensionManagement",
     "PermissionRequestExtensionPermissionAccess",
+    "PermissionRequestFactory",
     "PermissionRequestHook",
     "PermissionRequestMcp",
     "PermissionRequestMemory",