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

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 = [

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

@@ -256,3 +256,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),
+  searchOtherChats: v.optional(v.boolean()),
+});
+
+export const vStorageOptions = v.object({
+  saveAllInputMessages: v.optional(v.boolean()),
+  saveAllOutputMessages: v.optional(v.boolean()),
+});
+
+export const vChatArgs = 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)),
+});