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

package/dist/commonjs/component/messages.js

@@ -3,74 +3,74 @@ import { paginator } from "convex-helpers/server/pagination";
 import { mergedStream, stream } from "convex-helpers/server/stream";
 import { nullable, partial } from "convex-helpers/validators";
 import { DEFAULT_MESSAGE_RANGE, extractText, isTool } from "../shared.js";
-import { vChatStatus, vMessageStatus, vMessageWithFileAndId, vSearchOptions, vStepWithMessagesWithFileAndId, } from "../validators.js";
+import { vThreadStatus, vMessageStatus, vMessageWithFileAndId, vSearchOptions, vStepWithMessagesWithFileAndId, } from "../validators.js";
 import { api, internal } from "./_generated/api.js";
 import { action, internalMutation, internalQuery, mutation, query, } from "./_generated/server.js";
 import { schema, v } from "./schema.js";
 import { getVectorTableName, VectorDimensions, vVectorId, } from "./vector/tables.js";
-export const getChat = query({
-    args: { chatId: v.id("chats") },
+export const getThread = query({
+    args: { threadId: v.id("threads") },
     handler: async (ctx, args) => {
-        return ctx.db.get(args.chatId);
+        return ctx.db.get(args.threadId);
     },
-    returns: v.union(v.doc("chats"), v.null()),
+    returns: v.union(v.doc("threads"), v.null()),
 });
-export const getChatsByUserId = query({
+export const getThreadsByUserId = query({
     args: {
         userId: v.string(),
         // Note: the other arguments cannot change from when the cursor was created.
         cursor: v.optional(v.union(v.string(), v.null())),
         limit: v.optional(v.number()),
         offset: v.optional(v.number()),
-        statuses: v.optional(v.array(vChatStatus)),
+        statuses: v.optional(v.array(vThreadStatus)),
     },
     handler: async (ctx, args) => {
         const streams = (args.statuses ?? ["active"]).map((status) => stream(ctx.db, schema)
-            .query("chats")
+            .query("threads")
             .withIndex("status_userId_order", (q) => q
             .eq("status", status)
             .eq("userId", args.userId)
             .gte("order", args.offset ?? 0)));
-        const chats = await mergedStream(streams, ["order", "stepOrder"]).paginate({
+        const threads = await mergedStream(streams, ["order"]).paginate({
             numItems: args.limit ?? 100,
             cursor: args.cursor ?? null,
         });
         return {
-            chats: chats.page,
-            continueCursor: chats.continueCursor,
-            isDone: chats.isDone,
+            threads: threads.page,
+            continueCursor: threads.continueCursor,
+            isDone: threads.isDone,
         };
     },
     returns: v.object({
-        chats: v.array(v.doc("chats")),
+        threads: v.array(v.doc("threads")),
         continueCursor: v.string(),
         isDone: v.boolean(),
     }),
 });
-const vChat = schema.tables.chats.validator;
-const statuses = vChat.fields.status.members.map((m) => m.value);
-export const createChat = mutation({
-    args: omit(vChat.fields, ["order", "status"]),
+const vThread = schema.tables.threads.validator;
+const statuses = vThread.fields.status.members.map((m) => m.value);
+export const createThread = mutation({
+    args: omit(vThread.fields, ["order", "status"]),
     handler: async (ctx, args) => {
         const streams = statuses.map((status) => stream(ctx.db, schema)
-            .query("chats")
+            .query("threads")
             .withIndex("status_userId_order", (q) => q.eq("status", status).eq("userId", args.userId))
             .order("desc"));
-        const latestChat = await mergedStream(streams, ["order"]).first();
-        const order = (latestChat?.order ?? -1) + 1;
-        const chatId = await ctx.db.insert("chats", {
+        const latestThread = await mergedStream(streams, ["order"]).first();
+        const order = (latestThread?.order ?? -1) + 1;
+        const threadId = await ctx.db.insert("threads", {
             ...args,
             order,
             status: "active",
         });
-        return (await ctx.db.get(chatId));
+        return (await ctx.db.get(threadId));
     },
-    returns: v.doc("chats"),
+    returns: v.doc("threads"),
 });
-export const updateChat = mutation({
+export const updateThread = mutation({
     args: {
-        chatId: v.id("chats"),
-        patch: v.object(partial(pick(vChat.fields, [
+        threadId: v.id("threads"),
+        patch: v.object(partial(pick(vThread.fields, [
             "title",
             "summary",
             "defaultSystemPrompt",
@@ -78,37 +78,37 @@ export const updateChat = mutation({
         ]))),
     },
     handler: async (ctx, args) => {
-        const chat = await ctx.db.get(args.chatId);
-        assert(chat, `Chat ${args.chatId} not found`);
-        await ctx.db.patch(args.chatId, args.patch);
-        return (await ctx.db.get(args.chatId));
+        const thread = await ctx.db.get(args.threadId);
+        assert(thread, `Thread ${args.threadId} not found`);
+        await ctx.db.patch(args.threadId, args.patch);
+        return (await ctx.db.get(args.threadId));
     },
-    returns: v.doc("chats"),
+    returns: v.doc("threads"),
 });
-export const archiveChat = mutation({
-    args: { chatId: v.id("chats") },
+export const archiveThread = mutation({
+    args: { threadId: v.id("threads") },
     handler: async (ctx, args) => {
-        const chat = await ctx.db.get(args.chatId);
-        assert(chat, `Chat ${args.chatId} not found`);
-        await ctx.db.patch(args.chatId, { status: "archived" });
-        return (await ctx.db.get(args.chatId));
+        const thread = await ctx.db.get(args.threadId);
+        assert(thread, `Thread ${args.threadId} not found`);
+        await ctx.db.patch(args.threadId, { status: "archived" });
+        return (await ctx.db.get(args.threadId));
     },
-    returns: v.doc("chats"),
+    returns: v.doc("threads"),
 });
 export const deleteAllForUserId = action({
     args: { userId: v.string() },
     handler: async (ctx, args) => {
         let messagesCursor = null;
-        let chatsCursor = null;
+        let threadsCursor = null;
         let isDone = false;
         while (!isDone) {
             const result = await ctx.runMutation(internal.messages._deletePageForUserId, {
                 userId: args.userId,
                 messagesCursor,
-                chatsCursor,
+                threadsCursor,
             });
             messagesCursor = result.messagesCursor;
-            chatsCursor = result.chatsCursor;
+            threadsCursor = result.threadsCursor;
             isDone = result.isDone;
         }
     },
@@ -122,7 +122,7 @@ export const deleteAllForUserIdAsync = mutation({
         const isDone = await deleteAllFroUserIdAsyncHandler(ctx, {
             userId: args.userId,
             messagesCursor: null,
-            chatsCursor: null,
+            threadsCursor: null,
         });
         return isDone;
     },
@@ -131,11 +131,11 @@ export const deleteAllForUserIdAsync = mutation({
 const deleteAllArgs = {
     userId: v.string(),
     messagesCursor: nullable(v.string()),
-    chatsCursor: nullable(v.string()),
+    threadsCursor: nullable(v.string()),
 };
 const deleteAllReturns = {
     messagesCursor: v.string(),
-    chatsCursor: nullable(v.string()),
+    threadsCursor: nullable(v.string()),
     isDone: v.boolean(),
 };
 export const _deleteAllForUserIdAsync = internalMutation({
@@ -149,7 +149,7 @@ async function deleteAllFroUserIdAsyncHandler(ctx, args) {
         await ctx.scheduler.runAfter(0, internal.messages._deleteAllForUserIdAsync, {
             userId: args.userId,
             messagesCursor: result.messagesCursor,
-            chatsCursor: result.chatsCursor,
+            threadsCursor: result.threadsCursor,
         });
     }
     return result.isDone;
@@ -161,34 +161,34 @@ export const _deletePageForUserId = internalMutation({
 });
 async function deletePageForUserId(ctx, args) {
     const streams = statuses.map((status) => stream(ctx.db, schema)
-        .query("chats")
+        .query("threads")
         .withIndex("status_userId_order", (q) => q.eq("status", status).eq("userId", args.userId))
         .order("desc"));
-    const chatStreams = mergedStream(streams, ["order"]);
-    const messages = await chatStreams
+    const threadStreams = mergedStream(streams, ["order"]);
+    const messages = await threadStreams
         .flatMap(async (c) => stream(ctx.db, schema)
         .query("messages")
-        .withIndex("chatId_status_tool_order_stepOrder", (q) => q.eq("chatId", c._id).eq("status", "success")), ["tool", "order", "stepOrder"])
+        .withIndex("threadId_status_tool_order_stepOrder", (q) => q.eq("threadId", c._id).eq("status", "success")), ["tool", "order", "stepOrder"])
         .paginate({
         numItems: 100,
         cursor: args.messagesCursor ?? null,
     });
     await Promise.all(messages.page.map((m) => deleteMessage(ctx, m)));
     if (messages.isDone) {
-        const chats = await chatStreams.paginate({
+        const threads = await threadStreams.paginate({
             numItems: 100,
-            cursor: args.chatsCursor ?? null,
+            cursor: args.threadsCursor ?? null,
         });
-        await Promise.all(chats.page.map((c) => ctx.db.delete(c._id)));
+        await Promise.all(threads.page.map((c) => ctx.db.delete(c._id)));
         return {
             messagesCursor: messages.continueCursor,
-            chatsCursor: chats.continueCursor,
-            isDone: chats.isDone,
+            threadsCursor: threads.continueCursor,
+            isDone: threads.isDone,
         };
     }
     return {
         messagesCursor: messages.continueCursor,
-        chatsCursor: null,
+        threadsCursor: null,
         isDone: messages.isDone,
     };
 }
@@ -201,52 +201,52 @@ async function deleteMessage(ctx, messageDoc) {
         }
     }
 }
-const deleteChatArgs = {
-    chatId: v.id("chats"),
+const deleteThreadArgs = {
+    threadId: v.id("threads"),
     cursor: v.optional(v.string()),
     limit: v.optional(v.number()),
 };
-const deleteChatReturns = {
+const deleteThreadReturns = {
     cursor: v.string(),
     isDone: v.boolean(),
 };
-export const deleteAllForChatIdSync = action({
-    args: deleteChatArgs,
+export const deleteAllForThreadIdSync = action({
+    args: deleteThreadArgs,
     handler: async (ctx, args) => {
-        const result = await ctx.runMutation(internal.messages._deletePageForChatId, { chatId: args.chatId, cursor: args.cursor, limit: args.limit });
+        const result = await ctx.runMutation(internal.messages._deletePageForThreadId, { threadId: args.threadId, cursor: args.cursor, limit: args.limit });
         return result;
     },
-    returns: deleteChatReturns,
+    returns: deleteThreadReturns,
 });
-export const deleteAllForChatIdAsync = mutation({
-    args: deleteChatArgs,
+export const deleteAllForThreadIdAsync = mutation({
+    args: deleteThreadArgs,
     handler: async (ctx, args) => {
-        const result = await deletePageForChatIdHandler(ctx, args);
+        const result = await deletePageForThreadIdHandler(ctx, args);
         if (!result.isDone) {
-            await ctx.scheduler.runAfter(0, api.messages.deleteAllForChatIdAsync, {
-                chatId: args.chatId,
+            await ctx.scheduler.runAfter(0, api.messages.deleteAllForThreadIdAsync, {
+                threadId: args.threadId,
                 cursor: result.cursor,
             });
         }
         return result;
     },
-    returns: deleteChatReturns,
+    returns: deleteThreadReturns,
 });
-export const _deletePageForChatId = internalMutation({
-    args: deleteChatArgs,
-    handler: deletePageForChatIdHandler,
-    returns: deleteChatReturns,
+export const _deletePageForThreadId = internalMutation({
+    args: deleteThreadArgs,
+    handler: deletePageForThreadIdHandler,
+    returns: deleteThreadReturns,
 });
-async function deletePageForChatIdHandler(ctx, args) {
+async function deletePageForThreadIdHandler(ctx, args) {
     const messages = await stream(ctx.db, schema)
         .query("messages")
-        .withIndex("chatId_status_tool_order_stepOrder", (q) => q.eq("chatId", args.chatId).eq("status", "success"))
+        .withIndex("threadId_status_tool_order_stepOrder", (q) => q.eq("threadId", args.threadId).eq("status", "success"))
         .paginate({
         numItems: args.limit ?? 100,
         cursor: args.cursor ?? null,
     });
     await Promise.all(messages.page.map((m) => deleteMessage(ctx, m)));
-    await ctx.db.delete(args.chatId);
+    await ctx.db.delete(args.threadId);
     return {
         cursor: messages.continueCursor,
         isDone: messages.isDone,
@@ -280,7 +280,8 @@ export const getFilesToDelete = query({
 export const vMessageDoc = schema.tables.messages.validator;
 export const messageStatuses = vMessageDoc.fields.status.members.map((m) => m.value);
 const addMessagesArgs = {
-    chatId: v.id("chats"),
+    userId: v.optional(v.string()),
+    threadId: v.optional(v.id("threads")),
     stepId: v.optional(v.id("steps")),
     parentMessageId: v.optional(v.id("messages")),
     messages: v.array(vMessageWithFileAndId),
@@ -298,23 +299,25 @@ export const addMessages = mutation({
     }),
 });
 async function addMessagesHandler(ctx, args) {
-    const chat = await ctx.db.get(args.chatId);
-    assert(chat, `Chat ${args.chatId} not found`);
+    let userId = args.userId;
+    const threadId = args.threadId;
+    if (!userId && args.threadId) {
+        const thread = await ctx.db.get(args.threadId);
+        assert(thread, `Thread ${args.threadId} not found`);
+        userId = thread._id;
+    }
     const { failPendingSteps, pending, messages, parentMessageId, ...rest } = args;
-    if (failPendingSteps) {
+    const parent = parentMessageId && (await ctx.db.get(parentMessageId));
+    if (failPendingSteps && parent?.status !== "pending") {
+        assert(args.threadId, "threadId is required to fail pending steps");
         const pendingMessages = await ctx.db
             .query("messages")
-            .withIndex("chatId_status_tool_order_stepOrder", (q) => q.eq("chatId", args.chatId).eq("status", "pending"))
+            .withIndex("threadId_status_tool_order_stepOrder", (q) => q.eq("threadId", threadId).eq("status", "pending"))
             .collect();
         await Promise.all(pendingMessages.map((m) => ctx.db.patch(m._id, { status: "failed", text: "Restarting" })));
     }
-    let order;
-    const maxMessage = await getMaxMessage(ctx, args.chatId);
-    // If the previous message isn't our parent, we make a new thread.
-    const threadId = parentMessageId && maxMessage?._id === parentMessageId
-        ? maxMessage.threadId ?? parentMessageId
-        : parentMessageId;
-    order = maxMessage?.order ?? -1;
+    const maxMessage = await getMaxMessage(ctx, threadId, userId);
+    let order = maxMessage?.order ?? -1;
     const toReturn = [];
     if (messages.length > 0) {
         for (const { message, fileId, id } of messages) {
@@ -325,8 +328,8 @@ async function addMessagesHandler(ctx, args) {
             const text = extractText(message);
             const messageId = await ctx.db.insert("messages", {
                 ...rest,
-                threadId,
-                userId: chat.userId,
+                parentMessageId,
+                userId,
                 message,
                 id,
                 order,
@@ -340,14 +343,23 @@ async function addMessagesHandler(ctx, args) {
     }
     return { messages: toReturn };
 }
-async function getMaxMessage(ctx, chatId) {
-    return mergedStream(["success", "pending"].map((status) => stream(ctx.db, schema)
-        .query("messages")
-        .withIndex("chatId_status_tool_order_stepOrder", (q) => q.eq("chatId", chatId).eq("status", status).eq("tool", false))
-        .order("desc")), ["order", "stepOrder"]).first();
+async function getMaxMessage(ctx, threadId, userId) {
+    assert(threadId || userId, "One of threadId or userId is required");
+    if (threadId) {
+        return mergedStream(["success", "pending"].map((status) => stream(ctx.db, schema)
+            .query("messages")
+            .withIndex("threadId_status_tool_order_stepOrder", (q) => q.eq("threadId", threadId).eq("status", status).eq("tool", false))
+            .order("desc")), ["order", "stepOrder"]).first();
+    }
+    else {
+        return mergedStream(["success", "pending"].map((status) => stream(ctx.db, schema)
+            .query("messages")
+            .withIndex("userId_status_tool_order_stepOrder", (q) => q.eq("userId", userId).eq("status", status).eq("tool", false))
+            .order("desc")), ["order", "stepOrder"]).first();
+    }
 }
 const addStepsArgs = {
-    chatId: v.id("chats"),
+    threadId: v.id("threads"),
     messageId: v.id("messages"),
     steps: v.array(vStepWithMessagesWithFileAndId),
     failPendingSteps: v.optional(v.boolean()),
@@ -379,7 +391,7 @@ async function addStepsHandler(ctx, args) {
     let nextStepOrder = (steps.at(-1)?.stepOrder ?? -1) + 1;
     for (const { step, messages } of args.steps) {
         const stepId = await ctx.db.insert("steps", {
-            chatId: args.chatId,
+            threadId: args.threadId,
             parentMessageId: args.messageId,
             order,
             stepOrder: nextStepOrder,
@@ -387,7 +399,7 @@ async function addStepsHandler(ctx, args) {
             step,
         });
         await addMessagesHandler(ctx, {
-            chatId: args.chatId,
+            threadId: args.threadId,
             parentMessageId: args.messageId,
             stepId,
             messages,
@@ -396,7 +408,8 @@ async function addStepsHandler(ctx, args) {
             pending: step.finishReason === "stop" ? false : true,
             failPendingSteps: false,
         });
-        if (step.finishReason === "stop") {
+        // We don't commit if the parent is still pending.
+        if (step.finishReason === "stop" && parentMessage.status === "success") {
             await commitMessageHandler(ctx, { messageId: args.messageId });
         }
         steps.push((await ctx.db.get(stepId)));
@@ -441,18 +454,19 @@ async function commitMessageHandler(ctx, { messageId }) {
     const order = message.order;
     const messages = await mergedStream([true, false].map((tool) => stream(ctx.db, schema)
         .query("messages")
-        .withIndex("chatId_status_tool_order_stepOrder", (q) => q
-        .eq("chatId", message.chatId)
+        .withIndex("threadId_status_tool_order_stepOrder", (q) => q
+        .eq("threadId", message.threadId)
         .eq("status", "pending")
         .eq("tool", tool)
         .eq("order", order))), ["order", "stepOrder"]).collect();
     for (const message of messages) {
         await ctx.db.patch(message._id, { status: "success" });
+        // TODO: recursively commit steps & messages that might depend on this one.
     }
 }
-export const getChatMessages = query({
+export const getThreadMessages = query({
     args: {
-        chatId: v.id("chats"),
+        threadId: v.id("threads"),
         isTool: v.optional(v.boolean()),
         order: v.optional(v.union(v.literal("asc"), v.literal("desc"))),
         limit: v.optional(v.number()),
@@ -468,9 +482,9 @@ export const getChatMessages = query({
         const order = args.order ?? "desc";
         const streams = toolOptions.flatMap((tool) => statuses.map((status) => stream(ctx.db, schema)
             .query("messages")
-            .withIndex("chatId_status_tool_order_stepOrder", (q) => {
+            .withIndex("threadId_status_tool_order_stepOrder", (q) => {
             const qq = q
-                .eq("chatId", args.chatId)
+                .eq("threadId", args.threadId)
                 .eq("status", status)
                 .eq("tool", tool);
             if (parent) {
@@ -501,19 +515,19 @@ export const getChatMessages = query({
 export const searchMessages = action({
     args: {
         userId: v.optional(v.string()),
-        chatId: v.optional(v.id("chats")),
+        threadId: v.optional(v.id("threads")),
         parentMessageId: v.optional(v.id("messages")),
         ...vSearchOptions.fields,
     },
     returns: v.array(v.doc("messages")),
     handler: async (ctx, args) => {
-        assert(args.userId || args.chatId, "Specify userId or chatId");
+        assert(args.userId || args.threadId, "Specify userId or threadId");
         const limit = args.limit;
         let textSearchMessages;
         if (args.text) {
             textSearchMessages = await ctx.runQuery(api.messages.textSearch, {
                 userId: args.userId,
-                chatId: args.chatId,
+                threadId: args.threadId,
                 text: args.text,
                 limit,
             });
@@ -528,8 +542,8 @@ export const searchMessages = action({
             const vectors = (await ctx.vectorSearch(tableName, "vector", {
                 vector: args.vector,
                 filter: (q) => args.userId
-                    ? q.eq("model_kind_userId", [model, "chat", args.userId])
-                    : q.eq("model_kind_chatId", [model, "chat", args.chatId]),
+                    ? q.eq("model_kind_userId", [model, "thread", args.userId])
+                    : q.eq("model_kind_threadId", [model, "thread", args.threadId]),
                 limit,
             })).filter((v) => v._score > 0.5);
             // Reciprocal rank fusion
@@ -545,7 +559,7 @@ export const searchMessages = action({
             const vectorIds = vectorScores.slice(0, limit).map((v) => v.id);
             const messages = await ctx.runQuery(internal.messages._fetchVectorMessages, {
                 userId: args.userId,
-                chatId: args.chatId,
+                threadId: args.threadId,
                 vectorIds,
                 textSearchMessages: textSearchMessages?.filter((m) => !vectorIds.includes(m.embeddingId)),
                 messageRange: args.messageRange ?? DEFAULT_MESSAGE_RANGE,
@@ -560,7 +574,7 @@ export const searchMessages = action({
 export const _fetchVectorMessages = internalQuery({
     args: {
         userId: v.optional(v.string()),
-        chatId: v.optional(v.id("chats")),
+        threadId: v.optional(v.id("threads")),
         vectorIds: v.array(vVectorId),
         textSearchMessages: v.optional(v.array(v.doc("messages"))),
         messageRange: v.object({ before: v.number(), after: v.number() }),
@@ -570,60 +584,83 @@ export const _fetchVectorMessages = internalQuery({
     returns: v.array(v.doc("messages")),
     handler: async (ctx, args) => {
         const parent = args.parentMessageId && (await ctx.db.get(args.parentMessageId));
+        const { userId, threadId } = args;
+        assert(userId || threadId, "Specify userId or threadId to search");
         let messages = (await Promise.all(args.vectorIds.map((embeddingId) => ctx.db
             .query("messages")
             .withIndex("embeddingId", (q) => q.eq("embeddingId", embeddingId))
-            .filter((q) => args.userId
-            ? q.eq("userId", args.userId)
+            .filter((q) => userId
+            ? q.eq("userId", userId)
             : // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                q.eq("chatId", args.chatId) // not sure why it's failing...
-        )
+                q.eq("threadId", threadId))
             .first()))).filter((m) => 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
+        if (!threadId) {
+            return messages.sort((a, b) => a.order - b.order);
+        }
         const included = {};
         for (const m of messages) {
-            if (!included[m.chatId]) {
-                included[m.chatId] = new Set();
+            const searchId = m.threadId ?? m.userId;
+            if (!included[searchId]) {
+                included[searchId] = new Set();
             }
-            included[m.chatId].add(m.order);
+            included[searchId].add(m.order);
         }
         const ranges = {};
         const { before, after } = args.messageRange;
         for (const m of messages) {
+            const searchId = m.threadId ?? m.userId;
             const order = m.order;
             let earliest = order - before;
             let latest = order + after;
             for (; earliest <= latest; earliest++) {
-                if (!included[m.chatId].has(earliest)) {
+                if (!included[searchId].has(earliest)) {
                     break;
                 }
             }
             for (; latest >= earliest; latest--) {
-                if (!included[m.chatId].has(latest)) {
+                if (!included[searchId].has(latest)) {
                     break;
                 }
             }
             for (let i = earliest; i <= latest; i++) {
-                included[m.chatId].add(i);
+                included[searchId].add(i);
             }
             if (earliest !== latest) {
-                const surrounding = await ctx.db
-                    .query("messages")
-                    .withIndex("chatId_status_tool_order_stepOrder", (q) => q
-                    .eq("chatId", m.chatId)
-                    .eq("status", "success")
-                    .eq("tool", false)
-                    .gt("order", earliest)
-                    .lt("order", latest))
-                    .collect();
-                if (!ranges[m.chatId]) {
-                    ranges[m.chatId] = [];
+                if (m.threadId) {
+                    const surrounding = await ctx.db
+                        .query("messages")
+                        .withIndex("threadId_status_tool_order_stepOrder", (q) => q
+                        .eq("threadId", m.threadId)
+                        .eq("status", "success")
+                        .eq("tool", false)
+                        .gt("order", earliest)
+                        .lt("order", latest))
+                        .collect();
+                    if (!ranges[searchId]) {
+                        ranges[searchId] = [];
+                    }
+                    ranges[searchId].push(...surrounding);
+                }
+                else {
+                    const surrounding = await ctx.db
+                        .query("messages")
+                        .withIndex("userId_status_tool_order_stepOrder", (q) => q
+                        .eq("userId", m.userId)
+                        .eq("status", "success")
+                        .eq("tool", false)
+                        .gt("order", earliest)
+                        .lt("order", latest))
+                        .collect();
+                    if (!ranges[searchId]) {
+                        ranges[searchId] = [];
+                    }
+                    ranges[searchId].push(...surrounding);
                 }
-                ranges[m.chatId].push(...surrounding);
             }
         }
         return Object.values(ranges)
@@ -635,18 +672,18 @@ export const _fetchVectorMessages = internalQuery({
 // excluding duplicates in later ranges.
 export const textSearch = query({
     args: {
-        chatId: v.optional(v.id("chats")),
+        threadId: v.optional(v.id("threads")),
         userId: v.optional(v.string()),
         text: v.string(),
         limit: v.number(),
     },
     handler: async (ctx, args) => {
-        assert(args.userId || args.chatId, "Specify userId or chatId");
+        assert(args.userId || args.threadId, "Specify userId or threadId");
         const messages = await ctx.db
             .query("messages")
             .withSearchIndex("text_search", (q) => args.userId
             ? q.search("text", args.text).eq("userId", args.userId)
-            : q.search("text", args.text).eq("chatId", args.chatId))
+            : q.search("text", args.text).eq("threadId", args.threadId))
             .take(args.limit);
         return messages;
     },
@@ -695,9 +732,9 @@ export const textSearch = query({
 //   ),
 // });
 // const DEFAULT_MESSAGES_LIMIT = 40; // What pg & upstash do too.
-// export const getChatMessagesPage = query({
+// export const getThreadMessagesPage = query({
 //   args: {
-//     threadId: v.string(),
+//     parentMessageId: v.string(),
 //     selectBy: v.optional(vSelectBy),
 //     // Unimplemented and as far I can tell no storage provider has either.
 //     // memoryConfig: v.optional(vMemoryConfig),
@@ -705,7 +742,7 @@ export const textSearch = query({
 //   handler: async (ctx, args): Promise<SerializedMessage[]> => {
 //     const messages = await ctx.db
 //       .query("messages")
-//       .withIndex("threadId", (q) => q.eq("threadId", args.threadId))
+//       .withIndex("parentMessageId", (q) => q.eq("parentMessageId", args.parentMessageId))
 //       .order("desc")
 //       .take(args.selectBy?.last ? args.selectBy.last : DEFAULT_MESSAGES_LIMIT);
 //     const handled: boolean[] = [];
@@ -758,9 +795,9 @@ export const textSearch = query({
 //         ranges.map(async (range) => {
 //           return await ctx.db
 //             .query("messages")
-//             .withIndex("threadId", (q) =>
+//             .withIndex("parentMessageId", (q) =>
 //               q
-//                 .eq("threadId", args.threadId)
+//                 .eq("parentMessageId", args.parentMessageId)
 //                 .gte("threadOrder", range.start)
 //                 .lte("threadOrder", range.end)
 //             )
@@ -776,21 +813,21 @@ export const textSearch = query({
 // export const saveMessages = mutation({
 //   args: { messages: v.array(vSerializedMessage) },
 //   handler: async (ctx, args) => {
-//     const messagesByThreadId: Record<string, SerializedMessage[]> = {};
+//     const messagesByParentMessageId: Record<string, SerializedMessage[]> = {};
 //     for (const message of args.messages) {
-//       messagesByThreadId[message.threadId] = [
-//         ...(messagesByThreadId[message.threadId] ?? []),
+//       messagesByParentMessageId[message.parentMessageId] = [
+//         ...(messagesByParentMessageId[message.parentMessageId] ?? []),
 //         message,
 //       ];
 //     }
-//     for (const threadId in messagesByThreadId) {
+//     for (const parentMessageId in messagesByParentMessageId) {
 //       const lastMessage = await ctx.db
 //         .query("messages")
-//         .withIndex("threadId", (q) => q.eq("threadId", threadId))
+//         .withIndex("parentMessageId", (q) => q.eq("parentMessageId", parentMessageId))
 //         .order("desc")
 //         .first();
 //       let threadOrder = lastMessage?.threadOrder ?? 0;
-//       for (const message of messagesByThreadId[threadId]) {
+//       for (const message of messagesByParentMessageId[parentMessageId]) {
 //         threadOrder++;
 //         await ctx.db.insert("messages", {
 //           ...message,