@trigger.dev/sdk 0.0.0-prerelease-20260304181730 → 0.0.0-prerelease-20260305142821

package/dist/commonjs/v3/chat.test.js

@@ -516,6 +516,7 @@ const sampleChunks = [
     (0, vitest_1.describe)("multiple sessions", () => {
         (0, vitest_1.it)("should track multiple chat sessions independently", async () => {
             let callCount = 0;
+            const turnCompleteChunk = { type: "__trigger_turn_complete" };
             global.fetch = vitest_1.vi.fn().mockImplementation(async (url) => {
                 const urlStr = typeof url === "string" ? url : url.toString();
                 if (urlStr.includes("/trigger")) {
@@ -529,7 +530,9 @@ const sampleChunks = [
                     });
                 }
                 if (urlStr.includes("/realtime/v1/streams/")) {
-                    return new Response(createSSEStream(""), {
+                    // Include turn-complete chunk so the session is preserved
+                    const chunks = [...sampleChunks, turnCompleteChunk];
+                    return new Response(createSSEStream(sseEncode(chunks)), {
                         status: 200,
                         headers: {
                             "content-type": "text/event-stream",
@@ -544,21 +547,25 @@ const sampleChunks = [
                 accessToken: "token",
                 baseURL: "https://api.test.trigger.dev",
             });
-            // Start two independent chat sessions
-            await transport.sendMessages({
+            // Start two independent chat sessions and consume the streams
+            const s1 = await transport.sendMessages({
                 trigger: "submit-message",
                 chatId: "session-a",
                 messageId: undefined,
                 messages: [createUserMessage("Hello A")],
                 abortSignal: undefined,
             });
-            await transport.sendMessages({
+            const r1 = s1.getReader();
+            while (!(await r1.read()).done) { }
+            const s2 = await transport.sendMessages({
                 trigger: "submit-message",
                 chatId: "session-b",
                 messageId: undefined,
                 messages: [createUserMessage("Hello B")],
                 abortSignal: undefined,
             });
+            const r2 = s2.getReader();
+            while (!(await r2.read()).done) { }
             // Both sessions should be independently reconnectable
             const streamA = await transport.reconnectToStream({ chatId: "session-a" });
             const streamB = await transport.reconnectToStream({ chatId: "session-b" });
@@ -727,11 +734,7 @@ const sampleChunks = [
     });
     (0, vitest_1.describe)("lastEventId tracking", () => {
         (0, vitest_1.it)("should pass lastEventId to SSE subscription on subsequent turns", async () => {
-            const controlChunk = {
-                type: "__trigger_waitpoint_ready",
-                tokenId: "wp_token_eid",
-                publicAccessToken: "wp_access_eid",
-            };
+            const turnCompleteChunk = { type: "__trigger_turn_complete" };
             let triggerCallCount = 0;
             const streamFetchCalls = [];
             global.fetch = vitest_1.vi.fn().mockImplementation(async (url, init) => {
@@ -746,8 +749,9 @@ const sampleChunks = [
                         },
                     });
                 }
-                if (urlStr.includes("/api/v1/waitpoints/tokens/") && urlStr.includes("/complete")) {
-                    return new Response(JSON.stringify({ success: true }), {
+                // Handle input stream sends (for second message)
+                if (urlStr.includes("/realtime/v1/streams/") && urlStr.includes("/input/")) {
+                    return new Response(JSON.stringify({ ok: true }), {
                         status: 200,
                         headers: { "content-type": "application/json" },
                     });
@@ -760,7 +764,7 @@ const sampleChunks = [
                     const chunks = [
                         ...sampleChunks,
                         { type: "finish", id: "part-1" },
-                        controlChunk,
+                        turnCompleteChunk,
                     ];
                     return new Response(createSSEStream(sseEncode(chunks)), {
                         status: 200,
@@ -791,7 +795,7 @@ const sampleChunks = [
                 if (done)
                     break;
             }
-            // Second message — completes the waitpoint
+            // Second message — sends via input stream
             const stream2 = await transport.sendMessages({
                 trigger: "submit-message",
                 chatId: "chat-eid",
@@ -812,13 +816,125 @@ const sampleChunks = [
             (0, vitest_1.expect)(secondStreamHeaders["Last-Event-ID"]).toBeDefined();
         });
     });
+    (0, vitest_1.describe)("minimal wire payloads", () => {
+        (0, vitest_1.it)("should send only new messages via input stream on turn 2+", async () => {
+            const turnCompleteChunk = { type: "__trigger_turn_complete" };
+            const inputStreamPayloads = [];
+            global.fetch = vitest_1.vi.fn().mockImplementation(async (url, init) => {
+                const urlStr = typeof url === "string" ? url : url.toString();
+                if (urlStr.includes("/api/v1/tasks/") && urlStr.includes("/trigger")) {
+                    return new Response(JSON.stringify({ id: "run_minimal" }), {
+                        status: 200,
+                        headers: {
+                            "content-type": "application/json",
+                            "x-trigger-jwt": "pub_token_minimal",
+                        },
+                    });
+                }
+                // Capture input stream payloads (ApiClient wraps in { data: ... })
+                if (urlStr.includes("/realtime/v1/streams/") && urlStr.includes("/input/")) {
+                    const body = JSON.parse(init?.body);
+                    inputStreamPayloads.push(body.data);
+                    return new Response(JSON.stringify({ ok: true }), {
+                        status: 200,
+                        headers: { "content-type": "application/json" },
+                    });
+                }
+                if (urlStr.includes("/realtime/v1/streams/")) {
+                    const chunks = [
+                        ...sampleChunks,
+                        turnCompleteChunk,
+                    ];
+                    return new Response(createSSEStream(sseEncode(chunks)), {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/event-stream",
+                            "X-Stream-Version": "v1",
+                        },
+                    });
+                }
+                throw new Error(`Unexpected fetch URL: ${urlStr}`);
+            });
+            const transport = new chat_js_1.TriggerChatTransport({
+                task: "my-task",
+                accessToken: "token",
+                baseURL: "https://api.test.trigger.dev",
+            });
+            const userMsg1 = createUserMessage("Hello");
+            const assistantMsg = createAssistantMessage("Hi there!");
+            const userMsg2 = createUserMessage("What's up?");
+            // Turn 1 — triggers a new run with full history
+            const stream1 = await transport.sendMessages({
+                trigger: "submit-message",
+                chatId: "chat-minimal",
+                messageId: undefined,
+                messages: [userMsg1],
+                abortSignal: undefined,
+            });
+            const r1 = stream1.getReader();
+            while (!(await r1.read()).done) { }
+            // Turn 2 — sends via input stream, should only include NEW messages
+            const stream2 = await transport.sendMessages({
+                trigger: "submit-message",
+                chatId: "chat-minimal",
+                messageId: undefined,
+                messages: [userMsg1, assistantMsg, userMsg2],
+                abortSignal: undefined,
+            });
+            const r2 = stream2.getReader();
+            while (!(await r2.read()).done) { }
+            // Verify: the input stream payload should only contain the new user message
+            (0, vitest_1.expect)(inputStreamPayloads).toHaveLength(1);
+            const sentPayload = inputStreamPayloads[0];
+            // Only the new user message should be sent (backend already has the assistant response)
+            (0, vitest_1.expect)(sentPayload.messages).toHaveLength(1);
+            (0, vitest_1.expect)(sentPayload.messages[0]).toEqual(userMsg2);
+        });
+        (0, vitest_1.it)("should send full history on first message (trigger)", async () => {
+            let triggerPayload;
+            global.fetch = vitest_1.vi.fn().mockImplementation(async (url, init) => {
+                const urlStr = typeof url === "string" ? url : url.toString();
+                if (urlStr.includes("/api/v1/tasks/") && urlStr.includes("/trigger")) {
+                    triggerPayload = JSON.parse(init?.body);
+                    return new Response(JSON.stringify({ id: "run_full" }), {
+                        status: 200,
+                        headers: {
+                            "content-type": "application/json",
+                            "x-trigger-jwt": "pub_token_full",
+                        },
+                    });
+                }
+                if (urlStr.includes("/realtime/v1/streams/")) {
+                    return new Response(createSSEStream(sseEncode(sampleChunks)), {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/event-stream",
+                            "X-Stream-Version": "v1",
+                        },
+                    });
+                }
+                throw new Error(`Unexpected fetch URL: ${urlStr}`);
+            });
+            const transport = new chat_js_1.TriggerChatTransport({
+                task: "my-task",
+                accessToken: "token",
+                baseURL: "https://api.test.trigger.dev",
+            });
+            const messages = [createUserMessage("Hello"), createAssistantMessage("Hi!"), createUserMessage("More")];
+            await transport.sendMessages({
+                trigger: "submit-message",
+                chatId: "chat-full",
+                messageId: undefined,
+                messages,
+                abortSignal: undefined,
+            });
+            // First message always sends full history via trigger
+            (0, vitest_1.expect)(triggerPayload.payload.messages).toHaveLength(3);
+        });
+    });
     (0, vitest_1.describe)("AbortController cleanup", () => {
         (0, vitest_1.it)("should terminate SSE connection after intercepting control chunk", async () => {
-            const controlChunk = {
-                type: "__trigger_waitpoint_ready",
-                tokenId: "wp_token_abort",
-                publicAccessToken: "wp_access_abort",
-            };
+            const controlChunk = { type: "__trigger_turn_complete" };
             let streamAborted = false;
             global.fetch = vitest_1.vi.fn().mockImplementation(async (url, init) => {
                 const urlStr = typeof url === "string" ? url : url.toString();
@@ -925,14 +1041,10 @@ const sampleChunks = [
             });
             (0, vitest_1.expect)(tokenCallCount).toBe(1);
         });
-        (0, vitest_1.it)("should resolve async token for waitpoint completion flow", async () => {
-            const controlChunk = {
-                type: "__trigger_waitpoint_ready",
-                tokenId: "wp_token_async",
-                publicAccessToken: "wp_access_async",
-            };
+        (0, vitest_1.it)("should not resolve async token for input stream send flow", async () => {
+            const turnCompleteChunk = { type: "__trigger_turn_complete" };
             let tokenCallCount = 0;
-            let completeWaitpointCalled = false;
+            let inputStreamSendCalled = false;
             global.fetch = vitest_1.vi.fn().mockImplementation(async (url) => {
                 const urlStr = typeof url === "string" ? url : url.toString();
                 if (urlStr.includes("/api/v1/tasks/") && urlStr.includes("/trigger")) {
@@ -944,9 +1056,10 @@ const sampleChunks = [
                         },
                     });
                 }
-                if (urlStr.includes("/api/v1/waitpoints/tokens/") && urlStr.includes("/complete")) {
-                    completeWaitpointCalled = true;
-                    return new Response(JSON.stringify({ success: true }), {
+                // Handle input stream sends
+                if (urlStr.includes("/realtime/v1/streams/") && urlStr.includes("/input/")) {
+                    inputStreamSendCalled = true;
+                    return new Response(JSON.stringify({ ok: true }), {
                         status: 200,
                         headers: { "content-type": "application/json" },
                     });
@@ -955,7 +1068,7 @@ const sampleChunks = [
                     const chunks = [
                         ...sampleChunks,
                         { type: "finish", id: "part-1" },
-                        controlChunk,
+                        turnCompleteChunk,
                     ];
                     return new Response(createSSEStream(sseEncode(chunks)), {
                         status: 200,
@@ -991,7 +1104,7 @@ const sampleChunks = [
                     break;
             }
             const firstTokenCount = tokenCallCount;
-            // Second message — should complete waitpoint (does NOT call async token)
+            // Second message — should send via input stream (does NOT call async token)
             const stream2 = await transport.sendMessages({
                 trigger: "submit-message",
                 chatId: "chat-async-wp",
@@ -1005,18 +1118,14 @@ const sampleChunks = [
                 if (done)
                     break;
             }
-            // Token function should NOT have been called again for the waitpoint path
+            // Token function should NOT have been called again for the input stream path
             (0, vitest_1.expect)(tokenCallCount).toBe(firstTokenCount);
-            (0, vitest_1.expect)(completeWaitpointCalled).toBe(true);
+            (0, vitest_1.expect)(inputStreamSendCalled).toBe(true);
         });
     });
-    (0, vitest_1.describe)("single-run mode (waitpoint loop)", () => {
-        (0, vitest_1.it)("should store waitpoint token from control chunk and not forward it to consumer", async () => {
-            const controlChunk = {
-                type: "__trigger_waitpoint_ready",
-                tokenId: "wp_token_123",
-                publicAccessToken: "wp_access_abc",
-            };
+    (0, vitest_1.describe)("single-run mode (input stream loop)", () => {
+        (0, vitest_1.it)("should not forward turn-complete control chunk to consumer", async () => {
+            const turnCompleteChunk = { type: "__trigger_turn_complete" };
             global.fetch = vitest_1.vi.fn().mockImplementation(async (url) => {
                 const urlStr = typeof url === "string" ? url : url.toString();
                 if (urlStr.includes("/trigger")) {
@@ -1032,7 +1141,7 @@ const sampleChunks = [
                     const chunks = [
                         ...sampleChunks,
                         { type: "finish", id: "part-1" },
-                        controlChunk,
+                        turnCompleteChunk,
                     ];
                     return new Response(createSSEStream(sseEncode(chunks)), {
                         status: 200,
@@ -1068,16 +1177,12 @@ const sampleChunks = [
             // All AI SDK chunks should be forwarded
             (0, vitest_1.expect)(receivedChunks.length).toBe(sampleChunks.length + 1); // +1 for the finish chunk
             // Control chunk should not be in the output
-            (0, vitest_1.expect)(receivedChunks.every((c) => c.type !== "__trigger_waitpoint_ready")).toBe(true);
+            (0, vitest_1.expect)(receivedChunks.every((c) => c.type !== "__trigger_turn_complete")).toBe(true);
         });
-        (0, vitest_1.it)("should complete waitpoint token on second message instead of triggering a new run", async () => {
-            const controlChunk = {
-                type: "__trigger_waitpoint_ready",
-                tokenId: "wp_token_456",
-                publicAccessToken: "wp_access_def",
-            };
+        (0, vitest_1.it)("should send via input stream on second message instead of triggering a new run", async () => {
+            const turnCompleteChunk = { type: "__trigger_turn_complete" };
             let triggerCallCount = 0;
-            let completeWaitpointCalled = false;
+            let inputStreamSendCalled = false;
             global.fetch = vitest_1.vi.fn().mockImplementation(async (url, init) => {
                 const urlStr = typeof url === "string" ? url : url.toString();
                 if (urlStr.includes("/api/v1/tasks/") && urlStr.includes("/trigger")) {
@@ -1090,10 +1195,10 @@ const sampleChunks = [
                         },
                     });
                 }
-                // Handle waitpoint token completion
-                if (urlStr.includes("/api/v1/waitpoints/tokens/") && urlStr.includes("/complete")) {
-                    completeWaitpointCalled = true;
-                    return new Response(JSON.stringify({ success: true }), {
+                // Handle input stream sends
+                if (urlStr.includes("/realtime/v1/streams/") && urlStr.includes("/input/")) {
+                    inputStreamSendCalled = true;
+                    return new Response(JSON.stringify({ ok: true }), {
                         status: 200,
                         headers: { "content-type": "application/json" },
                     });
@@ -1102,7 +1207,7 @@ const sampleChunks = [
                     const chunks = [
                         ...sampleChunks,
                         { type: "finish", id: "part-1" },
-                        controlChunk,
+                        turnCompleteChunk,
                     ];
                     return new Response(createSSEStream(sseEncode(chunks)), {
                         status: 200,
@@ -1127,7 +1232,7 @@ const sampleChunks = [
                 messages: [createUserMessage("Hello")],
                 abortSignal: undefined,
             });
-            // Consume stream to capture the control chunk
+            // Consume stream
             const reader1 = stream1.getReader();
             while (true) {
                 const { done } = await reader1.read();
@@ -1135,7 +1240,7 @@ const sampleChunks = [
                     break;
             }
             (0, vitest_1.expect)(triggerCallCount).toBe(1);
-            // Second message — should complete the waitpoint instead of triggering
+            // Second message — should send via input stream instead of triggering
             const stream2 = await transport.sendMessages({
                 trigger: "submit-message",
                 chatId: "chat-resume",
@@ -1152,8 +1257,8 @@ const sampleChunks = [
             }
             // Should NOT have triggered a second run
             (0, vitest_1.expect)(triggerCallCount).toBe(1);
-            // Should have completed the waitpoint
-            (0, vitest_1.expect)(completeWaitpointCalled).toBe(true);
+            // Should have sent via input stream
+            (0, vitest_1.expect)(inputStreamSendCalled).toBe(true);
         });
         (0, vitest_1.it)("should fall back to triggering a new run if stream closes without control chunk", async () => {
             let triggerCallCount = 0;
@@ -1217,12 +1322,8 @@ const sampleChunks = [
             // Should have triggered a second run
             (0, vitest_1.expect)(triggerCallCount).toBe(2);
         });
-        (0, vitest_1.it)("should fall back to new run when completing waitpoint fails", async () => {
-            const controlChunk = {
-                type: "__trigger_waitpoint_ready",
-                tokenId: "wp_token_fail",
-                publicAccessToken: "wp_access_fail",
-            };
+        (0, vitest_1.it)("should fall back to new run when sendInputStream fails", async () => {
+            const turnCompleteChunk = { type: "__trigger_turn_complete" };
             let triggerCallCount = 0;
             global.fetch = vitest_1.vi.fn().mockImplementation(async (url) => {
                 const urlStr = typeof url === "string" ? url : url.toString();
@@ -1236,22 +1337,19 @@ const sampleChunks = [
                         },
                     });
                 }
-                // Waitpoint completion fails
-                if (urlStr.includes("/api/v1/waitpoints/tokens/") && urlStr.includes("/complete")) {
-                    return new Response(JSON.stringify({ error: "Token expired" }), {
-                        status: 400,
+                // Input stream send fails
+                if (urlStr.includes("/realtime/v1/streams/") && urlStr.includes("/input/")) {
+                    return new Response(JSON.stringify({ error: "Run not found" }), {
+                        status: 404,
                         headers: { "content-type": "application/json" },
                     });
                 }
                 if (urlStr.includes("/realtime/v1/streams/")) {
-                    // First call has control chunk, subsequent calls don't
                     const chunks = [
                         ...sampleChunks,
                         { type: "finish", id: "part-1" },
+                        turnCompleteChunk,
                     ];
-                    if (triggerCallCount <= 1) {
-                        chunks.push(controlChunk);
-                    }
                     return new Response(createSSEStream(sseEncode(chunks)), {
                         status: 200,
                         headers: {
@@ -1282,7 +1380,7 @@ const sampleChunks = [
                     break;
             }
             (0, vitest_1.expect)(triggerCallCount).toBe(1);
-            // Second message — waitpoint completion will fail, should fall back to new run
+            // Second message — sendInputStream will fail, should fall back to new run
             const stream2 = await transport.sendMessages({
                 trigger: "submit-message",
                 chatId: "chat-fail",
@@ -1300,5 +1398,160 @@ const sampleChunks = [
             (0, vitest_1.expect)(triggerCallCount).toBe(2);
         });
     });
+    (0, vitest_1.describe)("onSessionChange", () => {
+        (0, vitest_1.it)("should fire when a new session is created", async () => {
+            const onSessionChange = vitest_1.vi.fn();
+            const triggerRunId = "run_session_new";
+            const publicToken = "pub_session_new";
+            global.fetch = vitest_1.vi.fn().mockImplementation(async (url) => {
+                const urlStr = typeof url === "string" ? url : url.toString();
+                if (urlStr.includes("/trigger")) {
+                    return new Response(JSON.stringify({ id: triggerRunId }), {
+                        status: 200,
+                        headers: {
+                            "content-type": "application/json",
+                            "x-trigger-jwt": publicToken,
+                        },
+                    });
+                }
+                if (urlStr.includes("/realtime/v1/streams/")) {
+                    const chunks = [
+                        ...sampleChunks,
+                        { type: "__trigger_turn_complete" },
+                    ];
+                    return new Response(createSSEStream(sseEncode(chunks)), {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/event-stream",
+                            "X-Stream-Version": "v1",
+                        },
+                    });
+                }
+                throw new Error(`Unexpected fetch URL: ${urlStr}`);
+            });
+            const transport = new chat_js_1.TriggerChatTransport({
+                task: "my-task",
+                accessToken: "token",
+                baseURL: "https://api.test.trigger.dev",
+                onSessionChange,
+            });
+            const stream = await transport.sendMessages({
+                trigger: "submit-message",
+                chatId: "chat-1",
+                messageId: undefined,
+                messages: [createUserMessage("Hello")],
+                abortSignal: undefined,
+            });
+            // Session created notification should have fired
+            (0, vitest_1.expect)(onSessionChange).toHaveBeenCalledWith("chat-1", {
+                runId: triggerRunId,
+                publicAccessToken: publicToken,
+                lastEventId: undefined,
+            });
+            // Consume stream
+            const reader = stream.getReader();
+            while (!(await reader.read()).done) { }
+            // Should also fire with updated lastEventId on turn complete
+            const lastCall = onSessionChange.mock.calls[onSessionChange.mock.calls.length - 1];
+            (0, vitest_1.expect)(lastCall[0]).toBe("chat-1");
+            (0, vitest_1.expect)(lastCall[1]).not.toBeNull();
+            (0, vitest_1.expect)(lastCall[1].lastEventId).toBeDefined();
+        });
+        (0, vitest_1.it)("should fire with null when session is deleted (stream ends naturally)", async () => {
+            const onSessionChange = vitest_1.vi.fn();
+            global.fetch = vitest_1.vi.fn().mockImplementation(async (url) => {
+                const urlStr = typeof url === "string" ? url : url.toString();
+                if (urlStr.includes("/trigger")) {
+                    return new Response(JSON.stringify({ id: "run_end" }), {
+                        status: 200,
+                        headers: {
+                            "content-type": "application/json",
+                            "x-trigger-jwt": "pub_end",
+                        },
+                    });
+                }
+                if (urlStr.includes("/realtime/v1/streams/")) {
+                    // No turn-complete chunk — stream ends naturally (run completed)
+                    return new Response(createSSEStream(sseEncode(sampleChunks)), {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/event-stream",
+                            "X-Stream-Version": "v1",
+                        },
+                    });
+                }
+                throw new Error(`Unexpected fetch URL: ${urlStr}`);
+            });
+            const transport = new chat_js_1.TriggerChatTransport({
+                task: "my-task",
+                accessToken: "token",
+                baseURL: "https://api.test.trigger.dev",
+                onSessionChange,
+            });
+            const stream = await transport.sendMessages({
+                trigger: "submit-message",
+                chatId: "chat-end",
+                messageId: undefined,
+                messages: [createUserMessage("Hello")],
+                abortSignal: undefined,
+            });
+            // Consume the stream fully
+            const reader = stream.getReader();
+            while (!(await reader.read()).done) { }
+            // Session should have been created then deleted
+            (0, vitest_1.expect)(onSessionChange).toHaveBeenCalledWith("chat-end", vitest_1.expect.objectContaining({
+                runId: "run_end",
+            }));
+            (0, vitest_1.expect)(onSessionChange).toHaveBeenCalledWith("chat-end", null);
+        });
+        (0, vitest_1.it)("should be updatable via setOnSessionChange", async () => {
+            const onSessionChange1 = vitest_1.vi.fn();
+            const onSessionChange2 = vitest_1.vi.fn();
+            global.fetch = vitest_1.vi.fn().mockImplementation(async (url) => {
+                const urlStr = typeof url === "string" ? url : url.toString();
+                if (urlStr.includes("/trigger")) {
+                    return new Response(JSON.stringify({ id: "run_update" }), {
+                        status: 200,
+                        headers: {
+                            "content-type": "application/json",
+                            "x-trigger-jwt": "pub_update",
+                        },
+                    });
+                }
+                if (urlStr.includes("/realtime/v1/streams/")) {
+                    const chunks = [
+                        ...sampleChunks,
+                        { type: "__trigger_turn_complete" },
+                    ];
+                    return new Response(createSSEStream(sseEncode(chunks)), {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/event-stream",
+                            "X-Stream-Version": "v1",
+                        },
+                    });
+                }
+                throw new Error(`Unexpected fetch URL: ${urlStr}`);
+            });
+            const transport = new chat_js_1.TriggerChatTransport({
+                task: "my-task",
+                accessToken: "token",
+                baseURL: "https://api.test.trigger.dev",
+                onSessionChange: onSessionChange1,
+            });
+            // Update the callback before sending
+            transport.setOnSessionChange(onSessionChange2);
+            await transport.sendMessages({
+                trigger: "submit-message",
+                chatId: "chat-update",
+                messageId: undefined,
+                messages: [createUserMessage("Hello")],
+                abortSignal: undefined,
+            });
+            // Only onSessionChange2 should have been called
+            (0, vitest_1.expect)(onSessionChange1).not.toHaveBeenCalled();
+            (0, vitest_1.expect)(onSessionChange2).toHaveBeenCalled();
+        });
+    });
 });
 //# sourceMappingURL=chat.test.js.map