@convex-dev/agent 0.6.0 → 0.6.1

package/dist/UIMessages.d.ts

@@ -0,0 +1,46 @@
+import { type UIMessage as AIUIMessage, type UIDataTypes, type UITools } from "ai";
+import type { MessageDoc, MessageStatus, ProviderOptions } from "./validators.js";
+export type UIStatus = "streaming" | MessageStatus;
+export type UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = AIUIMessage<METADATA, DATA_PARTS, TOOLS> & {
+    key: string;
+    order: number;
+    stepOrder: number;
+    status: UIStatus;
+    agentName?: string;
+    userId?: string;
+    text: string;
+    _creationTime: number;
+};
+/**
+ * Converts a list of UIMessages to MessageDocs, along with extra metadata that
+ * may be available to associate with the MessageDocs.
+ * @param messages - The UIMessages to convert to MessageDocs.
+ * @param meta - The metadata to add to the MessageDocs.
+ * @returns
+ */
+export declare function fromUIMessages<METADATA = unknown>(messages: UIMessage<METADATA>[], meta: {
+    threadId: string;
+    userId?: string;
+    model?: string;
+    provider?: string;
+    providerOptions?: ProviderOptions;
+    metadata?: METADATA;
+}): Promise<(MessageDoc & {
+    streaming: boolean;
+    metadata?: METADATA;
+})[]>;
+type ExtraFields<METADATA = unknown> = {
+    streaming?: boolean;
+    metadata?: METADATA;
+};
+/**
+ * Converts a list of MessageDocs to UIMessages.
+ * This is somewhat lossy, as many fields are not supported by UIMessages, e.g.
+ * the model, provider, userId, etc.
+ * The UIMessage type is the augmented type that includes more fields such as
+ * key, order, stepOrder, status, agentName, text, etc.
+ */
+export declare function toUIMessages<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools>(messages: (MessageDoc & ExtraFields<METADATA>)[]): UIMessage<METADATA, DATA_PARTS, TOOLS>[];
+export declare function combineUIMessages(messages: UIMessage[]): UIMessage[];
+export {};
+//# sourceMappingURL=UIMessages.d.ts.map

package/dist/UIMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UIMessages.d.ts","sourceRoot":"","sources":["../src/UIMessages.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,IAAI,WAAW,EAU7B,KAAK,WAAW,EAChB,KAAK,OAAO,EACb,MAAM,IAAI,CAAC;AAUZ,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,eAAe,EAGhB,MAAM,iBAAiB,CAAC;AAGzB,MAAM,MAAM,QAAQ,GAAG,WAAW,GAAG,aAAa,CAAC;AAEnD,MAAM,MAAM,SAAS,CACnB,QAAQ,GAAG,OAAO,EAClB,UAAU,SAAS,WAAW,GAAG,WAAW,EAC5C,KAAK,SAAS,OAAO,GAAG,OAAO,IAC7B,WAAW,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,CAAC,GAAG;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,QAAQ,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,QAAQ,GAAG,OAAO,EACrD,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,EAAE,EAC/B,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,GACA,OAAO,CAAC,CAAC,UAAU,GAAG;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAE,CAAC,EAAE,CAAC,CAiEvE;AA8BD,KAAK,WAAW,CAAC,QAAQ,GAAG,OAAO,IAAI;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,GAAG,OAAO,EAClB,UAAU,SAAS,WAAW,GAAG,WAAW,EAC5C,KAAK,SAAS,OAAO,GAAG,OAAO,EAE/B,QAAQ,EAAE,CAAC,UAAU,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,EAAE,GAC/C,SAAS,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,CAiB1C;AA6lBD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CA2CpE"}

package/dist/UIMessages.js

@@ -0,0 +1,634 @@
+import { convertToModelMessages, } from "ai";
+import { toModelMessage, fromModelMessage, toUIFilePart } from "./mapping.js";
+import { extractReasoning, extractText, isTool, joinText, sorted, } from "./shared.js";
+import { omit, pick } from "convex-helpers";
+/**
+ * Converts a list of UIMessages to MessageDocs, along with extra metadata that
+ * may be available to associate with the MessageDocs.
+ * @param messages - The UIMessages to convert to MessageDocs.
+ * @param meta - The metadata to add to the MessageDocs.
+ * @returns
+ */
+export async function fromUIMessages(messages, meta) {
+    const nested = await Promise.all(messages.map(async (uiMessage) => {
+        const stepOrder = uiMessage.stepOrder;
+        const commonFields = {
+            ...pick(meta, [
+                "threadId",
+                "userId",
+                "model",
+                "provider",
+                "providerOptions",
+                "metadata",
+            ]),
+            ...omit(uiMessage, ["parts", "role", "key", "text", "userId"]),
+            userId: uiMessage.userId ?? meta.userId,
+            status: uiMessage.status === "streaming" ? "pending" : "success",
+            streaming: uiMessage.status === "streaming",
+            // to override
+            _id: uiMessage.id,
+            tool: false,
+        };
+        const modelMessages = await convertToModelMessages([uiMessage]);
+        return modelMessages
+            .map((modelMessage, i) => {
+            if (modelMessage.content.length === 0) {
+                return undefined;
+            }
+            const message = fromModelMessage(modelMessage);
+            const tool = isTool(message);
+            const doc = {
+                ...commonFields,
+                _id: uiMessage.id + `-${i}`,
+                stepOrder: stepOrder + i,
+                message,
+                tool,
+                text: extractText(message),
+                reasoning: extractReasoning(message),
+                finishReason: tool ? "tool-calls" : "stop",
+                sources: fromSourceParts(uiMessage.parts),
+            };
+            if (Array.isArray(modelMessage.content)) {
+                // Find a content part with providerOptions (type assertion needed for SDK compatibility)
+                const partWithProviderOptions = modelMessage.content.find((c) => "providerOptions" in c && c.providerOptions !== undefined);
+                if (partWithProviderOptions?.providerOptions) {
+                    // convertToModelMessages changes providerMetadata to providerOptions
+                    const providerOptions = partWithProviderOptions.providerOptions;
+                    if (providerOptions) {
+                        doc.providerMetadata = providerOptions;
+                        doc.providerOptions ??= providerOptions;
+                    }
+                }
+            }
+            return doc;
+        })
+            .filter((d) => d !== undefined);
+    }));
+    return nested.flat();
+}
+function fromSourceParts(parts) {
+    return parts
+        .map((part) => {
+        if (part.type === "source-url") {
+            return {
+                type: "source",
+                sourceType: "url",
+                url: part.url,
+                id: part.sourceId,
+                providerMetadata: part.providerMetadata,
+                title: part.title,
+            };
+        }
+        if (part.type === "source-document") {
+            return {
+                type: "source",
+                sourceType: "document",
+                mediaType: part.mediaType,
+                id: part.sourceId,
+                providerMetadata: part.providerMetadata,
+                title: part.title,
+            };
+        }
+        return undefined;
+    })
+        .filter((p) => p !== undefined);
+}
+/**
+ * Converts a list of MessageDocs to UIMessages.
+ * This is somewhat lossy, as many fields are not supported by UIMessages, e.g.
+ * the model, provider, userId, etc.
+ * The UIMessage type is the augmented type that includes more fields such as
+ * key, order, stepOrder, status, agentName, text, etc.
+ */
+export function toUIMessages(messages) {
+    // Group assistant and tool messages together
+    const assistantGroups = groupAssistantMessages(sorted(messages));
+    const uiMessages = [];
+    for (const group of assistantGroups) {
+        if (group.role === "system") {
+            uiMessages.push(createSystemUIMessage(group.message));
+        }
+        else if (group.role === "user") {
+            uiMessages.push(createUserUIMessage(group.message));
+        }
+        else {
+            // Assistant/tool group
+            uiMessages.push(createAssistantUIMessage(group.messages));
+        }
+    }
+    return uiMessages;
+}
+function groupAssistantMessages(messages) {
+    const groups = [];
+    let currentAssistantGroup = [];
+    let currentOrder;
+    for (const message of messages) {
+        const coreMessage = message.message && toModelMessage(message.message);
+        if (!coreMessage)
+            continue;
+        if (coreMessage.role === "user" || coreMessage.role === "system") {
+            // Finish any current assistant group
+            if (currentAssistantGroup.length > 0) {
+                groups.push({
+                    role: "assistant",
+                    messages: currentAssistantGroup,
+                });
+                currentAssistantGroup = [];
+                currentOrder = undefined;
+            }
+            // Add singleton group
+            groups.push({
+                role: coreMessage.role,
+                message,
+            });
+        }
+        else {
+            // Assistant or tool message
+            // Start new group if order changes or this is the first assistant/tool message
+            if (currentOrder !== undefined && message.order !== currentOrder) {
+                if (currentAssistantGroup.length > 0) {
+                    groups.push({
+                        role: "assistant",
+                        messages: currentAssistantGroup,
+                    });
+                    currentAssistantGroup = [];
+                }
+            }
+            currentOrder = message.order;
+            currentAssistantGroup.push(message);
+            // End group if this is an assistant message without tool calls
+            if (coreMessage.role === "assistant" && !message.tool) {
+                groups.push({
+                    role: "assistant",
+                    messages: currentAssistantGroup,
+                });
+                currentAssistantGroup = [];
+                currentOrder = undefined;
+            }
+        }
+    }
+    // Add any remaining assistant group
+    if (currentAssistantGroup.length > 0) {
+        groups.push({
+            role: "assistant",
+            messages: currentAssistantGroup,
+        });
+    }
+    return groups;
+}
+function createSystemUIMessage(message) {
+    const text = extractTextFromMessageDoc(message);
+    const partCommon = {
+        state: message.streaming ? "streaming" : "done",
+        ...(message.providerMetadata
+            ? { providerMetadata: message.providerMetadata }
+            : {}),
+    };
+    return {
+        id: message._id,
+        _creationTime: message._creationTime,
+        order: message.order,
+        stepOrder: message.stepOrder,
+        status: message.streaming ? "streaming" : message.status,
+        key: `${message.threadId}-${message.order}-${message.stepOrder}`,
+        text,
+        role: "system",
+        agentName: message.agentName,
+        userId: message.userId,
+        parts: [{ type: "text", text, ...partCommon }],
+        metadata: message.metadata,
+    };
+}
+function extractTextFromMessageDoc(message) {
+    return ((message.message && extractText(message.message)) || message.text || "");
+}
+function createUserUIMessage(message) {
+    const text = extractTextFromMessageDoc(message);
+    const coreMessage = toModelMessage(message.message);
+    const content = coreMessage.content;
+    const nonStringContent = content && typeof content !== "string" ? content : [];
+    const partCommon = {
+        state: message.streaming ? "streaming" : "done",
+        ...(message.providerMetadata
+            ? { providerMetadata: message.providerMetadata }
+            : {}),
+    };
+    const parts = [];
+    if (text && !nonStringContent.length) {
+        parts.push({ type: "text", text });
+    }
+    for (const contentPart of nonStringContent) {
+        switch (contentPart.type) {
+            case "text":
+                parts.push({ type: "text", text: contentPart.text, ...partCommon });
+                break;
+            case "file":
+            case "image":
+                parts.push(toUIFilePart(contentPart));
+                break;
+            default:
+                console.warn("Unknown content part type for user", contentPart);
+                break;
+        }
+    }
+    return {
+        id: message._id,
+        _creationTime: message._creationTime,
+        order: message.order,
+        stepOrder: message.stepOrder,
+        status: message.streaming ? "streaming" : message.status,
+        key: `${message.threadId}-${message.order}-${message.stepOrder}`,
+        text,
+        role: "user",
+        userId: message.userId,
+        parts,
+        metadata: message.metadata,
+    };
+}
+function createAssistantUIMessage(groupUnordered) {
+    const group = sorted(groupUnordered);
+    const firstMessage = group[0];
+    // Use first message for special fields
+    const common = {
+        id: firstMessage._id,
+        _creationTime: firstMessage._creationTime,
+        order: firstMessage.order,
+        stepOrder: firstMessage.stepOrder,
+        key: `${firstMessage.threadId}-${firstMessage.order}-${firstMessage.stepOrder}`,
+        agentName: firstMessage.agentName,
+        userId: firstMessage.userId,
+    };
+    // Get status from last message
+    const lastMessage = group[group.length - 1];
+    const status = lastMessage.streaming
+        ? "streaming"
+        : lastMessage.status;
+    const approvalParts = [];
+    const executionDeniedResults = [];
+    for (const message of group) {
+        const rawContent = message.message?.content;
+        if (Array.isArray(rawContent)) {
+            for (const part of rawContent) {
+                if (part.type === "tool-approval-request" ||
+                    part.type === "tool-approval-response") {
+                    approvalParts.push(part);
+                }
+                // Check for execution-denied in tool-result outputs
+                if (part.type === "tool-result" &&
+                    typeof part.output === "object" &&
+                    part.output !== null &&
+                    part.output.type === "execution-denied") {
+                    executionDeniedResults.push({
+                        toolCallId: part.toolCallId,
+                        reason: part.output.reason,
+                    });
+                }
+            }
+        }
+    }
+    // Collect all parts from all messages
+    const allParts = [];
+    for (const message of group) {
+        const coreMessage = message.message && toModelMessage(message.message);
+        if (!coreMessage)
+            continue;
+        const content = coreMessage.content;
+        const nonStringContent = content && typeof content !== "string" ? content : [];
+        const text = extractTextFromMessageDoc(message);
+        const partCommon = {
+            state: message.streaming ? "streaming" : "done",
+            ...(message.providerMetadata
+                ? { providerMetadata: message.providerMetadata }
+                : {}),
+        };
+        // Add reasoning parts
+        if (message.reasoning &&
+            !nonStringContent.some((c) => c.type === "reasoning")) {
+            allParts.push({
+                type: "reasoning",
+                text: message.reasoning,
+                ...partCommon,
+            });
+        }
+        // Add text parts if no structured content
+        if (text && !nonStringContent.length) {
+            allParts.push({
+                type: "text",
+                text: text,
+                ...partCommon,
+            });
+        }
+        // Add all structured content parts
+        for (const contentPart of nonStringContent) {
+            switch (contentPart.type) {
+                case "text":
+                    allParts.push({
+                        ...partCommon,
+                        ...contentPart,
+                    });
+                    break;
+                case "reasoning":
+                    allParts.push({
+                        ...partCommon,
+                        ...contentPart,
+                    });
+                    break;
+                case "file":
+                case "image":
+                    allParts.push(toUIFilePart(contentPart));
+                    break;
+                case "tool-call": {
+                    allParts.push({
+                        type: "step-start",
+                    });
+                    const toolPart = {
+                        type: `tool-${contentPart.toolName}`,
+                        toolCallId: contentPart.toolCallId,
+                        input: contentPart.input,
+                        providerExecuted: contentPart.providerExecuted,
+                        ...(message.streaming
+                            ? { state: "input-streaming" }
+                            : {
+                                state: "input-available",
+                                callProviderMetadata: message.providerMetadata,
+                            }),
+                    };
+                    allParts.push(toolPart);
+                    break;
+                }
+                case "tool-result": {
+                    // Note: execution-denied outputs are handled separately via pre-extraction
+                    // from raw content (converted to text format for providers in start.ts).
+                    // See executionDeniedResults processing at the end of this function.
+                    const typedPart = contentPart;
+                    // Check if this is an execution-denied result
+                    if (typedPart.output?.type === "execution-denied") {
+                        const call = allParts.find((part) => part.type === `tool-${contentPart.toolName}` &&
+                            "toolCallId" in part &&
+                            part.toolCallId === contentPart.toolCallId);
+                        if (call) {
+                            call.state = "output-denied";
+                            if (!("approval" in call) || !call.approval) {
+                                call.approval = {
+                                    id: "",
+                                    approved: false,
+                                    reason: typedPart.output.reason,
+                                };
+                            }
+                            else {
+                                const approval = call.approval;
+                                approval.approved = false;
+                                approval.reason = typedPart.output.reason;
+                            }
+                        }
+                        break;
+                    }
+                    const output = typeof typedPart.output?.type === "string"
+                        ? typedPart.output.value
+                        : typedPart.output;
+                    // Check for error at both the content part level (isError) and message level
+                    // isError may exist on stored tool results but isn't in ToolResultPart type
+                    const hasError = contentPart.isError || message.error;
+                    const errorText = message.error || (hasError ? String(output) : undefined);
+                    const call = allParts.find((part) => part.type === `tool-${contentPart.toolName}` &&
+                        "toolCallId" in part &&
+                        part.toolCallId === contentPart.toolCallId);
+                    if (call) {
+                        if (hasError) {
+                            call.state = "output-error";
+                            call.errorText = errorText ?? "Unknown error";
+                            call.output = output;
+                        }
+                        else {
+                            call.state = "output-available";
+                            call.output = output;
+                        }
+                    }
+                    else {
+                        // Tool call is on a previous page - create standalone tool part
+                        if (hasError) {
+                            allParts.push({
+                                type: `tool-${contentPart.toolName}`,
+                                toolCallId: contentPart.toolCallId,
+                                state: "output-error",
+                                input: undefined,
+                                errorText: errorText ?? "Unknown error",
+                                callProviderMetadata: message.providerMetadata,
+                            });
+                        }
+                        else {
+                            allParts.push({
+                                type: `tool-${contentPart.toolName}`,
+                                toolCallId: contentPart.toolCallId,
+                                state: "output-available",
+                                input: undefined,
+                                output,
+                                callProviderMetadata: message.providerMetadata,
+                            });
+                        }
+                    }
+                    break;
+                }
+                case "tool-approval-request": {
+                    // Find the matching tool call
+                    const typedPart = contentPart;
+                    const toolCallPart = allParts.find((part) => "toolCallId" in part && part.toolCallId === typedPart.toolCallId);
+                    if (toolCallPart) {
+                        toolCallPart.state = "approval-requested";
+                        toolCallPart.approval = {
+                            id: typedPart.approvalId,
+                        };
+                    }
+                    else {
+                        console.warn("Tool approval request without preceding tool call", contentPart);
+                    }
+                    break;
+                }
+                case "tool-approval-response": {
+                    // Find the tool call that has this approval by matching approval.id
+                    const typedPart = contentPart;
+                    const toolCallPart = allParts.find((part) => "approval" in part &&
+                        part.approval
+                            ?.id === typedPart.approvalId);
+                    if (toolCallPart) {
+                        if (typedPart.approved) {
+                            toolCallPart.state = "approval-responded";
+                            toolCallPart.approval = {
+                                id: typedPart.approvalId,
+                                approved: true,
+                                reason: typedPart.reason,
+                            };
+                        }
+                        else {
+                            toolCallPart.state = "output-denied";
+                            toolCallPart.approval = {
+                                id: typedPart.approvalId,
+                                approved: false,
+                                reason: typedPart.reason,
+                            };
+                        }
+                    }
+                    else {
+                        console.warn("Tool approval response without matching approval request", contentPart);
+                    }
+                    break;
+                }
+                default: {
+                    const maybeSource = contentPart;
+                    if (maybeSource.type === "source") {
+                        allParts.push(toSourcePart(maybeSource));
+                    }
+                    else {
+                        console.warn("Unknown content part type for assistant", contentPart);
+                    }
+                }
+            }
+        }
+        // Add source parts
+        for (const source of message.sources ?? []) {
+            allParts.push(toSourcePart(source));
+        }
+    }
+    // Final output states that should not be overwritten by approval processing
+    const finalStates = new Set([
+        "output-available",
+        "output-error",
+        "output-denied",
+    ]);
+    // Process approval parts to update tool call states
+    for (const approvalPart of approvalParts) {
+        if (approvalPart.type === "tool-approval-request") {
+            const toolCallPart = allParts.find((part) => "toolCallId" in part && part.toolCallId === approvalPart.toolCallId);
+            if (toolCallPart) {
+                // Always set approval info (needed for response matching), but only
+                // update state if not in a final state
+                toolCallPart.approval = {
+                    id: approvalPart.approvalId,
+                };
+                if (!finalStates.has(toolCallPart.state)) {
+                    toolCallPart.state = "approval-requested";
+                }
+            }
+        }
+        else if (approvalPart.type === "tool-approval-response") {
+            const toolCallPart = allParts.find((part) => "approval" in part &&
+                part.approval?.id ===
+                    approvalPart.approvalId);
+            if (toolCallPart) {
+                // Always update approval info, but only update state if not in a final state
+                toolCallPart.approval = {
+                    id: approvalPart.approvalId,
+                    approved: approvalPart.approved,
+                    reason: approvalPart.reason,
+                };
+                if (!finalStates.has(toolCallPart.state)) {
+                    if (approvalPart.approved) {
+                        toolCallPart.state = "approval-responded";
+                    }
+                    else {
+                        toolCallPart.state = "output-denied";
+                    }
+                }
+            }
+        }
+    }
+    // Process execution-denied results to update tool call states
+    for (const denied of executionDeniedResults) {
+        const toolCallPart = allParts.find((part) => "toolCallId" in part && part.toolCallId === denied.toolCallId);
+        if (toolCallPart) {
+            toolCallPart.state = "output-denied";
+            if (!("approval" in toolCallPart) || !toolCallPart.approval) {
+                toolCallPart.approval = {
+                    id: "",
+                    approved: false,
+                    reason: denied.reason,
+                };
+            }
+            else {
+                const approval = toolCallPart.approval;
+                approval.approved = false;
+                approval.reason = denied.reason;
+            }
+        }
+    }
+    return {
+        ...common,
+        role: "assistant",
+        text: joinText(allParts),
+        status,
+        parts: allParts,
+        metadata: group.find((m) => m.metadata)?.metadata,
+    };
+}
+function toSourcePart(part) {
+    if (part.sourceType === "url") {
+        return {
+            type: "source-url",
+            url: part.url,
+            sourceId: part.id,
+            providerMetadata: part.providerMetadata,
+            title: part.title,
+        };
+    }
+    return {
+        type: "source-document",
+        mediaType: part.mediaType,
+        sourceId: part.id,
+        title: part.title,
+        filename: part.filename,
+        providerMetadata: part.providerMetadata,
+    };
+}
+export function combineUIMessages(messages) {
+    const combined = messages.reduce((acc, message) => {
+        if (!acc.length) {
+            return [message];
+        }
+        const previous = acc.at(-1);
+        if (message.order !== previous.order ||
+            previous.role !== message.role ||
+            message.role !== "assistant") {
+            acc.push(message);
+            return acc;
+        }
+        // We will replace it with a combined message
+        acc.pop();
+        const newParts = [...previous.parts];
+        for (const part of message.parts) {
+            const toolCallId = getToolCallId(part);
+            if (!toolCallId) {
+                newParts.push(part);
+                continue;
+            }
+            const previousPartIndex = newParts.findIndex((p) => getToolCallId(p) === toolCallId);
+            if (previousPartIndex === -1) {
+                // Tool call not found in previous parts, add it as new
+                newParts.push(part);
+                continue;
+            }
+            const previousPart = newParts.splice(previousPartIndex, 1)[0];
+            newParts.push(mergeParts(previousPart, part));
+        }
+        acc.push({
+            ...previous,
+            ...pick(message, ["status", "metadata", "agentName"]),
+            parts: newParts,
+            text: joinText(newParts),
+        });
+        return acc;
+    }, []);
+    return combined;
+}
+function getToolCallId(part) {
+    return part.toolCallId;
+}
+function mergeParts(previousPart, part) {
+    const merged = { ...previousPart };
+    for (const [key, value] of Object.entries(part)) {
+        if (value !== undefined) {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+//# sourceMappingURL=UIMessages.js.map