@gea-ai/agent-sdk 0.1.260922-alpha.2 → 0.1.260922-alpha.3

package/dist/agent-session-execution.js

@@ -1,6 +1,7 @@
+import { digestAgentSessionMessage } from "./agent-session-transport.js";
 import { getSessionPayload, putSessionPayload } from "./agent-session-payload.js";
 import { agentModelCallsSchema, } from "@gea-ai/contract/agent-usage";
-import { AGENT_SESSION_COMPUTER_LEASE_MS, MAX_AGENT_SESSION_TRANSFER_BYTES, agentSessionTransferChunkSchema, agentSessionTransferReferenceSchema, agentSessionTransferIdentitySchema, agentSessionComputerSchema, agentSessionComputerReferenceSchema, AGENT_SESSION_EXECUTION_LEASE_MS, AGENT_SESSION_EXECUTION_PROTOCOL_VERSION, MAX_AGENT_SESSION_RESPONSE_BYTES, MAX_AGENT_SESSION_EXECUTION_ATTEMPTS, MAX_AGENT_SESSION_EXECUTION_BODY_BYTES, MAX_AGENT_SESSION_PAGE_SIZE, agentSessionAttemptIdentitySchema, agentSessionExecutionRenewSchema, agentSessionExecutionCompleteSchema, agentSessionExecutionPauseSchema, agentSessionExecutionControlSchema, agentSessionExecutionMutationSchema, agentSessionExecutionStartSchema, agentSessionExecutionPrepareSchema, } from "@gea-ai/contract/agent-session";
+import { AGENT_SESSION_COMPUTER_LEASE_MS, MAX_AGENT_SESSION_TRANSFER_BYTES, agentSessionTransferChunkSchema, agentSessionTransferReferenceSchema, agentSessionTransferIdentitySchema, agentSessionComputerSchema, agentSessionComputerReferenceSchema, AGENT_SESSION_EXECUTION_LEASE_MS, AGENT_SESSION_EXECUTION_PROTOCOL_VERSION, MAX_AGENT_SESSION_RESPONSE_BYTES, MAX_AGENT_SESSION_EXECUTION_ATTEMPTS, MAX_AGENT_SESSION_EXECUTION_BODY_BYTES, MAX_AGENT_SESSION_PAGE_SIZE, agentSessionAttemptIdentitySchema, agentSessionExecutionRenewSchema, agentSessionExecutionCompleteSchema, agentSessionExecutionCompleteStoredSchema, agentSessionExecutionPauseSchema, agentSessionExecutionControlSchema, agentSessionExecutionMutationSchema, agentSessionExecutionStartSchema, agentSessionExecutionPrepareSchema, } from "@gea-ai/contract/agent-session";
 import { z } from "zod";
 import { activeComputerOperation } from "./agent-session-computer.js";
 import { isAgentSessionInboxBusy, scheduleAgentSessionInbox, getAgentSessionRunState, handleAgentSessionInboxRequest, hasAgentSessionInbox, skipAgentSessionInputWait, } from "./agent-session-inbox.js";
@@ -506,12 +507,39 @@ export async function handleAgentSessionExecutionRequest(request, storage) {
                 return { duplicate: false, turn, revision };
             }));
         }
-        if (request.method === "POST" && url.pathname === "/v2/turns/complete") {
-            const input = agentSessionExecutionCompleteSchema.parse(await readBody(request, storage));
-            const inputDigest = await digest(input);
+        if (request.method === "POST" &&
+            (url.pathname === "/v2/turns/complete" ||
+                url.pathname === "/v2/turns/complete-stored")) {
+            const body = await readBody(request, storage);
+            const stored = url.pathname === "/v2/turns/complete-stored"
+                ? agentSessionExecutionCompleteStoredSchema.parse(body)
+                : undefined;
+            const { messageReferences: _references, ...storedValues } = stored ?? {};
+            const input = agentSessionExecutionCompleteSchema.parse(stored ? storedValues : body);
+            const storedRequestDigest = stored ? await digest(stored) : undefined;
+            const standardDigest = stored ? undefined : await digest(input);
             return json(await storage.transaction(async (tx) => {
                 const receiptKey = key(`outcome:${encodeURIComponent(input.runId)}`);
                 const existing = await tx.get(receiptKey);
+                if (stored && existing?.storedRequestDigest) {
+                    if (existing.storedRequestDigest !== storedRequestDigest)
+                        throw new SessionProtocolError("completion_mismatch");
+                    return { duplicate: true, outcome: existing.outcome };
+                }
+                if (stored) {
+                    for (const reference of stored.messageReferences) {
+                        const sequence = await tx.get(key(`message-id:${encodeURIComponent(reference.id)}`));
+                        const entry = sequence === undefined
+                            ? undefined
+                            : await getSessionPayload(tx, sequenceKey("message", sequence));
+                        if (!entry ||
+                            (await digestAgentSessionMessage(entry.message)) !==
+                                reference.sha256)
+                            throw new SessionProtocolError("stored_message_mismatch", 412);
+                        input.messages.push(entry.message);
+                    }
+                }
+                const inputDigest = standardDigest ?? (await digest(input));
                 if (existing) {
                     if (existing.digest !== inputDigest)
                         throw new SessionProtocolError("completion_mismatch");
@@ -566,7 +594,7 @@ export async function handleAgentSessionExecutionRequest(request, storage) {
                 if (input.context && input.context.runId !== input.runId)
                     throw new SessionProtocolError("context_run_mismatch");
                 const previousRevision = await readRevision(tx);
-                await writeValues(tx, input);
+                await writeValues(tx, stored ? { ...input, messages: [] } : input);
                 const modelCalls = await tx.get(key(`model-calls:${encodeURIComponent(input.runId)}`));
                 const outcome = {
                     ...(modelCalls === undefined
@@ -586,6 +614,7 @@ export async function handleAgentSessionExecutionRequest(request, storage) {
                 await tx.put(receiptKey, {
                     outcome,
                     digest: inputDigest,
+                    ...(storedRequestDigest ? { storedRequestDigest } : {}),
                 });
                 const rangeKey = key(`run-events:${encodeURIComponent(input.runId)}`);
                 const storedRange = await tx.get(rangeKey);

package/dist/agent-session-transport.d.ts

@@ -1,6 +1,10 @@
+import { type AgentSessionMessage } from "@gea-ai/contract/agent-session";
 /** Both hosted and in-Worker clients use the same bounded, non-retrying transport. */
 export declare function sendAgentSessionRequest(input: {
     path: string;
     body?: unknown;
     send: (path: string, body: string | undefined) => Promise<Response>;
 }): Promise<Response>;
+/** Compare message content independently of object-key insertion order. JSON
+ * serialization also gives Dates the same representation as persisted values. */
+export declare function digestAgentSessionMessage(message: AgentSessionMessage): Promise<string>;

package/dist/agent-session-transport.js

@@ -1,4 +1,4 @@
-import { AGENT_SESSION_TRANSFER_CHARS, agentSessionExecutionMutationSchema, agentSessionExecutionPauseSchema, agentSessionExecutionCompleteSchema, MAX_AGENT_SESSION_EXECUTION_BODY_BYTES, MAX_AGENT_SESSION_TRANSFER_BYTES, agentSessionAttemptIdentitySchema, agentSessionTransferIdentitySchema, } from "@gea-ai/contract/agent-session";
+import { AGENT_SESSION_TRANSFER_CHARS, agentSessionExecutionMutationSchema, agentSessionMessageSchema, agentSessionExecutionPauseSchema, agentSessionExecutionCompleteSchema, MAX_AGENT_SESSION_EXECUTION_BODY_BYTES, MAX_AGENT_SESSION_TRANSFER_BYTES, agentSessionAttemptIdentitySchema, agentSessionTransferIdentitySchema, } from "@gea-ai/contract/agent-session";
 /** Both hosted and in-Worker clients use the same bounded, non-retrying transport. */
 export async function sendAgentSessionRequest(input) {
     const serialized = input.body === undefined ? undefined : JSON.stringify(input.body);
@@ -49,3 +49,11 @@ export async function sendAgentSessionRequest(input) {
     }
     return input.send(input.path, JSON.stringify({ $agentSessionTransfer: { ...identity, chunks } }));
 }
+/** Compare message content independently of object-key insertion order. JSON
+ * serialization also gives Dates the same representation as persisted values. */
+export async function digestAgentSessionMessage(message) {
+    const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(agentSessionMessageSchema.parse(message), (_key, value) => value !== null && typeof value === "object" && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))
+        : value)));
+    return Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}

package/dist/agent-stream-coalescing.d.ts

@@ -4,3 +4,9 @@ import type { UIMessageChunk } from "ai";
  * Control events, tool results and part boundaries retain their exact order.
  */
 export declare function coalesceAgentTextDeltas<T extends UIMessageChunk>(stream: ReadableStream<T>): ReadableStream<T>;
+/** Group ready events for one durable mutation. Start/finish stay separate so
+ * first bytes are immediate and context settlement cannot hold back prior text.
+ * At most 5 ms, 64 events or 64 Ki serialized characters are collected. An
+ * oversized individual event uses the existing Session transfer protocol.
+ */
+export declare function batchAgentStreamEvents<T extends UIMessageChunk>(stream: ReadableStream<T>): ReadableStream<T[]>;

package/dist/agent-stream-coalescing.js

@@ -71,3 +71,86 @@ export function coalesceAgentTextDeltas(stream) {
         },
     });
 }
+/** Group ready events for one durable mutation. Start/finish stay separate so
+ * first bytes are immediate and context settlement cannot hold back prior text.
+ * At most 5 ms, 64 events or 64 Ki serialized characters are collected. An
+ * oversized individual event uses the existing Session transfer protocol.
+ */
+export function batchAgentStreamEvents(stream) {
+    const reader = stream.getReader();
+    let pending;
+    let held;
+    let failure;
+    let cancelled = false;
+    const read = () => (pending ??= reader.read());
+    const boundary = (chunk) => chunk.type === "start" ||
+        chunk.type === "finish" ||
+        chunk.type === "abort" ||
+        chunk.type === "error";
+    return new ReadableStream({
+        async pull(controller) {
+            let timer;
+            try {
+                if (failure)
+                    throw failure.error;
+                const first = held ?? (await read());
+                held = undefined;
+                pending = undefined;
+                if (cancelled)
+                    return;
+                if (first.done) {
+                    reader.releaseLock();
+                    controller.close();
+                    return;
+                }
+                const batch = [first.value];
+                let size = JSON.stringify(first.value).length;
+                if (!boundary(first.value) && size < 64 * 1024) {
+                    const deadline = new Promise((resolve) => {
+                        timer = setTimeout(() => resolve(null), 5);
+                    });
+                    while (batch.length < 64 && size < 64 * 1024) {
+                        let next;
+                        try {
+                            next = await Promise.race([read(), deadline]);
+                        }
+                        catch (error) {
+                            // Received events still precede the failure in the durable journal.
+                            failure = { error };
+                            break;
+                        }
+                        if (next === null)
+                            break;
+                        pending = undefined;
+                        if (next.done || boundary(next.value)) {
+                            held = next;
+                            break;
+                        }
+                        const nextSize = JSON.stringify(next.value).length;
+                        if (size + nextSize > 64 * 1024) {
+                            held = next;
+                            break;
+                        }
+                        batch.push(next.value);
+                        size += nextSize;
+                    }
+                }
+                if (!cancelled)
+                    controller.enqueue(batch);
+            }
+            catch (error) {
+                if (!cancelled)
+                    controller.error(error);
+                reader.releaseLock();
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+        async cancel(reason) {
+            cancelled = true;
+            await reader.cancel(reason);
+            reader.releaseLock();
+        },
+    });
+}

package/dist/agent-worker.js

@@ -1,6 +1,6 @@
 import { AGENT_SUBAGENT_CONCURRENCY_HEADER } from "@gea-ai/contract/agent-worker-tools";
 import { DEFAULT_MAX_CONCURRENT_SUBAGENTS } from "@gea-ai/contract/agent-packages";
-import { coalesceAgentTextDeltas } from "./agent-stream-coalescing.js";
+import { batchAgentStreamEvents, coalesceAgentTextDeltas, } from "./agent-stream-coalescing.js";
 import { sendAgentSessionRequest } from "./agent-session-transport.js";
 import { agentSessionOverridesSchema } from "@gea-ai/contract/agent-session-overrides";
 import { resolveModelOptions } from "@gea-ai/contract/model-options";
@@ -13,7 +13,6 @@ export { createGeaAI } from "./gea-ai.js";
 import { mergeLlmJson, llmRuntimeRequestOptionsSchema, } from "@gea-ai/contract/llm-catalog";
 import { executeChannelAgentRun, uploadChannelInput, } from "./agent-channel-api.js";
 export { extractChannelReply } from "./agent-channel-api.js";
-import { agentWorkerAttachmentOutputSchema } from "@gea-ai/contract/agent-api-host";
 import { streamManagedAgentSessionRun } from "./agent-session-stream.js";
 import { agentSessionReadToolOutputSchema, agentSessionReadToolOutputResultSchema, } from "@gea-ai/contract/agent-session";
 import { handleAgentComputerRequest, readSessionComputer, } from "./agent-computer-http.js";
@@ -32,7 +31,7 @@ import { agentModelCallSchema, } from "@gea-ai/contract/agent-usage";
 import { createAgentContextRuntime } from "./context-runtime.js";
 import { studioExternalUserPrincipalSchema } from "@gea-ai/contract";
 import { replaceInputFiles, withTurnImages } from "./agent-worker-attachments.js";
-import { toAgentHttpFile, } from "@gea-ai/contract/agent-http-api";
+import { toAgentHttpFile } from "@gea-ai/contract/agent-http-api";
 import { handleHostedAgentHttp } from "./agent-http.js";
 import { createWorkerAgentTool, createWorkerRunCancelTool } from "./agent-call.js";
 import { AgentSessionRunner, resumeSessionWait } from "./agent-session-runner.js";
@@ -1602,7 +1601,6 @@ function createAgentWorkerHostAdapter(bindings) {
             }
             if (path === `${HOST_PATH}/tools/initialize` ||
                 path === `${HOST_PATH}/tools/attachments/read` ||
-                path === `${HOST_PATH}/tools/attachments/outputs` ||
                 path === `${HOST_PATH}/tools/attachments/prepare` ||
                 path === `${HOST_PATH}/tools/invoke` ||
                 path === `${HOST_PATH}/agents/runs` ||
@@ -2709,6 +2707,7 @@ export async function runAgentWorkerRequest(input) {
     }, async (signal, waitUntil) => {
         const invocationTraceContext = captureTraceContext();
         const invocationSpan = trace.getActiveSpan();
+        const invocationTiming = {};
         const cancellation = new AbortController();
         let stopComputer;
         let inboxOutcome = {
@@ -2748,6 +2747,7 @@ export async function runAgentWorkerRequest(input) {
                 clearTimeout(cancellationTimer);
                 if (leaseMaintenance)
                     await leaseMaintenance;
+                const leaseDrainedAt = performance.now();
                 if (input.sessionExecution) {
                     results.push(...(await Promise.allSettled([
                         requestSessionJson({
@@ -2764,9 +2764,11 @@ export async function runAgentWorkerRequest(input) {
                     "gea.session.finish.background_ms": Math.round(drainedAt - cleanupStartedAt),
                     "gea.session.finish.computer_stop_ms": Math.round(computerStoppedAt - drainedAt),
                     "gea.session.finish.session_release_ms": Math.round(sessionFinishedAt - computerStoppedAt),
-                    "gea.session.finish.lease_handoff_ms": Math.round(performance.now() - sessionFinishedAt),
+                    "gea.session.finish.lease_observer_wait_ms": Math.round(leaseDrainedAt - sessionFinishedAt),
+                    "gea.session.finish.lease_handoff_ms": Math.round(performance.now() - leaseDrainedAt),
                 });
                 if (input.inboxExecution) {
+                    const inboxStartedAt = performance.now();
                     const status = cancellation.signal.aborted
                         ? "cancelled"
                         : results.some((result) => result.status === "rejected")
@@ -2790,7 +2792,8 @@ export async function runAgentWorkerRequest(input) {
                                     },
                                 }),
                         }),
-                    }));
+                    }))
+                        .finally(() => invocationSpan?.setAttribute("gea.session.finish.inbox_ms", Math.round(performance.now() - inboxStartedAt)));
                     if (!sessionResponse.ok)
                         throw new Error(`Session finish rejected (${sessionResponse.status}).`);
                 }
@@ -2873,7 +2876,7 @@ export async function runAgentWorkerRequest(input) {
                 stopComputer = stop;
             }, (outcome) => {
                 inboxOutcome = outcome;
-            });
+            }, invocationTiming);
         }
         catch (error) {
             cancellation.abort(error);
@@ -2917,6 +2920,8 @@ export async function runAgentWorkerRequest(input) {
                     }
                     signal.removeEventListener("abort", onAbort);
                     await finish();
+                    if (invocationTiming.lastModelFinishedAt !== undefined)
+                        invocationSpan?.setAttribute("gea.session.finish.model_to_close_ms", Math.round(performance.now() - invocationTiming.lastModelFinishedAt));
                     controller.close();
                 }
                 catch (error) {
@@ -2938,7 +2943,7 @@ export async function runAgentWorkerRequest(input) {
         });
     });
 }
-async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessionOutcome) {
+async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessionOutcome, invocationTiming) {
     const invocationTrace = activeTraceRef();
     const host = input.bindings
         ? createAgentWorkerHostAdapter(input.bindings)
@@ -2968,7 +2973,13 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
     let writeTail = Promise.resolve();
     let writeFailure;
     const persistenceSpan = trace.getActiveSpan();
-    const persistenceTotals = { writes: 0, queueMs: 0, requestMs: 0 };
+    const persistenceTotals = {
+        writes: 0,
+        queueMs: 0,
+        requestMs: 0,
+        events: 0,
+        eventBatches: 0,
+    };
     if (sessionExecution) {
         if (sessionExecution.runId !== payload.runId)
             throw new Error("Session Run identity mismatch.");
@@ -3009,10 +3020,16 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             finally {
                 const requestMs = performance.now() - startedAt;
                 persistenceTotals.writes++;
+                if (values.events?.length) {
+                    persistenceTotals.events += values.events.length;
+                    persistenceTotals.eventBatches++;
+                }
                 persistenceTotals.queueMs += queueMs;
                 persistenceTotals.requestMs += requestMs;
                 persistenceSpan?.setAttributes({
                     "gea.session.persistence.writes": persistenceTotals.writes,
+                    "gea.session.persistence.events": persistenceTotals.events,
+                    "gea.session.persistence.event_batches": persistenceTotals.eventBatches,
                     "gea.session.persistence.queue_ms": Math.round(persistenceTotals.queueMs),
                     "gea.session.persistence.request_ms": Math.round(persistenceTotals.requestMs),
                 });
@@ -3832,6 +3849,7 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
     let mergedResponseMessageCount = 0;
     let contextCheckpoint;
     let reusedContextCheckpoints = 0;
+    let modelCallsInitialized = false;
     const persistModelContext = () => {
         const modelContext = {
             contextSize: context.contextSize,
@@ -3848,7 +3866,10 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             return contextCheckpoint.pending;
         }
         const pending = sessionExecution
-            ? mutateSession({ context: modelContext })
+            ? mutateSession({
+                context: modelContext,
+                ...(!modelCallsInitialized ? { modelCalls: [] } : {}),
+            })
             : requestSessionJson({
                 body: { context: modelContext },
                 chatId: payload.chatId,
@@ -3857,6 +3878,8 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                 path: "/v1/model-context",
                 schema: agentSessionPutModelContextResultSchema,
             }).then(() => undefined);
+        if (sessionExecution)
+            modelCallsInitialized = true;
         contextCheckpoint = { serialized, pending };
         return pending;
     };
@@ -3902,8 +3925,10 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             await appendStreamEvent({ type: "data-model-call", data: call }, `model-call:${call.callId}`);
         }
     };
-    if (sessionExecution)
+    if (sessionExecution && !modelCallsInitialized) {
         await mutateSession({ modelCalls: [] });
+        modelCallsInitialized = true;
+    }
     let contextSignal = input.request.signal;
     const contextRuntime = createAgentContextRuntime({
         ai: host,
@@ -4073,12 +4098,16 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             catch (error) {
                 fail(error);
             }
+            const finalContextStartedAt = performance.now();
             try {
                 await persistModelContext();
             }
             catch (error) {
                 fail(error);
             }
+            finally {
+                persistenceSpan?.setAttribute("gea.session.finish.final_context_ms", Math.round(performance.now() - finalContextStartedAt));
+            }
             resolveContext({
                 ...(!failure && inboxRunner?.suspended
                     ? { sessionStatus: "waiting" }
@@ -4095,52 +4124,10 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         })();
         return settling;
     };
-    const publishedArtifacts = new Map();
-    const emittedArtifacts = new Set();
-    const refreshArtifacts = async () => {
-        if (!artifactScope || input.request.signal.aborted)
-            return;
-        let cursor;
-        do {
-            const response = await host.fetch(`${HOST_PATH}/tools/attachments/outputs`, {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ scope: artifactScope, cursor }),
-                signal: input.request.signal,
-            });
-            if (!response.ok)
-                throw new Error(`Could not list published Artifacts (${response.status}).`);
-            const page = z
-                .object({
-                items: z.array(agentWorkerAttachmentOutputSchema),
-                next_cursor: z.uuid().nullable(),
-            })
-                .parse(await response.json());
-            for (const artifact of page.items)
-                publishedArtifacts.set(artifact.id, artifact);
-            cursor = page.next_cursor ?? undefined;
-        } while (cursor);
-    };
-    let finalArtifacts;
-    const refreshFinalArtifacts = () => 
-    // Context callbacks can publish outputs. Both terminal consumers use the
-    // same snapshot, taken only after those callbacks and their work settle.
-    (finalArtifacts ??= contextFinished.then(() => refreshArtifacts()));
     const saveResponseMessage = async ({ responseMessage, }) => {
         const saveStartedAt = performance.now();
         const metadata = await contextFinished;
         const contextFinishedAt = performance.now();
-        await refreshFinalArtifacts();
-        const artifactsFinishedAt = performance.now();
-        responseMessage.parts = [
-            ...responseMessage.parts.filter((part) => part.type !== "data-artifact" ||
-                !publishedArtifacts.has(part.data.id)),
-            ...[...publishedArtifacts.values()].map((data) => ({
-                type: "data-artifact",
-                id: data.id,
-                data,
-            })),
-        ];
         if (inboxRunner?.suspendedToolCallId) {
             responseMessage.parts = responseMessage.parts.map((part) => {
                 if (isToolUIPart(part) &&
@@ -4178,7 +4165,6 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         await persistModelContext();
         const contextPersistedAt = performance.now();
         persistenceSpan?.setAttributes({
-            "gea.session.finish.artifacts_ms": Math.round(artifactsFinishedAt - contextFinishedAt),
             "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),
@@ -4517,6 +4503,7 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                         : part.finish_reason;
                 const usage = coreUsage(part.usage);
                 mainUsage = addAgentWorkerUsage(mainUsage, usage);
+                invocationTiming.lastModelFinishedAt = performance.now();
                 await recordMainCall("completed", usage);
                 modelSpan?.setAttribute("gen_ai.output.messages", JSON.stringify(toModelMessages([part.message])));
                 if (usage.inputTokens !== undefined)
@@ -4607,6 +4594,9 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             throw new Error("Agent Worker model is missing.");
         const result = streamText({
             telemetry: agentModelTelemetry,
+            onLanguageModelCallEnd() {
+                invocationTiming.lastModelFinishedAt = performance.now();
+            },
             onError: ({ error }) => {
                 fail(error);
             },
@@ -4722,89 +4712,84 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             },
         });
     }
-    const durableStream = (sessionExecution ? coalesceAgentTextDeltas(stream) : stream).pipeThrough(new TransformStream({
-        async transform(chunk, controller) {
-            if (chunk.type === "start" && interruptedResponse) {
-                const events = [
-                    ...(interruptedWait ? [interruptedWait] : []),
-                    { type: "finish", finishReason: "other" },
-                ];
-                if (sessionExecution)
-                    await mutateSession({
-                        messages: [{ ...interruptedResponse }],
-                        events,
-                    });
-                else {
-                    await appendSessionValue({
-                        body: { message: interruptedResponse, runId: payload.runId },
-                        chatId: payload.chatId,
-                        namespace: input.sessionNamespace,
-                        path: "/v1/messages",
-                    });
-                    for (const event of events)
-                        await appendStreamEvent(event);
-                }
-            }
-            if (chunk.type === "start" && responseBaseline) {
-                // Each internal invocation still has its own start/finish for accounting.
-                // The public journal represents one response across those invocations.
-                controller.enqueue(chunk);
-                const result = input.inboxExecution?.waitResult;
-                if (result) {
-                    const output = {
-                        type: "tool-output-available",
-                        toolCallId: result.toolCallId,
-                        output: toAgentRunWaitOutput(result),
-                    };
-                    if (sessionExecution)
-                        await mutateSession({ events: [output] });
-                    else
-                        await appendStreamEvent(output);
-                    controller.enqueue(output);
-                }
-                return;
-            }
-            if (chunk.type === "tool-output-available" &&
-                chunk.toolCallId === inboxRunner?.suspendedToolCallId)
-                return;
-            if (chunk.type === "finish-step" || chunk.type === "finish") {
-                if (chunk.type === "finish")
-                    await refreshFinalArtifacts();
-                else
-                    await refreshArtifacts();
-                for (const data of publishedArtifacts.values()) {
-                    if (emittedArtifacts.has(data.id))
-                        continue;
-                    const event = { type: "data-artifact", id: data.id, data };
+    const durableStream = (sessionExecution
+        ? batchAgentStreamEvents(coalesceAgentTextDeltas(stream))
+        : stream.pipeThrough(new TransformStream({
+            transform(chunk, controller) {
+                controller.enqueue([chunk]);
+            },
+        }))).pipeThrough(new TransformStream({
+        async transform(chunks, controller) {
+            const events = [];
+            for (let chunk of chunks) {
+                if (chunk.type === "start" && interruptedResponse) {
+                    const events = [
+                        ...(interruptedWait ? [interruptedWait] : []),
+                        { type: "finish", finishReason: "other" },
+                    ];
                     if (sessionExecution)
-                        await mutateSession({ events: [event] });
-                    else
-                        await appendStreamEvent(event, `artifact:${data.id}`);
-                    controller.enqueue(event);
-                    emittedArtifacts.add(data.id);
+                        await mutateSession({
+                            messages: [{ ...interruptedResponse }],
+                            events,
+                        });
+                    else {
+                        await appendSessionValue({
+                            body: { message: interruptedResponse, runId: payload.runId },
+                            chatId: payload.chatId,
+                            namespace: input.sessionNamespace,
+                            path: "/v1/messages",
+                        });
+                        for (const event of events)
+                            await appendStreamEvent(event);
+                    }
                 }
-            }
-            // AI SDK emits finish before awaiting onEnd. Publish success and usage
-            // only after the context strategy and its registered work have settled.
-            if (chunk.type === "finish") {
-                const metadata = await contextFinished;
-                chunk = {
-                    ...chunk,
-                    finishReason: metadata.finishReason,
-                    messageMetadata: metadata,
-                };
-                if (metadata.sessionStatus === "waiting") {
+                if (chunk.type === "start" && responseBaseline) {
+                    // Each internal invocation still has its own start/finish for accounting.
+                    // The public journal represents one response across those invocations.
                     controller.enqueue(chunk);
-                    return;
+                    const result = input.inboxExecution?.waitResult;
+                    if (result) {
+                        const output = {
+                            type: "tool-output-available",
+                            toolCallId: result.toolCallId,
+                            output: toAgentRunWaitOutput(result),
+                        };
+                        if (sessionExecution)
+                            await mutateSession({ events: [output] });
+                        else
+                            await appendStreamEvent(output);
+                        controller.enqueue(output);
+                    }
+                    continue;
                 }
+                if (chunk.type === "tool-output-available" &&
+                    chunk.toolCallId === inboxRunner?.suspendedToolCallId)
+                    continue;
+                // AI SDK emits finish before awaiting onEnd. Publish success and usage
+                // only after the context strategy and its registered work have settled.
+                if (chunk.type === "finish") {
+                    const metadata = await contextFinished;
+                    chunk = {
+                        ...chunk,
+                        finishReason: metadata.finishReason,
+                        messageMetadata: metadata,
+                    };
+                    if (metadata.sessionStatus === "waiting") {
+                        controller.enqueue(chunk);
+                        continue;
+                    }
+                }
+                events.push(chunk);
             }
-            if (sessionExecution) {
-                await mutateSession({ events: [chunk] });
-                controller.enqueue(chunk);
+            if (events.length === 0)
                 return;
-            }
-            await appendStreamEvent(chunk);
-            controller.enqueue(chunk);
+            if (sessionExecution)
+                await mutateSession({ events });
+            else
+                for (const event of events)
+                    await appendStreamEvent(event);
+            for (const event of events)
+                controller.enqueue(event);
         },
     }));
     if (engine) {

package/dist/context-runtime.js

@@ -195,21 +195,53 @@ export function createAgentContextRuntime(input) {
                 });
         },
         async onEnd(stepNumber, end, runCallback = true) {
+            const endSpan = createAgentTracing().currentSpan;
             const finalize = async () => {
+                const startedAt = performance.now();
+                let backgroundMs = 0;
+                let callbackMs = 0;
+                let compactMs = 0;
                 try {
-                    const updated = await compact(false);
-                    if (descriptor.type === "default" || offload !== false)
-                        await persist(updated);
-                    await settle();
-                    if (runCallback && strategy.onEnd)
-                        await invoke(stepNumber, (event) => strategy.onEnd({ ...event, ...end }));
+                    const compactStartedAt = performance.now();
+                    try {
+                        const updated = await compact(false);
+                        if (descriptor.type === "default" || offload !== false)
+                            await persist(updated);
+                    }
+                    finally {
+                        compactMs = performance.now() - compactStartedAt;
+                    }
+                    const backgroundStartedAt = performance.now();
+                    try {
+                        await settle();
+                    }
+                    finally {
+                        backgroundMs += performance.now() - backgroundStartedAt;
+                    }
+                    if (runCallback && strategy.onEnd) {
+                        const callbackStartedAt = performance.now();
+                        try {
+                            await invoke(stepNumber, (event) => strategy.onEnd({ ...event, ...end }));
+                        }
+                        finally {
+                            callbackMs = performance.now() - callbackStartedAt;
+                        }
+                    }
                 }
                 finally {
+                    const backgroundStartedAt = performance.now();
                     try {
                         await settle();
                     }
                     finally {
+                        backgroundMs += performance.now() - backgroundStartedAt;
                         closed = true;
+                        endSpan?.setAttributes({
+                            "gea.session.finish.context_compact_ms": Math.round(compactMs),
+                            "gea.session.finish.context_background_ms": Math.round(backgroundMs),
+                            "gea.session.finish.context_callback_ms": Math.round(callbackMs),
+                            "gea.session.finish.context_total_ms": Math.round(performance.now() - startedAt),
+                        });
                     }
                 }
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gea-ai/agent-sdk",
-  "version": "0.1.260922-alpha.2",
+  "version": "0.1.260922-alpha.3",
   "private": false,
   "homepage": "https://musegea.com/developers",
   "license": "Apache-2.0",
@@ -108,7 +108,7 @@
     "@ai-sdk/otel": "1.0.9",
     "@ai-sdk/provider": "4.0.1",
     "@ai-sdk/provider-utils": "5.0.2",
-    "@gea-ai/contract": "0.1.260922-alpha.2",
+    "@gea-ai/contract": "0.1.260922-alpha.3",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/context-async-hooks": "2.10.0",
     "@opentelemetry/core": "2.10.0",