@convex-dev/agent 0.6.3 → 0.6.4

package/dist/deltas.js

@@ -1,9 +1,8 @@
 import { readUIMessageStream, } from "ai";
-import { assert, pick } from "convex-helpers";
+import { assert } from "convex-helpers";
 import {} from "./UIMessages.js";
 import { joinText, sorted } from "./shared.js";
 import {} from "./validators.js";
-import { getErrorMessage } from "@ai-sdk/provider-utils";
 export function blankUIMessage(streamMessage, threadId) {
     return {
         id: `stream:${streamMessage.streamId}`,
@@ -32,6 +31,9 @@ export function statusFromStreamStatus(status) {
     }
 }
 export async function updateFromUIMessageChunks(uiMessage, parts) {
+    if (parts.length === 0) {
+        return uiMessage;
+    }
     const partsStream = new ReadableStream({
         start(controller) {
             for (const part of parts) {
@@ -47,11 +49,7 @@ export async function updateFromUIMessageChunks(uiMessage, parts) {
         stream: partsStream,
         onError: (e) => {
             const errorMessage = e instanceof Error ? e.message : String(e);
-            // Tool invocation errors can be safely ignored when streaming continuation
-            // after tool approval - the stored messages have the complete tool context
             if (errorMessage.toLowerCase().includes("no tool invocation found")) {
-                // Silently suppress - this is expected after tool approval when the
-                // continuation stream has tool-result without the original tool-call
                 suppressError = true;
                 return;
             }
@@ -68,8 +66,6 @@ export async function updateFromUIMessageChunks(uiMessage, parts) {
         }
     }
     catch (e) {
-        // If we've already handled this error in onError and marked it as suppressed,
-        // don't rethrow - the stored messages provide the fallback
         if (!suppressError) {
             throw e;
         }
@@ -80,349 +76,336 @@ export async function updateFromUIMessageChunks(uiMessage, parts) {
     message.text = joinText(message.parts);
     return message;
 }
-export async function deriveUIMessagesFromDeltas(threadId, streamMessages, allDeltas) {
-    const messages = [];
-    for (const streamMessage of streamMessages) {
-        if (streamMessage.format === "UIMessageChunk") {
-            const { parts } = getParts(allDeltas.filter((d) => d.streamId === streamMessage.streamId), 0);
-            const uiMessage = await updateFromUIMessageChunks(blankUIMessage(streamMessage, threadId), parts);
-            messages.push(uiMessage);
-        }
-        else {
-            const [uiMessages] = deriveUIMessagesFromTextStreamParts(threadId, [streamMessage], [], allDeltas);
-            messages.push(...uiMessages);
-        }
-    }
-    return sorted(messages);
+function transitionToolPart(part, updates) {
+    Object.assign(part, updates);
+}
+export function emptyIncrementalStreamState() {
+    return { activeText: {}, activeReasoning: {}, toolInputText: {} };
 }
 /**
- *
+ * Apply a batch of new UIMessageChunks to an existing UIMessage without
+ * replaying prior chunks. `prev` carries the ephemeral stream state that the
+ * UIMessage itself can't hold (which text/reasoning parts are still streaming,
+ * and the raw accumulated tool input text). Parts are append-only, so part
+ * indices stay stable across the structuredClone between batches. Behavior
+ * mirrors the AI SDK's processUIMessageStream.
  */
-export function deriveUIMessagesFromTextStreamParts(threadId, streamMessages, existingStreams, allDeltas) {
-    const newStreams = [];
-    // Seed the existing chunks
-    let changed = false;
-    for (const streamMessage of streamMessages) {
-        const deltas = allDeltas.filter((d) => d.streamId === streamMessage.streamId);
-        const existing = existingStreams.find((s) => s.streamId === streamMessage.streamId);
-        const [newStream, messageChanged] = updateFromTextStreamParts(threadId, streamMessage, existing, deltas);
-        newStreams.push(newStream);
-        if (messageChanged)
-            changed = true;
-    }
-    for (const { streamId } of existingStreams) {
-        if (!newStreams.find((s) => s.streamId === streamId)) {
-            // There's a stream that's no longer active.
-            changed = true;
+export function applyUIMessageChunksIncremental(uiMessage, newParts, prev) {
+    const message = structuredClone(uiMessage);
+    const activeText = { ...prev.activeText };
+    const activeReasoning = { ...prev.activeReasoning };
+    const toolInputText = { ...prev.toolInputText };
+    const touchedTools = new Set();
+    const toolIndexById = new Map();
+    message.parts.forEach((p, i) => {
+        if ("toolCallId" in p &&
+            (p.type.startsWith("tool-") || p.type === "dynamic-tool")) {
+            toolIndexById.set(p.toolCallId, i);
         }
-    }
-    const messages = sorted(newStreams.map((s) => s.message));
-    return [messages, newStreams, changed];
-}
-export function getParts(deltas, fromCursor) {
-    const parts = [];
-    let cursor = fromCursor ?? 0;
-    for (const delta of deltas.sort((a, b) => a.start - b.start)) {
-        if (delta.parts.length === 0) {
-            console.debug(`Got delta with no parts: ${JSON.stringify(delta)}`);
-            continue;
+    });
+    const toolPartAt = (toolCallId) => {
+        const idx = toolIndexById.get(toolCallId);
+        return idx === undefined ? undefined : message.parts[idx];
+    };
+    const mergeMetadata = (metadata) => {
+        if (metadata == null) {
+            return;
         }
-        if (cursor !== delta.start) {
-            if (cursor >= delta.end) {
-                continue;
-            }
-            else if (cursor < delta.start) {
-                console.warn(`Got delta for stream ${delta.streamId} that has a gap ${cursor} -> ${delta.start}`);
+        message.metadata = {
+            ...message.metadata,
+            ...metadata,
+        };
+    };
+    for (const part of newParts) {
+        switch (part.type) {
+            case "text-start": {
+                const newPart = {
+                    type: "text",
+                    text: "",
+                    state: "streaming",
+                    providerMetadata: part.providerMetadata,
+                };
+                message.parts.push(newPart);
+                activeText[part.id] = message.parts.length - 1;
                 break;
             }
-            else {
-                throw new Error(`Got unexpected delta for stream ${delta.streamId}: delta: ${delta.start} -> ${delta.end} existing cursor: ${cursor}`);
-            }
-        }
-        parts.push(...delta.parts);
-        cursor = delta.end;
-    }
-    return { parts, cursor };
-}
-/**
- * This is historically from when we would use the onChunk callback instead of
- * consuming the full UIMessageStream.
- */
-// exported for testing
-export function updateFromTextStreamParts(threadId, streamMessage, existing, deltas) {
-    const { cursor, parts } = getParts(deltas, existing?.cursor);
-    const changed = parts.length > 0 ||
-        (existing &&
-            statusFromStreamStatus(streamMessage.status) !== existing.message.status);
-    const existingMessage = existing?.message ?? blankUIMessage(streamMessage, threadId);
-    if (!changed) {
-        return [
-            existing ?? {
-                streamId: streamMessage.streamId,
-                cursor,
-                message: existingMessage,
-            },
-            false,
-        ];
-    }
-    const message = structuredClone(existingMessage);
-    message.status = statusFromStreamStatus(streamMessage.status);
-    const textPartsById = new Map();
-    const toolPartsById = new Map(message.parts
-        .filter((p) => p.type.startsWith("tool-") || p.type === "dynamic-tool")
-        .map((p) => [p.toolCallId, p]));
-    const reasoningPartsById = new Map();
-    for (const part of parts) {
-        switch (part.type) {
-            case "text-start":
             case "text-delta": {
-                if (!textPartsById.has(part.id)) {
-                    const lastPart = message.parts.at(-1);
-                    if (lastPart?.type === "text") {
-                        textPartsById.set(part.id, lastPart);
-                    }
-                    else {
-                        const newPart = {
-                            type: "text",
-                            text: "",
-                            providerMetadata: part.providerMetadata,
-                        };
-                        textPartsById.set(part.id, newPart);
-                        message.parts.push(newPart);
-                    }
-                }
-                if (part.type === "text-delta") {
-                    const textPart = textPartsById.get(part.id);
-                    textPart.text += part.text;
+                const idx = activeText[part.id];
+                if (idx !== undefined) {
+                    const textPart = message.parts[idx];
+                    textPart.text += part.delta;
                     textPart.providerMetadata = mergeProviderMetadata(textPart.providerMetadata, part.providerMetadata);
                 }
                 break;
             }
-            case "tool-input-start": {
-                let newPart;
-                if (part.dynamic) {
-                    newPart = {
-                        type: "dynamic-tool",
-                        toolCallId: part.id,
-                        toolName: part.toolName,
-                        state: "input-streaming",
-                        input: "",
-                    };
-                }
-                else {
-                    newPart = {
-                        type: `tool-${part.toolName}`,
-                        toolCallId: part.id,
-                        state: "input-streaming",
-                        input: "",
-                        providerExecuted: part.providerExecuted,
-                    };
+            case "text-end": {
+                const idx = activeText[part.id];
+                if (idx !== undefined) {
+                    const textPart = message.parts[idx];
+                    textPart.state = "done";
+                    textPart.providerMetadata = mergeProviderMetadata(textPart.providerMetadata, part.providerMetadata);
+                    delete activeText[part.id];
                 }
-                toolPartsById.set(part.id, newPart);
+                break;
+            }
+            case "reasoning-start": {
+                const newPart = {
+                    type: "reasoning",
+                    text: "",
+                    state: "streaming",
+                    providerMetadata: part.providerMetadata,
+                };
                 message.parts.push(newPart);
+                activeReasoning[part.id] = message.parts.length - 1;
                 break;
             }
-            case "tool-input-delta":
-                {
-                    const toUpdate = toolPartsById.get(part.id);
-                    assert(toUpdate, `Expected to find tool call part ${part.id} to update`);
-                    toUpdate.input = (toUpdate.input ?? "") + part.delta;
+            case "reasoning-delta": {
+                const idx = activeReasoning[part.id];
+                if (idx !== undefined) {
+                    const reasoningPart = message.parts[idx];
+                    reasoningPart.text += part.delta;
+                    reasoningPart.providerMetadata = mergeProviderMetadata(reasoningPart.providerMetadata, part.providerMetadata);
                 }
                 break;
-            case "tool-input-end":
-                {
-                    const toUpdate = toolPartsById.get(part.id);
-                    assert(toUpdate, `Expected to find tool call part ${part.id} to update`);
-                    toUpdate.state = "input-available";
-                    if (part.providerMetadata) {
-                        const updatable = toUpdate;
-                        updatable.callProviderMetadata = mergeProviderMetadata(updatable.callProviderMetadata, part.providerMetadata);
-                    }
+            }
+            case "reasoning-end": {
+                const idx = activeReasoning[part.id];
+                if (idx !== undefined) {
+                    const reasoningPart = message.parts[idx];
+                    reasoningPart.state = "done";
+                    reasoningPart.providerMetadata = mergeProviderMetadata(reasoningPart.providerMetadata, part.providerMetadata);
+                    delete activeReasoning[part.id];
                 }
                 break;
-            case "tool-call": {
-                let newPart;
-                if (part.dynamic) {
-                    newPart = {
+            }
+            case "tool-input-start": {
+                const newToolPart = part.dynamic
+                    ? {
                         type: "dynamic-tool",
                         toolCallId: part.toolCallId,
                         toolName: part.toolName,
-                        input: part.input,
-                        state: "input-available",
-                    };
-                }
-                else {
-                    newPart = {
+                        state: "input-streaming",
+                        input: undefined,
+                    }
+                    : {
                         type: `tool-${part.toolName}`,
                         toolCallId: part.toolCallId,
-                        input: part.input,
-                        state: "input-available",
+                        state: "input-streaming",
+                        input: undefined,
+                        providerExecuted: part.providerExecuted,
                     };
-                    if (part.providerExecuted) {
-                        newPart.providerExecuted = part.providerExecuted;
-                    }
-                }
-                if (part.providerMetadata) {
-                    newPart.callProviderMetadata = part.providerMetadata;
-                }
-                if (toolPartsById.has(part.toolCallId)) {
-                    const toUpdate = toolPartsById.get(part.toolCallId);
-                    Object.assign(toUpdate, newPart);
-                }
-                else {
-                    toolPartsById.set(part.toolCallId, newPart);
-                    message.parts.push(newPart);
-                }
+                message.parts.push(newToolPart);
+                toolIndexById.set(part.toolCallId, message.parts.length - 1);
+                toolInputText[part.toolCallId] = "";
                 break;
             }
-            case "tool-result": {
-                const toolCall = toolPartsById.get(part.toolCallId);
-                assert(toolCall, `Expected to find tool call part ${part.toolCallId} to update with result`);
-                let newPart;
-                if (toolCall.type === "dynamic-tool") {
-                    newPart = {
-                        ...toolCall,
-                        state: "output-available",
-                        input: part.input ?? toolCall.input,
-                        output: part.output ?? toolCall.output,
-                        ...pick(part, ["preliminary"]),
-                    };
+            case "tool-input-delta": {
+                if (toolIndexById.has(part.toolCallId)) {
+                    toolInputText[part.toolCallId] =
+                        (toolInputText[part.toolCallId] ?? "") + part.inputTextDelta;
+                    touchedTools.add(part.toolCallId);
                 }
                 else {
-                    newPart = {
-                        ...toolCall,
-                        state: "output-available",
-                        input: part.input ?? toolCall.input,
-                        output: part.output ?? toolCall.output,
-                        preliminary: part.preliminary,
-                    };
+                    console.warn(`tool-input-delta for unknown toolCallId ${part.toolCallId}`);
                 }
-                Object.assign(toolCall, newPart);
                 break;
             }
-            case "reasoning-start":
-            case "reasoning-delta": {
-                if (!reasoningPartsById.has(part.id)) {
-                    const lastPart = message.parts.at(-1);
-                    if (lastPart?.type === "reasoning") {
-                        reasoningPartsById.set(part.id, lastPart);
-                    }
-                    else {
-                        const newPart = {
-                            type: "reasoning",
-                            state: "streaming",
-                            text: "",
-                            providerMetadata: part.providerMetadata,
-                        };
-                        reasoningPartsById.set(part.id, newPart);
-                        message.parts.push(newPart);
-                    }
-                }
-                const reasoningPart = reasoningPartsById.get(part.id);
-                if (part.type === "reasoning-delta") {
-                    reasoningPart.text += part.text;
-                    reasoningPart.providerMetadata = mergeProviderMetadata(reasoningPart.providerMetadata, part.providerMetadata);
+            case "tool-input-available": {
+                const toolPart = toolPartAt(part.toolCallId);
+                if (toolPart) {
+                    transitionToolPart(toolPart, {
+                        state: "input-available",
+                        input: part.input,
+                        callProviderMetadata: mergeProviderMetadata(toolPart
+                            .callProviderMetadata, part.providerMetadata),
+                    });
                 }
+                touchedTools.delete(part.toolCallId);
+                // The raw JSON buffer is no longer needed; drop it so it doesn't get
+                // carried through every later batch on the hot path.
+                delete toolInputText[part.toolCallId];
                 break;
             }
-            case "reasoning-end": {
-                const reasoningPart = reasoningPartsById.get(part.id) ??
-                    message.parts.find((p) => p.type === "reasoning" && p.state === "streaming");
-                if (reasoningPart) {
-                    reasoningPart.state = "done";
-                }
-                else {
-                    console.warn(`Expected to find reasoning part ${part.id} to finish, but found none`);
+            case "tool-input-error": {
+                const toolPart = toolPartAt(part.toolCallId);
+                if (toolPart) {
+                    transitionToolPart(toolPart, {
+                        state: "output-error",
+                        errorText: part.errorText,
+                        providerExecuted: part.providerExecuted,
+                        ...(toolPart.type === "dynamic-tool"
+                            ? { input: part.input }
+                            : { input: undefined, rawInput: part.input }),
+                        callProviderMetadata: mergeProviderMetadata(toolPart
+                            .callProviderMetadata, part.providerMetadata),
+                    });
                 }
+                touchedTools.delete(part.toolCallId);
+                delete toolInputText[part.toolCallId];
                 break;
             }
-            case "source":
-                if (part.sourceType === "url") {
-                    message.parts.push({
-                        type: "source-url",
-                        url: part.url,
-                        sourceId: part.id,
-                        providerMetadata: part.providerMetadata,
-                        title: part.title,
+            case "tool-output-available": {
+                const toolPart = toolPartAt(part.toolCallId);
+                if (toolPart) {
+                    transitionToolPart(toolPart, {
+                        state: "output-available",
+                        output: part.output,
+                        preliminary: part.preliminary,
+                        providerExecuted: part.providerExecuted,
                     });
                 }
-                else if (part.sourceType === "document") {
-                    message.parts.push({
-                        type: "source-document",
-                        mediaType: part.mediaType,
-                        sourceId: part.id,
-                        title: part.title,
-                        filename: part.filename,
-                        providerMetadata: part.providerMetadata,
+                break;
+            }
+            case "tool-output-error": {
+                const toolPart = toolPartAt(part.toolCallId);
+                if (toolPart) {
+                    transitionToolPart(toolPart, {
+                        state: "output-error",
+                        errorText: part.errorText,
+                        providerExecuted: part.providerExecuted,
                     });
                 }
-                else {
-                    console.warn("Got source part with unknown source type", part);
-                }
-                break;
-            case "abort":
-                message.status = "failed";
-                break;
-            case "error":
-                message.status = "failed";
-                console.warn("Generation failed with error", part.error);
                 break;
-            case "tool-error": {
-                const toolPart = toolPartsById.get(part.toolCallId);
+            }
+            case "tool-output-denied": {
+                const toolPart = toolPartAt(part.toolCallId);
                 if (toolPart) {
-                    toolPart.errorText = getErrorMessage(part.error);
+                    transitionToolPart(toolPart, { state: "output-denied" });
                 }
                 break;
             }
             case "tool-approval-request": {
-                const typedPart = part;
-                const toolPart = toolPartsById.get(typedPart.toolCallId);
+                const toolPart = toolPartAt(part.toolCallId);
                 if (toolPart) {
-                    toolPart.state = "approval-requested";
-                    toolPart.approval = {
-                        id: typedPart.approvalId,
-                    };
-                }
-                else {
-                    console.warn(`Expected tool call part ${typedPart.toolCallId} for approval request`);
+                    transitionToolPart(toolPart, {
+                        state: "approval-requested",
+                        approval: { id: part.approvalId },
+                    });
                 }
                 break;
             }
+            case "source-url":
+                message.parts.push({
+                    type: "source-url",
+                    url: part.url,
+                    sourceId: part.sourceId,
+                    title: part.title,
+                    providerMetadata: part.providerMetadata,
+                });
+                break;
+            case "source-document":
+                message.parts.push({
+                    type: "source-document",
+                    mediaType: part.mediaType,
+                    sourceId: part.sourceId,
+                    title: part.title,
+                    filename: part.filename,
+                    providerMetadata: part.providerMetadata,
+                });
+                break;
             case "file":
-            case "text-end":
-            case "finish-step":
-            case "finish":
-            case "raw":
+                message.parts.push({
+                    type: "file",
+                    mediaType: part.mediaType,
+                    url: part.url,
+                });
+                break;
             case "start-step":
+                message.parts.push({ type: "step-start" });
+                break;
+            case "finish-step":
+                // Match the SDK: a new step starts fresh streaming parts; the prior
+                // parts keep their state rather than being forced to "done".
+                for (const id of Object.keys(activeText))
+                    delete activeText[id];
+                for (const id of Object.keys(activeReasoning))
+                    delete activeReasoning[id];
+                break;
             case "start":
-                // ignore
+            case "finish":
+            case "message-metadata":
+                mergeMetadata(part.messageMetadata);
+                break;
+            case "abort":
+            case "error":
+                // The stream-level status (statusFromStreamStatus) is authoritative and
+                // is applied by the caller; nothing to mutate on the message here.
                 break;
             default: {
-                // Exhaustiveness check disabled intentionally for forwards compatibility.
-                // New TextStreamPart types from future AI SDK versions will trigger a
-                // runtime warning rather than a compile error, allowing graceful degradation.
-                // const _: never = part;
-                console.warn(`Received unexpected part: ${JSON.stringify(part)}`);
+                if (typeof part.type === "string" && part.type.startsWith("data-")) {
+                    const dataPart = part;
+                    const existingIdx = dataPart.id != null
+                        ? message.parts.findIndex((p) => p.type === dataPart.type &&
+                            p.id === dataPart.id)
+                        : -1;
+                    if (existingIdx >= 0) {
+                        message.parts[existingIdx].data =
+                            dataPart.data;
+                    }
+                    else {
+                        message.parts.push(dataPart);
+                    }
+                }
+                else {
+                    console.warn(`applyUIMessageChunksIncremental: unhandled chunk type ${String(part.type)}`);
+                }
                 break;
             }
         }
     }
-    // Consider reasoning done once something else happens
-    for (let i = 0; i < message.parts.length - 1; i++) {
-        const part = message.parts[i];
-        if (part.type === "reasoning") {
-            part.state = "done";
+    for (const toolCallId of touchedTools) {
+        const toolPart = toolPartAt(toolCallId);
+        if (toolPart && toolPart.state === "input-streaming") {
+            try {
+                toolPart.input = JSON.parse(toolInputText[toolCallId] ?? "");
+            }
+            catch {
+                // partial JSON — leave input unset until complete
+            }
         }
     }
     message.text = joinText(message.parts);
-    return [
-        {
-            streamId: streamMessage.streamId,
-            cursor,
-            message,
-        },
-        true,
-    ];
+    return {
+        message,
+        streamState: { activeText, activeReasoning, toolInputText },
+    };
+}
+export async function deriveUIMessagesFromDeltas(threadId, streamMessages, allDeltas) {
+    const messages = [];
+    for (const streamMessage of streamMessages) {
+        if (streamMessage.format !== "UIMessageChunk") {
+            throw new Error(`deriveUIMessagesFromDeltas: unsupported stream format "${streamMessage.format ?? "text"}" for stream ${streamMessage.streamId}`);
+        }
+        const { parts } = getParts(allDeltas.filter((d) => d.streamId === streamMessage.streamId), 0);
+        const uiMessage = await updateFromUIMessageChunks(blankUIMessage(streamMessage, threadId), parts);
+        messages.push(uiMessage);
+    }
+    return sorted(messages);
+}
+export function getParts(deltas, fromCursor) {
+    const parts = [];
+    let cursor = fromCursor ?? 0;
+    for (const delta of deltas.sort((a, b) => a.start - b.start)) {
+        if (delta.parts.length === 0) {
+            console.debug(`Got delta with no parts: ${JSON.stringify(delta)}`);
+            continue;
+        }
+        if (cursor !== delta.start) {
+            if (cursor >= delta.end) {
+                continue;
+            }
+            else if (cursor < delta.start) {
+                console.warn(`Got delta for stream ${delta.streamId} that has a gap ${cursor} -> ${delta.start}`);
+                break;
+            }
+            else {
+                throw new Error(`Got unexpected delta for stream ${delta.streamId}: delta: ${delta.start} -> ${delta.end} existing cursor: ${cursor}`);
+            }
+        }
+        parts.push(...delta.parts);
+        cursor = delta.end;
+    }
+    return { parts, cursor };
 }
 function mergeProviderMetadata(existing, part) {
     if (!existing && !part) {