@convex-dev/agent 0.2.11-alpha.2 → 0.2.11-alpha.4

package/src/deltas.test.ts

@@ -1,7 +1,6 @@
 import { describe, it, expect } from "vitest";
 import {
   blankUIMessage,
-  combineUIMessages,
   deriveUIMessagesFromTextStreamParts,
   updateFromTextStreamParts,
   updateFromUIMessageChunks,
@@ -535,274 +534,3 @@ describe("mergeDeltas", () => {
     ]);
   });
 });
-
-describe("combineUIMessages", () => {
-  it("combines messages spanning two pages correctly", () => {
-    const message1 = {
-      id: "msg1",
-      key: "msg1-key",
-      _creationTime: Date.now(),
-      order: 1,
-      stepOrder: 1,
-      status: "success" as const,
-      role: "assistant" as const,
-      text: "",
-      parts: [
-        {
-          type: "dynamic-tool" as const,
-          state: "input-available" as const,
-          toolCallId: "call_123",
-          toolName: "calculator",
-          input: { operation: "add", a: 2, b: 3 },
-        },
-      ],
-    };
-
-    const message2 = {
-      id: "msg2",
-      key: "msg2-key",
-      _creationTime: Date.now() + 1,
-      order: 1,
-      stepOrder: 2,
-      status: "success" as const,
-      role: "assistant" as const,
-      text: "The result is 5.",
-      parts: [
-        {
-          type: "tool-calculator" as const,
-          state: "output-available" as const,
-          toolCallId: "call_123",
-          input: { operation: "add", a: 2, b: 3 },
-          output: { result: 5 },
-        },
-        {
-          type: "text" as const,
-          text: "The result is 5.",
-          state: "done" as const,
-        },
-      ],
-    };
-
-    const combined = combineUIMessages([message1, message2]);
-
-    expect(combined).toHaveLength(1);
-    expect(combined[0].role).toBe("assistant");
-    expect(combined[0].text).toBe("The result is 5.");
-    expect(combined[0].parts).toHaveLength(2);
-
-    const toolPart = combined[0].parts.find(
-      (p) => p.type === "tool-calculator",
-    );
-    expect(toolPart).toMatchObject({
-      type: "tool-calculator",
-      state: "output-available",
-      toolCallId: "call_123",
-      input: { operation: "add", a: 2, b: 3 },
-      output: { result: 5 },
-    });
-
-    const textPart = combined[0].parts.find((p) => p.type === "text");
-    expect(textPart).toMatchObject({
-      type: "text",
-      text: "The result is 5.",
-      state: "done",
-    });
-  });
-
-  it("preserves separate messages with different roles", () => {
-    const userMessage = {
-      id: "user1",
-      key: "user1-key",
-      _creationTime: Date.now(),
-      order: 1,
-      stepOrder: 0,
-      status: "success" as const,
-      role: "user" as const,
-      text: "Calculate 2 + 3",
-      parts: [{ type: "text" as const, text: "Calculate 2 + 3" }],
-    };
-
-    const assistantMessage = {
-      id: "assistant1",
-      key: "assistant1-key",
-      _creationTime: Date.now() + 1,
-      order: 2,
-      stepOrder: 0,
-      status: "success" as const,
-      role: "assistant" as const,
-      text: "The result is 5.",
-      parts: [
-        {
-          type: "text" as const,
-          text: "The result is 5.",
-          state: "done" as const,
-        },
-      ],
-    };
-
-    const combined = combineUIMessages([userMessage, assistantMessage]);
-
-    expect(combined).toHaveLength(2);
-    expect(combined[0]).toEqual(userMessage);
-    expect(combined[1]).toEqual(assistantMessage);
-  });
-
-  it("combines multiple tool calls across pages", () => {
-    const message1 = {
-      id: "msg1",
-      key: "msg1-key",
-      _creationTime: Date.now(),
-      order: 1,
-      stepOrder: 1,
-      status: "success" as const,
-      role: "assistant" as const,
-      text: "",
-      parts: [
-        {
-          type: "dynamic-tool" as const,
-          state: "input-available" as const,
-          toolCallId: "call_1",
-          toolName: "calculator",
-          input: { operation: "add", a: 2, b: 3 },
-        },
-        {
-          type: "dynamic-tool" as const,
-          state: "input-available" as const,
-          toolCallId: "call_2",
-          toolName: "formatter",
-          input: { text: "result" },
-        },
-      ],
-    };
-
-    const message2 = {
-      id: "msg2",
-      key: "msg2-key",
-      _creationTime: Date.now() + 1,
-      order: 1,
-      stepOrder: 2,
-      status: "success" as const,
-      role: "assistant" as const,
-      text: "The formatted result is: 5",
-      parts: [
-        {
-          type: "tool-calculator" as const,
-          state: "output-available" as const,
-          toolCallId: "call_1",
-          input: { operation: "add", a: 2, b: 3 },
-          output: { result: 5 },
-        },
-        {
-          type: "tool-formatter" as const,
-          state: "output-available" as const,
-          toolCallId: "call_2",
-          input: { text: "result" },
-          output: { formatted: "The formatted result is: 5" },
-        },
-        {
-          type: "text" as const,
-          text: "The formatted result is: 5",
-          state: "done" as const,
-        },
-      ],
-    };
-
-    const combined = combineUIMessages([message1, message2]);
-
-    expect(combined).toHaveLength(1);
-    expect(combined[0].role).toBe("assistant");
-    expect(combined[0].text).toBe("The formatted result is: 5");
-    expect(combined[0].parts).toHaveLength(3);
-
-    const calculatorPart = combined[0].parts.find(
-      (p) =>
-        p.type === "tool-calculator" &&
-        "toolCallId" in p &&
-        p.toolCallId === "call_1",
-    );
-    expect(calculatorPart).toMatchObject({
-      type: "tool-calculator",
-      state: "output-available",
-      toolCallId: "call_1",
-      input: { operation: "add", a: 2, b: 3 },
-      output: { result: 5 },
-    });
-
-    const formatterPart = combined[0].parts.find(
-      (p) =>
-        p.type === "tool-formatter" &&
-        "toolCallId" in p &&
-        p.toolCallId === "call_2",
-    );
-    expect(formatterPart).toMatchObject({
-      type: "tool-formatter",
-      state: "output-available",
-      toolCallId: "call_2",
-      input: { text: "result" },
-      output: { formatted: "The formatted result is: 5" },
-    });
-  });
-
-  it("handles tool call without corresponding output", () => {
-    const message1 = {
-      id: "msg1",
-      key: "msg1-key",
-      _creationTime: Date.now(),
-      order: 1,
-      stepOrder: 1,
-      status: "success" as const,
-      role: "assistant" as const,
-      text: "",
-      parts: [
-        {
-          type: "dynamic-tool" as const,
-          state: "input-available" as const,
-          toolCallId: "call_orphan",
-          toolName: "calculator",
-          input: { operation: "add", a: 2, b: 3 },
-        },
-      ],
-    };
-
-    const message2 = {
-      id: "msg2",
-      key: "msg2-key",
-      _creationTime: Date.now() + 1,
-      order: 1,
-      stepOrder: 2,
-      status: "success" as const,
-      role: "assistant" as const,
-      text: "Still processing...",
-      parts: [
-        {
-          type: "text" as const,
-          text: "Still processing...",
-          state: "done" as const,
-        },
-      ],
-    };
-
-    const combined = combineUIMessages([message1, message2]);
-
-    expect(combined).toHaveLength(1);
-    expect(combined[0].role).toBe("assistant");
-    expect(combined[0].text).toBe("Still processing...");
-    expect(combined[0].parts).toHaveLength(2);
-
-    const toolPart = combined[0].parts.find((p) => p.type === "dynamic-tool");
-    expect(toolPart).toMatchObject({
-      type: "dynamic-tool",
-      state: "input-available",
-      toolCallId: "call_orphan",
-      toolName: "calculator",
-      input: { operation: "add", a: 2, b: 3 },
-    });
-
-    const textPart = combined[0].parts.find((p) => p.type === "text");
-    expect(textPart).toMatchObject({
-      type: "text",
-      text: "Still processing...",
-      state: "done",
-    });
-  });
-});

package/src/deltas.ts

@@ -529,66 +529,3 @@ function mergeProviderMetadata(
   }
   return merged;
 }
-
-export function combineUIMessages(messages: UIMessage[]): UIMessage[] {
-  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,
-      );
-      const previousPart = newParts.splice(previousPartIndex, 1)[0];
-      if (!previousPart) {
-        newParts.push(part);
-        continue;
-      }
-      newParts.push(mergeParts(previousPart, part));
-    }
-    acc.push({
-      ...previous,
-      ...pick(message, ["status", "metadata", "agentName"]),
-      parts: newParts,
-      text: joinText(newParts),
-    });
-    return acc;
-  }, [] as UIMessage[]);
-  return combined;
-}
-
-function getToolCallId(
-  part: UIMessage["parts"][number] & { toolCallId?: string },
-) {
-  return part.toolCallId;
-}
-
-function mergeParts(
-  previousPart: UIMessage["parts"][number],
-  part: UIMessage["parts"][number],
-): UIMessage["parts"][number] {
-  const merged: Record<string, unknown> = { ...previousPart };
-  for (const [key, value] of Object.entries(part)) {
-    if (value !== undefined) {
-      merged[key] = value;
-    }
-  }
-  return merged as ToolUIPart | DynamicToolUIPart;
-}

package/src/react/useUIMessages.ts

@@ -19,10 +19,13 @@ import { useMemo } from "react";
 import type { SyncStreamsReturnValue } from "../client/types.js";
 import type { StreamArgs } from "../validators.js";
 import type { StreamQuery } from "./types.js";
-import { type UIMessage, type UIStatus } from "../UIMessages.js";
+import {
+  type UIMessage,
+  type UIStatus,
+  combineUIMessages,
+} from "../UIMessages.js";
 import { sorted } from "../shared.js";
 import { useStreamingUIMessages } from "./useStreamingUIMessages.js";
-import { combineUIMessages } from "../deltas.js";
 
 export type UIMessageLike = {
   order: number;

package/src/test.ts

@@ -0,0 +1,17 @@
+import type { TestConvex } from "convex-test";
+import type { GenericSchema, SchemaDefinition } from "convex/server";
+import schema from "./component/schema.js";
+const modules = import.meta.glob("./component/**/*.ts");
+
+/**
+ * Register the component with the test convex instance.
+ * @param t - The test convex instance, e.g. from calling `convexTest`.
+ * @param name - The name of the component, as registered in convex.config.ts.
+ */
+function register(
+  t: TestConvex<SchemaDefinition<GenericSchema, boolean>>,
+  name: string = "agent",
+) {
+  t.registerComponent(name, schema, modules);
+}
+export default { register, schema, modules };

package/dist/client/_generated/_ignore.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=_ignore.d.ts.map

package/dist/client/_generated/_ignore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_ignore.d.ts","sourceRoot":"","sources":["../../../src/client/_generated/_ignore.ts"],"names":[],"mappings":""}

package/dist/client/_generated/_ignore.js

@@ -1,3 +0,0 @@
-"use strict";
-// This is only here so convex-test can detect a _generated folder
-//# sourceMappingURL=_ignore.js.map

package/dist/client/_generated/_ignore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_ignore.js","sourceRoot":"","sources":["../../../src/client/_generated/_ignore.ts"],"names":[],"mappings":";AAAA,kEAAkE"}