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

package/src/component/_generated/api.d.ts

@@ -10,6 +10,7 @@
 
 import type * as lib from "../lib.js";
 import type * as messages from "../messages.js";
+import type * as vector_index from "../vector/index.js";
 import type * as vector_tables from "../vector/tables.js";
 
 import type {
@@ -29,6 +30,7 @@ import type {
 declare const fullApi: ApiFromModules<{
   lib: typeof lib;
   messages: typeof messages;
+  "vector/index": typeof vector_index;
   "vector/tables": typeof vector_tables;
 }>;
 export type Mounts = {
@@ -262,7 +264,7 @@ export type Mounts = {
                 role: "system";
               };
           model?: string;
-          order?: number;
+          order: number;
           status: "pending" | "success" | "failed";
           stepId?: string;
           stepOrder?: number;
@@ -386,7 +388,7 @@ export type Mounts = {
                 role: "system";
               };
           model?: string;
-          order?: number;
+          order: number;
           status: "pending" | "success" | "failed";
           stepId?: string;
           stepOrder?: number;
@@ -1009,6 +1011,7 @@ export type Mounts = {
         isTool?: boolean;
         limit?: number;
         order?: "asc" | "desc";
+        parentMessageId?: string;
         statuses?: Array<"pending" | "success" | "failed">;
       },
       {
@@ -1129,7 +1132,7 @@ export type Mounts = {
                 role: "system";
               };
           model?: string;
-          order?: number;
+          order: number;
           status: "pending" | "success" | "failed";
           stepId?: string;
           stepOrder?: number;
@@ -1195,6 +1198,7 @@ export type Mounts = {
         chatId?: string;
         limit: number;
         messageRange?: { after: number; before: number };
+        parentMessageId?: string;
         text?: string;
         userId?: string;
         vector?: Array<number>;
@@ -1315,7 +1319,7 @@ export type Mounts = {
               role: "system";
             };
         model?: string;
-        order?: number;
+        order: number;
         status: "pending" | "success" | "failed";
         stepId?: string;
         stepOrder?: number;
@@ -1444,7 +1448,7 @@ export type Mounts = {
               role: "system";
             };
         model?: string;
-        order?: number;
+        order: number;
         status: "pending" | "success" | "failed";
         stepId?: string;
         stepOrder?: number;
@@ -1479,6 +1483,128 @@ export type Mounts = {
       }
     >;
   };
+  vector: {
+    index: {
+      deleteBatch: FunctionReference<
+        "mutation",
+        "public",
+        {
+          ids: Array<
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+          >;
+        },
+        null
+      >;
+      deleteBatchForChat: FunctionReference<
+        "mutation",
+        "public",
+        {
+          chatId: string;
+          cursor?: string;
+          limit: number;
+          model: string;
+          vectorDimension:
+            | 128
+            | 256
+            | 512
+            | 768
+            | 1024
+            | 1536
+            | 2048
+            | 3072
+            | 4096;
+        },
+        { continueCursor: string; isDone: boolean }
+      >;
+      insertBatch: FunctionReference<
+        "mutation",
+        "public",
+        {
+          vectorDimension:
+            | 128
+            | 256
+            | 512
+            | 768
+            | 1024
+            | 1536
+            | 2048
+            | 3072
+            | 4096;
+          vectors: Array<{
+            chatId?: string;
+            kind: "chat" | "memory";
+            model: string;
+            userId?: string;
+            vector: Array<number>;
+          }>;
+        },
+        null
+      >;
+      paginate: FunctionReference<
+        "query",
+        "public",
+        {
+          cursor?: string;
+          limit: number;
+          targetModel: string;
+          vectorDimension:
+            | 128
+            | 256
+            | 512
+            | 768
+            | 1024
+            | 1536
+            | 2048
+            | 3072
+            | 4096;
+        },
+        {
+          continueCursor: string;
+          ids: Array<
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+          >;
+          isDone: boolean;
+        }
+      >;
+      updateBatch: FunctionReference<
+        "mutation",
+        "public",
+        {
+          vectors: Array<{
+            id:
+              | string
+              | string
+              | string
+              | string
+              | string
+              | string
+              | string
+              | string
+              | string;
+            model: string;
+            vector: Array<number>;
+          }>;
+        },
+        null
+      >;
+    };
+  };
 };
 // For now fullApiWithMounts is only fullApi which provides
 // jump-to-definition in component client code.

package/src/component/messages.ts

@@ -597,9 +597,12 @@ export const getChatMessages = query({
     // Note: the other arguments cannot change from when the cursor was created.
     cursor: v.optional(v.string()),
     statuses: v.optional(v.array(vMessageStatus)),
+    parentMessageId: v.optional(v.id("messages")),
   },
   handler: async (ctx, args) => {
     const statuses = args.statuses ?? ["success"];
+    const parent =
+      args.parentMessageId && (await ctx.db.get(args.parentMessageId));
     const toolOptions =
       args.isTool === undefined ? [true, false] : [args.isTool];
     const order = args.order ?? "desc";
@@ -607,9 +610,16 @@ export const getChatMessages = query({
       statuses.map((status) =>
         stream(ctx.db, schema)
           .query("messages")
-          .withIndex("chatId_status_tool_order_stepOrder", (q) =>
-            q.eq("chatId", args.chatId).eq("status", status).eq("tool", tool)
-          )
+          .withIndex("chatId_status_tool_order_stepOrder", (q) => {
+            const qq = q
+              .eq("chatId", args.chatId)
+              .eq("status", status)
+              .eq("tool", tool);
+            if (parent) {
+              return qq.lte("order", parent.order);
+            }
+            return qq;
+          })
           .order(order)
       )
     );
@@ -637,6 +647,7 @@ export const searchMessages = action({
   args: {
     userId: v.optional(v.string()),
     chatId: v.optional(v.id("chats")),
+    parentMessageId: v.optional(v.id("messages")),
     ...vSearchOptions.fields,
   },
   returns: v.array(v.doc("messages")),
@@ -688,10 +699,12 @@ export const searchMessages = action({
           userId: args.userId,
           chatId: args.chatId,
           vectorIds,
-          textSearchMessages: textSearchMessages
-            ?.filter((m) => !vectorIds.includes(m.embeddingId!))
-            .slice(0, limit - vectorIds.length),
+          textSearchMessages: textSearchMessages?.filter(
+            (m) => !vectorIds.includes(m.embeddingId!)
+          ),
           messageRange: args.messageRange ?? DEFAULT_MESSAGE_RANGE,
+          parentMessageId: args.parentMessageId,
+          limit,
         }
       );
       return messages;
@@ -707,10 +720,14 @@ export const _fetchVectorMessages = internalQuery({
     vectorIds: v.array(vVectorId),
     textSearchMessages: v.optional(v.array(v.doc("messages"))),
     messageRange: v.object({ before: v.number(), after: v.number() }),
+    parentMessageId: v.optional(v.id("messages")),
+    limit: v.number(),
   },
   returns: v.array(v.doc("messages")),
   handler: async (ctx, args): Promise<Doc<"messages">[]> => {
-    const messages = (
+    const parent =
+      args.parentMessageId && (await ctx.db.get(args.parentMessageId));
+    let messages = (
       await Promise.all(
         args.vectorIds.map((embeddingId) =>
           ctx.db
@@ -726,9 +743,14 @@ export const _fetchVectorMessages = internalQuery({
             .first()
         )
       )
-    ).filter((m): m is Doc<"messages"> => m !== undefined);
+    ).filter(
+      (m): m is Doc<"messages"> =>
+        m !== undefined && m !== null && (!parent || m.order <= parent.order)
+    );
     messages.push(...(args.textSearchMessages ?? []));
+    // TODO: prioritize more recent messages
     messages.sort((a, b) => a.order! - b.order!);
+    messages = messages.slice(0, args.limit);
     // Fetch the surrounding messages
     const included: Record<Id<"chats">, Set<number>> = {};
     for (const m of messages) {

package/src/component/schema.ts

@@ -34,7 +34,7 @@ export const schema = defineSchema({
     tool: v.boolean(),
     // Repeats until a non-tool message.
     // Set when the message is finished
-    order: v.optional(v.number()),
+    order: v.number(),
     stepOrder: v.optional(v.number()),
     fileId: v.optional(v.id("files")),
     status: vMessageStatus,

package/src/component/vector/index.ts

@@ -0,0 +1,144 @@
+import { paginator } from "convex-helpers/server/pagination";
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server";
+import { getVectorTableName, vVectorDimension, vVectorId } from "./tables";
+import schema from "../schema";
+import { mergedStream } from "convex-helpers/server/stream";
+import { stream } from "convex-helpers/server/stream";
+
+export const paginate = query({
+  args: {
+    vectorDimension: vVectorDimension,
+    targetModel: v.string(),
+    cursor: v.optional(v.string()),
+    limit: v.number(),
+  },
+  returns: v.object({
+    ids: v.array(vVectorId),
+    isDone: v.boolean(),
+    continueCursor: v.string(),
+  }),
+  handler: async (ctx, args) => {
+    const tableName = getVectorTableName(args.vectorDimension);
+    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) =>
+        q.eq("model", args.targetModel)
+      )
+      .paginate({
+        cursor: args.cursor ?? null,
+        numItems: args.limit,
+        maximumRowsRead: 300,
+      });
+    return {
+      ids: vectors.page.map((v) => v._id),
+      isDone: vectors.isDone,
+      continueCursor: vectors.continueCursor,
+    };
+  },
+});
+
+export const deleteBatchForChat = mutation({
+  args: {
+    vectorDimension: vVectorDimension,
+    model: v.string(),
+    chatId: v.string(),
+    cursor: v.optional(v.string()),
+    limit: v.number(),
+  },
+  returns: v.object({
+    isDone: v.boolean(),
+    continueCursor: v.string(),
+  }),
+  handler: async (ctx, args) => {
+    const tableName = getVectorTableName(args.vectorDimension);
+    const vectors = await mergedStream(
+      ["chat", "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) =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (q.eq("model", args.model) as any)
+              .eq("kind", kind)
+              .eq("chatId", args.chatId)
+          )
+      ),
+      ["chatId"]
+    ).paginate({
+      cursor: args.cursor ?? null,
+      numItems: args.limit,
+      maximumRowsRead: 300,
+    });
+    await Promise.all(vectors.page.map((v) => ctx.db.delete(v._id)));
+    return {
+      isDone: vectors.isDone,
+      continueCursor: vectors.continueCursor,
+    };
+  },
+});
+
+export const insertBatch = mutation({
+  args: {
+    vectorDimension: vVectorDimension,
+    vectors: v.array(
+      v.object({
+        model: v.string(),
+        kind: v.union(v.literal("chat"), v.literal("memory")),
+        userId: v.optional(v.string()),
+        chatId: v.optional(v.string()),
+        vector: v.array(v.number()),
+      })
+    ),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    await Promise.all(
+      args.vectors.map((v) =>
+        ctx.db.insert(getVectorTableName(args.vectorDimension), {
+          model: v.model,
+          kind: v.kind,
+          userId: v.userId,
+          chatId: v.chatId,
+          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,
+        })
+      )
+    );
+  },
+});
+
+export const updateBatch = mutation({
+  args: {
+    vectors: v.array(
+      v.object({
+        model: v.string(),
+        id: vVectorId,
+        vector: v.array(v.number()),
+      })
+    ),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    await Promise.all(
+      args.vectors.map((v) =>
+        ctx.db.patch(v.id, {
+          model: v.model,
+          vector: v.vector,
+        })
+      )
+    );
+  },
+});
+
+export const deleteBatch = mutation({
+  args: {
+    ids: v.array(vVectorId),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    await Promise.all(args.ids.map((id) => ctx.db.delete(id)));
+  },
+});

package/src/component/vector/tables.ts

@@ -20,11 +20,13 @@ const embeddings = {
 };
 
 function table<D extends number>(dimensions: D): Table<D> {
-  return defineTable(embeddings).vectorIndex("vector", {
-    vectorField: "vector",
-    dimensions,
-    filterFields: ["model_kind_userId", "model_kind_chatId"],
-  });
+  return defineTable(embeddings)
+    .vectorIndex("vector", {
+      vectorField: "vector",
+      dimensions,
+      filterFields: ["model_kind_userId", "model_kind_chatId"],
+    })
+    .index("model_kind_chatId", ["model", "kind", "chatId"]);
 }
 
 export const VectorDimensions = [