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

package/dist/agent-session-execution.js

@@ -1,9 +1,10 @@
+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, agentSessionExecutionReleaseSchema, 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";
+import { isAgentSessionInboxBusy, scheduleAgentSessionInbox, getAgentSessionRunState, handleAgentSessionInboxRequest, finishAgentSessionInbox, hasAgentSessionInbox, skipAgentSessionInputWait, } from "./agent-session-inbox.js";
 // Managed execution owns its own durable state; PostgreSQL copies the live stream.
 const prefix = "execution-v2:";
 const key = (name) => `${prefix}${name}`;
@@ -424,6 +425,28 @@ export async function handleAgentSessionExecutionRequest(request, storage) {
             });
             return json(preparing ? { ...result, capabilities } : result);
         }
+        if (request.method === "POST" && url.pathname === "/v2/turns/release") {
+            const input = agentSessionExecutionReleaseSchema.parse(await readBody(request, storage));
+            const startedAt = performance.now();
+            let handlerMs = 0;
+            const response = await storage.transaction(async (tx) => {
+                const handlerStartedAt = performance.now();
+                const active = await requireAttempt(tx, input);
+                const response = await finishAgentSessionInbox(tx, input.inbox, input.runId);
+                if (!response.ok)
+                    return response;
+                await tx.put(key("active-turn"), {
+                    ...active,
+                    leaseOwner: "host",
+                    leaseExpiresAt: new Date(Date.now() + AGENT_SESSION_EXECUTION_LEASE_MS).toISOString(),
+                });
+                await advanceRevision(tx);
+                handlerMs = performance.now() - handlerStartedAt;
+                return response;
+            });
+            response.headers.set("server-timing", `session-handler;dur=${handlerMs.toFixed(1)}, session-transaction;dur=${(performance.now() - startedAt).toFixed(1)}`);
+            return response;
+        }
         if (request.method === "POST" && url.pathname === "/v2/turns/renew") {
             const input = agentSessionExecutionRenewSchema.parse(await readBody(request, storage));
             return json(await storage.transaction(async (tx) => {
@@ -506,12 +529,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 +616,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 +636,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-inbox.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { agentSessionInboxFinishSchema } from "@gea-ai/contract/agent-session-inbox";
 import type { AgentChildRun } from "@gea-ai/contract/agent-worker-tools";
 import type { AgentSessionStorage, AgentSessionTransactionStorage } from "./agent-session";
 /** Only private definitions/self copies share the owning Agent's business context. */
@@ -47,6 +48,8 @@ export declare function queueAgentSessionChildRun(tx: AgentSessionTransactionSto
 export declare function acceptAgentSessionChildRun(tx: AgentSessionTransactionStorage, runId: string): Promise<void>;
 /** Called in the child-run transaction. Progress is recorded by the run store only. */
 export declare function notifyAgentSessionChildRun(tx: AgentSessionTransactionStorage, run: AgentChildRun): Promise<void>;
+/** Called inside the managed lease handoff transaction. */
+export declare function finishAgentSessionInbox(tx: AgentSessionTransactionStorage, input: z.infer<typeof agentSessionInboxFinishSchema>, runId: string): Promise<Response>;
 /** Private Session protocol. Ingress must authenticate initialization and sender provenance. */
 export declare function handleAgentSessionInboxRequest(request: Request, storage: AgentSessionStorage): Promise<Response | undefined>;
 /** Lazy Durable Object entrypoint. A pending dispatch retries with the same execution ID. */

package/dist/agent-session-inbox.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { agentSessionExecutionTurnSchema } from "@gea-ai/contract/agent-session";
 import { agentApplicationAssistantMessageSchema } from "@gea-ai/contract/agent-applications";
 import { canonicalAgentChannelJson } from "@gea-ai/contract/agent-channels";
-import { agentSessionIdentitySchema, agentSessionBootstrapSchema, agentSessionTransportSchema, agentSessionDispatchSchema, agentSessionInboxExecutionSchema, agentSessionSendSchema, agentRunWaitInputSchema, agentRunWaitResultSchema, toAgentRunWaitOutput, } from "@gea-ai/contract/agent-session-inbox";
+import { agentSessionIdentitySchema, agentSessionBootstrapSchema, agentSessionTransportSchema, agentSessionDispatchSchema, agentSessionInboxFinishSchema, agentSessionInboxExecutionSchema, agentSessionSendSchema, agentRunWaitInputSchema, agentRunWaitResultSchema, toAgentRunWaitOutput, } from "@gea-ai/contract/agent-session-inbox";
 import { combineTraceContexts, readTraceContext } from "./trace-context.js";
 import { traceContextSchema } from "@gea-ai/contract/traces";
 import { activeComputerOperation } from "./agent-session-computer.js";
@@ -408,6 +408,88 @@ export async function notifyAgentSessionChildRun(tx, run) {
     }
     await save(tx, state, runs);
 }
+async function finishInbox(tx, state, runs, input) {
+    if (!state.execution || state.execution.id !== input.executionId)
+        return Response.json({ error: "execution_mismatch" }, { status: 409 });
+    let { outcome, inputWait, requireExpiredLease } = input;
+    if (requireExpiredLease) {
+        const stored = await tx.get("execution-v2:active-turn");
+        const turn = stored === undefined
+            ? null
+            : agentSessionExecutionTurnSchema.parse(stored);
+        if (outcome?.status !== "interrupted" ||
+            turn?.runId !== state.execution.turnId ||
+            turn.status !== "running" ||
+            Date.parse(turn.leaseExpiresAt) > Date.now()) {
+            await save(tx, state, runs);
+            return Response.json({ error: "execution_not_expired" }, { status: 409 });
+        }
+    }
+    if (inputWait && !outcome && !state.stopped)
+        state.inputWait = {
+            turnId: state.execution.turnId,
+            messageId: inputWait.messageId,
+        };
+    // A transport disconnect does not revoke already accepted child runs.
+    if (outcome?.status === "cancelled" &&
+        !state.stopped &&
+        runs.some((run) => !run.outcome)) {
+        state.wait = {
+            turnId: state.execution.turnId,
+            toolCallId: null,
+            runIds: runs.filter((run) => !run.outcome).map((run) => run.id),
+            deadline: null,
+        };
+        outcome = undefined;
+    }
+    if (outcome && outcome.status !== "completed" && state.wait) {
+        if (state.wait.toolCallId)
+            state.resumeWait = waitResult(state, runs, true);
+        state.wait = null;
+    }
+    if (outcome && outcome.status !== "completed") {
+        state.stopped = true;
+        for (const run of runs)
+            if (!run.outcome) {
+                run.cancelRequested = true;
+                await putChildRun(tx, run);
+            }
+    }
+    if ((outcome || state.stopped) && state.transport) {
+        const terminal = {
+            execution: { ...state.execution, messages: [], waitResult: null },
+            outcome: outcome ?? {
+                status: "cancelled",
+                text: "Run cancelled.",
+            },
+            transport: state.transport,
+        };
+        if (runs.some((run) => !run.outcome))
+            state.draining = terminal;
+        else if (state.terminal)
+            state.terminalQueue.push(terminal);
+        else
+            state.terminal = terminal;
+    }
+    state.execution = null;
+    state.started = false;
+    await save(tx, state, runs);
+    return Response.json({
+        finished: true,
+        waiting: state.wait !== null || state.inputWait !== null,
+    });
+}
+/** Called inside the managed lease handoff transaction. */
+export async function finishAgentSessionInbox(tx, input, runId) {
+    if (!tx.setAlarm || !tx.deleteAlarm)
+        return Response.json({ error: "session_alarms_unavailable" }, { status: 503 });
+    const state = await readState(tx);
+    if (!state?.execution ||
+        state.execution.id !== input.executionId ||
+        state.execution.turnId !== runId)
+        return Response.json({ error: "execution_mismatch" }, { status: 409 });
+    return finishInbox(tx, state, await readInboxChildRuns(tx, state), input);
+}
 /** Private Session protocol. Ingress must authenticate initialization and sender provenance. */
 export async function handleAgentSessionInboxRequest(request, storage) {
     const path = new URL(request.url).pathname;
@@ -770,89 +852,18 @@ export async function handleAgentSessionInboxRequest(request, storage) {
                     return Response.json(result ? { status: "ready", result } : { status: "suspended" });
                 }
                 if (finishing) {
-                    let { outcome, inputWait, requireExpiredLease } = executionInputSchema
-                        .extend({
-                        outcome: agentSessionDispatchSchema.shape.outcome,
-                        requireExpiredLease: z.literal(true).optional(),
-                        inputWait: z
-                            .strictObject({ messageId: z.string().min(1) })
-                            .optional(),
-                    })
+                    const input = agentSessionInboxFinishSchema
+                        .extend({ requireExpiredLease: z.literal(true).optional() })
                         .parse(rejecting
                         ? {
-                            executionId: input.executionId,
+                            executionId: state.execution.id,
                             outcome: {
                                 status: "failed",
                                 text: "Session dispatch authorization was denied.",
                             },
                         }
                         : body);
-                    if (requireExpiredLease) {
-                        const stored = await tx.get("execution-v2:active-turn");
-                        const turn = stored === undefined
-                            ? null
-                            : agentSessionExecutionTurnSchema.parse(stored);
-                        if (outcome?.status !== "interrupted" ||
-                            turn?.runId !== state.execution.turnId ||
-                            turn.status !== "running" ||
-                            Date.parse(turn.leaseExpiresAt) > Date.now()) {
-                            await save(tx, state, runs);
-                            return Response.json({ error: "execution_not_expired" }, { status: 409 });
-                        }
-                    }
-                    if (inputWait && !outcome && !state.stopped)
-                        state.inputWait = {
-                            turnId: state.execution.turnId,
-                            messageId: inputWait.messageId,
-                        };
-                    // A transport disconnect does not revoke already accepted child runs.
-                    if (outcome?.status === "cancelled" &&
-                        !state.stopped &&
-                        runs.some((run) => !run.outcome)) {
-                        state.wait = {
-                            turnId: state.execution.turnId,
-                            toolCallId: null,
-                            runIds: runs.filter((run) => !run.outcome).map((run) => run.id),
-                            deadline: null,
-                        };
-                        outcome = undefined;
-                    }
-                    if (outcome && outcome.status !== "completed" && state.wait) {
-                        if (state.wait.toolCallId)
-                            state.resumeWait = waitResult(state, runs, true);
-                        state.wait = null;
-                    }
-                    if (outcome && outcome.status !== "completed") {
-                        state.stopped = true;
-                        for (const run of runs)
-                            if (!run.outcome) {
-                                run.cancelRequested = true;
-                                await putChildRun(tx, run);
-                            }
-                    }
-                    if ((outcome || state.stopped) && state.transport) {
-                        const terminal = {
-                            execution: { ...state.execution, messages: [], waitResult: null },
-                            outcome: outcome ?? {
-                                status: "cancelled",
-                                text: "Run cancelled.",
-                            },
-                            transport: state.transport,
-                        };
-                        if (runs.some((run) => !run.outcome))
-                            state.draining = terminal;
-                        else if (state.terminal)
-                            state.terminalQueue.push(terminal);
-                        else
-                            state.terminal = terminal;
-                    }
-                    state.execution = null;
-                    state.started = false;
-                    await save(tx, state, runs);
-                    return Response.json({
-                        finished: true,
-                        waiting: state.wait !== null || state.inputWait !== null,
-                    });
+                    return finishInbox(tx, state, runs, input);
                 }
                 const messages = takeMessages(state, true);
                 state.messages = state.messages.filter((entry) => !messages.includes(entry));

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,7 +2747,8 @@ export async function runAgentWorkerRequest(input) {
                 clearTimeout(cancellationTimer);
                 if (leaseMaintenance)
                     await leaseMaintenance;
-                if (input.sessionExecution) {
+                const leaseDrainedAt = performance.now();
+                if (input.sessionExecution && !input.inboxExecution) {
                     results.push(...(await Promise.allSettled([
                         requestSessionJson({
                             body: { ...input.sessionExecution, leaseOwner: "host" },
@@ -2764,33 +2764,62 @@ 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")
                             ? "failed"
                             : inboxOutcome.status;
                     invocationSpan?.setAttribute("gea.session.status", status);
+                    const inbox = {
+                        executionId: input.inboxExecution.id,
+                        ...(status === "waiting"
+                            ? { inputWait: inboxOutcome.inputWait }
+                            : {
+                                outcome: {
+                                    status,
+                                    text: inboxOutcome.text.slice(0, 200_000),
+                                    traceContext: invocationTraceContext,
+                                },
+                            }),
+                    };
+                    // Managed execution and Inbox are on the same Session object. Seal
+                    // the Inbox and hand its lease back in one fenced durable commit.
+                    const releasePath = input.sessionExecution
+                        ? "/v2/turns/release"
+                        : "/v1/inbox/finish";
                     const sessionResponse = await input.sessionNamespace
                         .get(input.sessionNamespace.idFromName(sessionChatId))
-                        .fetch(new Request("https://agent-session.internal/v1/inbox/finish", {
+                        .fetch(new Request(`https://agent-session.internal${releasePath}`, {
                         method: "POST",
                         headers: { "content-type": "application/json" },
-                        body: JSON.stringify({
-                            executionId: input.inboxExecution.id,
-                            ...(status === "waiting"
-                                ? { inputWait: inboxOutcome.inputWait }
-                                : {
-                                    outcome: {
-                                        status,
-                                        text: inboxOutcome.text.slice(0, 200_000),
-                                        traceContext: invocationTraceContext,
-                                    },
-                                }),
-                        }),
-                    }));
+                        body: JSON.stringify(input.sessionExecution
+                            ? { ...input.sessionExecution, inbox }
+                            : inbox),
+                    }))
+                        .finally(() => invocationSpan?.setAttribute("gea.session.finish.inbox_ms", Math.round(performance.now() - inboxStartedAt)));
+                    for (const [metric, attribute] of [
+                        ["session-handler", "gea.session.finish.inbox_handler_ms"],
+                        [
+                            "session-transaction",
+                            "gea.session.finish.inbox_transaction_ms",
+                        ],
+                    ]) {
+                        const timing = sessionResponse.headers
+                            .get("server-timing")
+                            ?.split(",")
+                            .map((entry) => entry.trim())
+                            .find((entry) => entry.startsWith(`${metric};dur=`));
+                        if (timing) {
+                            const duration = Number(timing.slice(`${metric};dur=`.length));
+                            if (Number.isFinite(duration) && duration >= 0)
+                                invocationSpan?.setAttribute(attribute, duration);
+                        }
+                    }
                     if (!sessionResponse.ok)
                         throw new Error(`Session finish rejected (${sessionResponse.status}).`);
                 }
@@ -2873,7 +2902,7 @@ export async function runAgentWorkerRequest(input) {
                 stopComputer = stop;
             }, (outcome) => {
                 inboxOutcome = outcome;
-            });
+            }, invocationTiming);
         }
         catch (error) {
             cancellation.abort(error);
@@ -2917,6 +2946,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 +2969,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 +2999,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 +3046,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 +3875,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 +3892,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 +3904,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 +3951,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 +4124,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 +4150,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 +4191,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 +4529,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 +4620,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 +4738,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/dist/experimental/agent-core-ui.js

@@ -13,7 +13,7 @@ export async function* projectAgentCoreEvents(turn, options) {
     let resumed = false;
     const blocks = new Map();
     const calls = new Map();
-    const steps = [];
+    let lastModelHadToolCalls = false;
     let outcome;
     try {
         yield {
@@ -38,7 +38,7 @@ export async function* projectAgentCoreEvents(turn, options) {
                 case "step_resumed":
                     step = event.step;
                     resumed = true;
-                    steps.push({ step, finish_reason: "tool_calls", usage: event.usage });
+                    lastModelHadToolCalls = true;
                     break;
                 case "step_started":
                     resumed = false;
@@ -113,11 +113,7 @@ export async function* projectAgentCoreEvents(turn, options) {
                     break;
                 }
                 case "model_finished":
-                    steps.push({
-                        step: event.step,
-                        finish_reason: event.finish_reason,
-                        usage: event.usage,
-                    });
+                    lastModelHadToolCalls = event.finish_reason === "tool_calls";
                     break;
                 case "approval_requested": {
                     const call = calls.get(event.call_id);
@@ -237,12 +233,7 @@ export async function* projectAgentCoreEvents(turn, options) {
         if (chunk)
             yield chunk;
     }
-    const messageMetadata = {
-        ...(outcome.output === undefined ? {} : { output: outcome.output }),
-        agentCore: { reason: outcome.reason, steps },
-    };
     if (outcome.reason === "cancelled") {
-        yield { type: "message-metadata", messageMetadata };
         yield { type: "abort", reason: "cancelled" };
         return;
     }
@@ -259,7 +250,7 @@ export async function* projectAgentCoreEvents(turn, options) {
     yield {
         type: "finish",
         finishReason: outcome.reason === "stopped"
-            ? steps.at(-1)?.finish_reason === "tool_calls"
+            ? lastModelHadToolCalls
                 ? "tool-calls"
                 : "stop"
             : outcome.reason === "completed"
@@ -271,7 +262,9 @@ export async function* projectAgentCoreEvents(turn, options) {
                         outcome.reason === "awaiting_tool_results"
                         ? "tool-calls"
                         : "error",
-        messageMetadata,
+        ...(outcome.output === undefined
+            ? {}
+            : { messageMetadata: { output: outcome.output } }),
     };
 }
 export function createAgentCoreUIStream(core, message, host, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gea-ai/agent-sdk",
-  "version": "0.1.260922-alpha.2",
+  "version": "0.1.260923-alpha.0",
   "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.260923-alpha.0",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/context-async-hooks": "2.10.0",
     "@opentelemetry/core": "2.10.0",