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

package/dist/agent-session-execution.js

@@ -471,31 +471,43 @@ export async function handleAgentSessionExecutionRequest(request, storage) {
             }));
         }
         if (request.method === "POST" && url.pathname === "/v2/mutations") {
+            const startedAt = performance.now();
             const input = agentSessionExecutionMutationSchema.parse(await readBody(request, storage));
             const inputDigest = await digest(input);
-            return json(await storage.transaction(async (tx) => {
-                const turn = await requireAttempt(tx, input);
-                if (input.mutationSequence === turn.nextMutationSequence - 1 &&
-                    turn.lastMutation?.digest === inputDigest)
-                    return { duplicate: true, revision: turn.lastMutation.revision };
-                if (input.mutationSequence !== turn.nextMutationSequence)
-                    throw new SessionProtocolError("mutation_sequence_mismatch");
-                if (input.context && input.context.runId !== input.runId)
-                    throw new SessionProtocolError("context_run_mismatch");
-                const previousRevision = await readRevision(tx);
-                await writeValues(tx, input);
-                const activeTurn = {
-                    ...turn,
-                    nextMutationSequence: turn.nextMutationSequence + 1,
-                    lastMutation: {
-                        digest: inputDigest,
-                        revision: previousRevision + 1,
-                    },
-                };
-                await tx.put(key("active-turn"), activeTurn);
-                const revision = await advanceRevision(tx);
-                return { duplicate: false, revision };
-            }));
+            const parsedAt = performance.now();
+            let handlerMs = 0;
+            const result = await storage.transaction(async (tx) => {
+                const handlerStartedAt = performance.now();
+                try {
+                    const turn = await requireAttempt(tx, input);
+                    if (input.mutationSequence === turn.nextMutationSequence - 1 &&
+                        turn.lastMutation?.digest === inputDigest)
+                        return { duplicate: true, revision: turn.lastMutation.revision };
+                    if (input.mutationSequence !== turn.nextMutationSequence)
+                        throw new SessionProtocolError("mutation_sequence_mismatch");
+                    if (input.context && input.context.runId !== input.runId)
+                        throw new SessionProtocolError("context_run_mismatch");
+                    const previousRevision = await readRevision(tx);
+                    await writeValues(tx, input);
+                    const activeTurn = {
+                        ...turn,
+                        nextMutationSequence: turn.nextMutationSequence + 1,
+                        lastMutation: {
+                            digest: inputDigest,
+                            revision: previousRevision + 1,
+                        },
+                    };
+                    await tx.put(key("active-turn"), activeTurn);
+                    const revision = await advanceRevision(tx);
+                    return { duplicate: false, revision };
+                }
+                finally {
+                    handlerMs = performance.now() - handlerStartedAt;
+                }
+            });
+            const response = json(result);
+            response.headers.set("server-timing", `session-parse;dur=${(parsedAt - startedAt).toFixed(1)}, session-handler;dur=${handlerMs.toFixed(1)}, session-transaction;dur=${(performance.now() - parsedAt).toFixed(1)}`);
+            return response;
         }
         if (request.method === "POST" && url.pathname === "/v2/turns/pause") {
             const input = agentSessionExecutionPauseSchema.parse(await readBody(request, storage));

package/dist/agent-worker.js

@@ -2604,6 +2604,7 @@ async function requestSessionJson(input) {
             method: input.method,
         })),
     });
+    input.onResponse?.(response);
     if (!response.ok)
         throw new Error(`AgentSession rejected ${input.path} (${response.status}).`);
     return input.schema.parse(await response.json());
@@ -3025,13 +3026,19 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
     }
     const mutateSession = (values) => {
         const queuedAt = performance.now();
+        const mutationSpan = trace
+            .getTracer("gea.agent-session")
+            .startSpan("agent.session.mutation", {
+            attributes: { "gea.agent.run.id": payload.runId },
+        });
         const result = writeTail.then(async () => {
-            if (writeFailure)
-                throw writeFailure;
             const startedAt = performance.now();
             const queueMs = startedAt - queuedAt;
+            const sequence = mutationSequence;
             let failed = true;
             try {
+                if (writeFailure)
+                    throw writeFailure;
                 await requestSessionJson({
                     body: { ...values, ...sessionExecution, mutationSequence },
                     chatId: payload.chatId,
@@ -3039,6 +3046,12 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                     namespace: input.sessionNamespace,
                     path: "/v2/mutations",
                     schema: agentSessionExecutionMutationResultSchema,
+                    onResponse(response) {
+                        mutationSpan.setAttribute("http.response.status_code", response.status);
+                        const timing = response.headers.get("server-timing");
+                        if (timing)
+                            mutationSpan.setAttribute("gea.session.mutation.server_timing", timing);
+                    },
                 });
                 mutationSequence += 1;
                 failed = false;
@@ -3059,6 +3072,22 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                     "gea.session.persistence.queue_ms": Math.round(persistenceTotals.queueMs),
                     "gea.session.persistence.request_ms": Math.round(persistenceTotals.requestMs),
                 });
+                mutationSpan.setAttributes({
+                    "gea.session.mutation.sequence": sequence,
+                    "gea.session.mutation.kinds": Object.keys(values),
+                    "gea.session.mutation.event_count": values.events?.length ?? 0,
+                    "gea.session.mutation.queue_ms": Math.round(queueMs),
+                    "gea.session.mutation.request_ms": Math.round(requestMs),
+                    ...(invocationTiming.lastModelFinishedAt === undefined
+                        ? {}
+                        : {
+                            "gea.session.mutation.start_after_model_ms": Math.round(startedAt - invocationTiming.lastModelFinishedAt),
+                            "gea.session.mutation.end_after_model_ms": Math.round(performance.now() - invocationTiming.lastModelFinishedAt),
+                        }),
+                });
+                if (failed)
+                    mutationSpan.setStatus({ code: SpanStatusCode.ERROR });
+                mutationSpan.end();
                 if (failed || queueMs + requestMs >= 250)
                     console.info("AgentSession mutation timing", {
                         runId: payload.runId,
@@ -3876,6 +3905,7 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
     let contextCheckpoint;
     let reusedContextCheckpoints = 0;
     let modelCallsInitialized = false;
+    const checkpointModelCalls = [];
     const persistModelContext = () => {
         const modelContext = {
             contextSize: context.contextSize,
@@ -3887,14 +3917,19 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         // Lifecycle callbacks can checkpoint the same projection several times.
         // Reuse the pending write too: an unchanged snapshot must still await its
         // durable commit, including propagating a failed commit to every waiter.
-        if (contextCheckpoint?.serialized === serialized) {
+        if (contextCheckpoint?.serialized === serialized &&
+            checkpointModelCalls.length === 0) {
             persistenceSpan?.setAttribute("gea.session.persistence.context_reused", ++reusedContextCheckpoints);
             return contextCheckpoint.pending;
         }
         const pending = sessionExecution
             ? mutateSession({
                 context: modelContext,
-                ...(!modelCallsInitialized ? { modelCalls: [] } : {}),
+                ...(checkpointModelCalls.length > 0
+                    ? { modelCalls: checkpointModelCalls.splice(0) }
+                    : !modelCallsInitialized
+                        ? { modelCalls: [] }
+                        : {}),
             })
             : requestSessionJson({
                 body: { context: modelContext },
@@ -3941,11 +3976,14 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         },
     });
     const modelCalls = [];
-    const recordModelCall = async (entry) => {
+    const recordModelCall = async (entry, checkpoint = false) => {
         const call = agentModelCallSchema.parse(entry);
         modelCalls.push(call);
         if (sessionExecution) {
-            await mutateSession({ modelCalls: [call] });
+            if (checkpoint)
+                checkpointModelCalls.push(call);
+            else
+                await mutateSession({ modelCalls: [call] });
         }
         else {
             await appendStreamEvent({ type: "data-model-call", data: call }, `model-call:${call.callId}`);
@@ -4074,7 +4112,7 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         failure ??= { error };
         recordExecutionFailure(error);
     };
-    const recordMainCall = async (status, usage) => {
+    const recordMainCall = async (status, usage, checkpoint = false) => {
         if (!pendingMainCall)
             return;
         const callId = pendingMainCall;
@@ -4087,7 +4125,7 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             status,
             usage,
             occurredAt: new Date().toISOString(),
-        });
+        }, checkpoint);
     };
     let settling;
     const finishContext = (end) => {
@@ -4100,6 +4138,10 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                 if (end?.finishReason === "stop" && !failure)
                     await inboxRunner?.join();
                 await recordMainCall(input.request.signal.aborted ? "aborted" : "failed", null);
+                // A failed/interrupted Core save or offload can skip the normal model
+                // checkpoint. Persist known usage before any fallible onEnd hook.
+                if (checkpointModelCalls.length > 0)
+                    await mutateSession({ modelCalls: checkpointModelCalls.splice(0) });
                 await contextRuntime.onEnd(lastStepNumber, end ?? {
                     totalUsage: mainUsage ?? {
                         inputTokens: undefined,
@@ -4150,6 +4192,8 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         })();
         return settling;
     };
+    let terminalMessage;
+    let terminalEvent;
     const saveResponseMessage = async ({ responseMessage, }) => {
         const saveStartedAt = performance.now();
         const metadata = await contextFinished;
@@ -4172,9 +4216,19 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             ...metadata,
         };
         const transcriptStartedAt = performance.now();
+        const combineTerminal = sessionExecution &&
+            !input.channelJournal &&
+            !inboxRunner?.suspended &&
+            !failure &&
+            metadata.finishReason === "stop";
         // Retain the generated transcript even if context settlement failed.
         // A failed settlement must never produce a successful Run completion.
-        if (sessionExecution) {
+        if (combineTerminal) {
+            // The managed durable stream drains independently of the HTTP consumer.
+            // Its flush commits this transcript with finish before publishing success.
+            terminalMessage = { ...responseMessage };
+        }
+        else if (sessionExecution) {
             await mutateSession({ messages: [{ ...responseMessage }] });
         }
         else {
@@ -4188,7 +4242,17 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
         const transcriptFinishedAt = performance.now();
         if (failure)
             throw failure.error;
-        await persistModelContext();
+        try {
+            await persistModelContext();
+        }
+        catch (error) {
+            // Preserve the transcript on a failed final context write as before.
+            if (terminalMessage) {
+                await mutateSession({ messages: [{ ...terminalMessage }] });
+                terminalMessage = undefined;
+            }
+            throw error;
+        }
         const contextPersistedAt = performance.now();
         persistenceSpan?.setAttributes({
             "gea.session.finish.context_wait_ms": Math.round(contextFinishedAt - saveStartedAt),
@@ -4530,7 +4594,9 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                 const usage = coreUsage(part.usage);
                 mainUsage = addAgentWorkerUsage(mainUsage, usage);
                 invocationTiming.lastModelFinishedAt = performance.now();
-                await recordMainCall("completed", usage);
+                // Core saves its validated model response before running tools or
+                // declaring completion. Commit usage with that same checkpoint.
+                await recordMainCall("completed", usage, true);
                 modelSpan?.setAttribute("gen_ai.output.messages", JSON.stringify(toModelMessages([part.message])));
                 if (usage.inputTokens !== undefined)
                     modelSpan?.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens);
@@ -4654,7 +4720,7 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                 mainUsage = addAgentWorkerUsage(mainUsage, step.usage);
                 lastStepNumber = step.stepNumber;
                 try {
-                    await recordMainCall(step.finishReason === "error" ? "failed" : "completed", step.usage);
+                    await recordMainCall(step.finishReason === "error" ? "failed" : "completed", step.usage, true);
                     await contextRuntime.offload();
                     await persistModelContext();
                     await contextRuntime.onStepEnd(step.stepNumber, {
@@ -4804,6 +4870,13 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
                         controller.enqueue(chunk);
                         continue;
                     }
+                    if (sessionExecution &&
+                        !input.channelJournal &&
+                        !inboxRunner?.suspended &&
+                        metadata.finishReason === "stop") {
+                        terminalEvent = chunk;
+                        continue;
+                    }
                 }
                 events.push(chunk);
             }
@@ -4817,8 +4890,20 @@ async function executeAgentWorkerRequest(input, waitUntil, ownComputer, ownSessi
             for (const event of events)
                 controller.enqueue(event);
         },
+        async flush(controller) {
+            if (!terminalMessage && !terminalEvent)
+                return;
+            const startedAt = performance.now();
+            await mutateSession({
+                ...(terminalMessage ? { messages: [{ ...terminalMessage }] } : {}),
+                ...(terminalEvent ? { events: [terminalEvent] } : {}),
+            });
+            persistenceSpan?.setAttribute("gea.session.finish.transcript_ms", Math.round(performance.now() - startedAt));
+            if (terminalEvent)
+                controller.enqueue(terminalEvent);
+        },
     }));
-    if (engine) {
+    if (engine || sessionExecution) {
         const [owned, response] = durableStream.tee();
         waitUntil((async () => {
             const reader = owned.getReader();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gea-ai/agent-sdk",
-  "version": "0.1.260923-alpha.0",
+  "version": "0.1.260923-alpha.2",
   "private": false,
   "homepage": "https://musegea.com/developers",
   "license": "Apache-2.0",
@@ -36,15 +36,6 @@
       "types": "./dist/evals.d.ts",
       "import": "./dist/evals.js"
     },
-    "./studio-client": {
-      "types": "./dist/studio-client.d.ts",
-      "import": "./dist/studio-client.js"
-    },
-    "./studio-server": {
-      "browser": null,
-      "types": "./dist/studio-server.d.ts",
-      "import": "./dist/studio-server.js"
-    },
     "./computer": {
       "types": "./dist/computer.d.ts",
       "import": "./dist/computer.js"
@@ -108,7 +99,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.260923-alpha.0",
+    "@gea-ai/contract": "0.1.260923-alpha.2",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/context-async-hooks": "2.10.0",
     "@opentelemetry/core": "2.10.0",

package/dist/studio-client.d.ts

@@ -1,22 +0,0 @@
-import { DefaultChatTransport, type ChatTransport, type HttpChatTransportInitOptions, type UIMessage } from "ai";
-import type { StudioAgentApiRunContext } from "@gea-ai/contract";
-import type { StudioAgentStreamReplay } from "@gea-ai/contract/studio-agent-api";
-export type StudioAgentChatTransportOptions<UI_MESSAGE extends UIMessage = UIMessage> = Pick<HttpChatTransportInitOptions<UI_MESSAGE>, "headers" | "credentials" | "fetch"> & {
-    /** Same-origin application backend path, without /run. Never a GEA URL. */
-    api: string;
-    /** Restore an existing GEA Chat; the AI SDK's local chat ID is independent. */
-    chatId?: string;
-    /** Called as soon as a response identifies its Run, before reading the stream. */
-    onRun?: (run: StudioAgentApiRunContext) => void;
-    /** Replace the matching assistant baseline before AI SDK consumes a full replay. */
-    onReplay?: (replay: StudioAgentStreamReplay<UI_MESSAGE>) => void | Promise<void>;
-};
-/** One transport per conversation. The caller's backend keeps the Project API key. */
-export declare class StudioAgentChatTransport<UI_MESSAGE extends UIMessage = UIMessage> extends DefaultChatTransport<UI_MESSAGE> {
-    private serverChatId;
-    private latestRun;
-    constructor(options: StudioAgentChatTransportOptions<UI_MESSAGE>);
-    get chatId(): string | undefined;
-    get lastRun(): StudioAgentApiRunContext | undefined;
-    reconnectToStream(options: Parameters<ChatTransport<UI_MESSAGE>["reconnectToStream"]>[0]): Promise<ReadableStream<import("ai").UIMessageChunk<unknown, import("ai").UIDataTypes>> | null>;
-}

package/dist/studio-client.js

@@ -1,97 +0,0 @@
-import { AGENT_APPLICATION_CHAT_ID_HEADER, AGENT_APPLICATION_RUN_ID_HEADER, AGENT_APPLICATION_REQUEST_ID_HEADER, agentApplicationUserMessageSchema, } from "@gea-ai/contract/agent-applications";
-import { DefaultChatTransport, } from "ai";
-import { restoreStudioStreamReplay } from "./studio-stream-replay.js";
-/** One transport per conversation. The caller's backend keeps the Project API key. */
-export class StudioAgentChatTransport extends DefaultChatTransport {
-    serverChatId;
-    latestRun;
-    constructor(options) {
-        const api = options.api.replace(/\/$/u, "");
-        if (!api.startsWith("/") || api.startsWith("//") || /[\\\s?#]/u.test(api)) {
-            throw new Error("Studio transport requires an application backend path such as /api/agent.");
-        }
-        super({
-            api: `${api}/run`,
-            credentials: options.credentials ?? "same-origin",
-            headers: options.headers,
-            fetch: async (url, init) => {
-                const response = await (options.fetch ?? globalThis.fetch)(url, init);
-                const chatId = response.headers.get(AGENT_APPLICATION_CHAT_ID_HEADER);
-                const runId = response.headers.get(AGENT_APPLICATION_RUN_ID_HEADER);
-                const requestId = response.headers.get(AGENT_APPLICATION_REQUEST_ID_HEADER);
-                // Failed startup can still create a Chat. Retain it for recovery.
-                if (chatId)
-                    this.serverChatId = chatId;
-                if (chatId && runId && requestId) {
-                    this.latestRun = { chatId, runId, requestId };
-                    options.onRun?.(this.latestRun);
-                }
-                if (init?.method === "GET" &&
-                    response.ok &&
-                    response.status !== 204 &&
-                    options.onReplay) {
-                    return restoreStudioStreamReplay(response, this.serverChatId, options.onReplay);
-                }
-                return response;
-            },
-            prepareSendMessagesRequest: ({ messages, trigger }) => {
-                if (trigger === "regenerate-message") {
-                    throw new Error("Studio Agent API does not support regenerating a previous turn.");
-                }
-                const message = messages.at(-1);
-                if (!message)
-                    throw new Error("Studio Agent API requires a message.");
-                if (message.role === "assistant") {
-                    if (!this.serverChatId)
-                        throw new Error("Tool continuation requires an existing Studio Chat.");
-                    return {
-                        body: {
-                            chatId: this.serverChatId,
-                            message: {
-                                id: message.id,
-                                role: "assistant",
-                                parts: message.parts,
-                            },
-                        },
-                    };
-                }
-                const userMessage = agentApplicationUserMessageSchema.parse({
-                    role: message.role,
-                    parts: message.parts,
-                });
-                if (userMessage.parts.some((part) => part.type === "file"))
-                    return {
-                        body: {
-                            ...(this.serverChatId ? { chatId: this.serverChatId } : {}),
-                            message: userMessage,
-                        },
-                    };
-                const text = message.parts
-                    .filter((part) => part.type === "text")
-                    .map((part) => part.text)
-                    .join("\n");
-                return {
-                    body: {
-                        ...(this.serverChatId ? { chatId: this.serverChatId } : {}),
-                        message: text,
-                    },
-                };
-            },
-            prepareReconnectToStreamRequest: () => ({
-                api: `${api}/chats/${encodeURIComponent(this.serverChatId)}/stream`,
-            }),
-        });
-        this.serverChatId = options.chatId;
-    }
-    get chatId() {
-        return this.serverChatId;
-    }
-    get lastRun() {
-        return this.latestRun;
-    }
-    async reconnectToStream(options) {
-        if (!this.serverChatId)
-            return null;
-        return super.reconnectToStream(options);
-    }
-}

package/dist/studio-server.d.ts

@@ -1,29 +0,0 @@
-import { type StudioAgentCreateUploadInput, type StudioAgentApiRunInput } from "@gea-ai/contract/studio-agent-api";
-export type StudioAgentClientOptions = {
-    /** GEA Agent environment base URL or the copied canonical /run URL. */
-    api: string;
-    /** Project API key or current GEA user's OAuth access token. */
-    token: string;
-    fetch?: typeof globalThis.fetch;
-};
-/**
- * Backend-to-GEA client. The application authenticates users and checks Chat
- * ownership before calling this client; it does not accept browser Requests.
- */
-export declare class StudioAgentClient {
-    private readonly options;
-    private readonly api;
-    private readonly token;
-    constructor(options: StudioAgentClientOptions);
-    run(input: StudioAgentApiRunInput, options?: {
-        signal?: AbortSignal;
-    }): Promise<Response>;
-    resumeStream(chatId: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<Response>;
-    /** Reserve a checksum-bound direct upload; PUT the file to the returned uploadUrl. */
-    createUpload(input: StudioAgentCreateUploadInput, options?: {
-        signal?: AbortSignal;
-    }): Promise<Response>;
-    private request;
-}

package/dist/studio-server.js

@@ -1,92 +0,0 @@
-import { buildAgentApplicationPath, parseAgentApplicationPath, AGENT_APPLICATION_CHAT_ID_HEADER, AGENT_APPLICATION_RUN_ID_HEADER, AGENT_APPLICATION_REQUEST_ID_HEADER, } from "@gea-ai/contract/agent-applications";
-import { studioAgentApiRunInputSchema, studioAgentClientRunInputSchema, studioAgentCreateUploadInputSchema, } from "@gea-ai/contract/studio-agent-api";
-/**
- * Backend-to-GEA client. The application authenticates users and checks Chat
- * ownership before calling this client; it does not accept browser Requests.
- */
-export class StudioAgentClient {
-    options;
-    api;
-    token;
-    constructor(options) {
-        this.options = options;
-        const url = new URL(options.api);
-        const local = url.hostname === "localhost" ||
-            url.hostname.endsWith(".localhost") ||
-            url.hostname === "127.0.0.1" ||
-            url.hostname === "[::1]";
-        if ((url.protocol !== "https:" && !(url.protocol === "http:" && local)) ||
-            url.username ||
-            url.password ||
-            url.search ||
-            url.hash) {
-            throw new Error("Studio server client requires an HTTPS Agent URL without credentials, query or fragment (HTTP is allowed on localhost).");
-        }
-        if (!options.token?.trim())
-            throw new Error("Studio server client requires a token.");
-        const route = parseAgentApplicationPath(url.pathname);
-        if (route?.agentKey &&
-            route.segments.length === 1 &&
-            route.segments[0] === "run") {
-            url.pathname = buildAgentApplicationPath(route.agentKey);
-        }
-        this.token = options.token;
-        this.api = url.href.replace(/\/$/u, "");
-    }
-    async run(input, options = {}) {
-        const body = studioAgentApiRunInputSchema.parse(input);
-        return this.request("/run", {
-            method: "POST",
-            body: JSON.stringify(body),
-            signal: options.signal,
-        });
-    }
-    async resumeStream(chatId, options = {}) {
-        const id = studioAgentClientRunInputSchema.shape.chatId
-            .unwrap()
-            .parse(chatId);
-        return this.request(`/chats/${id}/stream`, {
-            method: "GET",
-            signal: options.signal,
-        });
-    }
-    /** Reserve a checksum-bound direct upload; PUT the file to the returned uploadUrl. */
-    async createUpload(input, options = {}) {
-        return this.request("/uploads", {
-            method: "POST",
-            body: JSON.stringify(studioAgentCreateUploadInputSchema.parse(input)),
-            signal: options.signal,
-        });
-    }
-    async request(path, init) {
-        // This is the HTTP response boundary: never expose transport exceptions to the browser.
-        try {
-            const upstream = await (this.options.fetch ?? globalThis.fetch)(`${this.api}${path}`, {
-                ...init,
-                headers: {
-                    Authorization: `Bearer ${this.token}`,
-                    ...(init.body ? { "Content-Type": "application/json" } : {}),
-                },
-                credentials: "omit",
-                redirect: "error",
-                cache: "no-store",
-            });
-            const headers = new Headers({ "cache-control": "no-store" });
-            for (const name of [
-                "content-type",
-                "x-vercel-ai-ui-message-stream",
-                AGENT_APPLICATION_CHAT_ID_HEADER,
-                AGENT_APPLICATION_RUN_ID_HEADER,
-                AGENT_APPLICATION_REQUEST_ID_HEADER,
-            ]) {
-                const value = upstream.headers.get(name);
-                if (value !== null)
-                    headers.set(name, value);
-            }
-            return new Response(upstream.body, { status: upstream.status, headers });
-        }
-        catch {
-            return Response.json({ code: "BAD_GATEWAY", message: "Could not reach the Agent service." }, { status: 502, headers: { "cache-control": "no-store" } });
-        }
-    }
-}

package/dist/studio-stream-replay.d.ts

@@ -1,4 +0,0 @@
-import { type UIMessage } from "ai";
-import { type StudioAgentStreamReplay } from "@gea-ai/contract/studio-agent-api";
-/** Consume only the Run baseline. The remaining SSE stays streamed with backpressure. */
-export declare function restoreStudioStreamReplay<MESSAGE extends UIMessage>(response: Response, chatId: string, onReplay: (replay: StudioAgentStreamReplay<MESSAGE>) => void | Promise<void>): Promise<Response>;

package/dist/studio-stream-replay.js

@@ -1,62 +0,0 @@
-import { validateUIMessages } from "ai";
-import { STUDIO_AGENT_REPLAY_PREFIX, studioAgentStreamReplaySchema, } from "@gea-ai/contract/studio-agent-api";
-/** Consume only the Run baseline. The remaining SSE stays streamed with backpressure. */
-export async function restoreStudioStreamReplay(response, chatId, onReplay) {
-    if (!response.body)
-        throw new Error("Missing Agent replay context. Refresh conversation history.");
-    const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-    // The owned replay format starts with one JSON SSE comment line. Its JSON
-    // escapes embedded CR/LF; the normal AI SDK SSE parser handles all later bytes.
-    try {
-        let prefix = "";
-        while (!prefix.includes("\n")) {
-            const next = await reader.read();
-            if (next.done)
-                throw new Error("Missing Agent replay context. Refresh conversation history.");
-            prefix += next.value;
-        }
-        const end = prefix.indexOf("\n");
-        const line = prefix.slice(0, end);
-        if (!line.startsWith(STUDIO_AGENT_REPLAY_PREFIX))
-            throw new Error("Missing Agent replay context. Refresh conversation history.");
-        const replay = studioAgentStreamReplaySchema.parse(JSON.parse(line.slice(STUDIO_AGENT_REPLAY_PREFIX.length)));
-        if (replay.chatId !== chatId)
-            throw new Error("Agent replay belongs to another Chat.");
-        // A new Run starts with no parts. This is valid streaming state, although
-        // AI SDK's validator intentionally rejects empty submitted/history messages.
-        const message = replay.message.parts.length === 0
-            ? replay.message
-            : (await validateUIMessages({ messages: [replay.message] }))[0];
-        // useChat captures its streaming state after reconnectToStream resolves.
-        await onReplay({ ...replay, message });
-        const remainder = prefix.slice(end + 1);
-        const body = new ReadableStream({
-            start(controller) {
-                if (remainder)
-                    controller.enqueue(remainder);
-            },
-            async pull(controller) {
-                const next = await reader.read();
-                if (next.done) {
-                    reader.releaseLock();
-                    controller.close();
-                }
-                else
-                    controller.enqueue(next.value);
-            },
-            async cancel(reason) {
-                await reader.cancel(reason);
-                reader.releaseLock();
-            },
-        }).pipeThrough(new TextEncoderStream());
-        const headers = new Headers(response.headers);
-        headers.delete("content-length");
-        return new Response(body, { status: response.status, headers });
-    }
-    catch (error) {
-        // Cleanup must not replace the original protocol/callback failure.
-        await reader.cancel(error).catch(() => { });
-        reader.releaseLock();
-        throw error;
-    }
-}