@convex-dev/agent 0.1.18 → 0.2.0-alpha.2

package/src/client/definePlaygroundAPI.ts

@@ -1,27 +1,27 @@
 import {
+  actionGeneric,
+  mutationGeneric,
   paginationOptsValidator,
   queryGeneric,
-  mutationGeneric,
-  actionGeneric,
-  type GenericDataModel,
-  type GenericQueryCtx,
   type ApiFromModules,
   type GenericActionCtx,
+  type GenericDataModel,
+  type GenericQueryCtx,
 } from "convex/server";
+import { v } from "convex/values";
 import {
+  createThread as createThread_,
+  listMessages as listMessages_,
+  deserializeMessage,
+  vContextOptions,
+  vMessage,
   vMessageDoc,
-  vThreadDoc,
   vPaginationResult,
-  vMessage,
-  vContextOptions,
   vStorageOptions,
-  type AgentComponent,
+  vThreadDoc,
   type Agent,
-  listMessages as listMessages_,
-  createThread as createThread_,
+  type AgentComponent,
 } from "./index.js";
-import { v } from "convex/values";
-import { deserializeMessage } from "../mapping.js";
 
 export type PlaygroundAPI = ApiFromModules<{
   playground: ReturnType<typeof definePlaygroundAPI>;
@@ -61,9 +61,7 @@ export function definePlaygroundAPI<DataModel extends GenericDataModel>(
   }
 
   const isApiKeyValid = queryGeneric({
-    args: {
-      apiKey: v.string(),
-    },
+    args: { apiKey: v.string() },
     handler: async (ctx, args) => {
       try {
         await validateApiKey(ctx, args.apiKey);
@@ -107,18 +105,14 @@ export function definePlaygroundAPI<DataModel extends GenericDataModel>(
         instructions: agent.options.instructions,
         contextOptions: agent.options.contextOptions,
         storageOptions: agent.options.storageOptions,
-        maxSteps: agent.options.maxSteps,
-        maxRetries: agent.options.maxRetries,
+        maxRetries: agent.options.callSettings?.maxRetries,
         tools: agent.options.tools ? Object.keys(agent.options.tools) : [],
       }));
     },
   });
 
   const listUsers = queryGeneric({
-    args: {
-      apiKey: v.string(),
-      paginationOpts: paginationOptsValidator,
-    },
+    args: { apiKey: v.string(), paginationOpts: paginationOptsValidator },
     handler: async (ctx, args) => {
       await validateApiKey(ctx, args.apiKey);
       const users = await ctx.runQuery(component.users.listUsersWithThreads, {
@@ -134,12 +128,7 @@ export function definePlaygroundAPI<DataModel extends GenericDataModel>(
         ),
       };
     },
-    returns: vPaginationResult(
-      v.object({
-        _id: v.string(),
-        name: v.string(),
-      }),
-    ),
+    returns: vPaginationResult(v.object({ _id: v.string(), name: v.string() })),
   });
 
   // List threads for a user (query)
@@ -168,10 +157,7 @@ export function definePlaygroundAPI<DataModel extends GenericDataModel>(
             } = await ctx.runQuery(component.messages.listMessagesByThreadId, {
               threadId: thread._id,
               order: "desc",
-              paginationOpts: {
-                numItems: 1,
-                cursor: null,
-              },
+              paginationOpts: { numItems: 1, cursor: null },
             });
             return {
               ...thread,

package/src/client/files.ts

@@ -22,8 +22,8 @@ type File = {
  * @param ctx A ctx object from an action.
  * @param component The agent component.
  * @param blob The blob to store.
- * @param filename The filename to store.
- * @param sha256 The sha256 hash of the file. If not provided, it will be
+ * @param args.filename The filename to store.
+ * @param args.sha256 The sha256 hash of the file. If not provided, it will be
  *   computed. However, to ensure no corruption during transfer, you can
  *   calculate this on the client to enforce integrity.
  * @returns The URL, fileId, and storageId of the stored file.
@@ -32,8 +32,7 @@ export async function storeFile(
   ctx: ActionCtx | RunMutationCtx,
   component: AgentComponent,
   blob: Blob,
-  filename?: string,
-  sha256?: string,
+  { filename, sha256 }: { filename?: string; sha256?: string } = {},
 ): Promise<{
   file: File;
   filePart: FilePart;
@@ -148,7 +147,7 @@ export async function getFile(
 
 function getParts(
   url: string,
-  mimeType: string,
+  mediaType: string,
   filename: string | undefined,
 ): {
   filePart: FilePart;
@@ -157,14 +156,14 @@ function getParts(
   const filePart: FilePart = {
     type: "file",
     data: new URL(url),
-    mimeType,
+    mediaType,
     filename,
   };
-  const imagePart: ImagePart | undefined = mimeType.startsWith("image/")
+  const imagePart: ImagePart | undefined = mediaType.startsWith("image/")
     ? {
         type: "image",
         image: new URL(url),
-        mimeType,
+        mediaType,
       }
     : undefined;
   return { filePart, imagePart };

package/src/client/index.test.ts

@@ -19,11 +19,14 @@ import type {
 } from "convex/server";
 import { v } from "convex/values";
 import { defineSchema } from "convex/server";
-import { MockLanguageModelV1 } from "ai/test";
-import type { LanguageModelV1, LanguageModelV1StreamPart } from "ai";
-import { simulateReadableStream } from "ai";
+import { MockLanguageModelV2 } from "ai/test";
+import type {
+  LanguageModelV2,
+  LanguageModelV2StreamPart,
+} from "@ai-sdk/provider";
+import { simulateReadableStream, stepCountIs } from "ai";
 import { components, initConvexTest } from "./setup.test.js";
-import { z } from "zod";
+import { z } from "zod/v3";
 
 const schema = defineSchema({});
 type DataModel = DataModelFromSchemaDefinition<typeof schema>;
@@ -252,16 +255,16 @@ describe("filterOutOrphanedToolMessages", () => {
   });
 });
 
-function mockModel(): LanguageModelV1 {
-  return new MockLanguageModelV1({
+function mockModel(): LanguageModelV2 {
+  return new MockLanguageModelV2({
     provider: "mock",
     modelId: "mock",
-    defaultObjectGenerationMode: "json",
     // supportsStructuredOutputs: true,
     doGenerate: async ({ prompt }) => ({
       finishReason: "stop",
-      usage: { completionTokens: 10, promptTokens: 3 },
-      logprobs: undefined,
+      content: [{ type: "text", text: JSON.stringify({ prompt }) }],
+      warnings: [],
+      usage: { outputTokens: 10, inputTokens: 3, totalTokens: 13 },
       rawCall: { rawPrompt: null, rawSettings: {} },
       text: JSON.stringify({ prompt }),
     }),
@@ -277,10 +280,9 @@ function mockModel(): LanguageModelV1 {
           {
             type: "finish",
             finishReason: "stop",
-            logprobs: undefined,
-            usage: { completionTokens: 10, promptTokens: 3 },
+            usage: { outputTokens: 10, inputTokens: 3, totalTokens: 13 },
           },
-        ] as LanguageModelV1StreamPart[],
+        ] as LanguageModelV2StreamPart[],
       }),
       rawCall: { rawPrompt: null, rawSettings: {} },
     }),
@@ -300,8 +302,8 @@ describe("Agent option variations and normal behavior", () => {
       instructions: "Test instructions",
       contextOptions: { recentMessages: 5 },
       storageOptions: { saveMessages: "all" },
-      maxSteps: 2,
-      maxRetries: 1,
+      stopWhen: stepCountIs(2),
+      callSettings: { maxRetries: 1 },
       usageHandler: async () => {},
       rawRequestResponseHandler: async () => {},
     });
@@ -346,7 +348,7 @@ describe("Agent message operations", () => {
     );
     expect(messageId).toBeTypeOf("string");
 
-    const { lastMessageId, messages } = await t.run(async (ctx) =>
+    const { messages } = await t.run(async (ctx) =>
       agent.saveMessages(ctx, {
         threadId,
         userId: "4",
@@ -357,7 +359,7 @@ describe("Agent message operations", () => {
       }),
     );
     expect(messages.length).toBe(2);
-    expect(lastMessageId).toBe(messages[1]._id);
+    expect(messages[1]._id).toBeDefined();
   });
 });
 
@@ -433,8 +435,8 @@ describe("Agent-generated mutations/actions/queries", () => {
         },
       ],
     });
-    expect(result.lastMessageId).toBeDefined();
-    expect(result.messageIds.length).toBe(1);
+    expect(result.messages.length).toBe(1);
+    expect(result.messages[0]._id).toBeDefined();
   });
 });