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

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();
+  });
 });

package/src/component/messages.ts

@@ -83,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"),
@@ -390,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,
@@ -409,15 +437,7 @@ export const finalizeMessage = mutation({
       }
     }
     if (result.status === "failed") {
-      if (message.embeddingId) {
-        const { tableName } = getVectorIdInfo(ctx, message.embeddingId);
-        await ctx.db.delete(tableName, message.embeddingId);
-      }
-      await ctx.db.patch("messages", messageId, {
-        status: "failed",
-        error: result.error,
-        embeddingId: undefined,
-      });
+      await markPendingMessageFailed(ctx, message, result.error);
     } else {
       await ctx.db.patch("messages", messageId, { status: "success" });
     }
@@ -830,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
@@ -922,12 +944,16 @@ export const textSearch = query({
     const targetMessage =
       args.targetMessageId &&
       (await ctx.db.get("messages", args.targetMessageId));
-    const order = targetMessage?.order;
     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) =>
@@ -939,20 +965,24 @@ export const textSearch = query({
       // 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),

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;
@@ -536,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,
@@ -544,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 {

package/src/eslintConfig.test.ts

@@ -0,0 +1,44 @@
+import { Linter } from "eslint";
+import { describe, expect, it } from "vitest";
+
+describe("provider adapter boundary lint selectors", () => {
+  it("parse on Node 20 and reject every restricted dynamic import shape", async () => {
+    const configUrl = new URL("../eslint.config.js", import.meta.url).href;
+    const { default: eslintConfig } = (await import(configUrl)) as {
+      default: Array<{
+        files?: string[];
+        rules?: Record<string, unknown>;
+      }>;
+    };
+    const boundaryConfig = eslintConfig.find(
+      (config) =>
+        "files" in config &&
+        config.files?.some((pattern) => pattern.includes("src/streaming/")) &&
+        config.rules?.["no-restricted-syntax"],
+    );
+    const restrictedSyntax = boundaryConfig?.rules?.["no-restricted-syntax"];
+    expect(restrictedSyntax).toBeDefined();
+
+    const messages = new Linter({ configType: "flat" }).verify(
+      [
+        'import("ai");',
+        'import("ai/test");',
+        'import("@ai-sdk/provider");',
+        'import("vercel");',
+        'import("vercel/test");',
+        'import("../vercel");',
+        'import("../vercel/test");',
+      ].join("\n"),
+      {
+        languageOptions: { ecmaVersion: 2020, sourceType: "module" },
+        rules: {
+          "no-restricted-syntax": restrictedSyntax as Linter.RuleEntry,
+        },
+      },
+    );
+
+    expect(messages).toHaveLength(7);
+    expect(messages.every((message) => message.ruleId === "no-restricted-syntax"))
+      .toBe(true);
+  });
+});

package/src/react/index.ts

@@ -1,17 +1,20 @@
 "use client";
 import { useMemo, useState } from "react";
-export { toUIMessages, type UIMessage } from "../UIMessages.js";
+export { toUIMessages, type UIMessage } from "../vercel/UIMessages.js";
 
-export { optimisticallySendMessage } from "./optimisticallySendMessage.js";
+export { optimisticallySendMessage } from "../vercel/react/optimisticallySendMessage.js";
 export { useSmoothText } from "./useSmoothText.js";
 export { SmoothText } from "./SmoothText.js";
 export {
   type ThreadMessagesQuery,
   useThreadMessages,
   useStreamingThreadMessages,
-} from "./useThreadMessages.js";
-export { type UIMessagesQuery, useUIMessages } from "./useUIMessages.js";
-export { useStreamingUIMessages } from "./useStreamingUIMessages.js";
+} from "../vercel/react/useThreadMessages.js";
+export {
+  type UIMessagesQuery,
+  useUIMessages,
+} from "../vercel/react/useUIMessages.js";
+export { useStreamingUIMessages } from "../vercel/react/useStreamingUIMessages.js";
 
 /**
  * @deprecated use useThreadMessages or useStreamingThreadMessages instead