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

package/src/component/apiKeys.ts

@@ -13,7 +13,7 @@ export const issue = mutation({
         .first();
       if (existingApiKey) {
         console.warn(`API key ${args.name} already exists, deleting...`);
-        await ctx.db.delete(existingApiKey._id);
+        await ctx.db.delete("apiKeys", existingApiKey._id);
       }
     }
     const apiKey = await ctx.db.insert("apiKeys", args);
@@ -27,7 +27,7 @@ export const validate = query({
     apiKey: v.id("apiKeys"),
   },
   handler: async (ctx, args) => {
-    const apiKey = await ctx.db.get(args.apiKey);
+    const apiKey = await ctx.db.get("apiKeys", args.apiKey);
     if (!apiKey) {
       throw new Error("Invalid API key");
     }
@@ -43,14 +43,14 @@ export const destroy = mutation({
   }),
   handler: async (ctx, args) => {
     if (args.apiKey) {
-      const apiKey = await ctx.db.get(args.apiKey);
+      const apiKey = await ctx.db.get("apiKeys", args.apiKey);
       if (!apiKey) {
         return "missing";
       }
       if (apiKey.name !== args.name) {
         return "name mismatch";
       }
-      await ctx.db.delete(args.apiKey);
+      await ctx.db.delete("apiKeys", args.apiKey);
     } else if (args.name) {
       const apiKey = await ctx.db
         .query("apiKeys")
@@ -59,7 +59,7 @@ export const destroy = mutation({
       if (!apiKey) {
         return "missing";
       }
-      await ctx.db.delete(apiKey._id);
+      await ctx.db.delete("apiKeys", apiKey._id);
     } else {
       return "must provide either apiKey or name";
     }

package/src/component/files.test.ts

@@ -96,7 +96,7 @@ describe("files", () => {
       });
       // Manually set refcount to 0
       await t.run(async (ctx) => {
-        await ctx.db.patch(fileId, { refcount: 0 });
+        await ctx.db.patch("files", fileId, { refcount: 0 });
       });
       files.push(fileId);
     }

package/src/component/files.ts

@@ -29,15 +29,16 @@ export async function addFileHandler(
 ) {
   // Support both mediaType (preferred) and mimeType (deprecated)
   const mediaType = args.mediaType ?? args.mimeType;
-  
+
   const existingFile = await ctx.db
     .query("files")
     .withIndex("hash", (q) => q.eq("hash", args.hash))
+    // eslint-disable-next-line @convex-dev/no-filter-in-query -- We do not expect many files with the same hash and different filenames
     .filter((q) => q.eq(q.field("filename"), args.filename))
     .first();
   if (existingFile) {
     // increment the refcount
-    await ctx.db.patch(existingFile._id, {
+    await ctx.db.patch("files", existingFile._id, {
       refcount: existingFile.refcount + 1,
       lastTouchedAt: Date.now(),
     });
@@ -68,7 +69,7 @@ export const get = query({
   },
   returns: v.union(v.null(), v.doc("files")),
   handler: async (ctx, args) => {
-    return ctx.db.get(args.fileId);
+    return ctx.db.get("files", args.fileId);
   },
 });
 
@@ -87,12 +88,13 @@ export const useExistingFile = mutation({
     const file = await ctx.db
       .query("files")
       .withIndex("hash", (q) => q.eq("hash", args.hash))
+      // eslint-disable-next-line @convex-dev/no-filter-in-query -- We do not expect many files with the same hash and different filenames
       .filter((q) => q.eq(q.field("filename"), args.filename))
       .first();
     if (!file) {
       return null;
     }
-    await ctx.db.patch(file._id, {
+    await ctx.db.patch("files", file._id, {
       lastTouchedAt: Date.now(),
     });
     return { fileId: file._id, storageId: file.storageId };
@@ -115,9 +117,9 @@ export async function changeRefcount(
   const nextSet = new Set(next);
   for (const fileId of prevSet) {
     if (!nextSet.has(fileId)) {
-      const file = await ctx.db.get(fileId);
+      const file = await ctx.db.get("files", fileId);
       if (file) {
-        await ctx.db.patch(fileId, {
+        await ctx.db.patch("files", fileId, {
           refcount: file.refcount - 1,
         });
       } else {
@@ -127,9 +129,9 @@ export async function changeRefcount(
   }
   for (const fileId of nextSet) {
     if (!prevSet.has(fileId)) {
-      const file = await ctx.db.get(fileId);
+      const file = await ctx.db.get("files", fileId);
       if (file) {
-        await ctx.db.patch(fileId, {
+        await ctx.db.patch("files", fileId, {
           refcount: file.refcount + 1,
         });
       } else {
@@ -151,11 +153,11 @@ export async function copyFileHandler(
   ctx: MutationCtx,
   args: { fileId: Id<"files"> },
 ) {
-  const file = await ctx.db.get(args.fileId);
+  const file = await ctx.db.get("files", args.fileId);
   if (!file) {
     throw new Error("File not found");
   }
-  await ctx.db.patch(args.fileId, {
+  await ctx.db.patch("files", args.fileId, {
     refcount: file.refcount + 1,
     lastTouchedAt: Date.now(),
   });
@@ -195,7 +197,7 @@ export const deleteFiles = mutation({
   handler: async (ctx, args) => {
     const deletedFileIds = await Promise.all(
       args.fileIds.map(async (fileId) => {
-        const file = await ctx.db.get(fileId);
+        const file = await ctx.db.get("files", fileId);
         if (!file) {
           console.error(`File ${fileId} not found when deleting, skipping...`);
           return null;
@@ -208,7 +210,7 @@ export const deleteFiles = mutation({
             return null;
           }
         }
-        await ctx.db.delete(fileId);
+        await ctx.db.delete("files", fileId);
         return fileId;
       }),
     );

package/src/component/messages.test.ts

@@ -1,7 +1,7 @@
 /// <reference types="vite/client" />
 
 import { convexTest } from "convex-test";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { api } from "./_generated/api.js";
 import type { Id } from "./_generated/dataModel.js";
 import { getMaxMessage } from "./messages.js";
@@ -652,4 +652,276 @@ describe("agent", () => {
     );
     expect(remainingMessages.page).toHaveLength(1);
   });
+
+  // Regression test for #256: when searching across threads with
+  // searchAllMessagesForUserId, the targetMessage's order should not filter
+  // out messages from other threads (their order sequences are independent).
+  test("textSearch returns cross-thread matches even when target order is lower", async () => {
+    const t = convexTest(schema, modules);
+    const userId = "user-256";
+
+    // Old thread: build up several messages so the matching one has a high order.
+    const oldThread = await t.mutation(api.threads.createThread, { userId });
+    for (let i = 0; i < 5; i++) {
+      await t.mutation(api.messages.addMessages, {
+        threadId: oldThread._id as Id<"threads">,
+        userId,
+        messages: [
+          { message: { role: "user", content: `filler message ${i}` } },
+        ],
+      });
+    }
+    await t.mutation(api.messages.addMessages, {
+      threadId: oldThread._id as Id<"threads">,
+      userId,
+      messages: [
+        {
+          message: {
+            role: "user",
+            content:
+              "tom and jerry are both amazing high-ticket coaches and educators",
+          },
+        },
+      ],
+    });
+
+    // New thread: only one message — its order will be 0, lower than the
+    // matching message in the old thread.
+    const newThread = await t.mutation(api.threads.createThread, { userId });
+    const { messages: newMessages } = await t.mutation(
+      api.messages.addMessages,
+      {
+        threadId: newThread._id as Id<"threads">,
+        userId,
+        messages: [
+          {
+            message: {
+              role: "user",
+              content: "what do you remember about high-ticket coaches",
+            },
+          },
+        ],
+      },
+    );
+    const targetMessageId = newMessages[0]._id as Id<"messages">;
+
+    const results = await t.query(api.messages.textSearch, {
+      searchAllMessagesForUserId: userId,
+      targetMessageId,
+      text: "high-ticket coaches",
+      limit: 10,
+    });
+
+    // The cross-thread match should NOT be filtered out by the target's order.
+    expect(
+      results.some((m) =>
+        m.text?.includes("tom and jerry are both amazing high-ticket coaches"),
+      ),
+    ).toBe(true);
+    // The target message itself must still be excluded.
+    expect(results.some((m) => m._id === targetMessageId)).toBe(false);
+  });
+
+  // Regression test for #256: same-thread order filter must still work even
+  // when searching across threads.
+  test("textSearch still filters same-thread results past the target order", async () => {
+    const t = convexTest(schema, modules);
+    const userId = "user-256-same";
+
+    const thread = await t.mutation(api.threads.createThread, { userId });
+    // earlier match
+    await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      userId,
+      messages: [
+        { message: { role: "user", content: "earlier high-ticket match" } },
+      ],
+    });
+    // target
+    const { messages: targetMessages } = await t.mutation(
+      api.messages.addMessages,
+      {
+        threadId: thread._id as Id<"threads">,
+        userId,
+        messages: [
+          { message: { role: "user", content: "target high-ticket message" } },
+        ],
+      },
+    );
+    // later match in same thread — should be filtered out
+    await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      userId,
+      messages: [
+        { message: { role: "user", content: "later high-ticket match" } },
+      ],
+    });
+
+    const results = await t.query(api.messages.textSearch, {
+      searchAllMessagesForUserId: userId,
+      targetMessageId: targetMessages[0]._id as Id<"messages">,
+      text: "high-ticket",
+      limit: 10,
+    });
+
+    expect(results.some((m) => m.text === "earlier high-ticket match")).toBe(
+      true,
+    );
+    expect(results.some((m) => m.text === "later high-ticket match")).toBe(
+      false,
+    );
+    expect(results.some((m) => m._id === targetMessages[0]._id)).toBe(false);
+  });
+
+  test("finalizeMessage commits a failed pending message when stream recovery is malformed", async () => {
+    const t = initConvexTest();
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "recovery-user",
+    });
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        {
+          message: { role: "assistant", content: [] },
+          status: "pending",
+        },
+      ],
+    });
+    const pending = messages[0];
+    const streamId = await t.run(async (ctx) =>
+      ctx.db.insert("streamingMessages", {
+        threadId: thread._id as Id<"threads">,
+        order: pending.order,
+        stepOrder: pending.stepOrder,
+        format: "UIMessageChunk",
+        state: { kind: "aborted", reason: "interrupted" },
+      }),
+    );
+    await t.run(async (ctx) =>
+      ctx.db.insert("streamDeltas", {
+        streamId,
+        start: 0,
+        end: 1,
+        parts: [{ type: "text-delta", id: "missing", delta: "partial" }],
+      }),
+    );
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      await expect(
+        t.mutation(api.messages.finalizeMessage, {
+          messageId: pending._id as Id<"messages">,
+          result: { status: "success" },
+        }),
+      ).resolves.toBeNull();
+    } finally {
+      errorSpy.mockRestore();
+    }
+
+    const finalized = await t.run((ctx) =>
+      ctx.db.get("messages", pending._id as Id<"messages">),
+    );
+    expect(finalized).toMatchObject({
+      status: "failed",
+      error: "Failed to recover persisted assistant stream output",
+      message: { role: "assistant", content: [] },
+    });
+  });
+
+  test("finalizeMessage discards all recovered output when any stream is malformed", async () => {
+    const t = initConvexTest();
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "mixed-recovery-user",
+    });
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        {
+          message: { role: "assistant", content: [] },
+          status: "pending",
+        },
+      ],
+    });
+    const pending = messages[0];
+    const embeddingId = await t.run(async (ctx) =>
+      ctx.db.insert("embeddings_128", {
+        model: "embedding-model",
+        table: "messages",
+        threadId: thread._id,
+        vector: Array.from({ length: 128 }, () => 0),
+      }),
+    );
+    await t.run((ctx) =>
+      ctx.db.patch("messages", pending._id as Id<"messages">, { embeddingId }),
+    );
+
+    const validStreamId = await t.run(async (ctx) =>
+      ctx.db.insert("streamingMessages", {
+        threadId: thread._id as Id<"threads">,
+        order: pending.order,
+        stepOrder: pending.stepOrder,
+        format: "UIMessageChunk",
+        state: { kind: "finished", endedAt: Date.now() },
+      }),
+    );
+    await t.run(async (ctx) =>
+      ctx.db.insert("streamDeltas", {
+        streamId: validStreamId,
+        start: 0,
+        end: 3,
+        parts: [
+          { type: "text-start", id: "valid" },
+          { type: "text-delta", id: "valid", delta: "must not be inserted" },
+          { type: "text-end", id: "valid" },
+        ],
+      }),
+    );
+    const malformedStreamId = await t.run(async (ctx) =>
+      ctx.db.insert("streamingMessages", {
+        threadId: thread._id as Id<"threads">,
+        order: pending.order,
+        stepOrder: pending.stepOrder,
+        format: "UIMessageChunk",
+        state: { kind: "aborted", reason: "interrupted" },
+      }),
+    );
+    await t.run(async (ctx) =>
+      ctx.db.insert("streamDeltas", {
+        streamId: malformedStreamId,
+        start: 0,
+        end: 1,
+        parts: [
+          {
+            type: "tool-input-delta",
+            toolCallId: "missing",
+            inputTextDelta: "{}",
+          },
+        ],
+      }),
+    );
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      await t.mutation(api.messages.finalizeMessage, {
+        messageId: pending._id as Id<"messages">,
+        result: { status: "failed", error: "provider failed" },
+      });
+    } finally {
+      errorSpy.mockRestore();
+    }
+
+    const state = await t.run(async (ctx) => ({
+      messages: await ctx.db.query("messages").collect(),
+      embedding: await ctx.db.get("embeddings_128", embeddingId),
+    }));
+    expect(state.messages).toHaveLength(1);
+    expect(state.messages[0]).toMatchObject({
+      _id: pending._id,
+      status: "failed",
+      error: "provider failed",
+      message: { role: "assistant", content: [] },
+    });
+    expect(state.messages[0].embeddingId).toBeUndefined();
+    expect(state.embedding).toBeNull();
+  });
 });