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

package/src/component/schema.ts

@@ -1,29 +1,29 @@
 import { defineSchema, defineTable } from "convex/server";
 import { v } from "convex/values";
-import { vChatStatus, vMessage, vMessageStatus, vStep } from "../validators";
+import { vThreadStatus, vMessage, vMessageStatus, vStep } from "../validators";
 import { typedV } from "convex-helpers/validators";
 import vectorTables, { vVectorId } from "./vector/tables";
 
 export const schema = defineSchema({
-  chats: defineTable({
+  threads: defineTable({
     userId: v.optional(v.string()), // Unset for anonymous
     order: v.optional(v.number()), // within a domain
     // TODO: is this bubbling up in continue?
     defaultSystemPrompt: v.optional(v.string()),
     title: v.optional(v.string()),
     summary: v.optional(v.string()),
-    status: vChatStatus,
-    // If this is a chat continuation, we can use this to find context from
-    // the parent chat(s). There are multiple if the chat is a merging of
-    // multiple chats.
-    parentChatIds: v.optional(v.array(v.id("chats"))),
+    status: vThreadStatus,
+    // If this is a thread continuation, we can use this to find context from
+    // the parent thread(s). There are multiple if the thread is a merging of
+    // multiple threads.
+    parentThreadIds: v.optional(v.array(v.id("threads"))),
   }).index("status_userId_order", ["status", "userId", "order"]),
   // TODO: text search on title/ summary
   messages: defineTable({
     id: v.optional(v.string()), // external id, e.g. from Vercel AI SDK
     userId: v.optional(v.string()), // useful for future indexes (text search)
-    chatId: v.id("chats"),
-    threadId: v.optional(v.id("messages")),
+    threadId: v.optional(v.id("threads")),
+    parentMessageId: v.optional(v.id("messages")),
     stepId: v.optional(v.id("steps")),
     agentName: v.optional(v.string()),
     message: v.optional(vMessage),
@@ -33,7 +33,7 @@ export const schema = defineSchema({
     // TODO: add sub-messages back in? or be able to skip them?
     tool: v.boolean(),
     // Repeats until a non-tool message.
-    // Set when the message is finished
+    // Unset if it's not in a thread.
     order: v.number(),
     stepOrder: v.optional(v.number()),
     fileId: v.optional(v.id("files")),
@@ -41,8 +41,15 @@ export const schema = defineSchema({
   })
     // Allows finding successful visible messages in order
     // Also surface pending messages separately to e.g. stream
-    .index("chatId_status_tool_order_stepOrder", [
-      "chatId",
+    .index("threadId_status_tool_order_stepOrder", [
+      "threadId",
+      "status",
+      "tool",
+      "order",
+      "stepOrder",
+    ])
+    .index("userId_status_tool_order_stepOrder", [
+      "userId",
       "status",
       "tool",
       "order",
@@ -50,22 +57,22 @@ export const schema = defineSchema({
     ])
     // Allows finding all threaded messages in order
     // Allows finding all failed messages to evaluate
-    // .index("status_threadId_order_stepOrder", [
+    // .index("status_parentMessageId_order_stepOrder", [
     //   "status",
-    //   "threadId",
+    //   "parentMessageId",
     //   "order",
     //   "stepOrder",
     // ])
     // Allows text search on message content
     .searchIndex("text_search", {
       searchField: "text",
-      filterFields: ["userId", "chatId"],
+      filterFields: ["userId", "threadId"],
     })
     // Allows finding messages by vector embedding id
     .index("embeddingId", ["embeddingId"]),
 
   steps: defineTable({
-    chatId: v.id("chats"),
+    threadId: v.id("threads"),
     // Could be different from the order if we fail.
     parentMessageId: v.id("messages"),
     order: v.number(), // parent message order
@@ -73,9 +80,9 @@ export const schema = defineSchema({
     step: vStep,
     status: vMessageStatus,
   })
-    .index("status_chatId_order_stepOrder", [
+    .index("status_threadId_order_stepOrder", [
       "status",
-      "chatId",
+      "threadId",
       "order",
       "stepOrder",
     ])

package/src/component/vector/index.ts

@@ -23,7 +23,7 @@ export const paginate = query({
     const vectors = await paginator(ctx.db, schema)
       .query(tableName)
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      .withIndex("model_kind_chatId" as any, (q) =>
+      .withIndex("model_kind_threadId" as any, (q) =>
         q.eq("model", args.targetModel)
       )
       .paginate({
@@ -39,11 +39,11 @@ export const paginate = query({
   },
 });
 
-export const deleteBatchForChat = mutation({
+export const deleteBatchForThread = mutation({
   args: {
     vectorDimension: vVectorDimension,
     model: v.string(),
-    chatId: v.string(),
+    threadId: v.string(),
     cursor: v.optional(v.string()),
     limit: v.number(),
   },
@@ -54,18 +54,18 @@ export const deleteBatchForChat = mutation({
   handler: async (ctx, args) => {
     const tableName = getVectorTableName(args.vectorDimension);
     const vectors = await mergedStream(
-      ["chat", "memory"].map((kind) =>
+      ["thread", "memory"].map((kind) =>
         stream(ctx.db, schema)
           .query(tableName)
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          .withIndex("model_kind_chatId" as any, (q) =>
+          .withIndex("model_kind_threadId" as any, (q) =>
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             (q.eq("model", args.model) as any)
               .eq("kind", kind)
-              .eq("chatId", args.chatId)
+              .eq("threadId", args.threadId)
           )
       ),
-      ["chatId"]
+      ["threadId"]
     ).paginate({
       cursor: args.cursor ?? null,
       numItems: args.limit,
@@ -85,9 +85,9 @@ export const insertBatch = mutation({
     vectors: v.array(
       v.object({
         model: v.string(),
-        kind: v.union(v.literal("chat"), v.literal("memory")),
+        kind: v.union(v.literal("thread"), v.literal("memory")),
         userId: v.optional(v.string()),
-        chatId: v.optional(v.string()),
+        threadId: v.optional(v.string()),
         vector: v.array(v.number()),
       })
     ),
@@ -100,10 +100,12 @@ export const insertBatch = mutation({
           model: v.model,
           kind: v.kind,
           userId: v.userId,
-          chatId: v.chatId,
+          threadId: v.threadId,
           vector: v.vector,
           model_kind_userId: v.userId ? [v.model, v.kind, v.userId] : undefined,
-          model_kind_chatId: v.chatId ? [v.model, v.kind, v.chatId] : undefined,
+          model_kind_threadId: v.threadId
+            ? [v.model, v.kind, v.threadId]
+            : undefined,
         })
       )
     );

package/src/component/vector/tables.ts

@@ -10,12 +10,12 @@ import { QueryCtx } from "../_generated/server";
 // We only generate embeddings for non-tool, non-system messages
 const embeddings = {
   model: v.string(),
-  kind: v.union(v.literal("chat"), v.literal("memory")),
+  kind: v.union(v.literal("thread"), v.literal("memory")),
   userId: v.optional(v.string()),
-  chatId: v.optional(v.string()),
-  // not set for private chats
+  threadId: v.optional(v.string()),
+  // not set for private threads
   model_kind_userId: v.optional(v.array(v.string())),
-  model_kind_chatId: v.optional(v.array(v.string())),
+  model_kind_threadId: v.optional(v.array(v.string())),
   vector: v.array(v.number()),
 };
 
@@ -24,9 +24,9 @@ function table<D extends number>(dimensions: D): Table<D> {
     .vectorIndex("vector", {
       vectorField: "vector",
       dimensions,
-      filterFields: ["model_kind_userId", "model_kind_chatId"],
+      filterFields: ["model_kind_userId", "model_kind_threadId"],
     })
-    .index("model_kind_chatId", ["model", "kind", "chatId"]);
+    .index("model_kind_threadId", ["model", "kind", "threadId"]);
 }
 
 export const VectorDimensions = [

package/src/mapping.ts

@@ -1,16 +1,20 @@
-import type {
-  AssistantContent,
-  CoreAssistantMessage,
-  CoreMessage,
-  CoreToolMessage,
-  DataContent,
-  GenerateTextResult,
-  StepResult,
-  ToolContent,
-  ToolSet,
-  UserContent,
+import {
+  convertToCoreMessages,
+  coreMessageSchema,
+  type AssistantContent,
+  type CoreAssistantMessage,
+  type CoreMessage,
+  type CoreToolMessage,
+  type DataContent,
+  type GenerateTextResult,
+  type StepResult,
+  type ToolContent,
+  type ToolSet,
+  type Message as UIMessage,
+  type UserContent,
 } from "ai";
 import { MessageWithFileAndId, Step } from "./validators";
+import { assert } from "convex-helpers";
 
 export type SerializeUrlsAndUint8Arrays<T> = T extends URL
   ? string
@@ -158,3 +162,34 @@ function deserializeUrl(urlOrString: string | ArrayBuffer): URL | DataContent {
   }
   return urlOrString;
 }
+
+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 });
+  }
+  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));
+  }
+  assert(messages.length > 0, "Messages must contain at least one message");
+  return messages;
+}

package/src/validators.test.ts

@@ -3,11 +3,13 @@ import { expectTypeOf, test } from "vitest";
 import {
   vAssistantContent,
   vAssistantMessage,
+  vContextOptions,
   vFilePart,
   vImagePart,
   vMessage,
   vReasoningPart,
   vRedactedReasoningPart,
+  vStorageOptions,
   vSystemMessage,
   vTextPart,
   vToolCallPart,
@@ -31,6 +33,7 @@ import {
   UserContent,
 } from "ai";
 import { SerializeUrlsAndUint8Arrays } from "./mapping";
+import { ContextOptions, StorageOptions } from "./client";
 
 // type assertion
 type OurUserContent = SerializeUrlsAndUint8Arrays<UserContent>;
@@ -98,4 +101,10 @@ type OurMessage = SerializeUrlsAndUint8Arrays<CoreMessage>;
 expectTypeOf<OurMessage>().toExtend<Infer<typeof vMessage>>();
 expectTypeOf<Infer<typeof vMessage>>().toExtend<OurMessage>();
 
+expectTypeOf<Infer<typeof vContextOptions>>().toExtend<ContextOptions>();
+expectTypeOf<ContextOptions>().toExtend<Infer<typeof vContextOptions>>();
+
+expectTypeOf<Infer<typeof vStorageOptions>>().toExtend<StorageOptions>();
+expectTypeOf<StorageOptions>().toExtend<Infer<typeof vStorageOptions>>();
+
 test("noop", () => { });

package/src/validators.ts

@@ -5,7 +5,10 @@ import { Infer, v } from "convex/values";
 const providerOptions = v.optional(v.record(v.string(), v.any()));
 const experimental_providerMetadata = providerOptions;
 
-export const vChatStatus = v.union(v.literal("active"), v.literal("archived"));
+export const vThreadStatus = v.union(
+  v.literal("active"),
+  v.literal("archived")
+);
 export const vMessageStatus = v.union(
   v.literal("pending"),
   v.literal("success"),
@@ -256,3 +259,35 @@ export const vSearchOptions = v.object({
   messageRange: v.optional(v.object({ before: v.number(), after: v.number() })),
 });
 export type SearchOptions = Infer<typeof vSearchOptions>;
+
+export const vContextOptionsSearchOptions = v.object({
+  limit: v.number(),
+  textSearch: v.optional(v.boolean()),
+  vectorSearch: v.optional(v.boolean()),
+  messageRange: v.optional(v.object({ before: v.number(), after: v.number() })),
+});
+
+export const vContextOptions = v.object({
+  includeToolCalls: v.optional(v.boolean()),
+  recentMessages: v.optional(v.number()),
+  searchOptions: v.optional(vContextOptionsSearchOptions),
+  searchOtherThreads: v.optional(v.boolean()),
+});
+
+export const vStorageOptions = v.object({
+  saveAllInputMessages: v.optional(v.boolean()),
+  saveAllOutputMessages: v.optional(v.boolean()),
+});
+
+export const vThreadArgs = v.object({
+  maxSteps: v.optional(v.number()),
+  prompt: v.optional(v.string()),
+  messages: v.optional(v.array(vMessage)),
+});
+
+export const vObjectArgs = v.object({
+  output: v.optional(v.any()),
+  mode: v.optional(v.literal("json")),
+  prompt: v.optional(v.string()),
+  messages: v.optional(v.array(vMessage)),
+});