fix(node): preserve first sendAndWait outcome

Use a shared terminal latch so a later shutdown cannot override an earlier idle or error while the send RPC is still pending.

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

Author: connor4312

nodejs/src/session.ts

@@ -754,6 +754,17 @@ export class CopilotSession {
         const shutdownPromise = new Promise<Error>((resolve) => {
             resolveShutdown = resolve;
         });
+        let outcomeSettled = false;
+        const settleOutcome = (outcome: SessionOutcome, shutdown = false): void => {
+            if (outcomeSettled) {
+                return;
+            }
+            outcomeSettled = true;
+            resolveOutcome(outcome);
+            if (shutdown && outcome.kind === "error") {
+                resolveShutdown(outcome.error);
+            }
+        };
 
         let lastAssistantMessage: AssistantMessageEvent | undefined;
 
@@ -763,29 +774,29 @@ export class CopilotSession {
             if (event.type === "assistant.message") {
                 lastAssistantMessage = event;
             } else if (event.type === "session.idle") {
-                resolveOutcome({ kind: "idle" });
+                settleOutcome({ kind: "idle" });
             } else if (event.type === "session.error") {
                 const error = new Error(event.data.message);
                 error.stack = event.data.stack;
-                resolveOutcome({ kind: "error", error });
+                settleOutcome({ kind: "error", error });
             } else if (event.type === "session.shutdown") {
                 const reason = event.data.errorReason ? `: ${event.data.errorReason}` : "";
                 const error = new Error(
                     `Session ${this.sessionId} shut down before becoming idle${reason}`
                 );
-                resolveOutcome({ kind: "error", error });
-                resolveShutdown(error);
+                settleOutcome({ kind: "error", error }, true);
             }
         });
 
         let timeoutId: ReturnType<typeof setTimeout> | undefined;
         try {
-            await Promise.race([
-                this.send(options),
-                shutdownPromise.then((error) => {
-                    throw error;
-                }),
+            const sendResult = await Promise.race([
+                this.send(options).then(() => ({ kind: "sent" }) as const),
+                shutdownPromise.then((error) => ({ kind: "shutdown", error }) as const),
             ]);
+            if (sendResult.kind === "shutdown") {
+                throw sendResult.error;
+            }
 
             const timeoutPromise = new Promise<never>((_, reject) => {
                 timeoutId = setTimeout(

nodejs/test/session-send-and-wait.test.ts

@@ -112,6 +112,7 @@ describe("sendAndWait", () => {
         await sendStarted;
 
         session._dispatchEvent(sessionEvent("session.idle"));
+        session._dispatchEvent(shutdownEvent("later shutdown"));
 
         const stateBeforeSend = await Promise.race([
             pending.then(() => "settled"),