@convex-dev/agent 0.5.0-alpha.1 → 0.6.0-alpha.0

package/README.md

@@ -21,34 +21,39 @@ The Agent component is a core building block for building AI agents. It manages
 threads and messages, around which you Agents can cooperate in static or dynamic
 workflows.
 
-- [Agents](./docs/getting-started.mdx) provide an abstraction for using LLMs to
-  represent units of use-case-specific prompting with associated models,
-  prompts, [Tool Calls](./docs/tools.mdx), and behavior in relation to other
-  Agents, functions, APIs, and more.
-- [Threads](./docs/threads.mdx) persist [messages](./docs/messages.mdx) and can
-  be shared by multiple users and agents (including
-  [human agents](./docs/human-agents.mdx)).
+- [Agents](https://docs.convex.dev/agents/agent-usage) provide an abstraction
+  for using LLMs to represent units of use-case-specific prompting with
+  associated models, prompts,
+  [Tool Calls](https://docs.convex.dev/agents/tools), and behavior in relation
+  to other Agents, functions, APIs, and more.
+- [Threads](https://docs.convex.dev/agents/threads) persist
+  [messages](https://docs.convex.dev/agents/messages) and can be shared by
+  multiple users and agents (including
+  [human agents](https://docs.convex.dev/agents/human-agents)).
 - Streaming text and objects using deltas over websockets so all clients stay in
   sync efficiently, without http streaming. Enables streaming from async
   functions.
-- [Conversation context](./docs/context.mdx) is automatically included in each
-  LLM call, including built-in hybrid vector/text search for messages in the
-  thread and opt-in search for messages from other threads (for the same
-  specified user).
-- [RAG](./docs/rag.mdx) techniques are supported for prompt augmentation from
-  other sources, either up front in the prompt or as tool calls. Integrates with
-  the [RAG Component](https://www.convex.dev/components/rag), or DIY.
-- [Workflows](./docs/workflows.mdx) allow building multi-step operations that
-  can span agents, users, durably and reliably.
-- [Files](./docs/files.mdx) are supported in thread history with automatic
-  saving to [file storage](https://docs.convex.dev/file-storage) and
-  ref-counting.
-- [Debugging](./docs/debugging.mdx) is enabled by callbacks, the
-  [agent playground](./docs/playground.mdx) where you can inspect all metadata
-  and iterate on prompts and context settings, and inspection in the dashboard.
-- [Usage tracking](./docs/usage-tracking.mdx) is easy to set up, enabling usage
-  attribution per-provider, per-model, per-user, per-agent, for billing & more.
-- [Rate limiting](./docs/rate-limiting.mdx), powered by the
+- [Conversation context](https://docs.convex.dev/agents/context) is
+  automatically included in each LLM call, including built-in hybrid vector/text
+  search for messages in the thread and opt-in search for messages from other
+  threads (for the same specified user).
+- [RAG](https://docs.convex.dev/agents/rag) techniques are supported for prompt
+  augmentation from other sources, either up front in the prompt or as tool
+  calls. Integrates with the
+  [RAG Component](https://www.convex.dev/components/rag), or DIY.
+- [Workflows](https://docs.convex.dev/agents/workflows) allow building
+  multi-step operations that can span agents, users, durably and reliably.
+- [Files](https://docs.convex.dev/agents/files) are supported in thread history
+  with automatic saving to [file storage](https://docs.convex.dev/file-storage)
+  and ref-counting.
+- [Debugging](https://docs.convex.dev/agents/debugging) is enabled by callbacks,
+  the [agent playground](https://docs.convex.dev/agents/playground) where you
+  can inspect all metadata and iterate on prompts and context settings, and
+  inspection in the dashboard.
+- [Usage tracking](https://docs.convex.dev/agents/usage-tracking) is easy to set
+  up, enabling usage attribution per-provider, per-model, per-user, per-agent,
+  for billing & more.
+- [Rate limiting](https://docs.convex.dev/agents/rate-limiting), powered by the
   [Rate Limiter Component](https://www.convex.dev/components/rate-limiter),
   helps control the rate at which users can interact with agents and keep you
   from exceeding your LLM provider's limits.
@@ -58,13 +63,13 @@ workflows.
 [![Powerful AI Apps Made Easy with the Agent Component](https://thumbs.video-to-markdown.com/b323ac24.jpg)](https://youtu.be/tUKMPUlOCHY)
 **Read the [docs](https://docs.convex.dev/agents) for more details.**
 
-Play with the [example](./example/):
+Play with the example:
 
 ```sh
 git clone https://github.com/get-convex/agent.git
 cd agent
 npm run setup
-npm run example
+npm run dev
 ```
 
 Found a bug? Feature request?

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;AA+dD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CA2CpE"}

package/dist/UIMessages.js

@@ -0,0 +1,546 @@
+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;
+    // 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": {
+                    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));
+        }
+    }
+    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