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

package/src/react/toUIMessages.test.ts

@@ -1,420 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { toUIMessages } from "./toUIMessages.js";
-import type { MessageDoc } from "../client/index.js";
-import { assert } from "convex-helpers";
-
-// Helper to create a base message doc
-function baseMessageDoc(overrides: Partial<MessageDoc> = {}): MessageDoc {
-  return {
-    _id: "msg1",
-    _creationTime: Date.now(),
-    order: 1,
-    stepOrder: 0,
-    status: "success",
-    threadId: "thread1",
-    tool: false,
-    ...overrides,
-  };
-}
-
-describe("toUIMessages", () => {
-  it("handles user message", () => {
-    const messages = [
-      baseMessageDoc({
-        message: {
-          role: "user",
-          content: "Hello!",
-        },
-        text: "Hello!",
-      }),
-    ];
-    const uiMessages = toUIMessages(messages);
-    expect(uiMessages).toHaveLength(1);
-    expect(uiMessages[0].role).toBe("user");
-    expect(uiMessages[0].text).toBe("Hello!");
-    expect(uiMessages[0].parts[0]).toEqual({ type: "text", text: "Hello!" });
-  });
-
-  it("handles assistant message", () => {
-    const messages = [
-      baseMessageDoc({
-        message: {
-          role: "assistant",
-          content: "Hi, how can I help?",
-        },
-        text: "Hi, how can I help?",
-      }),
-    ];
-    const uiMessages = toUIMessages(messages);
-    expect(uiMessages).toHaveLength(1);
-    expect(uiMessages[0].role).toBe("assistant");
-    expect(uiMessages[0].text).toBe("Hi, how can I help?");
-    expect(uiMessages[0].parts[0]).toEqual({
-      type: "text",
-      text: "Hi, how can I help?",
-      state: "done",
-    });
-  });
-
-  it("handles multiple messages", () => {
-    const messages = [
-      baseMessageDoc({
-        message: {
-          role: "user",
-          content: "Hello!",
-        },
-        text: "Hello!",
-      }),
-      baseMessageDoc({
-        message: {
-          role: "assistant",
-          content: [
-            {
-              type: "reasoning",
-              text: "I'm thinking...",
-            },
-            {
-              type: "redacted-reasoning",
-              data: "asdfasdfasdf",
-            },
-            {
-              type: "text",
-              text: "I'm thinking...",
-            },
-            {
-              type: "file",
-              mimeType: "text/plain",
-              data: "https://example.com/file.txt",
-            },
-            {
-              type: "tool-call",
-              toolName: "myTool",
-              toolCallId: "call1",
-              args: "an arg",
-            },
-          ],
-        },
-        tool: true,
-        reasoning: "I'm thinking...",
-        text: "I'm thinking...",
-      }),
-      baseMessageDoc({
-        message: {
-          role: "tool",
-          content: [
-            {
-              type: "tool-result",
-              toolCallId: "call1",
-              toolName: "myTool",
-              result: "42",
-            },
-          ],
-        },
-        tool: true,
-      }),
-    ];
-    const uiMessages = toUIMessages(messages);
-    expect(uiMessages).toHaveLength(2);
-    expect(uiMessages[0].role).toBe("user");
-    expect(uiMessages[0].parts.filter((p) => p.type === "text")).toHaveLength(
-      1,
-    );
-    expect(uiMessages[1].role).toBe("assistant");
-    expect(
-      uiMessages[1].parts.filter((p) => p.type === "tool-myTool"),
-    ).toHaveLength(1);
-    expect(
-      uiMessages[1].parts.filter((p) => p.type === "tool-myTool")[0],
-    ).toMatchObject({
-      type: "tool-myTool",
-      toolCallId: "call1",
-      state: "output-available",
-      output: "42",
-    });
-  });
-
-  it("handles multiple text and reasoning parts", () => {
-    const messages = [
-      baseMessageDoc({
-        message: {
-          role: "assistant",
-          content: [
-            {
-              type: "reasoning",
-              text: "I'm thinking...",
-            },
-            {
-              type: "text",
-              text: "Here's one idea.",
-            },
-            {
-              type: "reasoning",
-              text: "I'm thinking...",
-            },
-            {
-              type: "text",
-              text: "Here's another idea.",
-            },
-          ],
-        },
-        reasoning: "I'm thinking...I'm thinking...",
-        text: "Here's one idea. Here's another idea.",
-      }),
-    ];
-    const uiMessages = toUIMessages(messages);
-    expect(uiMessages).toHaveLength(1);
-    expect(uiMessages[0].role).toBe("assistant");
-    expect(uiMessages[0].text).toBe("Here's one idea. Here's another idea.");
-    expect(uiMessages[0].parts.filter((p) => p.type === "reasoning")).toEqual([
-      {
-        providerMetadata: undefined,
-        state: undefined,
-        text: "I'm thinking...",
-        type: "reasoning",
-      },
-      {
-        providerMetadata: undefined,
-        state: undefined,
-        text: "I'm thinking...",
-        type: "reasoning",
-      },
-    ]);
-    expect(uiMessages[0].parts[0].type).toBe("reasoning");
-    assert(uiMessages[0].parts[0].type === "reasoning");
-    expect(uiMessages[0].parts[0].text).toBe("I'm thinking...");
-    expect(uiMessages[0].parts[1].type).toBe("text");
-    assert(uiMessages[0].parts[1].type === "text");
-    expect(uiMessages[0].parts[1].text).toBe("Here's one idea.");
-    expect(uiMessages[0].parts[2].type).toBe("reasoning");
-    assert(uiMessages[0].parts[2].type === "reasoning");
-    expect(uiMessages[0].parts[2].text).toBe("I'm thinking...");
-
-    expect(uiMessages[0].parts.filter((p) => p.type === "text")).toHaveLength(
-      2,
-    );
-    expect(uiMessages[0].parts.filter((p) => p.type === "text")[0].text).toBe(
-      "Here's one idea.",
-    );
-    expect(uiMessages[0].parts.filter((p) => p.type === "text")[1].text).toBe(
-      "Here's another idea.",
-    );
-  });
-
-  it("handles system message", () => {
-    const messages = [
-      baseMessageDoc({
-        message: {
-          role: "system",
-          content: "System message here",
-        },
-        text: "System message here",
-      }),
-    ];
-    const uiMessages = toUIMessages(messages);
-    expect(uiMessages).toHaveLength(1);
-    expect(uiMessages[0].role).toBe("system");
-    expect(uiMessages[0].text).toBe("System message here");
-    expect(uiMessages[0].parts[0]).toEqual({
-      type: "text",
-      text: "System message here",
-      state: "done",
-      providerMetadata: undefined,
-    });
-  });
-
-  it("handles wrapped JSON tool output", () => {
-    const messages = [
-      baseMessageDoc({
-        message: {
-          role: "assistant",
-          content: [
-            {
-              type: "tool-call",
-              toolName: "myTool",
-              toolCallId: "call1",
-              args: { query: "test" },
-            },
-          ],
-        },
-        tool: true,
-      }),
-      baseMessageDoc({
-        message: {
-          role: "tool",
-          content: [
-            {
-              type: "tool-result",
-              toolName: "myTool",
-              toolCallId: "call1",
-              result: {
-                type: "json",
-                value: { data: "wrapped result", success: true },
-              },
-            },
-          ],
-        },
-        tool: true,
-      }),
-    ];
-    const uiMessages = toUIMessages(messages);
-    expect(uiMessages).toHaveLength(1);
-    const toolPart = uiMessages[0].parts.find((p) => p.type === "tool-myTool");
-    expect(toolPart).toMatchObject({
-      type: "tool-myTool",
-      toolCallId: "call1",
-      state: "output-available",
-      input: { query: "test" },
-      output: { data: "wrapped result", success: true }, // Should be unwrapped
-    });
-  });
-
-  it("handles tool call", () => {
-    const messages = [
-      baseMessageDoc({
-        message: {
-          role: "assistant",
-          content: [
-            {
-              type: "tool-call",
-              toolName: "myTool",
-              toolCallId: "call1",
-              args: "hi",
-            },
-          ],
-        },
-        text: "",
-      }),
-    ];
-    const uiMessages = toUIMessages(messages);
-    expect(uiMessages).toHaveLength(1);
-    expect(uiMessages[0].role).toBe("assistant");
-    expect(
-      uiMessages[0].parts.filter((p) => p.type === "tool-myTool")[0],
-    ).toMatchObject({
-      type: "tool-myTool",
-      toolCallId: "call1",
-      input: "hi",
-      state: "input-available",
-    });
-  });
-
-  it("handles tool result", () => {
-    const messages = [
-      baseMessageDoc({
-        tool: true,
-        message: {
-          role: "assistant",
-          content: [
-            {
-              type: "tool-call",
-              toolName: "myTool",
-              toolCallId: "call1",
-              args: "",
-            },
-          ],
-        },
-        text: "",
-      }),
-      baseMessageDoc({
-        message: {
-          role: "tool",
-          content: [
-            {
-              type: "tool-result",
-              toolCallId: "call1",
-              toolName: "myTool",
-              result: "42",
-            },
-          ],
-        },
-        text: "",
-      }),
-    ];
-    const uiMessages = toUIMessages(messages);
-    expect(uiMessages).toHaveLength(1);
-    expect(uiMessages[0].role).toBe("assistant");
-    // Should have a tool-invocation part
-    expect(uiMessages[0].parts.some((p) => p.type === "tool-myTool")).toBe(
-      true,
-    );
-  });
-
-  it("does not duplicate text content", () => {
-    const messages = [
-      baseMessageDoc({
-        message: {
-          role: "assistant",
-          content: "Hello!",
-        },
-        text: "Hello!",
-      }),
-    ];
-    const uiMessages = toUIMessages(messages);
-    // There should only be one text part
-    const textParts = uiMessages[0].parts.filter((p) => p.type === "text");
-    expect(textParts).toHaveLength(1);
-    expect(textParts[0].text).toBe("Hello!");
-  });
-
-  // Add more tests for array content, tool calls, etc. as needed
-
-  it("should update tool call state from input-available to output-available", () => {
-    const messages = [
-      baseMessageDoc({
-        message: {
-          role: "assistant",
-          content: [
-            {
-              type: "tool-call",
-              toolName: "calculator",
-              toolCallId: "call1",
-              args: { operation: "add", a: 1, b: 2 },
-            },
-          ],
-        },
-        tool: true,
-      }),
-      baseMessageDoc({
-        message: {
-          role: "tool",
-          content: [
-            {
-              type: "tool-result",
-              toolCallId: "call1",
-              toolName: "calculator",
-              result: { sum: 3 },
-            },
-          ],
-        },
-        tool: true,
-      }),
-    ];
-
-    const uiMessages = toUIMessages(messages);
-
-    // Should have one assistant message
-    expect(uiMessages).toHaveLength(1);
-    expect(uiMessages[0].role).toBe("assistant");
-
-    // Should have a single tool-calculator part (not separate tool-call and tool-result parts)
-    const toolParts = uiMessages[0].parts.filter(
-      (p) => p.type === "tool-calculator",
-    );
-    expect(toolParts).toHaveLength(1);
-
-    const toolPart = toolParts[0];
-    expect(toolPart).toMatchObject({
-      type: "tool-calculator",
-      toolCallId: "call1",
-      state: "output-available",
-      input: { operation: "add", a: 1, b: 2 },
-      output: { sum: 3 },
-    });
-
-    // Should NOT have a tool-call part (which is what currently happens)
-    const toolCallParts = uiMessages[0].parts.filter(
-      (p) => p.type === "tool-call",
-    );
-    expect(toolCallParts).toHaveLength(0);
-  });
-});

package/src/react/toUIMessages.ts

@@ -1,253 +0,0 @@
-import type {
-  UIMessage as AIUIMessage,
-  DeepPartial,
-  ReasoningUIPart,
-  SourceDocumentUIPart,
-  SourceUrlUIPart,
-  StepStartUIPart,
-  TextUIPart,
-  ToolUIPart,
-  UIDataTypes,
-  UITools,
-} from "ai";
-import type { MessageDoc } from "../client/index.js";
-import { deserializeMessage, toUIFilePart } from "../mapping.js";
-import type { MessageStatus } from "../validators.js";
-
-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: "streaming" | MessageStatus;
-  agentName?: string;
-  text: string;
-};
-
-export function toUIMessages<
-  METADATA = unknown,
-  DATA_PARTS extends UIDataTypes = UIDataTypes,
-  TOOLS extends UITools = UITools,
->(
-  messages: (MessageDoc & { streaming?: boolean })[],
-): UIMessage<METADATA, DATA_PARTS, TOOLS>[] {
-  const uiMessages: UIMessage<METADATA, DATA_PARTS, TOOLS>[] = [];
-  let assistantMessage: UIMessage<METADATA, DATA_PARTS, TOOLS> | undefined;
-  for (const message of messages) {
-    const coreMessage = message.message && deserializeMessage(message.message);
-    const text = message.text ?? "";
-    const content = coreMessage?.content;
-    const nonStringContent =
-      content && typeof content !== "string" ? content : [];
-    if (!coreMessage) continue;
-    const common = {
-      id: message._id,
-      createdAt: new Date(message._creationTime),
-      order: message.order,
-      stepOrder: message.stepOrder,
-      status: message.streaming ? ("streaming" as const) : message.status,
-      key: `${message.threadId}-${message.order}-${message.stepOrder}`,
-      text,
-    };
-    const partCommon = {
-      state: message.streaming ? ("streaming" as const) : ("done" as const),
-      ...(message.providerMetadata
-        ? { providerMetadata: message.providerMetadata }
-        : {}),
-    };
-    if (coreMessage.role === "system") {
-      uiMessages.push({
-        ...common,
-        role: "system",
-        agentName: message.agentName,
-        parts: [{ type: "text", text, ...partCommon } satisfies TextUIPart],
-      });
-    } else if (coreMessage.role === "user") {
-      const parts: UIMessage<METADATA, DATA_PARTS, TOOLS>["parts"] = [];
-      if (text) {
-        parts.push({ type: "text", text });
-      }
-      nonStringContent.forEach((contentPart) => {
-        switch (contentPart.type) {
-          case "file":
-          case "image":
-            parts.push(toUIFilePart(contentPart));
-            break;
-        }
-      });
-      uiMessages.push({
-        ...common,
-        role: "user",
-        parts,
-      });
-    } else {
-      if (coreMessage.role === "tool" && !assistantMessage) {
-        console.warn(
-          "Tool message without preceding assistant message.. skipping",
-          message,
-        );
-        continue;
-      }
-      if (!assistantMessage) {
-        assistantMessage = {
-          ...common,
-          role: "assistant",
-          agentName: message.agentName,
-          parts: [],
-        };
-        uiMessages.push(assistantMessage);
-      } else {
-        assistantMessage.status = message.streaming
-          ? "streaming"
-          : message.status;
-      }
-      // update it to the last message's id
-      assistantMessage.id = message._id;
-      if (
-        message.reasoning &&
-        !nonStringContent.some((c) => c.type === "reasoning")
-      ) {
-        assistantMessage.parts.push({
-          type: "reasoning",
-          text: message.reasoning,
-          ...partCommon,
-        } satisfies ReasoningUIPart);
-      }
-      if (message.text && !nonStringContent.length) {
-        assistantMessage.parts.push({
-          type: "text",
-          text: message.text,
-          ...partCommon,
-        } satisfies TextUIPart);
-      }
-      for (const source of message.sources ?? []) {
-        if (source.sourceType === "url") {
-          assistantMessage.parts.push({
-            type: "source-url",
-            url: source.url!,
-            sourceId: source.id,
-            providerMetadata: message.providerMetadata,
-            title: source.title,
-          } satisfies SourceUrlUIPart);
-        } else {
-          assistantMessage.parts.push({
-            type: "source-document",
-            mediaType: source.mediaType,
-            sourceId: source.id,
-            title: source.title,
-            filename: source.filename,
-            providerMetadata: message.providerMetadata,
-          } satisfies SourceDocumentUIPart);
-        }
-      }
-      for (const contentPart of nonStringContent) {
-        switch (contentPart.type) {
-          case "text":
-            assistantMessage.parts.push({
-              ...partCommon,
-              ...contentPart,
-            } satisfies TextUIPart);
-            break;
-          case "reasoning":
-            assistantMessage.parts.push({
-              ...partCommon,
-              ...contentPart,
-            } satisfies ReasoningUIPart);
-            break;
-          case "file":
-          case "image":
-            assistantMessage.parts.push(toUIFilePart(contentPart));
-            break;
-          case "tool-call": {
-            assistantMessage.parts.push({
-              type: "step-start",
-            } satisfies StepStartUIPart);
-            const toolPart: ToolUIPart<TOOLS> = {
-              type: `tool-${contentPart.toolName as keyof TOOLS & string}`,
-              toolCallId: contentPart.toolCallId,
-              input: contentPart.input as DeepPartial<
-                TOOLS[keyof TOOLS & string]["input"]
-              >,
-              providerExecuted: contentPart.providerExecuted,
-              ...(message.streaming
-                ? { state: "input-streaming" }
-                : {
-                    state: "input-available",
-                    callProviderMetadata: message.providerMetadata,
-                  }),
-            };
-            assistantMessage.parts.push(toolPart);
-            break;
-          }
-          case "tool-result": {
-            const call = assistantMessage.parts.find(
-              (part) =>
-                part.type === `tool-${contentPart.toolName}` &&
-                "toolCallId" in part &&
-                part.toolCallId === contentPart.toolCallId,
-            ) as ToolUIPart | undefined;
-            if (call) {
-              if (message.error) {
-                call.state = "output-error";
-                call.errorText = message.error;
-                call.output = contentPart.output;
-              } else {
-                call.state = "output-available";
-                call.output =
-                  contentPart.output?.type === "json"
-                    ? contentPart.output.value
-                    : contentPart.output;
-                // Technically we could pull this from the doc.message
-                // but the ModelMessage doesn't have it
-                // call.providerExecuted = contentPart.providerExecuted;
-              }
-            } else {
-              console.warn(
-                "Tool result without preceding tool call.. adding anyways",
-                contentPart,
-              );
-              if (message.error) {
-                assistantMessage.parts.push({
-                  type: `tool-${contentPart.toolName}`,
-                  toolCallId: contentPart.toolCallId,
-                  state: "output-error",
-                  input: undefined,
-                  errorText: message.error,
-                  // Technically we could pull this from the doc.message
-                  // but the ModelMessage doesn't have it
-                  // providerExecuted: contentPart.providerExecuted,
-                  callProviderMetadata: message.providerMetadata,
-                } satisfies ToolUIPart<TOOLS>);
-              } else {
-                assistantMessage.parts.push({
-                  type: `tool-${contentPart.toolName}`,
-                  toolCallId: contentPart.toolCallId,
-                  state: "output-available",
-                  input: undefined,
-                  output:
-                    contentPart.output?.type === "json"
-                      ? contentPart.output.value
-                      : contentPart.output,
-                  callProviderMetadata: message.providerMetadata,
-                } satisfies ToolUIPart<TOOLS>);
-              }
-            }
-            break;
-          }
-        }
-      }
-    }
-    if (
-      !message.tool &&
-      assistantMessage &&
-      assistantMessage.parts.length > 0
-    ) {
-      // Reset it so the next set of tool calls will create a new assistant message
-      assistantMessage = undefined;
-    }
-  }
-  return uiMessages;
-}

package/src/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "edge-runtime",
-  },
-});