@convex-dev/agent 0.6.3 → 0.6.4

package/src/component/messages.ts

@@ -34,6 +34,7 @@ import {
 import { schema, v } from "./schema.js";
 import { insertVector, searchVectors } from "./vector/index.js";
 import {
+  getVectorIdInfo,
   validateVectorDimension,
   type VectorTableId,
   vVectorId,
@@ -50,9 +51,10 @@ export async function deleteMessage(
   ctx: MutationCtx,
   messageDoc: Doc<"messages">,
 ) {
-  await ctx.db.delete(messageDoc._id);
+  await ctx.db.delete("messages", messageDoc._id);
   if (messageDoc.embeddingId) {
-    await ctx.db.delete(messageDoc.embeddingId);
+    const { tableName } = getVectorIdInfo(ctx, messageDoc.embeddingId);
+    await ctx.db.delete(tableName, messageDoc.embeddingId);
   }
   if (messageDoc.fileIds) {
     await changeRefcount(ctx, messageDoc.fileIds, []);
@@ -65,7 +67,7 @@ export const deleteByIds = mutation({
   handler: async (ctx, args) => {
     const deletedMessageIds = await Promise.all(
       args.messageIds.map(async (id) => {
-        const message = await ctx.db.get(id);
+        const message = await ctx.db.get("messages", id);
         if (message) {
           await deleteMessage(ctx, message);
           return id;
@@ -157,7 +159,7 @@ async function addMessagesHandler(
   let userId = args.userId;
   const threadId = args.threadId;
   if (!userId && args.threadId) {
-    const thread = await ctx.db.get(args.threadId);
+    const thread = await ctx.db.get("threads", args.threadId);
     assert(thread, `Thread ${args.threadId} not found`);
     userId = thread.userId;
   }
@@ -172,7 +174,8 @@ async function addMessagesHandler(
     hideFromUserIdSearch,
     ...rest
   } = args;
-  const promptMessage = promptMessageId && (await ctx.db.get(promptMessageId));
+  const promptMessage =
+    promptMessageId && (await ctx.db.get("messages", promptMessageId));
   if (failPendingSteps) {
     assert(args.threadId, "threadId is required to fail pending steps");
     const pendingMessages = await ctx.db
@@ -188,9 +191,10 @@ async function addMessagesHandler(
         .filter((m) => !pendingMessageId || m._id !== pendingMessageId)
         .map(async (m) => {
           if (m.embeddingId) {
-            await ctx.db.delete(m.embeddingId);
+            const { tableName } = getVectorIdInfo(ctx, m.embeddingId);
+            await ctx.db.delete(tableName, m.embeddingId);
           }
-          await ctx.db.patch(m._id, {
+          await ctx.db.patch("messages", m._id, {
             status: "failed",
             error: "Restarting",
             embeddingId: undefined,
@@ -257,7 +261,7 @@ async function addMessagesHandler(
     // If there is a pending message, we replace that one with the first message
     // and subsequent ones will follow the regular order/subOrder advancement.
     if (i === 0 && pendingMessageId) {
-      const pendingMessage = await ctx.db.get(pendingMessageId);
+      const pendingMessage = await ctx.db.get("messages", pendingMessageId);
       assert(pendingMessage, `Pending msg ${pendingMessageId} not found`);
       if (pendingMessage.status === "failed") {
         fail = true;
@@ -274,12 +278,12 @@ async function addMessagesHandler(
           message.fileIds,
         );
       }
-      await ctx.db.replace(pendingMessage._id, {
+      await ctx.db.replace("messages", pendingMessage._id, {
         ...messageDoc,
         order: pendingMessage.order,
         stepOrder: pendingMessage.stepOrder,
       });
-      toReturn.push((await ctx.db.get(pendingMessage._id))!);
+      toReturn.push((await ctx.db.get("messages", pendingMessage._id))!);
       continue;
     }
     if (message.message.role === "user") {
@@ -306,7 +310,7 @@ async function addMessagesHandler(
       await changeRefcount(ctx, [], message.fileIds);
     }
     // TODO: delete the associated stream data for the order/stepOrder
-    toReturn.push((await ctx.db.get(messageId))!);
+    toReturn.push((await ctx.db.get("messages", messageId))!);
   }
   // Atomically finish the stream if requested, preventing UI flickering
   // from separate mutations for message save and stream finish (issue #181).
@@ -375,7 +379,7 @@ export const finalizeMessage = mutation({
   },
   returns: v.null(),
   handler: async (ctx, { messageId, result }) => {
-    const message = await ctx.db.get(messageId);
+    const message = await ctx.db.get("messages", messageId);
     assert(message, `Message ${messageId} not found`);
     if (message.status !== "pending") {
       console.debug(
@@ -406,15 +410,16 @@ export const finalizeMessage = mutation({
     }
     if (result.status === "failed") {
       if (message.embeddingId) {
-        await ctx.db.delete(message.embeddingId);
+        const { tableName } = getVectorIdInfo(ctx, message.embeddingId);
+        await ctx.db.delete(tableName, message.embeddingId);
       }
-      await ctx.db.patch(messageId, {
+      await ctx.db.patch("messages", messageId, {
         status: "failed",
         error: result.error,
         embeddingId: undefined,
       });
     } else {
-      await ctx.db.patch(messageId, { status: "success" });
+      await ctx.db.patch("messages", messageId, { status: "success" });
     }
   },
 });
@@ -439,7 +444,7 @@ export const updateMessage = mutation({
   },
   returns: vMessageDoc,
   handler: async (ctx, args) => {
-    const message = await ctx.db.get(args.messageId);
+    const message = await ctx.db.get("messages", args.messageId);
     assert(message, `Message ${args.messageId} not found`);
 
     if (args.patch.fileIds) {
@@ -456,13 +461,14 @@ export const updateMessage = mutation({
 
     if (args.patch.status === "failed") {
       if (message.embeddingId) {
-        await ctx.db.delete(message.embeddingId);
+        const { tableName } = getVectorIdInfo(ctx, message.embeddingId);
+        await ctx.db.delete(tableName, message.embeddingId);
       }
       patch.embeddingId = undefined;
     }
 
-    await ctx.db.patch(args.messageId, patch);
-    return publicMessage((await ctx.db.get(args.messageId))!);
+    await ctx.db.patch("messages", args.messageId, patch);
+    return publicMessage((await ctx.db.get("messages", args.messageId))!);
   },
 });
 
@@ -540,7 +546,8 @@ export const cloneMessageBatch = internalMutation({
           }
           let embeddingId: VectorTableId | undefined = undefined;
           if (m.embeddingId) {
-            const vector = await ctx.db.get(m.embeddingId);
+            const { tableName } = getVectorIdInfo(ctx, m.embeddingId);
+            const vector = await ctx.db.get(tableName, m.embeddingId);
             assert(vector, `Vector ${m.embeddingId} not found`);
             const dimension = vector.vector.length;
             validateVectorDimension(dimension);
@@ -636,7 +643,7 @@ async function listMessagesByThreadIdHandler(
   const statuses = args.statuses ?? vMessageStatus.members.map((m) => m.value);
   const last =
     args.upToAndIncludingMessageId &&
-    (await ctx.db.get(args.upToAndIncludingMessageId));
+    (await ctx.db.get("messages", args.upToAndIncludingMessageId));
   assert(
     !last || last.threadId === args.threadId,
     "upToAndIncludingMessageId must be a message in the thread",
@@ -679,9 +686,9 @@ async function listMessagesByThreadIdHandler(
 export const getMessagesByIds = query({
   args: { messageIds: v.array(v.id("messages")) },
   handler: async (ctx, args) => {
-    return (await Promise.all(args.messageIds.map((id) => ctx.db.get(id)))).map(
-      (m) => (m ? publicMessage(m) : null),
-    );
+    return (
+      await Promise.all(args.messageIds.map((id) => ctx.db.get("messages", id)))
+    ).map((m) => (m ? publicMessage(m) : null));
   },
   returns: v.array(v.union(v.null(), vMessageDoc)),
 });
@@ -793,7 +800,8 @@ export const _fetchSearchMessages = internalQuery({
   returns: v.array(vMessageDoc),
   handler: async (ctx, args): Promise<MessageDoc[]> => {
     const beforeMessage =
-      args.beforeMessageId && (await ctx.db.get(args.beforeMessageId));
+      args.beforeMessageId &&
+      (await ctx.db.get("messages", args.beforeMessageId));
     const { searchAllMessagesForUserId, threadId } = args;
     assert(
       searchAllMessagesForUserId || threadId,
@@ -809,6 +817,7 @@ export const _fetchSearchMessages = internalQuery({
                 ? q.eq("embeddingId", embeddingId)
                 : q.eq("embeddingId", embeddingId).eq("threadId", threadId!),
             )
+            // eslint-disable-next-line @convex-dev/no-filter-in-query -- We do not expect many messages with the same embeddingId for different users / threads
             .filter((q) =>
               q.and(
                 q.eq(q.field("status"), "success"),
@@ -911,7 +920,8 @@ export const textSearch = query({
       "Specify userId or threadId",
     );
     const targetMessage =
-      args.targetMessageId && (await ctx.db.get(args.targetMessageId));
+      args.targetMessageId &&
+      (await ctx.db.get("messages", args.targetMessageId));
     const order = targetMessage?.order;
     const text = args.text || targetMessage?.text;
     if (!text) {
@@ -926,6 +936,7 @@ export const textSearch = query({
           : q.search("text", text).eq("threadId", args.threadId!),
       )
       // Just in case tool messages slip through
+      // eslint-disable-next-line @convex-dev/no-filter-in-query -- we can't do this in the search index, but text search ideally isn't for really old orders
       .filter((q) => {
         const qq = q.eq(q.field("tool"), false);
         if (order) {
@@ -964,12 +975,13 @@ export const getMessageSearchFields = query({
     embedding?: number[] | undefined;
     embeddingModel?: string | undefined;
   }> => {
-    const message = await ctx.db.get(args.messageId);
+    const message = await ctx.db.get("messages", args.messageId);
     const text = message?.text;
     let embedding = undefined;
     let embeddingModel = undefined;
     if (message?.embeddingId) {
-      const target = await ctx.db.get(message.embeddingId);
+      const { tableName } = getVectorIdInfo(ctx, message.embeddingId);
+      const target = await ctx.db.get(tableName, message.embeddingId);
       embedding = target?.vector;
       embeddingModel = target?.model;
     }

package/src/component/streams.ts

@@ -38,7 +38,7 @@ export const addDelta = mutation({
   args: deltaValidator,
   returns: v.boolean(),
   handler: async (ctx, args) => {
-    const stream = await ctx.db.get(args.streamId);
+    const stream = await ctx.db.get("streamingMessages", args.streamId);
     if (!stream) {
       console.warn("Stream not found", args.streamId);
       return false;
@@ -101,7 +101,9 @@ export const create = mutation({
       internal.streams.timeoutStream,
       { streamId },
     );
-    await ctx.db.patch(streamId, { state: { ...state, timeoutFnId } });
+    await ctx.db.patch("streamingMessages", streamId, {
+      state: { ...state, timeoutFnId },
+    });
     return streamId;
   },
 });
@@ -197,7 +199,7 @@ async function abortById(
     finalDelta?: WithoutSystemFields<Doc<"streamDeltas">>;
   },
 ) {
-  const stream = await ctx.db.get(args.streamId);
+  const stream = await ctx.db.get("streamingMessages", args.streamId);
   if (!stream) {
     throw new Error(`Stream not found: ${args.streamId}`);
   }
@@ -208,7 +210,7 @@ async function abortById(
     return false;
   }
   await cleanupTimeoutFn(ctx, stream);
-  await ctx.db.patch(args.streamId, {
+  await ctx.db.patch("streamingMessages", args.streamId, {
     state: { kind: "aborted", reason: args.reason },
   });
   return true;
@@ -219,7 +221,10 @@ async function cleanupTimeoutFn(
   stream: Doc<"streamingMessages">,
 ) {
   if (stream.state.kind === "streaming" && stream.state.timeoutFnId) {
-    const timeoutFn = await ctx.db.system.get(stream.state.timeoutFnId);
+    const timeoutFn = await ctx.db.system.get(
+      "_scheduled_functions",
+      stream.state.timeoutFnId,
+    );
     if (timeoutFn?.state.kind === "pending") {
       await ctx.scheduler.cancel(stream.state.timeoutFnId);
     }
@@ -246,7 +251,7 @@ export async function finishHandler(
   if (args.finalDelta) {
     await ctx.db.insert("streamDeltas", args.finalDelta);
   }
-  const stream = await ctx.db.get(args.streamId);
+  const stream = await ctx.db.get("streamingMessages", args.streamId);
   if (!stream) {
     throw new Error(`Stream not found: ${args.streamId}`);
   }
@@ -262,7 +267,7 @@ export async function finishHandler(
     api.streams.deleteStreamAsync,
     { streamId: args.streamId },
   );
-  await ctx.db.patch(args.streamId, {
+  await ctx.db.patch("streamingMessages", args.streamId, {
     state: { kind: "finished", endedAt: Date.now(), cleanupFnId },
   });
 }
@@ -279,7 +284,7 @@ async function heartbeatStream(
   ctx: MutationCtx,
   args: { streamId: Id<"streamingMessages"> },
 ): Promise<void> {
-  const stream = await ctx.db.get(args.streamId);
+  const stream = await ctx.db.get("streamingMessages", args.streamId);
   if (!stream) {
     console.warn("Stream not found", args.streamId);
     return;
@@ -294,7 +299,10 @@ async function heartbeatStream(
   if (!stream.state.timeoutFnId) {
     throw new Error("Stream has no timeout function");
   }
-  const timeoutFn = await ctx.db.system.get(stream.state.timeoutFnId);
+  const timeoutFn = await ctx.db.system.get(
+    "_scheduled_functions",
+    stream.state.timeoutFnId,
+  );
   if (!timeoutFn) {
     throw new Error("Timeout function not found");
   }
@@ -307,7 +315,7 @@ async function heartbeatStream(
     internal.streams.timeoutStream,
     { streamId: args.streamId },
   );
-  await ctx.db.patch(args.streamId, {
+  await ctx.db.patch("streamingMessages", args.streamId, {
     state: { kind: "streaming", lastHeartbeat: Date.now(), timeoutFnId },
   });
 }
@@ -316,12 +324,12 @@ export const timeoutStream = internalMutation({
   args: { streamId: v.id("streamingMessages") },
   returns: v.null(),
   handler: async (ctx, args) => {
-    const stream = await ctx.db.get(args.streamId);
+    const stream = await ctx.db.get("streamingMessages", args.streamId);
     if (!stream || stream.state.kind !== "streaming") {
       console.warn("Stream not found", args.streamId);
       return;
     }
-    await ctx.db.patch(args.streamId, {
+    await ctx.db.patch("streamingMessages", args.streamId, {
       state: { kind: "aborted", reason: "timeout" },
     });
   },
@@ -338,15 +346,23 @@ async function deletePageForStreamId(
       numItems: MAX_DELTAS_PER_REQUEST,
       cursor: args.cursor ?? null,
     });
-  await Promise.all(deltas.page.map((d) => ctx.db.delete(d._id)));
+  await Promise.all(
+    deltas.page.map((d) => ctx.db.delete("streamDeltas", d._id)),
+  );
   if (deltas.isDone) {
-    const stream = await ctx.db.get(args.streamId);
+    const stream = await ctx.db.get("streamingMessages", args.streamId);
     if (stream) {
       await cleanupTimeoutFn(ctx, stream);
       if (stream.state.kind === "finished" && stream.state.cleanupFnId) {
-        await ctx.scheduler.cancel(stream.state.cleanupFnId);
+        const scheduledFunction = await ctx.db.system.get(
+          "_scheduled_functions",
+          stream.state.cleanupFnId,
+        );
+        if (scheduledFunction?.state.kind === "pending") {
+          await ctx.scheduler.cancel(stream.state.cleanupFnId);
+        }
       }
-      await ctx.db.delete(args.streamId);
+      await ctx.db.delete("streamingMessages", args.streamId);
     }
   }
   return deltas;
@@ -434,7 +450,7 @@ export const deleteAllStreamsForThreadIdAsync = mutation({
         },
       );
     } else {
-      await ctx.db.delete(args.threadId);
+      await ctx.db.delete("threads", args.threadId);
     }
     return result;
   },

package/src/component/threads.ts

@@ -32,7 +32,7 @@ function publicThread(thread: Doc<"threads">): ThreadDoc {
 export const getThread = query({
   args: { threadId: v.id("threads") },
   handler: async (ctx, args) => {
-    return publicThreadOrNull(await ctx.db.get(args.threadId));
+    return publicThreadOrNull(await ctx.db.get("threads", args.threadId));
   },
   returns: v.union(vThreadDoc, v.null()),
 });
@@ -66,7 +66,7 @@ export const createThread = mutation({
       ...args,
       status: "active",
     });
-    return publicThread((await ctx.db.get(threadId))!);
+    return publicThread((await ctx.db.get("threads", threadId))!);
   },
   returns: vThreadDoc,
 });
@@ -84,10 +84,10 @@ export const updateThread = mutation({
     patch: v.object(partial(pick(vThread.fields, threadFieldsSupportingPatch))),
   },
   handler: async (ctx, args) => {
-    const thread = await ctx.db.get(args.threadId);
+    const thread = await ctx.db.get("threads", args.threadId);
     assert(thread, `Thread ${args.threadId} not found`);
-    await ctx.db.patch(args.threadId, args.patch);
-    return publicThread((await ctx.db.get(args.threadId))!);
+    await ctx.db.patch("threads", args.threadId, args.patch);
+    return publicThread((await ctx.db.get("threads", args.threadId))!);
   },
   returns: vThreadDoc,
 });
@@ -231,9 +231,9 @@ async function deletePageForThreadIdHandler(
     });
   await Promise.all(messages.page.map((m) => deleteMessage(ctx, m)));
   if (messages.isDone) {
-    const thread = await ctx.db.get(args.threadId);
+    const thread = await ctx.db.get("threads", args.threadId);
     if (thread) {
-      await ctx.db.delete(args.threadId);
+      await ctx.db.delete("threads", args.threadId);
     }
   }
   return {

package/src/component/users.ts

@@ -227,7 +227,7 @@ async function deletePageForUserId(
 
   if (streamResult.isDone) {
     // Streams are done, delete the thread and reset for next thread
-    await ctx.db.delete(threadInProgress);
+    await ctx.db.delete("threads", threadInProgress);
     threadInProgress = null;
     messagesCursor = null;
     streamsInProgress = false;
@@ -256,7 +256,7 @@ export const getThreadUserId = internalQuery({
   },
   returns: v.union(v.string(), v.null()),
   handler: async (ctx, args) => {
-    const thread = await ctx.db.get(args.threadId);
+    const thread = await ctx.db.get("threads", args.threadId);
     return thread?.userId ?? null;
   },
 });

package/src/component/vector/index.ts

@@ -11,6 +11,7 @@ import {
 import schema from "../schema.js";
 import {
   type EmbeddingsWithoutDenormalizedFields,
+  getVectorIdInfo,
   getVectorTableName,
   type VectorDimension,
   vEmbeddingsWithoutDenormalizedFields,
@@ -84,7 +85,7 @@ export const deleteBatchForThread = mutation({
       numItems: args.limit,
       maximumRowsRead: 300,
     });
-    await Promise.all(vectors.page.map((v) => ctx.db.delete(v._id)));
+    await Promise.all(vectors.page.map((v) => ctx.db.delete(tableName, v._id)));
     return {
       isDone: vectors.isDone,
       continueCursor: vectors.continueCursor,
@@ -108,7 +109,7 @@ export const insertBatch = mutation({
       args.vectors.map(async ({ messageId, ...v }) => {
         const embeddingId = await insertVector(ctx, args.vectorDimension, v);
         if (messageId) {
-          await ctx.db.patch(messageId, { embeddingId });
+          await ctx.db.patch("messages", messageId, { embeddingId });
         }
         return embeddingId;
       }),
@@ -180,12 +181,13 @@ export const updateBatch = mutation({
   returns: v.null(),
   handler: async (ctx, args) => {
     await Promise.all(
-      args.vectors.map((embedding) =>
-        ctx.db.patch(embedding.id, {
+      args.vectors.map((embedding) => {
+        const { tableName } = getVectorIdInfo(ctx, embedding.id);
+        return ctx.db.patch(tableName, embedding.id, {
           model: embedding.model,
           vector: embedding.vector,
-        }),
-      ),
+        });
+      }),
     );
   },
 });
@@ -196,6 +198,11 @@ export const deleteBatch = mutation({
   },
   returns: v.null(),
   handler: async (ctx, args) => {
-    await Promise.all(args.ids.map((id) => ctx.db.delete(id)));
+    await Promise.all(
+      args.ids.map((id) => {
+        const { tableName } = getVectorIdInfo(ctx, id);
+        return ctx.db.delete(tableName, id);
+      }),
+    );
   },
 });