@convex-dev/agent 0.0.1-alpha.1 → 0.0.1-alpha.2

package/src/client/index.ts

@@ -11,26 +11,24 @@ import type {
   ToolChoice,
   ToolExecutionOptions,
   ToolSet,
-  Message as UIMessage,
 } from "ai";
-import {
-  convertToCoreMessages,
-  coreMessageSchema,
-  generateObject,
-  generateText,
-  streamObject,
-  streamText,
-} from "ai";
-import type { ZodType } from "zod";
+import { generateObject, generateText, streamObject, streamText } from "ai";
 import { api } from "../component/_generated/api";
-import { Message, MessageStatus, SearchOptions } from "../validators";
+import {
+  SearchOptions,
+  vChatArgs,
+  vContextOptions,
+  vObjectArgs,
+  vStorageOptions,
+} from "../validators";
 import { RunActionCtx, RunMutationCtx, RunQueryCtx, UseApi } from "./types";
 // TODO: is this the only dependency that needs helpers in client?
 import { assert } from "convex-helpers";
-import { convexToZod } from "convex-helpers/server/zod";
-import { GenericActionCtx, GenericDataModel } from "convex/server";
-import { Infer, Validator } from "convex/values";
+import { ConvexToZod, convexToZod } from "convex-helpers/server/zod";
+import { internalActionGeneric } from "convex/server";
+import { Infer, v, Validator } from "convex/values";
 import {
+  promptOrMessagesToCoreMessages,
   serializeMessageWithId,
   serializeNewMessagesInStep,
   serializeStep,
@@ -38,15 +36,42 @@ import {
 import { DEFAULT_MESSAGE_RANGE, extractText } from "../shared";
 
 export type ContextOptions = {
-  parentMessageId?: string;
-  includeToolMessages?: boolean;
+  /**
+   * Whether to include tool messages in the context.
+   */
+  includeToolCalls?: boolean;
+  /**
+   * How many recent messages to include. These are added after the search
+   * messages, and do not count against the search limit.
+   */
   recentMessages?: number;
+  /**
+   * Options for searching messages.
+   */
   searchOptions?: {
+    /**
+     * The maximum number of messages to fetch.
+     */
     limit: number;
+    /**
+     * Whether to use text search to find messages.
+     */
     textSearch?: boolean;
+    /**
+     * Whether to use vector search to find messages.
+     */
     vectorSearch?: boolean;
-    messageRange: { before: number; after: number };
+    /**
+     * Note, this is after the limit is applied.
+     * By default this will quadruple the number of messages fetched.
+     * (two before, and one after each message found in the search)
+     */
+    messageRange?: { before: number; after: number };
   };
+  /**
+   * Whether to search across other chats for relevant messages.
+   * By default, only the current chat is searched.
+   */
   searchOtherChats?: boolean;
 };
 
@@ -70,8 +95,12 @@ export class Agent<AgentTools extends ToolSet> {
       name?: string;
       chat: LanguageModelV1;
       textEmbedding?: EmbeddingModelV1<string>;
-      defaultSystemPrompt?: string;
+      instructions?: string;
       tools?: AgentTools;
+      contextOptions?: ContextOptions;
+      // TODO: storageOptions?: StorageOptions;
+      maxSteps?: number;
+      // TODO: maxRetries?: number;
     }
   ) {}
 
@@ -85,7 +114,7 @@ export class Agent<AgentTools extends ToolSet> {
    * @param args The chat metadata.
    * @returns The chatId of the new chat and the chat object.
    */
-  async startChat(
+  async createChat(
     ctx: RunActionCtx,
     args: {
       /**
@@ -121,7 +150,7 @@ export class Agent<AgentTools extends ToolSet> {
    * @param args The chat metadata.
    * @returns The chatId of the new chat.
    */
-  async startChat(
+  async createChat(
     ctx: RunMutationCtx,
     args: {
       userId?: string;
@@ -132,7 +161,7 @@ export class Agent<AgentTools extends ToolSet> {
   ): Promise<{
     chatId: string;
   }>;
-  async startChat(
+  async createChat(
     ctx: RunActionCtx | RunMutationCtx,
     args: {
       userId: string;
@@ -145,7 +174,7 @@ export class Agent<AgentTools extends ToolSet> {
     chat?: Chat<AgentTools>;
   }> {
     const chatDoc = await ctx.runMutation(this.component.messages.createChat, {
-      defaultSystemPrompt: this.options.defaultSystemPrompt,
+      defaultSystemPrompt: this.options.instructions,
       userId: args.userId,
       title: args.title,
       summary: args.summary,
@@ -171,6 +200,10 @@ export class Agent<AgentTools extends ToolSet> {
       userId,
     }: {
       chatId: string;
+      /**
+       * If supplied, the userId can be used to search across other chats for
+       * relevant messages from the same user as context for the LLM calls.
+       */
       userId?: string;
     }
   ): Promise<{
@@ -193,12 +226,14 @@ export class Agent<AgentTools extends ToolSet> {
       userId?: string;
       chatId?: string;
       messages: CoreMessage[];
+      parentMessageId?: string;
     } & ContextOptions
   ): Promise<CoreMessage[]> {
     assert(args.userId || args.chatId, "Specify userId or chatId");
     // Fetch the latest messages from the chat
     const contextMessages: CoreMessage[] = [];
-    if (args.searchOptions?.textSearch || args.searchOptions?.vectorSearch) {
+    const opts = this.mergedContextOptions(args);
+    if (opts.searchOptions?.textSearch || opts.searchOptions?.vectorSearch) {
       if (!("runAction" in ctx)) {
         throw new Error("searchUserMessages only works in an action");
       }
@@ -208,7 +243,7 @@ export class Agent<AgentTools extends ToolSet> {
           userId: args.searchOtherChats ? args.userId : undefined,
           chatId: args.chatId,
           parentMessageId: args.parentMessageId,
-          ...(await this.searchOptionsWithDefaults(args, args.messages)),
+          ...(await this.searchOptionsWithDefaults(opts, args.messages)),
         }
       );
       // TODO: track what messages we used for context
@@ -219,7 +254,7 @@ export class Agent<AgentTools extends ToolSet> {
         this.component.messages.getChatMessages,
         {
           chatId: args.chatId,
-          isTool: args.includeToolMessages ?? false,
+          isTool: args.includeToolCalls ?? false,
           limit: args.recentMessages,
           parentMessageId: args.parentMessageId,
           order: "desc",
@@ -234,10 +269,12 @@ export class Agent<AgentTools extends ToolSet> {
   async saveMessages(
     ctx: RunMutationCtx,
     args: {
-      chatId: string;
+      chatId?: string;
+      userId?: string;
       messages: CoreMessageMaybeWithId[];
       pending?: boolean;
       parentMessageId?: string;
+      failPendingSteps?: boolean;
     }
   ): Promise<{
     lastMessageId: string;
@@ -245,10 +282,11 @@ export class Agent<AgentTools extends ToolSet> {
   }> {
     const result = await ctx.runMutation(this.component.messages.addMessages, {
       chatId: args.chatId,
+      userId: args.userId,
       agentName: this.options.name,
       model: this.options.chat.modelId,
       messages: args.messages.map(serializeMessageWithId),
-      failPendingSteps: true,
+      failPendingSteps: args.failPendingSteps ?? true,
       pending: args.pending ?? false,
       parentMessageId: args.parentMessageId,
     });
@@ -318,7 +356,7 @@ export class Agent<AgentTools extends ToolSet> {
       chatId,
     }: {
       userId?: string;
-      chatId: string;
+      chatId?: string;
     },
     args: TextArgs<
       AgentTools,
@@ -338,23 +376,26 @@ export class Agent<AgentTools extends ToolSet> {
     });
     const { lastMessageId: messageId } = await this.saveMessages(ctx, {
       chatId,
+      userId,
       messages: args.saveAllInputMessages ? messages : messages.slice(-1),
       pending: true,
       parentMessageId: args.parentMessageId,
     });
-    const defaults = this.options.tools;
-    const tools = wrapTools(ctx, chatId, userId, defaults, args.tools) as TOOLS;
+    const toolCtx = { ...ctx, userId, chatId, messageId };
+    const tools = wrapTools(toolCtx, this.options.tools, args.tools) as TOOLS;
     try {
       const result = await generateText({
         model: this.options.chat,
         messages: [...contextMessages, ...messages],
-        system: this.options.defaultSystemPrompt,
-        tools,
+        system: this.options.instructions,
+        maxSteps: this.options.maxSteps,
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         toolChoice: args.toolChoice as any,
         ...rest,
+        tools,
         onStepFinish: async (step) => {
           if (chatId && messageId && args.saveOutputMessages) {
+            console.log("onStepFinish", step);
             await this.saveStep(ctx, {
               chatId,
               messageId,
@@ -367,6 +408,7 @@ export class Agent<AgentTools extends ToolSet> {
       return { ...result, messageId };
     } catch (error) {
       if (chatId && messageId) {
+        console.error("RollbackMessage", messageId);
         await ctx.runMutation(this.component.messages.rollbackMessage, {
           messageId,
           error: (error as Error).message,
@@ -382,12 +424,12 @@ export class Agent<AgentTools extends ToolSet> {
     PARTIAL_OUTPUT = never,
   >(
     ctx: RunActionCtx,
-    { userId, chatId }: { userId?: string; chatId: string },
-    args: Partial<
+    { userId, chatId }: { userId?: string; chatId?: string },
+    args: TextArgs<
+      AgentTools,
+      TOOLS,
       Parameters<typeof streamText<TOOLS, OUTPUT, PARTIAL_OUTPUT>>[0]
-    > &
-      ContextOptions &
-      StorageOptions
+    >
   ): Promise<
     StreamTextResult<TOOLS, PARTIAL_OUTPUT> & GenerationOutputMetadata
   > {
@@ -405,16 +447,17 @@ export class Agent<AgentTools extends ToolSet> {
       pending: true,
       parentMessageId: args.parentMessageId,
     });
-    const defaults = this.options.tools;
-    const tools = wrapTools(ctx, chatId, userId, defaults, args.tools) as TOOLS;
+    const toolCtx = { ...ctx, userId, chatId, messageId };
+    const tools = wrapTools(toolCtx, this.options.tools, args.tools) as TOOLS;
     const result = streamText({
       model: this.options.chat,
       messages: [...contextMessages, ...messages],
-      system: this.options.defaultSystemPrompt,
-      tools,
+      system: this.options.instructions,
+      maxSteps: this.options.maxSteps,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       toolChoice: args.toolChoice as any,
       ...rest,
+      tools,
       onChunk: async (chunk) => {
         console.log("onChunk", chunk);
         return args.onChunk?.(chunk);
@@ -453,10 +496,10 @@ export class Agent<AgentTools extends ToolSet> {
   // TODO: add the crazy number of overloads to get types through
   async generateObject<T>(
     ctx: RunActionCtx,
-    { userId, chatId }: { userId?: string; chatId: string },
+    { userId, chatId }: { userId?: string; chatId?: string },
     args: Omit<Parameters<typeof generateObject>[0], "model"> & {
       model?: LanguageModelV1;
-    } & ContextOptions &
+    } & { parentMessageId?: string } & ContextOptions &
       StorageOptions
   ): Promise<GenerateObjectResult<T> & GenerationOutputMetadata> {
     const { prompt, messages: raw, ...rest } = args;
@@ -482,10 +525,10 @@ export class Agent<AgentTools extends ToolSet> {
 
   async streamObject<T>(
     ctx: RunMutationCtx,
-    { userId, chatId }: { userId?: string; chatId: string },
+    { userId, chatId }: { userId?: string; chatId?: string },
     args: Omit<Parameters<typeof streamObject<T>>[0], "model"> & {
       model?: LanguageModelV1;
-    } & ContextOptions &
+    } & { parentMessageId?: string } & ContextOptions &
       StorageOptions
   ): Promise<
     StreamObjectResult<DeepPartial<T>, T, never> & GenerationOutputMetadata
@@ -518,27 +561,41 @@ export class Agent<AgentTools extends ToolSet> {
     return { ...result, messageId };
   }
 
+  mergedContextOptions(opts: ContextOptions): ContextOptions {
+    const searchOptions = {
+      ...this.options.contextOptions?.searchOptions,
+      ...opts.searchOptions,
+    };
+    return {
+      ...this.options.contextOptions,
+      ...opts,
+      searchOptions: searchOptions.limit
+        ? (searchOptions as SearchOptions)
+        : undefined,
+    };
+  }
+
   async searchOptionsWithDefaults(
-    searchArgs: ContextOptions,
+    contextOptions: ContextOptions,
     messages: CoreMessage[]
   ): Promise<SearchOptions> {
     assert(
-      searchArgs.searchOptions?.textSearch ||
-        searchArgs.searchOptions?.vectorSearch,
+      contextOptions.searchOptions?.textSearch ||
+        contextOptions.searchOptions?.vectorSearch,
       "searchOptions is required"
     );
     assert(messages.length > 0, "Core messages cannot be empty");
     const text = extractText(messages.at(-1)!);
     const search: SearchOptions = {
-      limit: searchArgs.searchOptions?.limit ?? 10,
+      limit: contextOptions.searchOptions?.limit ?? 10,
       messageRange: {
         ...DEFAULT_MESSAGE_RANGE,
-        ...searchArgs.searchOptions?.messageRange,
+        ...contextOptions.searchOptions?.messageRange,
       },
       text: extractText(messages.at(-1)!),
     };
     if (
-      searchArgs.searchOptions?.vectorSearch &&
+      contextOptions.searchOptions?.vectorSearch &&
       text &&
       this.options.textEmbedding
     ) {
@@ -552,71 +609,191 @@ export class Agent<AgentTools extends ToolSet> {
     return search;
   }
 
-  async getChatMessages(
-    ctx: RunQueryCtx,
-    args: {
-      chatId: string;
-      limit?: number;
-      statuses?: MessageStatus[];
-      cursor?: string;
-      includeToolMessages?: boolean;
-      order?: "asc" | "desc";
-    }
-  ): Promise<{
-    messages: (Message & { id: string })[];
-    continueCursor?: string;
-    isDone: boolean;
-  }> {
-    const messages = await ctx.runQuery(
-      this.component.messages.getChatMessages,
-      {
-        chatId: args.chatId,
-        limit: args.limit,
-        statuses: args.statuses,
-        cursor: args.cursor,
-        isTool: args.includeToolMessages,
-        order: args.order,
-      }
-    );
-    return {
-      messages: messages.messages
-        .map((m) => m && { ...m.message, id: m._id })
-        .filter((m): m is Message & { id: string } => m !== undefined),
-      continueCursor: messages.continueCursor,
-      isDone: messages.isDone,
-    };
+  /**
+   *
+   */
+  asAction(spec: { contextOptions?: ContextOptions; maxSteps?: number }) {
+    return internalActionGeneric({
+      args: {
+        userId: v.optional(v.string()),
+        chatId: v.optional(v.string()),
+        contextOptions: v.optional(vContextOptions),
+        storageOptions: v.optional(vStorageOptions),
+        maxRetries: v.optional(v.number()),
+
+        createChat: v.optional(
+          v.object({
+            userId: v.string(),
+            parentChatIds: v.optional(v.array(v.string())),
+            title: v.optional(v.string()),
+            summary: v.optional(v.string()),
+          })
+        ),
+        continueChat: v.optional(
+          v.object({
+            chatId: v.string(),
+            userId: v.optional(v.string()),
+          })
+        ),
+        generateText: v.optional(vChatArgs),
+        streamText: v.optional(vChatArgs),
+        generateObject: v.optional(vObjectArgs),
+        streamObject: v.optional(
+          v.object({ ...vObjectArgs.fields, schema: v.any() })
+        ),
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      handler: async (ctx, args): Promise<any> => {
+        const contextOptions =
+          spec.contextOptions && this.mergedContextOptions(spec.contextOptions);
+        const maxSteps = spec.maxSteps ?? this.options.maxSteps;
+        const maxRetries = args.maxRetries;
+        const commonArgs = {
+          userId: args.userId,
+          chatId: args.chatId,
+          ...contextOptions,
+          ...args.storageOptions,
+        };
+        if (args.createChat) {
+          return this.createChat(ctx, {
+            userId: args.createChat.userId,
+            parentChatIds: args.createChat.parentChatIds,
+            title: args.createChat.title,
+            summary: args.createChat.summary,
+          });
+        } else if (args.continueChat) {
+          return this.continueChat(ctx, {
+            chatId: args.continueChat.chatId,
+            userId: args.continueChat.userId,
+          });
+        } else if (args.generateText) {
+          return this.generateText(ctx, commonArgs, {
+            ...args.generateText,
+            maxSteps: args.generateText.maxSteps ?? maxSteps,
+            maxRetries,
+          });
+        } else if (args.streamText) {
+          return this.streamText(ctx, commonArgs, {
+            ...args.streamText,
+            maxSteps: args.streamText.maxSteps ?? maxSteps,
+            maxRetries,
+          });
+        } else if (args.generateObject) {
+          return this.generateObject(ctx, commonArgs, {
+            ...args.generateObject,
+            output: args.generateObject.output ?? "string",
+            maxRetries,
+          });
+        } else if (args.streamObject) {
+          return this.streamObject(ctx, commonArgs, {
+            ...args.streamObject,
+            output: args.streamObject.output ?? "string",
+            maxRetries,
+          });
+        }
+      },
+    });
   }
-}
 
-export function promptOrMessagesToCoreMessages(args: {
-  system?: string;
-  prompt?: string;
-  messages?: CoreMessage[] | Omit<UIMessage, "id">[];
-}): CoreMessage[] {
-  const messages: CoreMessage[] = [];
-  if (args.system) {
-    messages.push({ role: "system", content: args.system });
+  /**
+   * Create a tool that can call this agent.
+   * @param spec The specification for the arguments to this agent.
+   *   They will be encoded as JSON and passed to the agent.
+   * @returns The agent as a tool that can be passed to other agents.
+   */
+  asTool(spec: {
+    description: string;
+    args: Validator<unknown, "required", string>;
+    contextOptions?: ContextOptions;
+    maxSteps?: number;
+  }) {
+    return createTool({
+      ...spec,
+      handler: async (ctx, args) => {
+        const maxSteps = spec.maxSteps ?? this.options.maxSteps;
+        const contextOptions =
+          spec.contextOptions && this.mergedContextOptions(spec.contextOptions);
+        const value = await this.generateText(
+          ctx,
+          { userId: ctx.userId, chatId: ctx.chatId },
+          {
+            prompt: JSON.stringify(args),
+            parentMessageId: ctx.messageId,
+            maxSteps,
+            ...contextOptions,
+          }
+        );
+        return value.text;
+      },
+    });
   }
-  if (!args.messages) {
-    assert(args.prompt, "messages or prompt is required");
-    messages.push({ role: "user", content: args.prompt });
-  } else if (
-    args.messages.some(
-      (m) =>
-        typeof m === "object" &&
-        m !== null &&
-        (m.role === "data" || // UI-only role
-          "toolInvocations" in m || // UI-specific field
-          "parts" in m || // UI-specific field
-          "experimental_attachments" in m)
-    )
-  ) {
-    messages.push(...convertToCoreMessages(args.messages as UIMessage[]));
-  } else {
-    messages.push(...coreMessageSchema.array().parse(args.messages));
+}
+
+export type ToolCtx = RunActionCtx & {
+  userId?: string;
+  chatId?: string;
+  messageId?: string;
+};
+
+/**
+ * This is a wrapper around the ai.tool function that adds support for
+ * userId and chatId to the tool, if they're called within a chat from an agent.
+ * @param tool The AI tool. See https://sdk.vercel.ai/docs/ai-sdk-core/tools-and-tool-calling
+ * @returns The same tool, but with userId and chatId args support added.
+ */
+export function createTool<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  V extends Validator<any, any, any>,
+  RESULT,
+>(convexTool: {
+  args: V;
+  description?: string;
+  handler: (
+    ctx: ToolCtx,
+    args: Infer<V>,
+    options: ToolExecutionOptions
+  ) => PromiseLike<RESULT>;
+  ctx?: ToolCtx;
+}): Tool<ConvexToZod<V>, RESULT> {
+  const tool = {
+    __acceptsCtx: true,
+    ctx: convexTool.ctx,
+    description: convexTool.description,
+    parameters: convexToZod(convexTool.args),
+    async execute(args: Infer<V>, options: ToolExecutionOptions) {
+      if (!this.ctx) {
+        throw new Error(
+          "To use a Convex tool, you must either provide the ctx" +
+            " at definition time (dynamically in an action), or use the Agent to" +
+            " call it (which injects the ctx, userId and chatId)"
+        );
+      }
+      return convexTool.handler(this.ctx, args, options);
+    },
+  };
+  return tool;
+}
+
+function wrapTools(
+  ctx: ToolCtx,
+  ...toolSets: (ToolSet | undefined)[]
+): ToolSet {
+  const output = {} as ToolSet;
+  for (const toolSet of toolSets) {
+    if (!toolSet) {
+      continue;
+    }
+    for (const [name, tool] of Object.entries(toolSet)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (!(tool as any).__acceptsCtx) {
+        output[name] = tool;
+      } else {
+        const out = { ...tool, ctx };
+        output[name] = out;
+      }
+    }
   }
-  assert(messages.length > 0, "Messages must contain at least one message");
-  return messages;
+  return output;
 }
 
 type TextArgs<
@@ -629,6 +806,7 @@ type TextArgs<
   },
 > = Omit<T, "toolChoice" | "tools" | "model"> & {
   model?: LanguageModelV1;
+  parentMessageId?: string;
 } & {
   tools?: TOOLS;
   toolChoice?: ToolChoice<{ [key in keyof TOOLS | keyof AgentTools]: unknown }>;
@@ -675,79 +853,3 @@ interface Chat<AgentTools extends ToolSet> {
     StreamObjectResult<DeepPartial<T>, T, never> & GenerationOutputMetadata
   >;
 }
-
-// type ToolParameters = ZodTypeAny | Schema<unknown>; // TODO: support convex validator
-// type inferParameters<PARAMETERS extends ToolParameters> =
-//   PARAMETERS extends Schema<unknown>
-//     ? PARAMETERS["_type"]
-//     : PARAMETERS extends z.ZodTypeAny
-//       ? z.infer<PARAMETERS>
-//       : never;
-/**
- * This is a wrapper around the ai.tool function that adds support for
- * userId and chatId to the tool, if they're called within a chat from an agent.
- * @param tool The AI tool. See https://sdk.vercel.ai/docs/ai-sdk-core/tools-and-tool-calling
- * @returns The same tool, but with userId and chatId args support added.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function tool<V extends Validator<any, any, any>, RESULT>(convexTool: {
-  args: V;
-  description?: string;
-  handler: (
-    ctx: GenericActionCtx<GenericDataModel> & {
-      userId?: string;
-      chatId?: string;
-    },
-    args: Infer<V>,
-    options: ToolExecutionOptions
-  ) => PromiseLike<RESULT>;
-  ctx?: GenericActionCtx<GenericDataModel> & {
-    userId?: string;
-    chatId?: string;
-  };
-}): Tool<ZodType<Infer<V>>, RESULT> {
-  const tool = {
-    __acceptUserIdAndChatId: true,
-    description: convexTool.description,
-    parameters: convexToZod(convexTool.args),
-    execute: async (args: Infer<V>, options: ToolExecutionOptions) => {
-      if (!convexTool.ctx) {
-        throw new Error(
-          "To use a Convex tool, you must either provide the ctx" +
-            " at definition time (dynamically in an action), or use the Agent to" +
-            " call it (which injects the ctx, userId and chatId)"
-        );
-      }
-      return convexTool.handler(convexTool.ctx, args, options);
-    },
-  };
-  return tool;
-}
-
-export function wrapTools(
-  actionCtx: RunActionCtx,
-  chatId: string,
-  userId?: string,
-  ...toolSets: (ToolSet | undefined)[]
-): ToolSet {
-  const ctx = { ...actionCtx, chatId, userId };
-  const output = {} as ToolSet;
-  for (const toolSet of toolSets) {
-    if (!toolSet) {
-      continue;
-    }
-    for (const [name, tool] of Object.entries(toolSet)) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      if (!(tool as any).__acceptUserIdAndChatId) {
-        output[name] = tool;
-      } else {
-        const out = { ...tool, ctx };
-        output[name] = out;
-      }
-    }
-  }
-  return output;
-}
-// export function convexValidatorSchema<T>(validator: Validator<unknown>)  {
-//   return ai.jsonSchema(convexToJsonSchema(validator));
-// }