@convex-dev/agent 0.6.0 → 0.6.2

package/package.json

@@ -7,7 +7,7 @@
     "email": "support@convex.dev",
     "url": "https://github.com/get-convex/agent/issues"
   },
-  "version": "0.6.0",
+  "version": "0.6.2",
   "license": "Apache-2.0",
   "keywords": [
     "convex",
@@ -18,26 +18,23 @@
   "type": "module",
   "scripts": {
     "setup": "node setup.cjs --init",
-    "dev": "run-p -r 'dev:*'",
-    "dev:backend": "convex dev --typecheck-components",
+    "dev": "convex dev --start 'npm run dev:build'",
     "dev:frontend": "cd example && vite --clearScreen false",
     "dev:build": "chokidar 'tsconfig*.json' 'src/**/*.ts' -i '**/*.test.ts' -c 'npm run build:codegen' --initial",
-    "predev": "path-exists .env.local dist || (npm run build && convex dev --once)",
+    "predev": "convex init && npm run build:codegen",
     "build": "tsc --project ./tsconfig.build.json",
     "build:codegen": "npx convex codegen --component-dir ./src/component && npm run build",
     "build:clean": "rm -rf dist *.tsbuildinfo && npm run build:codegen",
     "typecheck": "tsc --noEmit && tsc -p example && tsc -p example/convex",
     "lint": "eslint .",
-    "all": "run-p -r 'dev:*' 'test:watch'",
     "test": "vitest run --typecheck",
     "test:watch": "vitest --typecheck --clearScreen false",
     "test:debug": "vitest --inspect-brk --no-file-parallelism",
     "test:coverage": "vitest run --coverage --coverage.reporter=text",
-    "preversion": "npm ci && npm run build:clean && run-p test lint typecheck",
-    "prepublishOnly": "npm whoami || npm login",
+    "preversion": "npm ci && npm run build:clean && npm run test && npm run lint && npm run typecheck",
     "alpha": "npm version prerelease --preid alpha && npm publish --tag alpha && git push --follow-tags",
     "release": "npm version patch && npm publish && git push --follow-tags",
-    "version": "vim -c 'normal o' -c 'normal o## '$npm_package_version CHANGELOG.md && prettier -w CHANGELOG.md && git add CHANGELOG.md"
+    "version": "(npm whoami || npm login) && vim -c 'normal o' -c 'normal o## '$npm_package_version CHANGELOG.md && prettier -w CHANGELOG.md && git add CHANGELOG.md"
   },
   "files": [
     "dist",
@@ -84,67 +81,64 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/anthropic": "^3.0.13",
-    "@ai-sdk/google": "^3.0.30",
-    "@ai-sdk/groq": "^3.0.8",
-    "@ai-sdk/openai": "^3.0.10",
-    "@ai-sdk/provider": "^3.0.3",
-    "@ai-sdk/provider-utils": "^4.0.6",
-    "@convex-dev/rag": "0.7.0",
-    "@convex-dev/rate-limiter": "0.3.0",
-    "@convex-dev/workflow": "0.3.2",
+    "@ai-sdk/anthropic": "3.0.13",
+    "@ai-sdk/google": "3.0.30",
+    "@ai-sdk/groq": "3.0.8",
+    "@ai-sdk/openai": "3.0.10",
+    "@ai-sdk/provider": "3.0.3",
+    "@ai-sdk/provider-utils": "4.0.6",
+    "@convex-dev/rag": "0.7.2",
+    "@convex-dev/rate-limiter": "0.3.2",
+    "@convex-dev/workflow": "0.3.6",
     "@edge-runtime/vm": "5.0.0",
-    "@eslint/js": "9.38.0",
+    "@eslint/js": "9.39.4",
     "@hookform/resolvers": "5.2.2",
-    "@langchain/textsplitters": "0.1.0",
+    "@langchain/textsplitters": "1.0.1",
     "@radix-ui/react-accordion": "1.2.12",
     "@radix-ui/react-checkbox": "1.3.3",
-    "@radix-ui/react-label": "2.1.7",
+    "@radix-ui/react-label": "2.1.8",
     "@radix-ui/react-select": "2.2.6",
-    "@radix-ui/react-slot": "1.2.3",
+    "@radix-ui/react-slot": "1.2.4",
     "@radix-ui/react-toast": "1.2.15",
     "@tailwindcss/typography": "0.5.19",
-    "@types/node": "20.19.24",
-    "@types/react": "19.2.2",
-    "@types/react-dom": "19.2.2",
+    "@types/node": "20.19.37",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
     "@vitejs/plugin-react": "4.7.0",
-    "ai": "^6.0.35",
-    "autoprefixer": "10.4.21",
+    "ai": "6.0.35",
+    "autoprefixer": "10.4.27",
     "chokidar-cli": "3.0.0",
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
-    "convex": "1.29.3",
-    "convex-helpers": "0.1.104",
-    "convex-test": "0.0.38",
-    "cpy-cli": "5.0.0",
-    "dayjs": "1.11.18",
+    "convex": "1.35.1",
+    "convex-helpers": "0.1.114",
+    "convex-test": "0.0.44",
+    "dayjs": "1.11.20",
     "dotenv": "16.6.1",
-    "eslint": "9.38.0",
+    "eslint": "9.39.4",
     "eslint-plugin-jsx-a11y": "6.10.2",
     "eslint-plugin-react": "7.37.5",
-    "eslint-plugin-react-hooks": "^6",
-    "eslint-plugin-react-refresh": "0.4.24",
-    "globals": "16.4.0",
-    "lucide-react": "0.548.0",
-    "npm-run-all2": "8.0.4",
-    "ollama-ai-provider": "^1.2.0",
+    "eslint-plugin-react-hooks": "6.1.1",
+    "eslint-plugin-react-refresh": "0.5.2",
+    "globals": "16.5.0",
+    "lucide-react": "0.577.0",
+    "ollama-ai-provider": "1.2.0",
     "openai": "5.23.2",
-    "path-exists-cli": "^2.0.0",
-    "pkg-pr-new": "0.0.60",
-    "postcss": "8.5.6",
-    "prettier": "3.6.2",
-    "react": "19.2.3",
-    "react-dom": "19.2.3",
-    "react-hook-form": "7.65.0",
+    "pkg-pr-new": "0.0.66",
+    "postcss": "8.5.10",
+    "prettier": "3.8.1",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "react-hook-form": "7.71.2",
     "react-markdown": "10.1.0",
-    "react-router-dom": "7.9.5",
+    "react-router-dom": "7.13.1",
     "readline": "1.3.0",
-    "tailwind-merge": "3.3.1",
-    "tailwindcss": "3.4.18",
+    "tailwind-merge": "3.5.0",
+    "tailwindcss": "3.4.19",
     "tailwindcss-animate": "1.0.7",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.46.2",
-    "vite": "6.4.1",
+    "typescript-eslint": "8.57.1",
+    "vite": "6.4.2",
     "vitest": "3.2.4",
     "zod": "3.25.76"
   },

package/src/UIMessages.ts

@@ -396,8 +396,6 @@ function createAssistantUIMessage<
     ? ("streaming" as const)
     : lastMessage.status;
 
-<<<<<<< Updated upstream
-=======
   // Extract approval parts from raw message content for UI rendering
   type ApprovalPart =
     | { type: "tool-approval-request"; approvalId: string; toolCallId: string }
@@ -443,7 +441,6 @@ function createAssistantUIMessage<
     }
   }
 
->>>>>>> Stashed changes
   // Collect all parts from all messages
   const allParts: UIMessage<METADATA, DATA_PARTS, TOOLS>["parts"] = [];
 
@@ -525,12 +522,9 @@ function createAssistantUIMessage<
           break;
         }
         case "tool-result": {
-<<<<<<< Updated upstream
-=======
           // Note: execution-denied outputs are handled separately via pre-extraction
           // from raw content (converted to text format for providers in start.ts).
           // See executionDeniedResults processing at the end of this function.
->>>>>>> Stashed changes
           const typedPart = contentPart as unknown as ToolResultPart & {
             output: { type: string; value?: unknown; reason?: string };
           };
@@ -696,8 +690,6 @@ function createAssistantUIMessage<
     }
   }
 
-<<<<<<< Updated upstream
-=======
   // Final output states that should not be overwritten by approval processing
   const finalStates = new Set([
     "output-available",
@@ -776,7 +768,6 @@ function createAssistantUIMessage<
     }
   }
 
->>>>>>> Stashed changes
   return {
     ...common,
     role: "assistant",

package/src/client/approval.test.ts

@@ -57,6 +57,17 @@ function getApprovalIdFromSavedMessages(
   return approvalRequest.approvalId;
 }
 
+// Second tool that also requires approval
+const renameFileTool = createTool({
+  description: "Rename a file",
+  inputSchema: z.object({
+    oldName: z.string(),
+    newName: z.string(),
+  }),
+  needsApproval: () => true,
+  execute: async (_ctx, input) => `Renamed: ${input.oldName} → ${input.newName}`,
+});
+
 // --- Agents (separate mock model instances to avoid shared callIndex) ---
 
 const approvalAgent = new Agent(components.agent, {
@@ -257,6 +268,114 @@ export const testApproveFlowWithInterveningMessage = action({
   },
 });
 
+// Agent that calls two tools in one step, both needing approval
+const multiToolAgent = new Agent(components.agent, {
+  name: "multi-tool-test",
+  instructions: "You manage files.",
+  tools: { deleteFile: deleteFileTool, renameFile: renameFileTool },
+  languageModel: mockModel({
+    contentSteps: [
+      // Step 1: model calls two tools at once
+      [
+        {
+          type: "tool-call",
+          toolCallId: "tc-multi-1",
+          toolName: "deleteFile",
+          input: JSON.stringify({ filename: "old.txt" }),
+        },
+        {
+          type: "tool-call",
+          toolCallId: "tc-multi-2",
+          toolName: "renameFile",
+          input: JSON.stringify({ oldName: "a.txt", newName: "b.txt" }),
+        },
+      ],
+      // Step 2: after both tools execute, model responds
+      [{ type: "text", text: "Done! Deleted old.txt and renamed a.txt to b.txt." }],
+    ],
+  }),
+  stopWhen: stepCountIs(5),
+  usageHandler: testUsageHandler,
+});
+
+export const testMultiToolApproveFlow = action({
+  args: {},
+  handler: async (ctx) => {
+    const { thread } = await multiToolAgent.createThread(ctx, {
+      userId: "u-multi",
+    });
+
+    // Step 1: Generate — model calls two tools, both need approval
+    const result1 = await thread.generateText({
+      prompt: "Delete old.txt and rename a.txt to b.txt",
+    });
+
+    // Extract both approval IDs
+    const approvalParts = result1.savedMessages
+      ?.flatMap((m) =>
+        Array.isArray(m.message?.content)
+          ? (m.message.content as unknown[])
+          : [],
+      )
+      .filter(
+        (
+          p,
+        ): p is {
+          type: "tool-approval-request";
+          approvalId: string;
+          toolCallId: string;
+        } => (p as { type?: string }).type === "tool-approval-request",
+      );
+
+    if (!approvalParts || approvalParts.length !== 2) {
+      throw new Error(
+        `Expected 2 approval requests, got ${approvalParts?.length ?? 0}`,
+      );
+    }
+
+    // Approve both tool calls
+    const { messageId: _msgId1 } = await ctx.runMutation(
+      anyApi["approval.test"].submitApprovalForMultiToolAgent,
+      { threadId: thread.threadId, approvalId: approvalParts[0].approvalId },
+    );
+    const { messageId: msgId2 } = await ctx.runMutation(
+      anyApi["approval.test"].submitApprovalForMultiToolAgent,
+      { threadId: thread.threadId, approvalId: approvalParts[1].approvalId },
+    );
+
+    // Continue generation with the last approval message
+    const result2 = await thread.generateText({
+      promptMessageId: msgId2,
+    });
+
+    const allMessages = await multiToolAgent.listMessages(ctx, {
+      threadId: thread.threadId,
+      paginationOpts: { cursor: null, numItems: 40 },
+    });
+
+    return {
+      approvalCount: approvalParts.length,
+      firstText: result1.text,
+      secondText: result2.text,
+      threadMessageRoles: allMessages.page.map((m) => m.message?.role),
+      // Check that both approvals were merged into one tool message
+      toolMessageCount: allMessages.page.filter(
+        (m) => m.message?.role === "tool",
+      ).length,
+    };
+  },
+});
+
+export const submitApprovalForMultiToolAgent = mutation({
+  args: {
+    threadId: v.string(),
+    approvalId: v.string(),
+  },
+  handler: async (ctx, { threadId, approvalId }) => {
+    return multiToolAgent.approveToolCall(ctx, { threadId, approvalId });
+  },
+});
+
 export const submitApprovalForApprovalAgent = mutation({
   args: { threadId: v.string(), approvalId: v.string(), reason: v.optional(v.string()) },
   handler: async (ctx, { threadId, approvalId, reason }) => {
@@ -276,7 +395,9 @@ const testApi: ApiFromModules<{
     testApproveFlow: typeof testApproveFlow;
     testDenyFlow: typeof testDenyFlow;
     testApproveFlowWithInterveningMessage: typeof testApproveFlowWithInterveningMessage;
+    testMultiToolApproveFlow: typeof testMultiToolApproveFlow;
     submitApprovalForApprovalAgent: typeof submitApprovalForApprovalAgent;
+    submitApprovalForMultiToolAgent: typeof submitApprovalForMultiToolAgent;
     submitDenialForDenialAgent: typeof submitDenialForDenialAgent;
   };
 }>["fns"] = anyApi["approval.test"] as any;
@@ -338,6 +459,29 @@ describe("Tool Approval Workflow", () => {
     expect(result.lastUsage!.outputTokenDetails).toBeDefined();
   });
 
+  test("multi-tool: approve two tool calls from the same step", async () => {
+    usageCalls.length = 0;
+    const t = initConvexTest(schema);
+    const result = await t.action(testApi.testMultiToolApproveFlow, {});
+
+    expect(result.approvalCount).toBe(2);
+    expect(result.firstText).toBe("");
+    expect(result.secondText).toBe(
+      "Done! Deleted old.txt and renamed a.txt to b.txt.",
+    );
+    // Both approval responses should be merged into one tool message
+    // (write-time merge in respondToToolCallApproval via findApprovalContext)
+    // Thread: user, assistant(2 tool-calls + 2 approvals),
+    //         tool(2 approval-responses merged), tool(2 tool-results), assistant(text)
+    expect(result.threadMessageRoles).toEqual([
+      "assistant", // final text
+      "tool", // tool-results
+      "tool", // approval-responses (merged)
+      "assistant", // tool-calls + approval-requests
+      "user", // prompt
+    ]);
+  });
+
   test("approve remains valid with an intervening thread message", async () => {
     usageCalls.length = 0;
     const t = initConvexTest(schema);

package/src/client/index.ts

@@ -99,9 +99,10 @@ import type {
   Output,
 } from "./types.js";
 import { streamText } from "./streamText.js";
-import { errorToString, willContinue } from "./utils.js";
+import { errorToString, hasSuccessfulToolCall, willContinue } from "./utils.js";
 
 export { stepCountIs } from "ai";
+export { hasSuccessfulToolCall };
 export {
   docsToModelMessages,
   toModelMessage,
@@ -476,8 +477,7 @@ export class Agent<
      * The arguments to the generateText function, similar to the ai sdk's
      * {@link generateText} function, along with Agent prompt options.
      */
-    generateTextArgs: AgentPrompt &
-      TextArgs<AgentTools, TOOLS, OUTPUT>,
+    generateTextArgs: AgentPrompt & TextArgs<AgentTools, TOOLS, OUTPUT>,
     options?: Options,
   ): Promise<
     GenerateTextResult<TOOLS extends undefined ? AgentTools : TOOLS, OUTPUT> &
@@ -535,8 +535,7 @@ export class Agent<
      * The arguments to the streamText function, similar to the ai sdk's
      * {@link streamText} function, along with Agent prompt options.
      */
-    streamTextArgs: AgentPrompt &
-      StreamingTextArgs<AgentTools, TOOLS, OUTPUT>,
+    streamTextArgs: AgentPrompt & StreamingTextArgs<AgentTools, TOOLS, OUTPUT>,
     /**
      * The {@link ContextOptions} and {@link StorageOptions}
      * options to use for fetching contextual messages and saving input/output messages.
@@ -555,10 +554,7 @@ export class Agent<
       saveStreamDeltas?: boolean | StreamingOptions;
     },
   ): Promise<
-    StreamTextResult<
-      TOOLS extends undefined ? AgentTools : TOOLS,
-      OUTPUT
-    > &
+    StreamTextResult<TOOLS extends undefined ? AgentTools : TOOLS, OUTPUT> &
       GenerationOutputMetadata
   > {
     type Tools = TOOLS extends undefined ? AgentTools : TOOLS;
@@ -1123,25 +1119,34 @@ export class Agent<
     // The "already handled" check (tool-approval-response) relies on seeing
     // responses before their corresponding requests. If the pagination order
     // changes, this logic will need to be updated.
-    let cursor: string | null = null;
     let existingResponseMessage: MessageDoc | undefined;
-    do {
-      const page = await this.listMessages(ctx, {
-        threadId: args.threadId,
-        paginationOpts: { cursor, numItems: 100 },
-      });
+    // Limit the search to the most recent messages. Approvals should always
+    // be near the end of the thread.
+    const page = await this.listMessages(ctx, {
+      threadId: args.threadId,
+      paginationOpts: { cursor: null, numItems: 100 },
+    });
+    {
       for (const message of page.page) {
         const content = message.message?.content;
         if (!Array.isArray(content)) continue;
         // Check if this assistant message starts a different approval step.
         // If so, any response message we've seen so far belongs to a newer
         // step — reset it so we don't merge across step boundaries.
+        // Only reset if the target approval is NOT in this message (i.e.,
+        // this is a genuinely different step, not the same step with
+        // multiple tool calls).
         if (
           message.message?.role === "assistant" &&
           content.some(
             (p: any) =>
               p.type === "tool-approval-request" &&
               p.approvalId !== args.approvalId,
+          ) &&
+          !content.some(
+            (p: any) =>
+              p.type === "tool-approval-request" &&
+              p.approvalId === args.approvalId,
           )
         ) {
           existingResponseMessage = undefined;
@@ -1169,11 +1174,10 @@ export class Agent<
           }
         }
       }
-      cursor = page.isDone ? null : page.continueCursor;
-    } while (cursor !== null);
+    }
 
     throw new Error(
-      `Approval request ${args.approvalId} was not found in thread ${args.threadId}`,
+      `Approval request ${args.approvalId} was not found in the last 100 messages of thread ${args.threadId}`,
     );
   }
 
@@ -1622,7 +1626,10 @@ export class Agent<
         } as GenerateObjectArgs<FlexibleSchema<T>>;
         const ctx = (
           options?.customCtx
-            ? { ...ctx_, ...options.customCtx(ctx_, targetArgs, llmArgs as any) }
+            ? {
+                ...ctx_,
+                ...options.customCtx(ctx_, targetArgs, llmArgs as any),
+              }
             : ctx_
         ) as GenericActionCtx<GenericDataModel> & CustomCtx;
         const value = await this.generateObject(ctx, targetArgs, llmArgs, {

package/src/client/search.ts

@@ -35,28 +35,6 @@ import {
   toModelMessage,
 } from "../mapping.js";
 
-/**
- * Filter out approval parts from messages before sending to AI providers.
- * Providers like Anthropic don't understand tool-approval-request and
- * tool-approval-response parts and will error if they are included.
- */
-function filterApprovalPartsForProvider(messages: ModelMessage[]): ModelMessage[] {
-  return messages.map((message) => {
-    if (!Array.isArray(message.content)) {
-      return message;
-    }
-    const filteredContent = message.content.filter(
-      (part) =>
-        (part as { type: string }).type !== "tool-approval-request" &&
-        (part as { type: string }).type !== "tool-approval-response",
-    );
-    return {
-      ...message,
-      content: filteredContent,
-    } as typeof message;
-  });
-}
-
 const DEFAULT_VECTOR_SCORE_THRESHOLD = 0.0;
 // 10k characters should be more than enough for most cases, and stays under
 // the 8k token limit for some models.
@@ -256,11 +234,7 @@ export async function fetchRecentAndSearchMessages(
     searchMessages = filterOutOrphanedToolMessages(
       sorted(searchResults.filter((m) => !included?.has(m._id))),
     );
-    searchMessages = filterApprovalPartsForProvider(searchMessages);
   }
-
-  // filter out approval parts before returning
-  searchMessages = filterApprovalPartsForProvider(searchMessages);
   // Ensure we don't include tool messages without a corresponding tool call
   return { recentMessages, searchMessages };
 }
@@ -704,9 +678,6 @@ export async function fetchContextWithPrompt(
     processedMessages = await inlineMessagesFiles(processedMessages);
   }
 
-  // Filter out approval parts before sending to AI providers
-  processedMessages = filterApprovalPartsForProvider(processedMessages);
-
   return {
     messages: processedMessages,
     order: promptMessage?.order,

package/src/client/setup.test.ts

@@ -10,15 +10,13 @@ import {
 } from "convex/server";
 import { type AgentComponent } from "./index.js";
 import { componentsGeneric } from "convex/server";
-export { componentSchema };
-import componentSchema from "../component/schema.js";
-export const componentModules = import.meta.glob("../component/**/*.ts");
+import component from "../test.js";
 
 export function initConvexTest<
   Schema extends SchemaDefinition<GenericSchema, boolean>,
 >(schema?: Schema) {
-  const t = convexTest(schema ?? defineSchema({}), modules);
-  t.registerComponent("agent", componentSchema, componentModules);
+  const t = convexTest((schema ?? defineSchema({})) as Schema, modules);
+  component.register(t);
   return t;
 }
 export const components = componentsGeneric() as unknown as {

package/src/client/start.ts

@@ -10,7 +10,7 @@ import {
   type ToolSet,
 } from "ai";
 import {
-  serializeNewMessagesInStep,
+  serializeResponseMessages,
   serializeObjectResult,
 } from "../mapping.js";
 import { embedMessages, fetchContextWithPrompt } from "./search.js";
@@ -252,7 +252,7 @@ export async function startGeneration<
             previousResponseMessageCount,
           );
           previousResponseMessageCount = allResponseMessages.length;
-          serialized = await serializeNewMessagesInStep(
+          serialized = await serializeResponseMessages(
             ctx,
             component,
             toSave.step,

package/src/client/streamText.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, test } from "vitest";
+import { Agent, createThread } from "./index.js";
+import {
+  defineSchema,
+  type DataModelFromSchemaDefinition,
+  type ApiFromModules,
+  type ActionBuilder,
+  actionGeneric,
+  anyApi,
+} from "convex/server";
+import { v } from "convex/values";
+import { components, initConvexTest } from "./setup.test.js";
+import { mockModel } from "./mockModel.js";
+
+const schema = defineSchema({});
+type DataModel = DataModelFromSchemaDefinition<typeof schema>;
+const action = actionGeneric as ActionBuilder<DataModel, "public">;
+
+const FINAL_TEXT = "Hello from the model";
+
+const agent = new Agent(components.agent, {
+  name: "stream-test",
+  languageModel: mockModel({
+    content: [{ type: "text", text: FINAL_TEXT }],
+  }),
+});
+
+// Action that exercises streamText with saveStreamDeltas.returnImmediately=true.
+// It consumes the stream after streamText returns, simulating the HTTP response
+// path described in issue #265.
+export const streamTextReturnImmediately = action({
+  args: { threadId: v.string() },
+  handler: async (ctx, { threadId }) => {
+    const result = await agent.streamText(
+      ctx,
+      { threadId },
+      { prompt: "Test" },
+      {
+        saveStreamDeltas: {
+          returnImmediately: true,
+          chunking: "word",
+          throttleMs: 0,
+        },
+      },
+    );
+    // Drain the stream the way an HTTP response would. This triggers
+    // onStepFinish for every step, including the final one.
+    await result.consumeStream();
+    return { ok: true };
+  },
+});
+
+const testApi: ApiFromModules<{
+  fns: { streamTextReturnImmediately: typeof streamTextReturnImmediately };
+}>["fns"] = anyApi["streamText.test"] as any;
+
+describe("streamText with saveStreamDeltas.returnImmediately (issue #265)", () => {
+  test("persists the final assistant text to the messages table", async () => {
+    const t = initConvexTest(schema);
+    const threadId = await t.run(async (ctx) =>
+      createThread(ctx, components.agent, { userId: "u1" }),
+    );
+
+    await t.action(testApi.streamTextReturnImmediately, { threadId });
+
+    // Allow any background work scheduled by consumeStream to settle.
+    await t.finishAllScheduledFunctions(() => {});
+
+    const messages = await t.run(async (ctx) =>
+      agent.listMessages(ctx, {
+        threadId,
+        paginationOpts: { cursor: null, numItems: 50 },
+      }),
+    );
+
+    const assistantTextMessages = messages.page.filter(
+      (m) =>
+        m.message?.role === "assistant" &&
+        typeof m.text === "string" &&
+        m.text.length > 0,
+    );
+    expect(
+      assistantTextMessages.length,
+      "expected at least one persisted assistant message with text",
+    ).toBeGreaterThan(0);
+
+    const combined = assistantTextMessages.map((m) => m.text).join("");
+    expect(combined).toContain(FINAL_TEXT);
+
+    // The stream should be marked finished, not stuck in "streaming".
+    const stillStreaming = await t.run(async (ctx) =>
+      ctx.runQuery(components.agent.streams.list, {
+        threadId,
+        statuses: ["streaming"],
+      }),
+    );
+    expect(
+      stillStreaming,
+      "stream should not be stuck in 'streaming' status",
+    ).toHaveLength(0);
+  });
+});