TS: emit JSON-RPC error on pending-buffer overflow + guard drop

Carries forward the Rust SDK PR #1394 follow-up review feedback into the
TS port:

1. Cap the per-session inbound-request parked-waiter list at 128. When
   exceeded, reject the oldest waiter with 'pending session buffer
   overflow'. vscode-jsonrpc translates the rejection into a JSON-RPC
   error response (-32603) back to the runtime so the request id isn't
   left hanging — silently dropping it would leave the runtime waiting
   on the response until its own timeout. Mirrors Rust commit 491b442.

2. Use a distinct message ('pending session routing ended before
   session was registered') when the pending guard drops without
   registration. Lets debugging tell the overflow path from the
   create-failed path. Mirrors Rust commit e0ff254.

Adds two tests:
- overflow path resolves to overflow error for the oldest waiter,
  remaining 128 resolve normally after registration
- guard-drop path rejects parked waiters with the distinct message

Author: tclem

nodejs/src/client.ts

@@ -1129,9 +1129,12 @@ export class CopilotClient {
                     this.pendingSessionEvents.clear();
                     for (const waiters of this.pendingSessionWaiters.values()) {
                         for (const w of waiters) {
+                            // Distinct phrasing from the overflow-eviction path so the
+                            // runtime / future debugging can tell the two cases apart.
+                            // Matches the Rust SDK message in PR #1394 (commit e0ff254f).
                             w.reject(
                                 new Error(
-                                    "Cloud session.create completed without registering this sessionId; request dropped"
+                                    "pending session routing ended before session was registered"
                                 )
                             );
                         }
@@ -2271,6 +2274,18 @@ export class CopilotClient {
                     waiters = [];
                     this.pendingSessionWaiters.set(sessionId, waiters);
                 }
+                // Cap parked waiters per session id. When exceeded, reject the
+                // oldest with a distinct message; vscode-jsonrpc surfaces the
+                // rejection as a JSON-RPC error response to the runtime (rather
+                // than silently dropping, which would hang the runtime on the
+                // request id). Matches the Rust SDK fix in PR #1394 (commit
+                // 491b4427).
+                if (waiters.length >= CopilotClient.PENDING_SESSION_BUFFER_LIMIT) {
+                    const oldest = waiters.shift();
+                    if (oldest) {
+                        oldest.reject(new Error("pending session buffer overflow"));
+                    }
+                }
                 waiters.push({ resolve, reject });
             });
         }

nodejs/test/client.test.ts

@@ -213,6 +213,96 @@ describe("CopilotClient", () => {
         await expect(parked).resolves.toEqual({ answer: "yes", wasFreeform: false });
     });
 
+    it("rejects parked requests with overflow error when buffer cap exceeded", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        let resolveCreate: ((value: unknown) => void) | undefined;
+        vi.spyOn((client as any).connection!, "sendRequest").mockImplementation(
+            (method: unknown) => {
+                if (method !== "session.create") return Promise.resolve({});
+                return new Promise((resolve) => {
+                    resolveCreate = resolve;
+                });
+            }
+        );
+
+        const sessionPromise = client.createCloudSession({
+            onPermissionRequest: approveAll,
+            cloud: { repository: { owner: "github", name: "copilot-sdk" } },
+            onUserInputRequest: async () => ({ answer: "ok", wasFreeform: false }),
+        });
+        await new Promise<void>((r) => setImmediate(r));
+
+        const handler = (
+            client as unknown as {
+                handleUserInputRequest: (p: {
+                    sessionId: string;
+                    question: string;
+                }) => Promise<{ answer: string; wasFreeform: boolean }>;
+            }
+        ).handleUserInputRequest.bind(client);
+
+        // Park 128 + 1 requests; the oldest must reject with overflow message.
+        // vscode-jsonrpc translates the rejection into a JSON-RPC error response
+        // back to the runtime so the request id isn't left hanging.
+        const parked: Promise<unknown>[] = [];
+        for (let i = 0; i < 129; i++) {
+            parked.push(handler({ sessionId: "cloud-session", question: `q${i}` }));
+        }
+
+        await expect(parked[0]).rejects.toThrow(/pending session buffer overflow/);
+
+        resolveCreate!({ sessionId: "cloud-session" });
+        await sessionPromise;
+
+        // The remaining 128 parked requests resolve after registration.
+        for (let i = 1; i < 129; i++) {
+            await expect(parked[i]).resolves.toEqual({ answer: "ok", wasFreeform: false });
+        }
+    });
+
+    it("rejects parked requests when pending routing ends without registration", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        let rejectCreate: ((err: Error) => void) | undefined;
+        vi.spyOn((client as any).connection!, "sendRequest").mockImplementation(
+            (method: unknown) => {
+                if (method !== "session.create") return Promise.resolve({});
+                return new Promise((_resolve, reject) => {
+                    rejectCreate = reject;
+                });
+            }
+        );
+
+        const sessionPromise = client.createCloudSession({
+            onPermissionRequest: approveAll,
+            cloud: { repository: { owner: "github", name: "copilot-sdk" } },
+        });
+        await new Promise<void>((r) => setImmediate(r));
+
+        const parked = (
+            client as unknown as {
+                handleUserInputRequest: (p: {
+                    sessionId: string;
+                    question: string;
+                }) => Promise<{ answer: string; wasFreeform: boolean }>;
+            }
+        ).handleUserInputRequest({ sessionId: "cloud-session", question: "ok?" });
+
+        // session.create fails before registration; guard drop must reject all
+        // parked waiters with a distinct message (separate from overflow).
+        rejectCreate!(new Error("create failed"));
+        await expect(sessionPromise).rejects.toThrow();
+
+        await expect(parked).rejects.toThrow(
+            /pending session routing ended before session was registered/
+        );
+    });
+
     it("forwards clientName in session.resume request", async () => {
         const client = new CopilotClient();
         await client.start();