@convex-dev/agent 0.2.6-alpha.1 → 0.2.7

package/src/client/messages.ts

@@ -1,6 +1,6 @@
 import type { ModelMessage } from "ai";
 import type { PaginationOptions, PaginationResult } from "convex/server";
-import type { MessageDoc } from "../component/schema.js";
+import type { MessageDoc } from "../validators.js";
 import { validateVectorDimension } from "../component/vector/tables.js";
 import {
   vMessageWithMetadata,

package/src/client/mock.json

@@ -0,0 +1,68 @@
+[
+  { "type": "start" },
+  { "type": "start-step" },
+  { "type": "reasoning-start", "id": "0-reasoning" },
+  {
+    "type": "reasoning-delta",
+    "id": "0-reasoning",
+    "delta": "I'm",
+    "providerMetadata": {
+      "mockProvider": { "mock": { "reasoningDetails": null } }
+    }
+  },
+  {
+    "type": "reasoning-delta",
+    "id": "0-reasoning",
+    "delta": " thinking",
+    "providerMetadata": {
+      "mockProvider": { "mock": { "reasoningDetails": null } }
+    }
+  },
+  { "type": "reasoning-end", "id": "0-reasoning" },
+  {
+    "type": "tool-input-available",
+    "toolCallId": "1",
+    "toolName": "say",
+    "input": { "question": "What is the best flavor of ice cream?" }
+  },
+  {
+    "type": "tool-output-available",
+    "toolCallId": "1",
+    "output": "I'm sorry I can't help you. Stop asking me questions."
+  },
+  {
+    "type": "tool-output-available",
+    "toolCallId": "1",
+    "output": "I'm sorry I can't help you. Stop asking me questions."
+  },
+  { "type": "reasoning-start", "id": "3-reasoning" },
+  {
+    "type": "reasoning-delta",
+    "id": "3-reasoning",
+    "delta": "I'm",
+    "providerMetadata": {
+      "mockProvider": { "mock": { "reasoningDetails": null } }
+    }
+  },
+  {
+    "type": "reasoning-delta",
+    "id": "3-reasoning",
+    "delta": " thinking",
+    "providerMetadata": {
+      "mockProvider": { "mock": { "reasoningDetails": null } }
+    }
+  },
+  { "type": "reasoning-end", "id": "3-reasoning" },
+  { "type": "text-start", "id": "4-text" },
+  { "type": "text-delta", "id": "4-text", "delta": "The" },
+  { "type": "text-delta", "id": "4-text", "delta": " best" },
+  { "type": "text-delta", "id": "4-text", "delta": " flavor" },
+  { "type": "text-delta", "id": "4-text", "delta": " of" },
+  { "type": "text-delta", "id": "4-text", "delta": " ice" },
+  { "type": "text-delta", "id": "4-text", "delta": " cream" },
+  { "type": "text-delta", "id": "4-text", "delta": " is" },
+  { "type": "text-delta", "id": "4-text", "delta": " vanilla." },
+  { "type": "text-end", "id": "4-text" },
+  { "type": "finish-step" },
+  { "type": "finish" }
+]

package/src/client/mockModel.ts

@@ -1,17 +1,18 @@
 import type {
   LanguageModelV2,
+  LanguageModelV2Content,
   LanguageModelV2StreamPart,
 } from "@ai-sdk/provider";
-import type { ReasoningPart, TextPart } from "@ai-sdk/provider-utils";
-import { simulateReadableStream } from "ai";
+import { simulateReadableStream, type ProviderMetadata } from "ai";
+import { pick } from "convex-helpers";
 
-const longDefaultText = `
+export const DEFAULT_TEXT = `
 A A A A A A A A A A A A A A A
 B B B B B B B B B B B B B B B
 C C C C C C C C C C C C C C C
 D D D D D D D D D D D D D D D
 `;
-const defaultUsage = { outputTokens: 10, inputTokens: 3, totalTokens: 13 };
+const DEFAULT_USAGE = { outputTokens: 10, inputTokens: 3, totalTokens: 13 };
 
 export type MockModelArgs = {
   provider?: LanguageModelV2["provider"];
@@ -22,9 +23,10 @@ export type MockModelArgs = {
   chunkDelayInMs?: number;
   initialDelayInMs?: number;
   // provide either content or doGenerate & doStream
-  content?: (TextPart | ReasoningPart)[];
+  content?: LanguageModelV2Content[];
   doGenerate?: LanguageModelV2["doGenerate"];
   doStream?: LanguageModelV2["doStream"];
+  providerMetadata?: ProviderMetadata;
   fail?:
     | boolean
     | {
@@ -55,9 +57,9 @@ export class MockLanguageModel implements LanguageModelV2 {
     this.provider = args.provider || "mock-provider";
     this.modelId = args.modelId || "mock-model-id";
     const {
-      content = [{ type: "text", text: longDefaultText }],
-      chunkDelayInMs = 200,
-      initialDelayInMs = 1000,
+      content = [{ type: "text", text: DEFAULT_TEXT }],
+      chunkDelayInMs = 0,
+      initialDelayInMs = 0,
       supportedUrls = {},
     } = args;
     const fail =
@@ -68,49 +70,62 @@ export class MockLanguageModel implements LanguageModelV2 {
     const error =
       (typeof args.fail === "object" && args.fail.error) ||
       "Mock error message";
+    const metadata = pick(args, ["providerMetadata"]);
 
     const chunks: LanguageModelV2StreamPart[] = [
       { type: "stream-start", warnings: [] },
     ];
     chunks.push(
-      ...content.flatMap((c, ci) => {
+      ...content.flatMap((c, ci): LanguageModelV2StreamPart[] => {
+        if (c.type !== "text" && c.type !== "reasoning") {
+          return [c];
+        }
+        const metadata = pick(c, ["providerMetadata"]);
         const deltas = c.text.split(" ");
-        let parts: LanguageModelV2StreamPart[] = [];
+        const parts: LanguageModelV2StreamPart[] = [];
         if (c.type === "reasoning") {
           parts.push({
             type: "reasoning-start",
-            id: `${ci}-reasoning-start`,
+            id: `reasoning-${ci}`,
+            ...metadata,
           });
           parts.push(
             ...deltas.map(
               (delta, di) =>
                 ({
                   type: "reasoning-delta",
-                  delta,
-                  id: `${ci}-reasoning-${di}`,
-                  providerMetadata: {
-                    mockProvider: { mock: { reasoningDetails: null } },
-                  },
+                  delta: (di ? " " : "") + delta,
+                  id: `reasoning-${ci}`,
+                  ...metadata,
                 }) satisfies LanguageModelV2StreamPart,
             ),
           );
           parts.push({
             type: "reasoning-end",
-            id: `${ci}-reasoning-end`,
+            id: `reasoning-${ci}`,
+            ...metadata,
           });
         } else if (c.type === "text") {
           parts.push({
             type: "text-start",
-            id: `${ci}-text-start`,
+            id: `txt-${ci}`,
+            ...metadata,
           });
-          parts = deltas.map((delta, di) => ({
-            type: "text-delta",
-            delta,
-            id: `${ci}-text-${di}`,
-          }));
+          parts.push(
+            ...deltas.map(
+              (delta, di) =>
+                ({
+                  type: "text-delta",
+                  delta: (di ? " " : "") + delta,
+                  id: `txt-${ci}`,
+                        ...metadata,
+                }) satisfies LanguageModelV2StreamPart,
+            ),
+          );
           parts.push({
             type: "text-end",
-            id: `${ci}-text-end`,
+            id: `txt-${ci}`,
+            ...metadata,
           });
         }
         return parts;
@@ -125,10 +140,8 @@ export class MockLanguageModel implements LanguageModelV2 {
     chunks.push({
       type: "finish",
       finishReason: fail ? "error" : "stop",
-      usage: defaultUsage,
-      providerMetadata: {
-        mockProvider: { mock: "mock metadata" },
-      },
+      usage: DEFAULT_USAGE,
+      ...metadata,
     });
     this.doGenerate = async (options) => {
       this.doGenerateCalls.push(options);
@@ -144,8 +157,8 @@ export class MockLanguageModel implements LanguageModelV2 {
         return {
           content,
           finishReason: "stop",
-          usage: defaultUsage,
-          providerMetadata: { mockProvider: { mock: "mock metadata" } },
+          usage: DEFAULT_USAGE,
+          ...metadata,
           warnings: [],
         };
       } else {
@@ -169,8 +182,11 @@ export class MockLanguageModel implements LanguageModelV2 {
           initialDelayInMs,
           chunkDelayInMs,
         });
+
         if (options.abortSignal) {
-          throw new Error("abortSignal in mock model");
+          options.abortSignal.addEventListener("abort", () => {
+            console.warn("abortSignal in mock model not supported");
+          });
         }
         return {
           stream,