@convex-dev/agent 0.0.16 → 0.0.17-alpha.0

package/dist/esm/component/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/component/messages.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/component/messages.ts"],"names":[],"mappings":"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"}

package/dist/esm/component/messages.js

@@ -1,251 +1,34 @@
-import { assert, omit, pick } from "convex-helpers";
-import { paginator } from "convex-helpers/server/pagination";
+import { assert } from "convex-helpers";
 import { mergedStream, stream } from "convex-helpers/server/stream";
-import { nullable, partial } from "convex-helpers/validators";
 import { DEFAULT_MESSAGE_RANGE, DEFAULT_RECENT_MESSAGES, extractText, isTool, } from "../shared.js";
 import { paginationResultValidator, vMessageStatus, vMessageWithMetadata, vSearchOptions, vStepWithMessages, } from "../validators.js";
 import { api, internal } from "./_generated/api.js";
-import { action, internalMutation, internalQuery, mutation, query, } from "./_generated/server.js";
+import { action, internalQuery, mutation, query, } from "./_generated/server.js";
 import { schema, v } from "./schema.js";
 import { insertVector, searchVectors } from "./vector/index.js";
 import { VectorDimensions, vVectorId, } from "./vector/tables.js";
+import { listThreadsByUserId as _listThreadsByUserId, getThread as _getThread, updateThread as _updateThread, } from "./threads.js";
 import { paginationOptsValidator } from "convex/server";
-export const getThread = query({
-    args: { threadId: v.id("threads") },
-    handler: async (ctx, args) => {
-        return ctx.db.get(args.threadId);
-    },
-    returns: v.union(v.doc("threads"), v.null()),
-});
-export const getThreadsByUserId = query({
-    args: {
-        userId: v.string(),
-        order: v.optional(v.union(v.literal("asc"), v.literal("desc"))),
-        paginationOpts: v.optional(paginationOptsValidator),
-    },
-    handler: async (ctx, args) => {
-        const threads = await paginator(ctx.db, schema)
-            .query("threads")
-            .withIndex("userId", (q) => q.eq("userId", args.userId))
-            .order(args.order ?? "desc")
-            .paginate(args.paginationOpts ?? { cursor: null, numItems: 100 });
-        return threads;
-    },
-    returns: paginationResultValidator(v.doc("threads")),
-});
-const vThread = schema.tables.threads.validator;
-export const createThread = mutation({
-    args: omit(vThread.fields, ["order", "status"]),
-    handler: async (ctx, args) => {
-        const threadId = await ctx.db.insert("threads", {
-            ...args,
-            status: "active",
-        });
-        return (await ctx.db.get(threadId));
-    },
-    returns: v.doc("threads"),
-});
-export const updateThread = mutation({
-    args: {
-        threadId: v.id("threads"),
-        patch: v.object(partial(pick(vThread.fields, ["title", "summary", "status"]))),
-    },
-    handler: async (ctx, args) => {
-        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("threads"),
-});
-// When we expose this, we need to also hide all the messages and steps
-// export const archiveThread = mutation({
-//   args: { threadId: v.id("threads") },
-//   handler: async (ctx, args) => {
-//     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("threads"),
-// });
-export const deleteAllForUserId = action({
-    args: { userId: v.string() },
-    handler: async (ctx, args) => {
-        let messagesCursor = null;
-        let threadsCursor = null;
-        let isDone = false;
-        while (!isDone) {
-            const result = await ctx.runMutation(internal.messages._deletePageForUserId, {
-                userId: args.userId,
-                messagesCursor,
-                threadsCursor,
-            });
-            messagesCursor = result.messagesCursor;
-            threadsCursor = result.threadsCursor;
-            isDone = result.isDone;
-        }
-    },
-    returns: v.null(),
-});
-export const deleteAllForUserIdAsync = mutation({
-    args: {
-        userId: v.string(),
-    },
-    handler: async (ctx, args) => {
-        const isDone = await deleteAllForUserIdAsyncHandler(ctx, {
-            userId: args.userId,
-            messagesCursor: null,
-            threadsCursor: null,
-        });
-        return isDone;
-    },
-    returns: v.boolean(),
-});
-const deleteAllArgs = {
-    userId: v.string(),
-    messagesCursor: nullable(v.string()),
-    threadsCursor: nullable(v.string()),
-};
-const deleteAllReturns = {
-    messagesCursor: v.string(),
-    threadsCursor: nullable(v.string()),
-    isDone: v.boolean(),
-};
-export const _deleteAllForUserIdAsync = internalMutation({
-    args: deleteAllArgs,
-    handler: deleteAllForUserIdAsyncHandler,
-    returns: v.boolean(),
-});
-async function deleteAllForUserIdAsyncHandler(ctx, args) {
-    const result = await deletePageForUserId(ctx, args);
-    if (!result.isDone) {
-        await ctx.scheduler.runAfter(0, internal.messages._deleteAllForUserIdAsync, {
-            userId: args.userId,
-            messagesCursor: result.messagesCursor,
-            threadsCursor: result.threadsCursor,
-        });
-    }
-    return result.isDone;
-}
-export const _deletePageForUserId = internalMutation({
-    args: deleteAllArgs,
-    handler: deletePageForUserId,
-    returns: deleteAllReturns,
-});
-async function deletePageForUserId(ctx, args) {
-    const threads = await paginator(ctx.db, schema)
-        .query("threads")
-        .withIndex("userId", (q) => q.eq("userId", args.userId))
-        .order("desc")
-        .paginate({
-        numItems: 100,
-        cursor: args.threadsCursor ?? null,
-    });
-    await Promise.all(threads.page.map((c) => ctx.db.delete(c._id)));
-    const messages = await paginator(ctx.db, schema)
-        .query("messages")
-        .withIndex("userId_status_tool_order_stepOrder", (q) => q.eq("userId", args.userId))
-        .order("desc")
-        .paginate({
-        numItems: 100,
-        cursor: args.messagesCursor ?? null,
-    });
-    await Promise.all(messages.page.map((m) => deleteMessage(ctx, m)));
-    return {
-        messagesCursor: messages.continueCursor,
-        threadsCursor: threads.continueCursor,
-        isDone: messages.isDone,
-    };
-}
-async function deleteMessage(ctx, messageDoc) {
+/** @deprecated Use *.threads.listMessagesByThreadId instead. */
+export const listThreadsByUserId = _listThreadsByUserId;
+/** @deprecated Use *.threads.getThread */
+export const getThread = _getThread;
+/** @deprecated Use *.threads.updateThread instead */
+export const updateThread = _updateThread;
+export async function deleteMessage(ctx, messageDoc) {
     await ctx.db.delete(messageDoc._id);
     if (messageDoc.embeddingId) {
         await ctx.db.delete(messageDoc.embeddingId);
     }
-    if (messageDoc.fileId) {
-        const file = await ctx.db.get(messageDoc.fileId);
+    for (const { fileId } of messageDoc.files ?? []) {
+        if (!fileId)
+            continue;
+        const file = await ctx.db.get(fileId);
         if (file) {
-            await ctx.db.patch(messageDoc.fileId, { refcount: file.refcount - 1 });
+            await ctx.db.patch(fileId, { refcount: file.refcount - 1 });
         }
     }
 }
-const deleteThreadArgs = {
-    threadId: v.id("threads"),
-    cursor: v.optional(v.string()),
-    limit: v.optional(v.number()),
-};
-const deleteThreadReturns = {
-    cursor: v.string(),
-    isDone: v.boolean(),
-};
-export const deleteAllForThreadIdSync = action({
-    args: deleteThreadArgs,
-    handler: async (ctx, args) => {
-        const result = await ctx.runMutation(internal.messages._deletePageForThreadId, { threadId: args.threadId, cursor: args.cursor, limit: args.limit });
-        return result;
-    },
-    returns: deleteThreadReturns,
-});
-export const deleteAllForThreadIdAsync = mutation({
-    args: deleteThreadArgs,
-    handler: async (ctx, args) => {
-        const result = await deletePageForThreadIdHandler(ctx, args);
-        if (!result.isDone) {
-            await ctx.scheduler.runAfter(0, api.messages.deleteAllForThreadIdAsync, {
-                threadId: args.threadId,
-                cursor: result.cursor,
-            });
-        }
-        return result;
-    },
-    returns: deleteThreadReturns,
-});
-export const _deletePageForThreadId = internalMutation({
-    args: deleteThreadArgs,
-    handler: deletePageForThreadIdHandler,
-    returns: deleteThreadReturns,
-});
-async function deletePageForThreadIdHandler(ctx, args) {
-    const messages = await paginator(ctx.db, schema)
-        .query("messages")
-        .withIndex("threadId_status_tool_order_stepOrder", (q) => q.eq("threadId", args.threadId))
-        .paginate({
-        numItems: args.limit ?? 100,
-        cursor: args.cursor ?? null,
-    });
-    await Promise.all(messages.page.map((m) => deleteMessage(ctx, m)));
-    await ctx.db.delete(args.threadId);
-    return {
-        cursor: messages.continueCursor,
-        isDone: messages.isDone,
-    };
-}
-export const getFilesToDelete = query({
-    args: {
-        cursor: v.optional(v.string()),
-        limit: v.optional(v.number()),
-    },
-    handler: async (ctx, args) => {
-        const files = await paginator(ctx.db, schema)
-            .query("files")
-            .withIndex("refcount", (q) => q.eq("refcount", 0))
-            .paginate({
-            numItems: args.limit ?? 100,
-            cursor: args.cursor ?? null,
-        });
-        return {
-            files: files.page,
-            continueCursor: files.continueCursor,
-            isDone: files.isDone,
-        };
-    },
-    returns: v.object({
-        files: v.array(v.doc("files")),
-        continueCursor: v.string(),
-        isDone: v.boolean(),
-    }),
-});
 export const vMessageDoc = schema.tables.messages.validator;
 export const messageStatuses = vMessageDoc.fields.status.members.map((m) => m.value);
 const addMessagesArgs = {
@@ -275,9 +58,7 @@ async function addMessagesHandler(ctx, args) {
         userId = thread.userId;
     }
     const { failPendingSteps, pending, messages, parentMessageId, ...rest } = args;
-    const parent = parentMessageId && (await ctx.db.get(parentMessageId));
-    // TODO: I think this is a bug - parent will be pending always?
-    if (failPendingSteps && parent?.status !== "pending") {
+    if (failPendingSteps) {
         assert(args.threadId, "threadId is required to fail pending steps");
         const pendingMessages = await ctx.db
             .query("messages")
@@ -287,9 +68,11 @@ async function addMessagesHandler(ctx, args) {
     }
     const maxMessage = await getMaxMessage(ctx, threadId, userId);
     let order = maxMessage?.order ?? -1;
+    let stepOrder = maxMessage?.stepOrder ?? 0;
+    let lastMessageIsTool = maxMessage?.tool ?? false;
     const toReturn = [];
     if (messages.length > 0) {
-        for (const { message, fileId, embedding, ...fields } of messages) {
+        for (const { message, files, embedding, ...fields } of messages) {
             let embeddingId;
             if (embedding) {
                 embeddingId = await insertVector(ctx, embedding.dimension, {
@@ -301,9 +84,14 @@ async function addMessagesHandler(ctx, args) {
                 });
             }
             const tool = isTool(message);
-            if (!tool) {
+            if (lastMessageIsTool) {
+                stepOrder++;
+            }
+            else {
                 order++;
+                stepOrder = 0;
             }
+            lastMessageIsTool = tool;
             const text = extractText(message);
             const messageId = await ctx.db.insert("messages", {
                 ...rest,
@@ -315,11 +103,18 @@ async function addMessagesHandler(ctx, args) {
                 order,
                 tool,
                 text,
-                fileId,
+                files,
                 status: pending ? "pending" : "success",
-                stepOrder: 0,
+                stepOrder,
             });
-            if (fileId) {
+            if (!fields.id) {
+                await ctx.db.patch(messageId, {
+                    id: messageId,
+                });
+            }
+            for (const { fileId } of files ?? []) {
+                if (!fileId)
+                    continue;
                 await ctx.db.patch(fileId, {
                     refcount: (await ctx.db.get(fileId)).refcount + 1,
                 });
@@ -329,39 +124,26 @@ async function addMessagesHandler(ctx, args) {
     }
     return { messages: toReturn };
 }
-async function getMaxMessage(ctx, threadId, userId) {
+// exported for tests
+export 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)
+        return mergedStream([true, false].flatMap((tool) => ["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();
+            .withIndex("threadId_status_tool_order_stepOrder", (q) => q.eq("threadId", threadId).eq("status", status).eq("tool", tool))
+            .order("desc"))), ["order", "stepOrder"]).first();
     }
     else {
-        // DO explicitly
-        const maxPending = await ctx.db
+        return mergedStream([true, false].flatMap((tool) => ["success", "pending"].map((status) => stream(ctx.db, schema)
             .query("messages")
-            .withIndex("userId_status_tool_order_stepOrder", (q) => q.eq("userId", userId).eq("status", "pending").eq("tool", false))
-            .order("desc")
-            .first();
-        const maxSuccess = await ctx.db
-            .query("messages")
-            .withIndex("userId_status_tool_order_stepOrder", (q) => q.eq("userId", userId).eq("status", "success").eq("tool", false))
-            .order("desc")
-            .first();
-        return maxPending
-            ? maxSuccess
-                ? maxPending.order > maxSuccess.order
-                    ? maxPending
-                    : maxSuccess
-                : maxPending
-            : maxSuccess ?? null;
+            .withIndex("userId_status_tool_order_stepOrder", (q) => q.eq("userId", userId).eq("status", status).eq("tool", tool))
+            .order("desc"))), ["order", "stepOrder"]).first();
     }
 }
 const addStepArgs = {
     userId: v.optional(v.string()),
     threadId: v.id("threads"),
-    messageId: v.id("messages"),
+    parentMessageId: v.id("messages"),
     step: vStepWithMessages,
     failPendingSteps: v.optional(v.boolean()),
 };
@@ -371,15 +153,16 @@ export const addStep = mutation({
     handler: addStepHandler,
 });
 async function addStepHandler(ctx, args) {
-    const parentMessage = await ctx.db.get(args.messageId);
-    assert(parentMessage, `Message ${args.messageId} not found`);
+    const parentMessage = await ctx.db.get(args.parentMessageId);
+    assert(parentMessage, `Message ${args.parentMessageId} not found`);
     const order = parentMessage.order;
-    assert(order !== undefined, `${args.messageId} has no order`);
+    assert(order !== undefined, `${args.parentMessageId} has no order`);
+    // TODO: only fetch the last one if we aren't failing pending steps
     let steps = await ctx.db
         .query("steps")
         .withIndex("parentMessageId_order_stepOrder", (q) => 
     // TODO: fetch pending, and commit later
-    q.eq("parentMessageId", args.messageId))
+    q.eq("parentMessageId", args.parentMessageId))
         .collect();
     if (args.failPendingSteps) {
         for (const step of steps) {
@@ -392,7 +175,7 @@ async function addStepHandler(ctx, args) {
     const { step, messages } = args.step;
     const stepId = await ctx.db.insert("steps", {
         threadId: args.threadId,
-        parentMessageId: args.messageId,
+        parentMessageId: args.parentMessageId,
         order,
         stepOrder: (steps.at(-1)?.stepOrder ?? -1) + 1,
         status: step.finishReason === "stop" ? "success" : "pending",
@@ -402,7 +185,7 @@ async function addStepHandler(ctx, args) {
         userId: args.userId,
         threadId: args.threadId,
         stepId,
-        parentMessageId: args.messageId,
+        parentMessageId: args.parentMessageId,
         agentName: parentMessage.agentName,
         messages,
         pending: step.finishReason === "stop" ? false : true,
@@ -410,7 +193,7 @@ async function addStepHandler(ctx, args) {
     });
     // We don't commit if the parent is still pending.
     if (step.finishReason === "stop") {
-        await commitMessageHandler(ctx, { messageId: args.messageId });
+        await commitMessageHandler(ctx, { messageId: args.parentMessageId });
     }
     steps.push((await ctx.db.get(stepId)));
     return steps;
@@ -475,19 +258,21 @@ async function commitMessageHandler(ctx, { messageId }) {
         // TODO: recursively commit steps & messages that might depend on this one.
     }
 }
-export const getThreadMessages = query({
+export const listMessagesByThreadId = query({
     args: {
         threadId: v.id("threads"),
-        isTool: v.optional(v.boolean()),
+        excludeToolMessages: v.optional(v.boolean()),
+        /** @deprecated Use excludeToolMessages instead. */
+        isTool: v.optional(v.literal("use excludeToolMessages instead of this")),
         order: v.optional(v.union(v.literal("asc"), v.literal("desc"))),
         paginationOpts: v.optional(paginationOptsValidator),
         statuses: v.optional(v.array(vMessageStatus)),
-        parentMessageId: v.optional(v.id("messages")),
+        beforeMessageId: 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 statuses = args.statuses ?? vMessageStatus.members.map((m) => m.value);
+        const before = args.beforeMessageId && (await ctx.db.get(args.beforeMessageId));
+        const toolOptions = args.excludeToolMessages ? [false] : [true, false];
         const order = args.order ?? "desc";
         const streams = toolOptions.flatMap((tool) => statuses.map((status) => stream(ctx.db, schema)
             .query("messages")
@@ -496,12 +281,15 @@ export const getThreadMessages = query({
                 .eq("threadId", args.threadId)
                 .eq("status", status)
                 .eq("tool", tool);
-            if (parent) {
-                return qq.lte("order", parent.order);
+            if (before) {
+                return qq.lte("order", before.order);
             }
             return qq;
         })
-            .order(order)));
+            .order(order)
+            .filterWith(async (m) => !before ||
+            m.order < before.order ||
+            (m.order === before.order && m.stepOrder < before.stepOrder))));
         const messages = await mergedStream(streams, [
             "order",
             "stepOrder",
@@ -513,11 +301,19 @@ export const getThreadMessages = query({
     },
     returns: paginationResultValidator(v.doc("messages")),
 });
+/** @deprecated Use listMessagesByThreadId instead. */
+export const getThreadMessages = query({
+    args: { deprecated: v.literal("Use listMessagesByThreadId instead") },
+    handler: async () => {
+        throw new Error("Use listMessagesByThreadId instead of getThreadMessages");
+    },
+    returns: paginationResultValidator(v.doc("messages")),
+});
 export const searchMessages = action({
     args: {
         userId: v.optional(v.string()),
         threadId: v.optional(v.id("threads")),
-        parentMessageId: v.optional(v.id("messages")),
+        beforeMessageId: v.optional(v.id("messages")),
         ...vSearchOptions.fields,
     },
     returns: v.array(v.doc("messages")),
@@ -531,6 +327,7 @@ export const searchMessages = action({
                 threadId: args.threadId,
                 text: args.text,
                 limit,
+                beforeMessageId: args.beforeMessageId,
             });
         }
         if (args.vector) {
@@ -557,13 +354,13 @@ export const searchMessages = action({
             }))
                 .sort((a, b) => b.score - a.score);
             const vectorIds = vectorScores.slice(0, limit).map((v) => v.id);
-            const messages = await ctx.runQuery(internal.messages._fetchVectorMessages, {
+            const messages = await ctx.runQuery(internal.messages._fetchSearchMessages, {
                 userId: args.userId,
                 threadId: args.threadId,
                 vectorIds,
                 textSearchMessages: textSearchMessages?.filter((m) => !vectorIds.includes(m.embeddingId)),
                 messageRange: args.messageRange ?? DEFAULT_MESSAGE_RANGE,
-                parentMessageId: args.parentMessageId,
+                beforeMessageId: args.beforeMessageId,
                 limit,
             });
             return messages;
@@ -571,19 +368,19 @@ export const searchMessages = action({
         return textSearchMessages?.flat() ?? [];
     },
 });
-export const _fetchVectorMessages = internalQuery({
+export const _fetchSearchMessages = internalQuery({
     args: {
         userId: v.optional(v.string()),
         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() }),
-        parentMessageId: v.optional(v.id("messages")),
+        beforeMessageId: v.optional(v.id("messages")),
         limit: v.number(),
     },
     returns: v.array(v.doc("messages")),
     handler: async (ctx, args) => {
-        const parent = args.parentMessageId && (await ctx.db.get(args.parentMessageId));
+        const beforeMessage = args.beforeMessageId && (await ctx.db.get(args.beforeMessageId));
         const { userId, threadId } = args;
         assert(userId || threadId, "Specify userId or threadId to search");
         let messages = (await Promise.all(args.vectorIds.map((embeddingId) => ctx.db
@@ -597,7 +394,10 @@ export const _fetchVectorMessages = internalQuery({
             .first()))).filter((m) => m !== undefined &&
             m !== null &&
             !m.tool &&
-            (!parent || m.order <= parent.order));
+            (!beforeMessage ||
+                m.order < beforeMessage.order ||
+                (m.order === beforeMessage.order &&
+                    m.stepOrder < beforeMessage.stepOrder)));
         messages.push(...(args.textSearchMessages ?? []));
         // TODO: prioritize more recent messages
         messages.sort((a, b) => a.order - b.order);
@@ -683,18 +483,30 @@ export const textSearch = query({
         userId: v.optional(v.string()),
         text: v.string(),
         limit: v.number(),
+        beforeMessageId: v.optional(v.id("messages")),
     },
     handler: async (ctx, args) => {
         assert(args.userId || args.threadId, "Specify userId or threadId");
+        const beforeMessage = args.beforeMessageId && (await ctx.db.get(args.beforeMessageId));
+        const order = beforeMessage?.order;
         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("threadId", args.threadId))
             // Just in case tool messages slip through
-            .filter((q) => q.eq(q.field("tool"), false))
+            .filter((q) => {
+            const qq = q.eq(q.field("tool"), false);
+            if (order) {
+                return q.and(qq, q.lte(q.field("order"), order));
+            }
+            return qq;
+        })
             .take(args.limit);
-        return messages;
+        return messages.filter((m) => !beforeMessage ||
+            m.order < beforeMessage.order ||
+            (m.order === beforeMessage.order &&
+                m.stepOrder < beforeMessage.stepOrder));
     },
     returns: v.array(v.doc("messages")),
 });