@convex-dev/agent 0.6.3 → 0.7.0-alpha.0

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;
@@ -81,6 +83,25 @@ export const messageStatuses = vMessageDoc.fields.status.members.map(
   (m) => m.value,
 );
 
+const STREAM_RECOVERY_FAILURE =
+  "Failed to recover persisted assistant stream output";
+
+async function markPendingMessageFailed(
+  ctx: MutationCtx,
+  message: Doc<"messages">,
+  error: string,
+) {
+  if (message.embeddingId) {
+    const { tableName } = getVectorIdInfo(ctx, message.embeddingId);
+    await ctx.db.delete(tableName, message.embeddingId);
+  }
+  await ctx.db.patch("messages", message._id, {
+    status: "failed",
+    error,
+    embeddingId: undefined,
+  });
+}
+
 export const deleteByOrder = mutation({
   args: {
     threadId: v.id("threads"),
@@ -157,7 +178,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 +193,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 +210,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 +280,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 +297,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 +329,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 +398,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(
@@ -386,11 +409,20 @@ export const finalizeMessage = mutation({
     }
     // See if we can add any in-progress data
     if (!message.message?.content.length) {
-      const messages = await getStreamingMessagesWithMetadata(
-        ctx,
-        message,
-        result,
-      );
+      const { messages, materializationFailures } =
+        await getStreamingMessagesWithMetadata(ctx, message, result);
+      if (materializationFailures.length > 0) {
+        console.error(
+          "Failed to materialize persisted assistant streams",
+          materializationFailures,
+        );
+        await markPendingMessageFailed(
+          ctx,
+          message,
+          result.status === "failed" ? result.error : STREAM_RECOVERY_FAILURE,
+        );
+        return;
+      }
       if (messages.length > 0) {
         await addMessagesHandler(ctx, {
           messages,
@@ -405,16 +437,9 @@ export const finalizeMessage = mutation({
       }
     }
     if (result.status === "failed") {
-      if (message.embeddingId) {
-        await ctx.db.delete(message.embeddingId);
-      }
-      await ctx.db.patch(messageId, {
-        status: "failed",
-        error: result.error,
-        embeddingId: undefined,
-      });
+      await markPendingMessageFailed(ctx, message, result.error);
     } else {
-      await ctx.db.patch(messageId, { status: "success" });
+      await ctx.db.patch("messages", messageId, { status: "success" });
     }
   },
 });
@@ -439,7 +464,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 +481,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 +566,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 +663,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 +706,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 +820,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 +837,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"),
@@ -821,16 +850,18 @@ export const _fetchSearchMessages = internalQuery({
         ),
       )
     )
-      .filter(
-        (m): m is Doc<"messages"> =>
-          m !== undefined &&
-          m !== null &&
-          !m.tool &&
-          (!beforeMessage ||
-            m.order < beforeMessage.order ||
-            (m.order === beforeMessage.order &&
-              m.stepOrder < beforeMessage.stepOrder)),
-      )
+      .filter((m): m is Doc<"messages"> => {
+        if (m === undefined || m === null || m.tool) return false;
+        if (!beforeMessage) return true;
+        // The order filter is only meaningful within the same thread.
+        // Messages from other threads have independent order sequences.
+        if (m.threadId !== beforeMessage.threadId) return true;
+        return (
+          m.order < beforeMessage.order ||
+          (m.order === beforeMessage.order &&
+            m.stepOrder < beforeMessage.stepOrder)
+        );
+      })
       .map(publicMessage);
     messages.push(...(args.textSearchMessages ?? []));
     // TODO: prioritize more recent messages
@@ -911,13 +942,18 @@ export const textSearch = query({
       "Specify userId or threadId",
     );
     const targetMessage =
-      args.targetMessageId && (await ctx.db.get(args.targetMessageId));
-    const order = targetMessage?.order;
+      args.targetMessageId &&
+      (await ctx.db.get("messages", args.targetMessageId));
     const text = args.text || targetMessage?.text;
     if (!text) {
       console.warn("No text to search", targetMessage, args.text);
       return [];
     }
+    // When searching across threads (searchAllMessagesForUserId), the
+    // targetMessage's order is only meaningful within its own thread, so we
+    // can't apply it as a database-level filter. We still apply it post-fetch
+    // for same-thread results below.
+    const restrictOrderInDb = !args.searchAllMessagesForUserId && targetMessage;
     const messages = await ctx.db
       .query("messages")
       .withSearchIndex("text_search", (q) =>
@@ -926,22 +962,27 @@ 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) {
-          return q.and(qq, q.lte(q.field("order"), order));
+        if (restrictOrderInDb) {
+          return q.and(qq, q.lte(q.field("order"), targetMessage.order));
         }
         return qq;
       })
       .take(args.limit);
     return messages
-      .filter(
-        (m) =>
-          !targetMessage ||
+      .filter((m) => {
+        if (!targetMessage) return true;
+        // Order is only meaningful within the same thread; cross-thread
+        // results have independent order sequences and should pass through.
+        if (m.threadId !== targetMessage.threadId) return true;
+        return (
           m.order < targetMessage.order ||
           (m.order === targetMessage.order &&
-            m.stepOrder < targetMessage.stepOrder),
-      )
+            m.stepOrder < targetMessage.stepOrder)
+        );
+      })
       .map(publicMessage);
   },
   returns: v.array(vMessageDoc),
@@ -964,12 +1005,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

@@ -21,8 +21,10 @@ import { stream } from "convex-helpers/server/stream";
 import { mergedStream } from "convex-helpers/server/stream";
 import { paginator } from "convex-helpers/server/pagination";
 import type { WithoutSystemFields } from "convex/server";
-import { deriveUIMessagesFromDeltas } from "../deltas.js";
-import { fromUIMessages } from "../UIMessages.js";
+import {
+  getPersistedUIMessageChunkParts,
+  projectPersistedUIMessageChunks,
+} from "../streaming/materializePersistedUIMessageChunks.js";
 
 const SECOND = 1000;
 const MINUTE = 60 * SECOND;
@@ -38,7 +40,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 +103,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 +201,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 +212,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 +223,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 +253,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 +269,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 +286,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 +301,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 +317,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 +326,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 +348,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 +452,7 @@ export const deleteAllStreamsForThreadIdAsync = mutation({
         },
       );
     } else {
-      await ctx.db.delete(args.threadId);
+      await ctx.db.delete("threads", args.threadId);
     }
     return result;
   },
@@ -520,7 +538,13 @@ export async function getStreamingMessagesWithMetadata(
     stepOrder,
   }: { threadId: Id<"threads">; order: number; stepOrder: number },
   metadata: { status: "success" | "failed"; error?: string },
-): Promise<MessageWithMetadataInternal[]> {
+): Promise<{
+  messages: MessageWithMetadataInternal[];
+  materializationFailures: Array<{
+    streamId: Id<"streamingMessages">;
+    reason: string;
+  }>;
+}> {
   // See if there are any streaming messages for this order
   const streamingMessages = await getStreamingMessages(
     ctx,
@@ -528,50 +552,42 @@ export async function getStreamingMessagesWithMetadata(
     order,
     stepOrder,
   );
-  const messages = (
-    await Promise.all(
-      streamingMessages.map(async (streamingMessage) => {
-        const deltas = await ctx.db
-          .query("streamDeltas")
-          .withIndex("streamId_start_end", (q) =>
-            q.eq("streamId", streamingMessage._id),
-          )
-          .take(1000);
-        const uiMessages = await deriveUIMessagesFromDeltas(
-          threadId,
-          [publicStreamMessage(streamingMessage)],
-          deltas,
-        );
+  const materializedStreams = await Promise.all(
+    streamingMessages.map(async (streamingMessage) => {
+      const deltas = await ctx.db
+        .query("streamDeltas")
+        .withIndex("streamId_start_end", (q) =>
+          q.eq("streamId", streamingMessage._id),
+        )
+        .take(1000);
+      try {
+        const streamMessage = publicStreamMessage(streamingMessage);
+        const { parts } = getPersistedUIMessageChunkParts(deltas);
         // We don't save messages that have already been saved
         const numToSkip = stepOrder - streamingMessage.stepOrder;
-        const messages = await Promise.all(
-          (await fromUIMessages(uiMessages, streamingMessage))
-            .slice(numToSkip)
-            .filter((m) => m.message !== undefined)
-            .map(async (msg) => {
-              return {
-                ...pick(msg, [
-                  "message",
-                  "fileIds",
-                  "status",
-                  "finishReason",
-                  "model",
-                  "provider",
-                  "providerMetadata",
-                  "sources",
-                  "reasoning",
-                  "reasoningDetails",
-                  "usage",
-                  "warnings",
-                  "error",
-                ]),
-                ...metadata,
-              } as MessageWithMetadataInternal;
-            }),
-        );
-        return messages;
-      }),
-    )
-  ).flat();
-  return messages;
+        return {
+          messages: projectPersistedUIMessageChunks(
+            streamMessage,
+            parts,
+            metadata,
+          ).slice(numToSkip),
+          failure: undefined,
+        };
+      } catch (error) {
+        return {
+          messages: [],
+          failure: {
+            streamId: streamingMessage._id,
+            reason: error instanceof Error ? error.message : String(error),
+          },
+        };
+      }
+    }),
+  );
+  return {
+    messages: materializedStreams.flatMap(({ messages }) => messages),
+    materializationFailures: materializedStreams.flatMap(({ failure }) =>
+      failure ? [failure] : [],
+    ),
+  };
 }

package/src/component/threads.ts

@@ -3,8 +3,11 @@ import { paginator } from "convex-helpers/server/pagination";
 import { partial } from "convex-helpers/validators";
 import { paginationOptsValidator } from "convex/server";
 import type { ObjectType } from "convex/values";
-import { type ThreadDoc, vThreadDoc } from "../client/index.js";
-import { vPaginationResult } from "../validators.js";
+import {
+  type ThreadDoc,
+  vPaginationResult,
+  vThreadDoc,
+} from "../validators.js";
 import { api, internal } from "./_generated/api.js";
 import type { Doc } from "./_generated/dataModel.js";
 import {
@@ -32,7 +35,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 +69,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 +87,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 +234,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;
   },
 });