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

package/src/component/messages.test.ts

@@ -152,14 +152,14 @@ describe("agent", () => {
       messages: [{ message: { role: "user", content: "hello" } }],
     });
     const messageId = messages[0]._id as Id<"messages">;
-    
+
     const updatedMessage = await t.mutation(api.messages.updateMessage, {
       messageId,
       patch: {
         message: { role: "user", content: "updated content" },
       },
     });
-    
+
     expect(updatedMessage.message).toEqual({
       role: "user",
       content: "updated content",
@@ -177,10 +177,10 @@ describe("agent", () => {
       pending: true,
     });
     const messageId = messages[0]._id as Id<"messages">;
-    
+
     // Initial status should be pending
     expect(messages[0].status).toBe("pending");
-    
+
     // Update to success
     const updatedMessage = await t.mutation(api.messages.updateMessage, {
       messageId,
@@ -188,7 +188,7 @@ describe("agent", () => {
         status: "success",
       },
     });
-    
+
     expect(updatedMessage.status).toBe("success");
   });
 
@@ -203,7 +203,7 @@ describe("agent", () => {
       pending: true,
     });
     const messageId = messages[0]._id as Id<"messages">;
-    
+
     const updatedMessage = await t.mutation(api.messages.updateMessage, {
       messageId,
       patch: {
@@ -211,7 +211,7 @@ describe("agent", () => {
         error: "Something went wrong",
       },
     });
-    
+
     expect(updatedMessage.status).toBe("failed");
     expect(updatedMessage.error).toBe("Something went wrong");
   });
@@ -223,22 +223,24 @@ describe("agent", () => {
     });
     const { messages } = await t.mutation(api.messages.addMessages, {
       threadId: thread._id as Id<"threads">,
-      messages: [{
-        message: {
-          role: "assistant",
-          content: [
-            {
-              type: "tool-call",
-              args: { a: 1 },
-              toolCallId: "1",
-              toolName: "tool",
-            },
-          ],
+      messages: [
+        {
+          message: {
+            role: "assistant",
+            content: [
+              {
+                type: "tool-call",
+                args: { a: 1 },
+                toolCallId: "1",
+                toolName: "tool",
+              },
+            ],
+          },
         },
-      }],
+      ],
     });
     const messageId = messages[0]._id as Id<"messages">;
-    
+
     const updatedMessage = await t.mutation(api.messages.updateMessage, {
       messageId,
       patch: {
@@ -255,7 +257,7 @@ describe("agent", () => {
         },
       },
     });
-    
+
     expect(updatedMessage.message).toEqual({
       role: "assistant",
       content: [
@@ -271,7 +273,7 @@ describe("agent", () => {
 
   test("updateMessage throws error for non-existent message", async () => {
     const t = convexTest(schema, modules);
-    
+
     await expect(
       t.mutation(api.messages.updateMessage, {
         messageId: "invalidId" as Id<"messages">,
@@ -281,4 +283,229 @@ describe("agent", () => {
       })
     ).rejects.toThrow();
   });
+
+  test("deleteByIds deletes existing messages and returns their IDs", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        { message: { role: "user", content: "hello" } },
+        { message: { role: "assistant", content: "world" } },
+        { message: { role: "user", content: "test" } },
+      ],
+    });
+
+    const messageIds = messages.map((m) => m._id as Id<"messages">);
+    const deletedIds = await t.mutation(api.messages.deleteByIds, {
+      messageIds: [messageIds[0], messageIds[2]], // Delete first and third messages
+    });
+
+    expect(deletedIds).toEqual([messageIds[0], messageIds[2]]);
+
+    // Verify messages are actually deleted
+    const remainingMessages = await t.query(
+      api.messages.listMessagesByThreadId,
+      {
+        threadId: thread._id as Id<"threads">,
+        order: "asc",
+      }
+    );
+    expect(remainingMessages.page).toHaveLength(1);
+    expect(remainingMessages.page[0]._id).toBe(messageIds[1]);
+  });
+
+  test("deleteByIds handles non-existent message IDs gracefully", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [{ message: { role: "user", content: "hello" } }],
+    });
+
+    const messageId = messages[0]._id as Id<"messages">;
+    const validDeletedIds = await t.mutation(api.messages.deleteByIds, {
+      messageIds: [messageId],
+    });
+    expect(validDeletedIds).toEqual([messageId]);
+
+    const deletedIds = await t.mutation(api.messages.deleteByIds, {
+      messageIds: [messageId],
+    });
+
+    // Should only return the valid ID that was actually deleted
+    expect(deletedIds).toEqual([]);
+
+    // Verify the valid message was deleted
+    const remainingMessages = await t.query(
+      api.messages.listMessagesByThreadId,
+      {
+        threadId: thread._id as Id<"threads">,
+        order: "asc",
+      }
+    );
+    expect(remainingMessages.page).toHaveLength(0);
+  });
+
+  test("deleteByOrder deletes messages within specified order range", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+
+    // Create multiple rounds of messages with different orders
+    const { messages: round1 } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        { message: { role: "user", content: "message order 0, step 0" } },
+        { message: { role: "assistant", content: "message order 0, step 1" } },
+      ],
+    });
+
+    const { messages: round2 } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        { message: { role: "user", content: "message order 1, step 0" } },
+        { message: { role: "assistant", content: "message order 1, step 1" } },
+      ],
+    });
+
+    const { messages: round3 } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        { message: { role: "user", content: "message order 2, step 0" } },
+      ],
+    });
+
+    // Delete messages in order range 0 to 1 (exclusive)
+    const result = await t.mutation(api.messages.deleteByOrder, {
+      threadId: thread._id as Id<"threads">,
+      startOrder: 0,
+      endOrder: 1,
+    });
+
+    expect(result.isDone).toBe(true);
+    expect(result.lastOrder).toBe(0);
+    expect(result.lastStepOrder).toBe(1);
+
+    // Verify only messages from order 0 were deleted
+    const remainingMessages = await t.query(
+      api.messages.listMessagesByThreadId,
+      {
+        threadId: thread._id as Id<"threads">,
+        order: "asc",
+      }
+    );
+
+    expect(remainingMessages.page).toHaveLength(3); // Should have messages from order 1 and 2
+    expect(remainingMessages.page.map((m) => m.order)).toEqual([1, 1, 2]);
+  });
+
+  test("deleteByOrder handles step order boundaries correctly", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+
+    // Create messages with the same order but different step orders
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        { message: { role: "user", content: "step 0" } },
+        { message: { role: "assistant", content: "step 1" } },
+        { message: { role: "user", content: "step 2" } },
+        { message: { role: "assistant", content: "step 3" } },
+      ],
+    });
+
+    // Delete messages from step 1 to step 3 (exclusive)
+    const result = await t.mutation(api.messages.deleteByOrder, {
+      threadId: thread._id as Id<"threads">,
+      startOrder: 0,
+      startStepOrder: 1,
+      endOrder: 0,
+      endStepOrder: 3,
+    });
+
+    expect(result.isDone).toBe(true);
+    expect(result.lastOrder).toBe(0);
+    expect(result.lastStepOrder).toBe(2);
+
+    // Verify only step 1 and 2 were deleted (step 3 is excluded by upperBoundInclusive: false)
+    const remainingMessages = await t.query(
+      api.messages.listMessagesByThreadId,
+      {
+        threadId: thread._id as Id<"threads">,
+        order: "asc",
+      }
+    );
+
+    expect(remainingMessages.page).toHaveLength(2);
+    expect(remainingMessages.page.map((m) => m.stepOrder)).toEqual([0, 3]);
+  });
+
+  test("deleteByOrder returns isDone false when batch limit is reached", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+
+    // This test would be more realistic with 65+ messages, but for test efficiency
+    // we'll just verify the basic structure works with fewer messages
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        { message: { role: "user", content: "message 1" } },
+        { message: { role: "assistant", content: "message 2" } },
+      ],
+    });
+
+    const result = await t.mutation(api.messages.deleteByOrder, {
+      threadId: thread._id as Id<"threads">,
+      startOrder: 0,
+      endOrder: 2,
+    });
+
+    // With only 2 messages, should be done
+    expect(result.isDone).toBe(true);
+    expect(result.lastOrder).toBe(0);
+    expect(result.lastStepOrder).toBe(1);
+  });
+
+  test("deleteByOrder handles empty result set", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [{ message: { role: "user", content: "message order 0" } }],
+    });
+
+    // Try to delete from a range that doesn't exist
+    const result = await t.mutation(api.messages.deleteByOrder, {
+      threadId: thread._id as Id<"threads">,
+      startOrder: 5,
+      endOrder: 10,
+    });
+
+    expect(result.isDone).toBe(true);
+    expect(result.lastOrder).toBeUndefined();
+    expect(result.lastStepOrder).toBeUndefined();
+
+    // Verify original message is still there
+    const remainingMessages = await t.query(
+      api.messages.listMessagesByThreadId,
+      {
+        threadId: thread._id as Id<"threads">,
+        order: "asc",
+      }
+    );
+    expect(remainingMessages.page).toHaveLength(1);
+  });
 });

package/src/component/messages.ts

@@ -39,6 +39,7 @@ import {
   type VectorTableId,
   vVectorId,
 } from "./vector/tables.js";
+import { changeRefcount } from "./files.js";
 
 /** @deprecated Use *.threads.listMessagesByThreadId instead. */
 export const listThreadsByUserId = _listThreadsByUserId;
@@ -61,31 +62,28 @@ export async function deleteMessage(
   if (messageDoc.embeddingId) {
     await ctx.db.delete(messageDoc.embeddingId);
   }
-  for (const fileId of messageDoc.fileIds ?? []) {
-    if (!fileId) continue;
-    const file = await ctx.db.get(fileId);
-    if (file) {
-      await ctx.db.patch(fileId, { refcount: file.refcount - 1 });
-    }
+  if (messageDoc.fileIds) {
+    await changeRefcount(ctx, messageDoc.fileIds, []);
   }
 }
 
-export const deleteMessages = mutation({
+export const deleteByIds = mutation({
   args: {
     messageIds: v.array(v.id("messages")),
   },
-  returns: v.null(),
+  returns: v.array(v.id("messages")),
   handler: async (ctx, args) => {
-    await Promise.all(
+    const deletedMessageIds = await Promise.all(
       args.messageIds.map(async (id) => {
         const message = await ctx.db.get(id);
         if (message) {
           await deleteMessage(ctx, message);
-        } else {
-          console.warn(`Message ${id} not found when trying to delete`);
+          return id;
         }
+        return null;
       })
     );
+    return deletedMessageIds.filter((id) => id !== null);
   },
 });
 
@@ -93,6 +91,46 @@ export const messageStatuses = vMessageDoc.fields.status.members.map(
   (m) => m.value
 );
 
+export const deleteByOrder = mutation({
+  args: {
+    threadId: v.id("threads"),
+    startOrder: v.number(),
+    startStepOrder: v.optional(v.number()),
+    endOrder: v.number(),
+    endStepOrder: v.optional(v.number()),
+  },
+  returns: v.object({
+    isDone: v.boolean(),
+    lastOrder: v.optional(v.number()),
+    lastStepOrder: v.optional(v.number()),
+  }),
+  handler: async (ctx, args) => {
+    const messages = await orderedMessagesStream(
+      ctx,
+      args.threadId,
+      "asc",
+      args.startOrder
+    )
+      .narrow({
+        lowerBound: args.startStepOrder
+          ? [args.startOrder, args.startStepOrder]
+          : [args.startOrder],
+        lowerBoundInclusive: true,
+        upperBound: args.endStepOrder
+          ? [args.endOrder, args.endStepOrder]
+          : [args.endOrder],
+        upperBoundInclusive: false,
+      })
+      .take(64);
+    await Promise.all(messages.map((m) => deleteMessage(ctx, m)));
+    return {
+      isDone: messages.length < 64,
+      lastOrder: messages[messages.length - 1]?.order,
+      lastStepOrder: messages[messages.length - 1]?.stepOrder,
+    };
+  },
+});
+
 const addMessagesArgs = {
   userId: v.optional(v.string()),
   threadId: v.id("threads"),
@@ -201,11 +239,8 @@ async function addMessagesHandler(
     //     id: messageId,
     //   });
     // }
-    for (const fileId of message.fileIds ?? []) {
-      if (!fileId) continue;
-      await ctx.db.patch(fileId, {
-        refcount: (await ctx.db.get(fileId))!.refcount + 1,
-      });
+    if (message.fileIds) {
+      await changeRefcount(ctx, [], message.fileIds);
     }
     // TODO: delete the associated stream data for the order/stepOrder
     toReturn.push((await ctx.db.get(messageId))!);
@@ -291,6 +326,7 @@ export const updateMessage = mutation({
     messageId: v.id("messages"),
     patch: v.object({
       message: v.optional(vMessageDoc.fields.message),
+      fileIds: v.optional(v.array(v.id("files"))),
       status: v.optional(vMessageStatus),
       error: v.optional(v.string()),
     }),
@@ -300,6 +336,10 @@ export const updateMessage = mutation({
     const message = await ctx.db.get(args.messageId);
     assert(message, `Message ${args.messageId} not found`);
 
+    if (args.patch.fileIds) {
+      await changeRefcount(ctx, message.fileIds ?? [], args.patch.fileIds);
+    }
+
     const patch: Partial<Doc<"messages">> = {
       ...args.patch,
     };

package/src/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"3.2.4","results":[[":client/index.test.ts",{"duration":60.55858325958252,"failed":false}],[":component/messages.test.ts",{"duration":27.41837501525879,"failed":false}]]}