[Codegen] Honor internal flag on session event types in Node codegen (#2177)

* [Codegen] Keep Internal Types That Public Declarations Reference

* Fix @internal stripping: filter union arms correctly, fail hard on violations

The root cause of dangling @internal types in the emitted .d.ts was in the
publicVariants filter inside generateSessionEvents. The filter checked only
the 'data' sub-property of each resolved variant for internal visibility,
but missed the case where the arm object itself or its resolved definition is
marked visibility:internal. Internal event types (AssistantTurnRetryEvent,
ModelCallStartEvent) therefore passed through the filter and appeared in the
generated SessionEvent union — while their declarations were separately tagged
@internal and stripped — leaving dangling references that collapsed to 'any'.

Fix the filter to also check isSchemaInternal on the arm object and on the
resolved definition. With this, internal union arms are excluded from
compilation entirely: no declaration, no union member, no dangling reference.

For RPC, fix emitClientGlobalApiRegistration to filter internal methods from
the generated handler interface (HooksHandler), so internal method param types
(HookInvokeRequest, HookType, etc.) are no longer referenced by any public
declaration. The registration function body still wires up the internal RPC
handler internally, but function bodies are not emitted in declaration files.

Replace the PR's strippableInternalTypes workaround (which silently promoted
internal types to public rather than failing) with assertNoPublicInternalReferences,
which throws hard if the codegen ever produces a public declaration referencing
an internal type. The schema lint in the runtime already guarantees the schema
is valid; a violation here means the codegen has a bug, not something to paper over.

Export filterPublicSessionEventVariants and assertNoPublicInternalReferences
and add unit tests covering: public arms kept, internal arms excluded (by arm
visibility, by definition visibility, and by data-property visibility), the
validator passing on @internal-tagged members and function bodies, and the
validator throwing on direct public references to internal types.

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

* fix: skip all-internal client global handler groups from public interface

When all methods in a client-global RPC group are marked visibility:internal
(currently: hooks.invoke), do not include the group in the generated
HooksHandler interface or ClientGlobalApiHandlers. The registration body
likewise only wires up public methods.

The SDK handles hooks.invoke internally: client.ts registers the handler
directly via connection.onRequest, bypassing ClientGlobalApiHandlers, so
that HookInvokeRequest/HookType never appear in the public .d.ts surface.

Tests that exercised clientGlobalHandlers.hooks.invoke are updated to call
handleHooksInvoke directly — the same validation of the wire-format contract
without depending on the now-removed public handler plumbing.

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

* style: apply prettier formatting to client hooks registration

Fix the CI-only formatting failure in nodejs/src/client.ts introduced by the
previous hooks.invoke plumbing change.

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

* test: tighten internal reference validation and coverage

Fix assertNoPublicInternalReferences so it only strips function bodies,
preserving interface/type member signatures for validation. Also remove
@internal-tagged members before scanning and add a regression test that a
public interface member referencing an internal type fails validation.

Add an explicit unit test that attachConnectionHandlers registers the
hand-written hooks.invoke JSON-RPC entry point and routes it to
handleHooksInvoke. Rename the legacy-pattern session-event test to match its
actual assertions.

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

* fix: ignore internal object-valued members in TS validator

The fail-hard validator correctly ignores simple @internal-tagged members,
but it still treated inline object-shaped members like
 as public references. That caused false failures
when public event payloads contained internal members whose types are removed
by stripInternal.

Extend the member-removal pass to drop both simple and inline object-valued
@internal members before scanning for public references, and add a regression
test covering that shape.

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

---------

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

Author: 3 people

nodejs/src/client.ts

@@ -831,11 +831,6 @@ export class CopilotClient {
 
     private setupClientGlobalHandlers(): void {
         const handlers: import("./generated/rpc.js").ClientGlobalApiHandlers = {};
-        // `hooks.invoke` is a client-global RPC method whose payload carries a
-        // `sessionId`; route each invocation to the matching session's dispatcher.
-        handlers.hooks = {
-            invoke: async (params) => await this.handleHooksInvoke(params),
-        };
         if (this.requestHandler) {
             handlers.llmInference = createCopilotRequestAdapter(this.requestHandler, () => {
                 if (!this.connection) {
@@ -2850,6 +2845,17 @@ export class CopilotClient {
         // — the runtime calls into a single handler for the whole connection.
         registerClientGlobalApiHandlers(this.connection, this.clientGlobalHandlers);
 
+        // `hooks.invoke` is an internal RPC method: the runtime calls it to
+        // invoke a hook callback on the client. Route each call to the matching
+        // session's dispatcher. Not part of the public ClientGlobalApiHandlers
+        // interface because HookInvokeRequest/HookType are internal types.
+        this.connection.onRequest(
+            "hooks.invoke",
+            async (params: { sessionId: string; hookType: string; input: unknown }) => {
+                return await this.handleHooksInvoke(params);
+            }
+        );
+
         this.connection.onClose(() => {
             this.state = "disconnected";
         });

nodejs/src/generated/rpc.ts

@@ -3139,16 +3139,47 @@ describe("CopilotClient", () => {
             expect(failureCalls).toEqual(["fail-tool"]);
         });
 
+        it("registers hooks.invoke on the JSON-RPC connection and routes it to handleHooksInvoke", async () => {
+            const client = new CopilotClient();
+            const handleHooksInvoke = vi
+                .spyOn(client as any, "handleHooksInvoke")
+                .mockResolvedValue({ output: { additionalContext: "ok" } });
+
+            const fakeConnection = {
+                onNotification: vi.fn(),
+                onRequest: vi.fn(),
+                onClose: vi.fn(),
+                onError: vi.fn(),
+            };
+
+            (client as any).connection = fakeConnection;
+            (client as any).attachConnectionHandlers();
+
+            const hooksRegistration = fakeConnection.onRequest.mock.calls.find(
+                ([method]: [string, unknown]) => method === "hooks.invoke"
+            );
+            expect(hooksRegistration).toBeDefined();
+
+            const handler = hooksRegistration![1] as (params: {
+                sessionId: string;
+                hookType: string;
+                input: unknown;
+            }) => Promise<{ output?: unknown }>;
+            const payload = {
+                sessionId: "session-1",
+                hookType: "postToolUseFailure",
+                input: { toolName: "shell" },
+            };
+
+            await expect(handler(payload)).resolves.toEqual({
+                output: { additionalContext: "ok" },
+            });
+            expect(handleHooksInvoke).toHaveBeenCalledWith(payload);
+        });
+
         it("routes hooks.invoke JSON-RPC requests to the SessionHooks handler", async () => {
-            // Validates the full JSON-RPC entry point used by the CLI:
-            // clientGlobalHandlers.hooks.invoke({sessionId, hookType, input})
-            // → CopilotSession._handleHooksInvoke(hookType, input)
-            // → SessionHooks.onPostToolUseFailure(normalizedInput, {sessionId})
-            //
-            // This guards the wire-format contract that the bundled Copilot
-            // CLI relies on: the hookType string "postToolUseFailure" and the
-            // input shape `{toolName, toolArgs, error, timestamp, cwd}`.
-            // The SDK maps that to public `{..., timestamp: Date, workingDirectory}`.
+            // Validates the dispatch behavior for the internal `hooks.invoke`
+            // payload after the JSON-RPC connection hands it to the SDK.
             const client = new CopilotClient();
             await client.start();
             onTestFinished(() => stopClient(client));
@@ -3172,7 +3203,7 @@ describe("CopilotClient", () => {
                 cwd: "/tmp",
             };
 
-            const response = await (client as any).clientGlobalHandlers.hooks.invoke({
+            const response = await (client as any).handleHooksInvoke({
                 sessionId: session.sessionId,
                 hookType: "postToolUseFailure",
                 input: failureInput,
@@ -3249,7 +3280,7 @@ describe("CopilotClient", () => {
                 },
             });
 
-            const response = await (client as any).clientGlobalHandlers.hooks.invoke({
+            const response = await (client as any).handleHooksInvoke({
                 sessionId: session.sessionId,
                 hookType: "agentStop",
                 input: {