@gea-ai/agent-sdk 0.1.261009-alpha.0 → 0.1.261009-alpha.1

package/dist/agent-worker.js

@@ -4207,6 +4207,9 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
     };
     let terminalMessage;
     let terminalEvent;
+    // Inbox suspension is a live protocol frame, not a journaled response end.
+    // Hold it until the final context commit so a failed commit cannot publish waiting.
+    let liveFinish;
     const saveResponseMessage = async ({ responseMessage, }) => {
         const saveStartedAt = performance.now();
         const metadata = await contextFinished;
@@ -4224,6 +4227,21 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         }
         if (inboxRunner?.suspended)
             context.metadata.suspendedMessageId = responseMessage.id;
+        const needsInput = !inboxRunner?.suspended &&
+            responseMessage.parts.some((part) => "state" in part &&
+                (part.state === "approval-requested" ||
+                    (part.state === "input-available" &&
+                        input.snapshot.tools.some((tool) => tool.type === "custom" &&
+                            tool.execution === "client" &&
+                            part.type === `tool-${tool.name}`))));
+        // The same metadata object is held by the deferred finish frame. Do not
+        // publish waiting until the final context commit succeeds; a failed commit
+        // seals the call as failed and must not leave the message looking suspended.
+        const markWaiting = !failure &&
+            (needsInput ||
+                Boolean(inboxRunner?.suspended && metadata.sessionStatus === "waiting"));
+        if (markWaiting)
+            delete metadata.sessionStatus;
         responseMessage.metadata = {
             ...responseMessage.metadata,
             ...metadata,
@@ -4276,19 +4294,39 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             }
             throw error;
         }
+        if (markWaiting) {
+            metadata.sessionStatus = "waiting";
+            responseMessage.metadata = {
+                ...responseMessage.metadata,
+                sessionStatus: "waiting",
+            };
+            if (terminalMessage) {
+                terminalMessage = {
+                    ...terminalMessage,
+                    metadata: {
+                        ...terminalMessage.metadata,
+                        sessionStatus: "waiting",
+                    },
+                };
+            }
+            else if (sessionExecution) {
+                await mutateSession({ messages: [{ ...responseMessage }] });
+            }
+            else {
+                await appendSessionValue({
+                    body: { message: responseMessage, runId: payload.runId },
+                    chatId: payload.chatId,
+                    namespace: input.sessionNamespace,
+                    path: "/v1/messages",
+                });
+            }
+        }
         const contextPersistedAt = performance.now();
         persistenceSpan?.setAttributes({
             "gea.session.finish.context_wait_ms": Math.round(contextFinishedAt - saveStartedAt),
             "gea.session.finish.transcript_ms": Math.round(transcriptFinishedAt - transcriptStartedAt),
             "gea.session.finish.context_write_ms": Math.round(contextPersistedAt - transcriptFinishedAt),
         });
-        const needsInput = !inboxRunner?.suspended &&
-            responseMessage.parts.some((part) => "state" in part &&
-                (part.state === "approval-requested" ||
-                    (part.state === "input-available" &&
-                        input.snapshot.tools.some((tool) => tool.type === "custom" &&
-                            tool.execution === "client" &&
-                            part.type === `tool-${tool.name}`))));
         ownSessionOutcome({
             ...(needsInput
                 ? {
@@ -4957,14 +4995,19 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                         finishReason: metadata.finishReason,
                         messageMetadata: metadata,
                     };
-                    if (metadata.sessionStatus === "waiting") {
-                        controller.enqueue(chunk);
+                    if (inboxRunner?.suspended && metadata.finishReason !== "error") {
+                        // onFinish commits context before this frame is published. The
+                        // journal keeps the resumed response's finish, not this boundary.
+                        liveFinish = chunk;
                         continue;
                     }
-                    if (sessionExecution &&
-                        !input.channelJournal &&
-                        !inboxRunner?.suspended &&
-                        metadata.finishReason === "stop") {
+                    if (metadata.finishReason === "tool-calls" ||
+                        (sessionExecution &&
+                            !input.channelJournal &&
+                            !inboxRunner?.suspended &&
+                            metadata.finishReason === "stop")) {
+                        // onFinish commits context before publishing waiting metadata.
+                        // Flush emits this frame only after that commit returns.
                         terminalEvent = chunk;
                         continue;
                     }
@@ -4982,16 +5025,26 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                 controller.enqueue(event);
         },
         async flush(controller) {
-            if (!terminalMessage && !terminalEvent)
+            if (!terminalMessage && !terminalEvent && !liveFinish)
                 return;
-            const startedAt = performance.now();
-            await mutateSession({
-                ...(terminalMessage ? { messages: [{ ...terminalMessage }] } : {}),
-                ...(terminalEvent ? { events: [terminalEvent] } : {}),
-            });
-            persistenceSpan?.setAttribute("gea.session.finish.transcript_ms", Math.round(performance.now() - startedAt));
+            if (terminalMessage || terminalEvent) {
+                const startedAt = performance.now();
+                if (sessionExecution) {
+                    await mutateSession({
+                        ...(terminalMessage
+                            ? { messages: [{ ...terminalMessage }] }
+                            : {}),
+                        ...(terminalEvent ? { events: [terminalEvent] } : {}),
+                    });
+                }
+                else if (terminalEvent)
+                    await appendStreamEvent(terminalEvent);
+                persistenceSpan?.setAttribute("gea.session.finish.transcript_ms", Math.round(performance.now() - startedAt));
+            }
             if (terminalEvent)
                 controller.enqueue(terminalEvent);
+            if (liveFinish)
+                controller.enqueue(liveFinish);
         },
     }));
     if (engine || sessionExecution) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const agentSdkVersion = "0.1.261009-alpha.0";
+export declare const agentSdkVersion = "0.1.261009-alpha.1";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Generated by scripts/build-sdk-version.mjs from package.json.
-export const agentSdkVersion = "0.1.261009-alpha.0";
+export const agentSdkVersion = "0.1.261009-alpha.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gea-ai/agent-sdk",
-  "version": "0.1.261009-alpha.0",
+  "version": "0.1.261009-alpha.1",
   "private": false,
   "homepage": "https://musegea.com/developers",
   "license": "Apache-2.0",
@@ -119,7 +119,7 @@
     "@ai-sdk/otel": "1.0.119",
     "@ai-sdk/provider": "4.0.19",
     "@ai-sdk/provider-utils": "5.0.50",
-    "@gea-ai/contract": "0.1.261009-alpha.0",
+    "@gea-ai/contract": "0.1.261009-alpha.1",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/context-async-hooks": "2.10.0",
     "@opentelemetry/core": "2.10.0",