@trigger.dev/sdk 4.5.0-rc.4 → 4.5.0-rc.6

package/dist/commonjs/v3/ai.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chat = exports.upsertIncomingMessage = exports.PENDING_MESSAGE_INJECTED_TYPE = exports.ai = void 0;
+exports.__findLatestSessionInCursorForTests = __findLatestSessionInCursorForTests;
 exports.__setReadChatSnapshotImplForTests = __setReadChatSnapshotImplForTests;
 exports.__setWriteChatSnapshotImplForTests = __setWriteChatSnapshotImplForTests;
 exports.__readChatSnapshotProductionPathForTests = __readChatSnapshotProductionPathForTests;
@@ -12,7 +13,9 @@ exports.__setReplaySessionInTailImplForTests = __setReplaySessionInTailImplForTe
 exports.__replaySessionInTailProductionPathForTests = __replaySessionInTailProductionPathForTests;
 exports.buildSkillTools = buildSkillTools;
 const v3_1 = require("@trigger.dev/core/v3");
-const ai_1 = require("ai");
+// Runtime VALUES go through the ESM/CJS shim so the CJS build can `require`
+// ESM-only `ai@7` (see ../imports/ai-runtime.ts).
+const ai_runtime_js_1 = require("../imports/ai-runtime.js");
 const api_1 = require("@opentelemetry/api");
 const auth_js_1 = require("./auth.js");
 const locals_js_1 = require("./locals.js");
@@ -29,6 +32,7 @@ const agentSkillsRuntime_js_1 = require("./agentSkillsRuntime.js");
 const streams_js_1 = require("./streams.js");
 const sessions_js_1 = require("./sessions.js");
 const shared_js_1 = require("./shared.js");
+const aiAutoTelemetry_js_1 = require("./aiAutoTelemetry.js");
 const v3_2 = require("@trigger.dev/core/v3");
 const tracer_js_1 = require("./tracer.js");
 const METADATA_KEY = "tool.execute.options";
@@ -44,7 +48,7 @@ function toModelMessages(messages) {
     // conditional spread keeps the options object byte-identical to the no-tools
     // path when nothing was declared.
     const tools = locals_js_1.locals.get(chatResolvedToolsKey);
-    return (0, ai_1.convertToModelMessages)(messages, {
+    return (0, ai_runtime_js_1.convertToModelMessages)(messages, {
         ignoreIncompleteToolCalls: true,
         ...(tools ? { tools } : {}),
     });
@@ -78,51 +82,41 @@ const lastTurnCompleteSeqNumKey = locals_js_1.locals.create("chat.lastTurnComple
  * the `.in` subscription so already-processed user messages don't get
  * replayed from S2.
  *
- * Implementation streams the SSE endpoint and listens for `turn-complete`
- * via the transport's `onControl` callback; the data-chunk for-await is
- * just there to drive the stream. The scan is O(1 turn) because
- * `session.out` is bounded to roughly one turn at steady state — every
- * successful turn-complete is followed by an S2 trim back to the
- * previous one (see `writeTurnCompleteChunk`).
+ * Implementation is a non-blocking records read (`wait=0`) — the
+ * endpoint returns everything currently stored (including pre-trim
+ * records, since S2 trims are eventually consistent) in one shot, and
+ * we keep the LAST matching header. The previous SSE-based scan had to
+ * idle-wait a full 5s window to know it reached the tail, which put a
+ * constant ~6s tax on every continuation boot.
  *
  * Returns `undefined` if no `turn-complete` carrying the header has been
  * written yet — first-turn-ever, first turn post-OOM-with-no-prior-runs,
- * or a `turn-complete` written before this header existed (cross-version
- * boot). Callers fall back to subscribing `.in` from seq 0 in that case;
- * the slim-wire merge handles any dedup against snapshot-restored
- * messages.
+ * a `turn-complete` written before this header existed, or a server old
+ * enough that the records endpoint doesn't serialize headers. Callers
+ * fall back to subscribing `.in` from seq 0 in that case; the slim-wire
+ * merge handles any dedup against snapshot-restored messages.
  * @internal
  */
 async function findLatestSessionInCursor(chatId) {
     const apiClient = v3_1.apiClientManager.clientOrThrow();
+    const response = await apiClient.readSessionStreamRecords(chatId, "out");
     let latestCursor;
-    const stream = await apiClient.subscribeToSessionStream(chatId, "out", {
-        // 5s rather than 1s: S2 trim is eventually-consistent (10-60s
-        // window), so a worker booting just after a trim could still see
-        // pre-trim records and need a bit longer to drain them all before
-        // the SSE long-poll closes. Without enough headroom the scan would
-        // fall back to `undefined`, the `.in` cursor wouldn't be seeded,
-        // and the next subscribe would replay messages already processed.
-        timeoutInSeconds: 5,
-        onControl: (event) => {
-            if (event.subtype !== v3_1.TRIGGER_CONTROL_SUBTYPE.TURN_COMPLETE)
-                return;
-            const raw = (0, v3_1.headerValue)(event.headers, v3_1.SESSION_IN_EVENT_ID_HEADER);
-            if (!raw)
-                return;
-            const parsed = Number.parseInt(raw, 10);
-            if (Number.isFinite(parsed))
-                latestCursor = parsed;
-        },
-    });
-    // Drain the stream so the underlying SSE reader runs to completion. We
-    // don't accumulate chunks; `onControl` fires inline as turn-complete
-    // records arrive.
-    for await (const _ of stream) {
-        // intentionally empty
+    for (const record of response.records) {
+        if ((0, v3_1.controlSubtype)(record.headers) !== v3_1.TRIGGER_CONTROL_SUBTYPE.TURN_COMPLETE)
+            continue;
+        const raw = (0, v3_1.headerValue)(record.headers, v3_1.SESSION_IN_EVENT_ID_HEADER);
+        if (!raw)
+            continue;
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isFinite(parsed))
+            latestCursor = parsed;
     }
     return latestCursor;
 }
+/** Test-only entry point for the records-based cursor scan. @internal */
+async function __findLatestSessionInCursorForTests(chatId) {
+    return findLatestSessionInCursor(chatId);
+}
 let readChatSnapshotImpl;
 function __setReadChatSnapshotImplForTests(impl) {
     readChatSnapshotImpl = impl;
@@ -451,7 +445,7 @@ async function replaySessionOutTail(sessionId, options) {
         });
         let last;
         try {
-            for await (const snapshot of (0, ai_1.readUIMessageStream)({ stream: segmentStream })) {
+            for await (const snapshot of (0, ai_runtime_js_1.readUIMessageStream)({ stream: segmentStream })) {
                 last = snapshot;
             }
         }
@@ -654,9 +648,14 @@ function createTaskToolExecuteHandler(task) {
         const toolMeta = {
             toolCallId: toolOpts?.toolCallId ?? "",
         };
-        if (toolOpts?.experimental_context !== undefined) {
+        // v6 passes user context as `experimental_context`, v7 as `context`. Read
+        // whichever is set and stamp both so subtasks reading either name work.
+        const toolContext = toolOpts?.context ?? toolOpts?.experimental_context;
+        if (toolContext !== undefined) {
             try {
-                toolMeta.experimental_context = JSON.parse(JSON.stringify(toolOpts.experimental_context));
+                const serialized = JSON.parse(JSON.stringify(toolContext));
+                toolMeta.experimental_context = serialized;
+                toolMeta.context = serialized;
             }
             catch {
                 /* non-serializable */
@@ -699,9 +698,9 @@ function toolFromTask(task, options) {
     // Zod-backed tasks: use static `tool()` so runtime shape matches `ToolSet`. Generic task context
     // prevents `tool()` overloads from inferring input; `as any` is localized to this call only.
     if ("schema" in task && task.schema && (0, v3_1.isSchemaZodEsque)(task.schema)) {
-        const staticTool = (0, ai_1.tool)({
+        const staticTool = (0, ai_runtime_js_1.tool)({
             description: task.description ?? "",
-            inputSchema: (0, ai_1.zodSchema)(task.schema),
+            inputSchema: (0, ai_runtime_js_1.zodSchema)(task.schema),
             execute: async (input, toolOpts) => executeFromTaskInput(input, toolOpts),
             ...(options?.experimental_toToolResultContent !== undefined
                 ? { experimental_toToolResultContent: options.experimental_toToolResultContent }
@@ -709,7 +708,7 @@ function toolFromTask(task, options) {
         });
         return staticTool;
     }
-    const toolDefinition = (0, ai_1.dynamicTool)({
+    const toolDefinition = (0, ai_runtime_js_1.dynamicTool)({
         description: task.description,
         inputSchema: convertTaskSchemaToToolParameters(task),
         ...(options?.experimental_toToolResultContent !== undefined
@@ -777,15 +776,15 @@ function convertTaskSchemaToToolParameters(task) {
     if ("schema" in task) {
         // If TaskSchema is ArkTypeEsque, use ai.jsonSchema to convert it to a Schema
         if ("toJsonSchema" in task.schema && typeof task.schema.toJsonSchema === "function") {
-            return (0, ai_1.jsonSchema)(task.schema.toJsonSchema());
+            return (0, ai_runtime_js_1.jsonSchema)(task.schema.toJsonSchema());
         }
         // If TaskSchema is ZodEsque, use ai.zodSchema to convert it to a Schema
         if ((0, v3_1.isSchemaZodEsque)(task.schema)) {
-            return (0, ai_1.zodSchema)(task.schema);
+            return (0, ai_runtime_js_1.zodSchema)(task.schema);
         }
     }
     if ("jsonSchema" in task) {
-        return (0, ai_1.jsonSchema)(task.jsonSchema);
+        return (0, ai_runtime_js_1.jsonSchema)(task.jsonSchema);
     }
     throw new Error("Cannot convert task to a tool. Make sure to use a task with a schema or jsonSchema.");
 }
@@ -985,8 +984,15 @@ const messagesInput = {
     on(handler) {
         return getChatSession().in.on((chunk) => {
             if (chunk.kind === "message") {
-                return handler(chunk.payload);
+                // Returning `true` marks the record CONSUMED at the manager level:
+                // it is neither buffered for a later `once()` nor re-delivered by
+                // the buffer drain when the next turn re-attaches its handler.
+                // Without this, a message arriving mid-stream was delivered twice
+                // and ran a duplicate turn.
+                void Promise.resolve(handler(chunk.payload)).catch(() => { });
+                return true;
             }
+            return undefined;
         });
     },
     once(options) {
@@ -1080,8 +1086,13 @@ const stopInput = {
     on(handler) {
         return getChatSession().in.on((chunk) => {
             if (chunk.kind === "stop") {
-                return handler({ stop: true, message: chunk.message });
+                // Consume stop records (see the messages facade above). A stop is
+                // only meaningful to the turn it interrupts — buffering it would
+                // let a stale stop abort a future turn.
+                void Promise.resolve(handler({ stop: true, message: chunk.message })).catch(() => { });
+                return true;
             }
+            return undefined;
         });
     },
     once(options) {
@@ -1235,6 +1246,9 @@ const chatHandoverIsFinalKey = locals_js_1.locals.create("chat.handoverIsFinal")
  * `tool-approval-response` rows are AI-SDK-internal and don't need a
  * UIMessage representation. We map:
  *   - `text` parts → `{ type: "text", text }`
+ *   - `reasoning` parts → `{ type: "reasoning", text, state: "done" }`
+ *      (provider metadata carried so an Anthropic thinking signature
+ *      survives a UIMessage → ModelMessage round trip)
  *   - `tool-call` parts → `{ type: "tool-${name}", toolCallId,
  *      state: "input-available", input }`
  *   - `tool-approval-request` parts → skipped (AI SDK derives the
@@ -1251,6 +1265,14 @@ function synthesizeHandoverUIMessage(partial, messageId) {
         if (part.type === "text" && typeof part.text === "string") {
             parts.push({ type: "text", text: part.text });
         }
+        else if (part.type === "reasoning" && typeof part.text === "string") {
+            parts.push({
+                type: "reasoning",
+                text: part.text,
+                state: "done",
+                ...(part.providerOptions ? { providerMetadata: part.providerOptions } : {}),
+            });
+        }
         else if (part.type === "tool-call" && part.toolCallId && part.toolName) {
             parts.push({
                 type: `tool-${part.toolName}`,
@@ -1269,7 +1291,7 @@ function synthesizeHandoverUIMessage(partial, messageId) {
     // browser). Fall back to a fresh id only if the handover signal
     // didn't carry one.
     return {
-        id: messageId ?? (0, ai_1.generateId)(),
+        id: messageId ?? (0, ai_runtime_js_1.generateId)(),
         role: "assistant",
         parts,
     };
@@ -1425,7 +1447,7 @@ function* iterateToolParts(message) {
     if (message.role !== "assistant")
         return;
     for (const part of (message.parts ?? [])) {
-        if (!(0, ai_1.isToolUIPart)(part))
+        if (!(0, ai_runtime_js_1.isToolUIPart)(part))
             continue;
         const toolCallId = part.toolCallId;
         if (typeof toolCallId !== "string" || toolCallId.length === 0)
@@ -1433,7 +1455,7 @@ function* iterateToolParts(message) {
         yield {
             part,
             toolCallId,
-            toolName: (0, ai_1.getToolName)(part),
+            toolName: (0, ai_runtime_js_1.getToolName)(part),
             state: part.state,
         };
     }
@@ -1457,7 +1479,7 @@ function extractPendingToolCallsFromPartial(partial) {
     const parts = (partial.parts ?? []);
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
-        if (!(0, ai_1.isToolUIPart)(part))
+        if (!(0, ai_runtime_js_1.isToolUIPart)(part))
             continue;
         if (!isPendingToolState(part.state))
             continue;
@@ -1466,7 +1488,7 @@ function extractPendingToolCallsFromPartial(partial) {
             continue;
         out.push({
             toolCallId,
-            toolName: (0, ai_1.getToolName)(part),
+            toolName: (0, ai_runtime_js_1.getToolName)(part),
             input: part.input,
             partIndex: i,
         });
@@ -1569,7 +1591,7 @@ function extractNewToolResultsFromHistory(message, messages) {
 function mergeIncomingIntoHydrated(hydrated, incoming) {
     const incomingAdvancedByCallId = new Map();
     for (const part of (incoming.parts ?? [])) {
-        if (!(0, ai_1.isToolUIPart)(part))
+        if (!(0, ai_runtime_js_1.isToolUIPart)(part))
             continue;
         const toolCallId = part.toolCallId;
         if (typeof toolCallId !== "string" || toolCallId.length === 0)
@@ -1583,7 +1605,7 @@ function mergeIncomingIntoHydrated(hydrated, incoming) {
     let mutated = false;
     const hydratedParts = (hydrated.parts ?? []);
     const mergedParts = hydratedParts.map((part) => {
-        if (!(0, ai_1.isToolUIPart)(part))
+        if (!(0, ai_runtime_js_1.isToolUIPart)(part))
             return part;
         const toolCallId = part.toolCallId;
         if (typeof toolCallId !== "string" || toolCallId.length === 0)
@@ -1973,7 +1995,7 @@ async function chatCompact(messages, steps, options) {
         return { type: "skipped" };
     }
     const result = await tracer_js_1.tracer.startActiveSpan("context compaction", async (span) => {
-        const compactionId = (0, ai_1.generateId)();
+        const compactionId = (0, ai_runtime_js_1.generateId)();
         let summary;
         const { waitUntilComplete } = chatStream.writer({
             spanName: "stream compaction chunks",
@@ -2148,7 +2170,7 @@ async function drainSteeringQueue(config, messages, steps, queueOverride) {
                     execute: ({ write }) => {
                         write({
                             type: ai_shared_js_2.PENDING_MESSAGE_INJECTED_TYPE,
-                            id: (0, ai_1.generateId)(),
+                            id: (0, ai_runtime_js_1.generateId)(),
                             data: {
                                 messageIds: uiMessages.map((m) => m.id),
                                 messages: uiMessages.map((m, idx) => ({
@@ -2302,9 +2324,9 @@ function findSkillByName(skills, name) {
  * (e.g. in a `chat.createSession` loop with custom streamText).
  */
 function buildSkillTools(skills) {
-    const loadSkill = (0, ai_1.tool)({
+    const loadSkill = (0, ai_runtime_js_1.tool)({
         description: "Load the full instructions for a skill by its name. Call this first before using a skill.",
-        inputSchema: (0, ai_1.jsonSchema)({
+        inputSchema: (0, ai_runtime_js_1.jsonSchema)({
             type: "object",
             properties: {
                 name: {
@@ -2332,9 +2354,9 @@ function buildSkillTools(skills) {
             };
         },
     });
-    const readFile = (0, ai_1.tool)({
+    const readFile = (0, ai_runtime_js_1.tool)({
         description: "Read a file from a skill's bundled folder. Paths must be relative to the skill's root.",
-        inputSchema: (0, ai_1.jsonSchema)({
+        inputSchema: (0, ai_runtime_js_1.jsonSchema)({
             type: "object",
             properties: {
                 skill: { type: "string", description: "The skill's name (from frontmatter)." },
@@ -2362,9 +2384,9 @@ function buildSkillTools(skills) {
             }
         },
     });
-    const bash = (0, ai_1.tool)({
+    const bash = (0, ai_runtime_js_1.tool)({
         description: "Run a bash command inside a skill's bundled folder. Use this to invoke the skill's scripts. The working directory is the skill's root.",
-        inputSchema: (0, ai_1.jsonSchema)({
+        inputSchema: (0, ai_runtime_js_1.jsonSchema)({
             type: "object",
             properties: {
                 skill: { type: "string", description: "The skill's name (from frontmatter)." },
@@ -2597,6 +2619,11 @@ function chatCustomAgent(options) {
             // No client-side upsert needed.
             locals_js_1.locals.set(chatSessionHandleKey, sessions_js_1.sessions.open(payload.chatId));
             locals_js_1.locals.set(chatAgentRunContextKey, runOptions.ctx);
+            // Initialize the turn-complete trim slot so `chat.writeTurnComplete`
+            // trims `session.out` back to the previous turn boundary. Without
+            // this the slot is undefined and the trim never runs, so `.out`
+            // grows without bound for the whole custom-agent surface.
+            locals_js_1.locals.set(lastTurnCompleteSeqNumKey, { value: undefined });
             (0, streams_js_1.markChatAgentRunForStreamsWarning)();
             v3_1.taskContext.setConversationId(payload.chatId);
             stampConversationIdOnActiveSpan(payload.chatId);
@@ -2630,6 +2657,11 @@ function chatAgent(options) {
         agentConfig: { type: "ai-sdk-chat" },
         run: async (payload, { signal: runSignal, ctx }) => {
             locals_js_1.locals.set(chatAgentRunContextKey, ctx);
+            // On AI SDK 7, register the `@ai-sdk/otel` integration (once per process)
+            // so `experimental_telemetry` spans flow into the run trace. Awaited here
+            // at run boot — before any `streamText` — and a no-op on v5/v6 or when the
+            // optional `@ai-sdk/otel` peer isn't installed. See ./aiAutoTelemetry.ts.
+            await (0, aiAutoTelemetry_js_1.ensureAiSdkTelemetry)();
             // Bind the run to its backing Session so every module-level helper
             // (chat.stream, chat.messages, chat.stopSignal) resolves to this
             // chat's `.in` / `.out` channels.
@@ -2717,6 +2749,11 @@ function chatAgent(options) {
             // `messagesInput.waitWithIdleTimeout` so recovered turns fire first.
             const bootInjectedQueue = [];
             const couldHavePriorState = payload.continuation === true || ctx.attempt.number > 1;
+            // `.in` resume cursor, computed at most once per boot. The boot
+            // block below resolves it (snapshot field or records scan) and the
+            // resume-cursor block reuses it instead of re-scanning.
+            let bootInCursor;
+            let bootInCursorResolved = false;
             if (!hydrateMessages && couldHavePriorState) {
                 // Single parent span for the whole boot read phase — snapshot
                 // read, session.out replay, session.in replay. Per-phase timing
@@ -2752,23 +2789,28 @@ function chatAgent(options) {
                                 slot.value = seeded;
                         }
                     }
-                    // session.out replay
-                    const replayOutStart = Date.now();
-                    try {
-                        const replayResult = await replaySessionOutTail(sessionIdForSnapshot, { lastEventId: bootSnapshot?.lastOutEventId });
-                        replayedSettled = replayResult.settled;
-                        replayedPartial = replayResult.partial;
-                        replayedPartialRaw = replayResult.partialRaw;
-                    }
-                    catch (error) {
-                        v3_1.logger.warn("chat.agent: session.out replay failed; using snapshot only", {
-                            error: error instanceof Error ? error.message : String(error),
-                            sessionId: sessionIdForSnapshot,
-                        });
-                    }
-                    bootSpan.setAttribute("chat.boot.replay.out.durationMs", Date.now() - replayOutStart);
-                    bootSpan.setAttribute("chat.boot.replay.out.settledCount", replayedSettled.length);
-                    bootSpan.setAttribute("chat.boot.replay.out.partialPresent", replayedPartial !== undefined);
+                    // The `.out` replay and the `.in` cursor + tail read are
+                    // independent (both depend only on the snapshot) — run them
+                    // concurrently. Each phase keeps its own catch + duration
+                    // attribute.
+                    const replayOutPhase = async () => {
+                        const replayOutStart = Date.now();
+                        try {
+                            const replayResult = await replaySessionOutTail(sessionIdForSnapshot, { lastEventId: bootSnapshot?.lastOutEventId });
+                            replayedSettled = replayResult.settled;
+                            replayedPartial = replayResult.partial;
+                            replayedPartialRaw = replayResult.partialRaw;
+                        }
+                        catch (error) {
+                            v3_1.logger.warn("chat.agent: session.out replay failed; using snapshot only", {
+                                error: error instanceof Error ? error.message : String(error),
+                                sessionId: sessionIdForSnapshot,
+                            });
+                        }
+                        bootSpan.setAttribute("chat.boot.replay.out.durationMs", Date.now() - replayOutStart);
+                        bootSpan.setAttribute("chat.boot.replay.out.settledCount", replayedSettled.length);
+                        bootSpan.setAttribute("chat.boot.replay.out.partialPresent", replayedPartial !== undefined);
+                    };
                     // session.in tail read
                     //
                     // session.in carries the user-side of the conversation
@@ -2779,20 +2821,43 @@ function chatAgent(options) {
                     // visible via the live SSE subscription — by which point they
                     // would arrive AFTER the partial-assistant orphan and look like
                     // brand-new turns to the model, producing inverted chains.
-                    const replayInStart = Date.now();
-                    const lastInEventId = await findLatestSessionInCursor(payload.chatId)
-                        .then((cursor) => (cursor !== undefined ? String(cursor) : undefined))
-                        .catch(() => undefined);
-                    try {
-                        replayedInTail = await replaySessionInTail(payload.chatId, {
-                            lastEventId: lastInEventId,
-                        });
-                    }
-                    catch (error) {
-                        v3_1.logger.warn("chat.agent: session.in replay failed; in-flight users may not be recovered", { error: error instanceof Error ? error.message : String(error) });
-                    }
-                    bootSpan.setAttribute("chat.boot.replay.in.durationMs", Date.now() - replayInStart);
-                    bootSpan.setAttribute("chat.boot.replay.in.userCount", replayedInTail.length);
+                    //
+                    // The cursor comes from the snapshot when present (written
+                    // there since `lastInEventId` was added) — otherwise from a
+                    // records scan of `.out`'s latest turn-complete header.
+                    const replayInPhase = async () => {
+                        const replayInStart = Date.now();
+                        const snapshotInCursor = bootSnapshot?.lastInEventId !== undefined
+                            ? Number.parseInt(bootSnapshot.lastInEventId, 10)
+                            : undefined;
+                        if (snapshotInCursor !== undefined && Number.isFinite(snapshotInCursor)) {
+                            bootInCursor = snapshotInCursor;
+                            bootInCursorResolved = true;
+                        }
+                        else {
+                            try {
+                                bootInCursor = await findLatestSessionInCursor(payload.chatId);
+                                bootInCursorResolved = true;
+                            }
+                            catch {
+                                // Transient scan failure: leave unresolved so the
+                                // resume-cursor block below retries the lookup.
+                                bootInCursor = undefined;
+                            }
+                        }
+                        bootSpan.setAttribute("chat.boot.replay.in.cursorFromSnapshot", snapshotInCursor !== undefined);
+                        try {
+                            replayedInTail = await replaySessionInTail(payload.chatId, {
+                                lastEventId: bootInCursor !== undefined ? String(bootInCursor) : undefined,
+                            });
+                        }
+                        catch (error) {
+                            v3_1.logger.warn("chat.agent: session.in replay failed; in-flight users may not be recovered", { error: error instanceof Error ? error.message : String(error) });
+                        }
+                        bootSpan.setAttribute("chat.boot.replay.in.durationMs", Date.now() - replayInStart);
+                        bootSpan.setAttribute("chat.boot.replay.in.userCount", replayedInTail.length);
+                    };
+                    await Promise.all([replayOutPhase(), replayInPhase()]);
                 }, {
                     attributes: {
                         [v3_1.SemanticInternalAttributes.STYLE_ICON]: "tabler-rotate-clockwise",
@@ -2833,7 +2898,12 @@ function chatAgent(options) {
                 bootSnapshot !== undefined;
             if (needsResumeCursor) {
                 try {
-                    const cursor = await findLatestSessionInCursor(payload.chatId);
+                    // Reuse the cursor the boot block already resolved (snapshot
+                    // field or records scan) — only scan here when the boot block
+                    // was skipped (hydrateMessages, or snapshot-only signals).
+                    const cursor = bootInCursorResolved
+                        ? bootInCursor
+                        : await findLatestSessionInCursor(payload.chatId);
                     if (cursor !== undefined) {
                         v3_1.sessionStreams.setLastSeqNum(payload.chatId, "in", cursor);
                         v3_1.sessionStreams.setLastDispatchedSeqNum(payload.chatId, "in", cursor);
@@ -3597,6 +3667,18 @@ function chatAgent(options) {
                             // therefore a delta merge, not a full-history reset.
                             if (currentWirePayload.trigger !== "action") {
                                 let cleanedUIMessages = cleanedIncomingMessages;
+                                // Turn-0 head-start with hydrateMessages: the boot seeding from
+                                // `payload.headStartMessages` is non-hydrate-only, so ship the
+                                // route handler's first-turn history to the hydrate hook as
+                                // incoming messages instead (gated on the pending handover).
+                                if (turn === 0 &&
+                                    hydrateMessages &&
+                                    cleanedUIMessages.length === 0 &&
+                                    (locals_js_1.locals.get(chatHandoverPartialKey)?.length ?? 0) > 0 &&
+                                    Array.isArray(payload.headStartMessages) &&
+                                    payload.headStartMessages.length > 0) {
+                                    cleanedUIMessages = payload.headStartMessages;
+                                }
                                 // Validate/transform UIMessages before conversion — catches malformed
                                 // messages from storage or untrusted input before they reach the model.
                                 // Slim wire: triggers like `regenerate-message` carry no incoming
@@ -3775,40 +3857,47 @@ function chatAgent(options) {
                                     // `preload` / `close` / `handover-prepare` and submits
                                     // with no incoming message fall through with the boot-
                                     // seeded accumulator unchanged.
-                                    if (turn === 0) {
-                                        // Head-start handover splice (turn 0 only): the
-                                        // `chat.handover` route handler signalled a mid-turn
-                                        // handover, so splice its partial assistant response
-                                        // (text + pending tool-calls + the synthesized
-                                        // tool-approval round) onto the accumulator.
-                                        // `streamText` then hits AI SDK's initial-tool-
-                                        // execution branch, runs the agent-side tool executes,
-                                        // and resumes from step 2 — skipping the first model
-                                        // call (already done by the handler).
-                                        //
-                                        // We also synthesize a UIMessage form of the partial
-                                        // assistant and push it to `accumulatedUIMessages` so
-                                        // AI SDK's `processUIMessageStream` (invoked when the
-                                        // run loop calls `runResult.toUIMessageStream({
-                                        // onFinish })`) can initialize `state.message` from
-                                        // the trailing assistant in `originalMessages`. Without
-                                        // that, the `tool-output-available` chunks emitted by
-                                        // the initial-tool-execution branch can't find their
-                                        // matching tool-call in state and AI SDK throws
-                                        // `UIMessageStreamError: No tool invocation found`.
-                                        const pendingHandoverPartial = locals_js_1.locals.get(chatHandoverPartialKey);
-                                        if (pendingHandoverPartial && pendingHandoverPartial.length > 0) {
+                                }
+                                if (turn === 0) {
+                                    // Head-start handover splice (turn 0 only, BOTH
+                                    // accumulation branches — hydrate and default): the
+                                    // `chat.handover` route handler signalled a mid-turn
+                                    // handover, so splice its partial assistant response
+                                    // (text + pending tool-calls + the synthesized
+                                    // tool-approval round) onto the accumulator.
+                                    // `streamText` then hits AI SDK's initial-tool-
+                                    // execution branch, runs the agent-side tool executes,
+                                    // and resumes from step 2 — skipping the first model
+                                    // call (already done by the handler).
+                                    //
+                                    // We also synthesize a UIMessage form of the partial
+                                    // assistant and push it to `accumulatedUIMessages` so
+                                    // AI SDK's `processUIMessageStream` (invoked when the
+                                    // run loop calls `runResult.toUIMessageStream({
+                                    // onFinish })`) can initialize `state.message` from
+                                    // the trailing assistant in `originalMessages`. Without
+                                    // that, the `tool-output-available` chunks emitted by
+                                    // the initial-tool-execution branch can't find their
+                                    // matching tool-call in state and AI SDK throws
+                                    // `UIMessageStreamError: No tool invocation found`.
+                                    const pendingHandoverPartial = locals_js_1.locals.get(chatHandoverPartialKey);
+                                    if (pendingHandoverPartial && pendingHandoverPartial.length > 0) {
+                                        const handoverMessageId = locals_js_1.locals.get(chatHandoverMessageIdKey);
+                                        // Skip if the hydrated chain already persisted the
+                                        // partial under the handover messageId.
+                                        const alreadyInChain = handoverMessageId !== undefined &&
+                                            accumulatedUIMessages.some((m) => m.id === handoverMessageId);
+                                        if (!alreadyInChain) {
                                             accumulatedMessages.push(...pendingHandoverPartial);
-                                            const handoverMessageId = locals_js_1.locals.get(chatHandoverMessageIdKey);
                                             const partialUI = synthesizeHandoverUIMessage(pendingHandoverPartial, handoverMessageId);
                                             if (partialUI) {
                                                 accumulatedUIMessages.push(partialUI);
                                             }
-                                            locals_js_1.locals.set(chatHandoverPartialKey, []); // consume once
                                         }
+                                        locals_js_1.locals.set(chatHandoverPartialKey, []); // consume once
                                     }
-                                    locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
                                 }
+                                locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
                             } // end if (trigger !== "action")
                             // ── Action result handling ──────────────────────────────
                             // For action turns, skip the turn machinery entirely.
@@ -3826,7 +3915,7 @@ function chatAgent(options) {
                                         const resolvedOptions = resolveUIMessageStreamOptions();
                                         const uiStream = actionStreamResult.toUIMessageStream({
                                             ...resolvedOptions,
-                                            generateMessageId: resolvedOptions.generateMessageId ?? ai_1.generateId,
+                                            generateMessageId: resolvedOptions.generateMessageId ?? ai_runtime_js_1.generateId,
                                         });
                                         await pipeChat(uiStream, {
                                             signal: combinedSignal,
@@ -4050,7 +4139,7 @@ function chatAgent(options) {
                                             // Always provide generateMessageId so the start chunk carries a
                                             // messageId. Without this, the frontend and backend generate IDs
                                             // independently and they won't match for ID-based dedup.
-                                            generateMessageId: resolvedOptions.generateMessageId ?? ai_1.generateId,
+                                            generateMessageId: resolvedOptions.generateMessageId ?? ai_runtime_js_1.generateId,
                                             onFinish: ({ responseMessage, finishReason, }) => {
                                                 capturedResponseMessage = responseMessage;
                                                 capturedFinishReason = finishReason;
@@ -4178,7 +4267,7 @@ function chatAgent(options) {
                                     // may produce a message with an empty ID since IDs are normally
                                     // assigned by the frontend's useChat).
                                     if (!capturedResponseMessage.id) {
-                                        capturedResponseMessage = { ...capturedResponseMessage, id: (0, ai_1.generateId)() };
+                                        capturedResponseMessage = { ...capturedResponseMessage, id: (0, ai_runtime_js_1.generateId)() };
                                     }
                                     // Append any non-transient data parts queued via chat.response or writer.write()
                                     const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
@@ -4234,7 +4323,7 @@ function chatAgent(options) {
                                     const remainingParts = locals_js_1.locals.get(chatResponsePartsKey);
                                     if (remainingParts && remainingParts.length > 0) {
                                         capturedResponseMessage = {
-                                            id: (0, ai_1.generateId)(),
+                                            id: (0, ai_runtime_js_1.generateId)(),
                                             role: "assistant",
                                             parts: [...remainingParts],
                                         };
@@ -4276,7 +4365,7 @@ function chatAgent(options) {
                                     });
                                     if (shouldTrigger) {
                                         await tracer_js_1.tracer.startActiveSpan("context compaction (outer loop)", async (compactionSpan) => {
-                                            const compactionId = (0, ai_1.generateId)();
+                                            const compactionId = (0, ai_runtime_js_1.generateId)();
                                             const { waitUntilComplete } = chatStream.writer({
                                                 spanName: "stream compaction chunks",
                                                 collapsed: true,
@@ -4505,11 +4594,15 @@ function chatAgent(options) {
                                 if (!hydrateMessages) {
                                     try {
                                         await tracer_js_1.tracer.startActiveSpan("snapshot.write", async () => {
+                                            const snapshotInCursor = getChatSession().in.lastDispatchedSeqNum();
                                             await writeChatSnapshot(sessionIdForSnapshot, {
                                                 version: 1,
                                                 savedAt: Date.now(),
                                                 messages: accumulatedUIMessages,
                                                 lastOutEventId: turnCompleteResult?.lastEventId,
+                                                lastInEventId: snapshotInCursor !== undefined
+                                                    ? String(snapshotInCursor)
+                                                    : undefined,
                                             });
                                         }, {
                                             attributes: {
@@ -4646,17 +4739,100 @@ function chatAgent(options) {
                         if (turnError instanceof v3_1.OutOfMemoryError) {
                             throw turnError;
                         }
+                        let errorTurnCompleteResult;
                         try {
                             await withChatWriter(async (writer) => {
                                 const errorText = turnError instanceof Error ? turnError.message : "An unexpected error occurred";
                                 writer.write({ type: "error", errorText });
                             });
                             // Signal turn complete so the client knows this turn is done
-                            await writeTurnCompleteChunk(currentWirePayload.chatId);
+                            errorTurnCompleteResult = await writeTurnCompleteChunk(currentWirePayload.chatId);
                         }
                         catch {
                             // Best-effort — if stream write fails, let the run continue anyway
                         }
+                        // The submit-message merge into the accumulator may not have run
+                        // yet (a pre-run hook threw), so fold the wire message in for the
+                        // error event + snapshot — the cursor has already advanced past it,
+                        // so otherwise it survives in neither the snapshot nor the `.in` tail.
+                        const erroredWireMessage = currentWirePayload.message;
+                        const erroredUIMessages = erroredWireMessage &&
+                            !accumulatedUIMessages.some((m) => m.id === erroredWireMessage.id)
+                            ? [...accumulatedUIMessages, erroredWireMessage]
+                            : accumulatedUIMessages;
+                        // Fire onTurnComplete on the error path too — the docs promise it
+                        // runs "after every turn, successful or errored" so customers can
+                        // mark the turn failed. `responseMessage` is undefined/partial and
+                        // `error` carries the thrown value.
+                        if (onTurnComplete) {
+                            try {
+                                await tracer_js_1.tracer.startActiveSpan("onTurnComplete()", async () => {
+                                    await onTurnComplete({
+                                        ctx,
+                                        chatId: currentWirePayload.chatId,
+                                        messages: accumulatedMessages,
+                                        uiMessages: erroredUIMessages,
+                                        newMessages: [],
+                                        newUIMessages: erroredWireMessage ? [erroredWireMessage] : [],
+                                        responseMessage: undefined,
+                                        rawResponseMessage: undefined,
+                                        turn,
+                                        runId: ctx.run.id,
+                                        chatAccessToken: "",
+                                        // Parsed `clientData` isn't reliably in scope here (parsing
+                                        // may itself be the failure), and the raw metadata is the
+                                        // wrong shape — leave it undefined on the error path.
+                                        clientData: undefined,
+                                        stopped: false,
+                                        continuation,
+                                        previousRunId,
+                                        preloaded,
+                                        totalUsage: cumulativeUsage,
+                                        finishReason: "error",
+                                        error: turnError,
+                                        lastEventId: errorTurnCompleteResult?.lastEventId,
+                                    });
+                                }, {
+                                    attributes: {
+                                        [v3_1.SemanticInternalAttributes.STYLE_ICON]: "task-hook-onComplete",
+                                        [v3_1.SemanticInternalAttributes.COLLAPSED]: true,
+                                        "chat.id": currentWirePayload.chatId,
+                                        "chat.turn": turn + 1,
+                                        "chat.errored": true,
+                                    },
+                                });
+                            }
+                            catch {
+                                // A throwing onTurnComplete on the error path must not crash
+                                // the run — keep the conversation alive for the next message.
+                            }
+                        }
+                        // Persist a snapshot so the failed turn's user message isn't
+                        // stranded. `writeTurnCompleteChunk` already advanced the `.in`
+                        // cursor past it (via the session-in-event-id header), and the
+                        // success-path snapshot write is skipped on error — without this
+                        // the next boot would resume past a message that exists in
+                        // neither the snapshot nor the replayable `.in` tail.
+                        if (!hydrateMessages) {
+                            try {
+                                const errorSnapshotInCursor = getChatSession().in.lastDispatchedSeqNum();
+                                await writeChatSnapshot(sessionIdForSnapshot, {
+                                    version: 1,
+                                    savedAt: Date.now(),
+                                    messages: erroredUIMessages,
+                                    lastOutEventId: errorTurnCompleteResult?.lastEventId,
+                                    lastInEventId: errorSnapshotInCursor !== undefined
+                                        ? String(errorSnapshotInCursor)
+                                        : undefined,
+                                });
+                            }
+                            catch (error) {
+                                v3_1.logger.warn("chat.agent: error-path snapshot write failed", {
+                                    error: error instanceof Error ? error.message : String(error),
+                                    sessionId: sessionIdForSnapshot,
+                                });
+                            }
+                        }
                         // chat.requestUpgrade() / chat.endRun() — exit after error turn too
                         if (locals_js_1.locals.get(chatUpgradeRequestedKey) ||
                             locals_js_1.locals.get(chatEndRunRequestedKey)) {
@@ -5350,7 +5526,7 @@ class ChatMessageAccumulator {
     }
     async addResponse(response) {
         if (!response.id) {
-            response = { ...response, id: (0, ai_1.generateId)() };
+            response = { ...response, id: (0, ai_runtime_js_1.generateId)() };
         }
         this.uiMessages.push(response);
         try {
@@ -5522,18 +5698,32 @@ function createChatSession(payload, options) {
             return {
                 async next() {
                     turn++;
-                    // First turn: handle preload — wait for the first real message
-                    if (turn === 0 && currentPayload.trigger === "preload") {
+                    // First turn: wait when the boot payload carries no message.
+                    // Preload boots wait for the first real message; continuation
+                    // boots (fresh run via `ensureRunForSession` / end-and-continue)
+                    // arrive with the sticky boot-payload fields stripped, so running
+                    // a turn immediately would invoke the model with no user input.
+                    const isMessagelessContinuationBoot = currentPayload.continuation === true && !currentPayload.message;
+                    if (turn === 0 && (currentPayload.trigger === "preload" || isMessagelessContinuationBoot)) {
                         const result = await messagesInput.waitWithIdleTimeout({
                             idleTimeoutInSeconds: sessionIdleTimeoutOpt ?? currentPayload.idleTimeoutInSeconds ?? 30,
                             timeout,
-                            spanName: "waiting for first message",
+                            spanName: currentPayload.trigger === "preload"
+                                ? "waiting for first message"
+                                : "waiting for first message (continuation)",
                         });
                         if (!result.ok || runSignal.aborted) {
                             stop.cleanup();
                             return { done: true, value: undefined };
                         }
+                        const continuationBoot = isMessagelessContinuationBoot;
                         currentPayload = result.output;
+                        // Preserve the continuation flag — the wire payload of the next
+                        // message doesn't carry it, and `turn.continuation` is how the
+                        // user knows to seed history (e.g. `turn.setMessages(stored)`).
+                        if (continuationBoot && currentPayload.continuation === undefined) {
+                            currentPayload = { ...currentPayload, continuation: true };
+                        }
                     }
                     // Subsequent turns: wait for the next message
                     if (turn > 0) {
@@ -5679,21 +5869,29 @@ function createChatSession(payload, options) {
                                 const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
                                 if (queuedParts && queuedParts.length > 0) {
                                     await accumulator.addResponse({
-                                        id: (0, ai_1.generateId)(),
+                                        id: (0, ai_runtime_js_1.generateId)(),
                                         role: "assistant",
                                         parts: queuedParts,
                                     });
                                     locals_js_1.locals.set(chatResponsePartsKey, []);
                                 }
                             }
-                            // Capture token usage from the streamText result
+                            // Capture token usage from the streamText result. Race with a 2s
+                            // timeout — on stop-abort the AI SDK's totalUsage promise can hang
+                            // indefinitely, which would wedge the turn loop (same guard as
+                            // chat.agent's turn loop).
                             let turnUsage;
                             if (typeof source.totalUsage?.then === "function") {
                                 try {
-                                    const usage = await source.totalUsage;
-                                    turnUsage = usage;
-                                    previousTurnUsage = usage;
-                                    cumulativeUsage = addUsage(cumulativeUsage, usage);
+                                    const usage = (await Promise.race([
+                                        source.totalUsage,
+                                        new Promise((r) => setTimeout(() => r(undefined), 2_000)),
+                                    ]));
+                                    if (usage) {
+                                        turnUsage = usage;
+                                        previousTurnUsage = usage;
+                                        cumulativeUsage = addUsage(cumulativeUsage, usage);
+                                    }
                                 }
                                 catch {
                                     /* non-fatal */
@@ -6036,7 +6234,8 @@ function createChatStartSessionAction(taskId, options) {
         // run-list filter by chat works without the customer having to wire it
         // up. Mirrors the browser-mediated `TriggerChatTransport.doStart` path.
         const userTags = params.triggerConfig?.tags ?? options?.triggerConfig?.tags ?? [];
-        const tags = [`chat:${params.chatId}`, ...userTags].slice(0, 5);
+        // Platform cap is 10 tags per run; the auto chat tag takes one slot.
+        const tags = [`chat:${params.chatId}`, ...userTags].slice(0, 10);
         const clientDataMetadata = params.clientData !== undefined ? { metadata: params.clientData } : {};
         const triggerConfig = {
             basePayload: {
@@ -6334,8 +6533,19 @@ async function writeTurnCompleteChunk(_chatId, publicAccessToken) {
     // 2. Trim back to the previous turn-complete, if we have one. Skipping on
     //    first-turn-ever (or first turn post-OOM without a snapshot seed) is
     //    fine — the chain catches up next turn.
-    const slot = locals_js_1.locals.get(lastTurnCompleteSeqNumKey);
-    const prev = slot?.value;
+    //
+    // Lazily create the slot if a caller reached here without one (a plain
+    // `task()` driving `chat.createSession` / `chat.writeTurnComplete`, vs.
+    // chatAgent/chatCustomAgent which seed it at boot). The first call then
+    // does no trim (nothing before it) and records its seq; later calls trim
+    // — so `.out` is bounded for every writeTurnComplete caller, not just the
+    // built-in agents.
+    let slot = locals_js_1.locals.get(lastTurnCompleteSeqNumKey);
+    if (!slot) {
+        slot = { value: undefined };
+        locals_js_1.locals.set(lastTurnCompleteSeqNumKey, slot);
+    }
+    const prev = slot.value;
     if (slot && prev !== undefined) {
         try {
             await session.out.trimTo(prev);