@convex-dev/agent 0.6.0-alpha.1 → 0.6.0-beta.0

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

@@ -1070,10 +1070,35 @@ export class Agent<
       reason?: string;
     },
   ): Promise<{ messageId: string }> {
-    const promptMessageId = await this.getApprovalRequestMessageId(ctx, {
-      threadId: args.threadId,
+    const { promptMessageId, existingResponseMessage } =
+      await this.findApprovalContext(ctx, {
+        threadId: args.threadId,
+        approvalId: args.approvalId,
+      });
+
+    const newPart = {
+      type: "tool-approval-response" as const,
       approvalId: args.approvalId,
-    });
+      approved: args.approved,
+      reason: args.reason,
+    };
+
+    // Merge into an existing approval-response message for this step
+    // so the AI SDK sees a single tool message per step.
+    if (existingResponseMessage) {
+      const existingContent = existingResponseMessage.message?.content;
+      const mergedContent = Array.isArray(existingContent)
+        ? [...(existingContent as any[]), newPart]
+        : [newPart];
+      await this.updateMessage(ctx, {
+        messageId: existingResponseMessage._id,
+        patch: {
+          message: { role: "tool", content: mergedContent },
+          status: "success",
+        },
+      });
+      return { messageId: existingResponseMessage._id };
+    }
 
     const { messageId } = await this.saveMessage(ctx, {
       threadId: args.threadId,
@@ -1081,36 +1106,55 @@ export class Agent<
       skipEmbeddings: true,
       message: {
         role: "tool",
-        content: [
-          {
-            type: "tool-approval-response",
-            approvalId: args.approvalId,
-            approved: args.approved,
-            reason: args.reason,
-          },
-        ],
+        content: [newPart],
       },
     });
     return { messageId };
   }
 
-  private async getApprovalRequestMessageId(
+  private async findApprovalContext(
     ctx: MutationCtx,
     args: { threadId: string; approvalId: string },
-  ): Promise<string> {
+  ): Promise<{
+    promptMessageId: string;
+    existingResponseMessage: MessageDoc | undefined;
+  }> {
     // NOTE: This pagination returns messages in descending order (newest first).
     // 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;
-    do {
-      const page = await this.listMessages(ctx, {
-        threadId: args.threadId,
-        paginationOpts: { cursor, numItems: 100 },
-      });
+    let existingResponseMessage: MessageDoc | undefined;
+    // 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;
+        }
         for (const part of content) {
           const typedPart = part as { type?: unknown; approvalId?: unknown };
           if (
@@ -1119,19 +1163,25 @@ export class Agent<
           ) {
             throw new Error(`Approval ${args.approvalId} was already handled`);
           }
+          // Track the most recent tool-approval-response message for merging
+          if (
+            typedPart.type === "tool-approval-response" &&
+            !existingResponseMessage
+          ) {
+            existingResponseMessage = message;
+          }
           if (
             typedPart.type === "tool-approval-request" &&
             typedPart.approvalId === args.approvalId
           ) {
-            return message._id;
+            return { promptMessageId: message._id, existingResponseMessage };
           }
         }
       }
-      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}`,
     );
   }
 

package/src/client/search.test.ts

@@ -292,7 +292,7 @@ describe("search.ts", () => {
       expect(result[1]._id).toBe("2");
     });
 
-    it("should filter out tool calls with approval request but NO approval response", () => {
+    it("should keep tool calls with approval request but NO approval response (auto-deny handles them)", () => {
       const messages: MessageDoc[] = [
         {
           _id: "1",
@@ -321,19 +321,18 @@ describe("search.ts", () => {
 
       const result = filterOutOrphanedToolMessages(messages);
       expect(result).toHaveLength(1);
-      // The assistant message should have the tool-call filtered out
+      // The assistant message should keep the tool-call (auto-deny resolves it downstream)
       const assistantContent = result[0].message?.content;
       expect(Array.isArray(assistantContent)).toBe(true);
       if (Array.isArray(assistantContent)) {
-        // Text and approval-request should remain, but tool-call should be filtered
-        expect(assistantContent).toHaveLength(2);
+        expect(assistantContent).toHaveLength(3);
         expect(assistantContent.find((p) => p.type === "text")).toBeDefined();
         expect(
           assistantContent.find((p) => p.type === "tool-approval-request"),
         ).toBeDefined();
         expect(
           assistantContent.find((p) => p.type === "tool-call"),
-        ).toBeUndefined();
+        ).toBeDefined();
       }
     });
 

package/src/client/search.ts

@@ -30,8 +30,8 @@ import type {
 } from "./types.js";
 import { inlineMessagesFiles } from "./files.js";
 import {
+  autoDenyUnresolvedApprovals,
   docsToModelMessages,
-  mergeApprovalResponseMessages,
   toModelMessage,
 } from "../mapping.js";
 
@@ -289,6 +289,12 @@ export function filterOutOrphanedToolMessages(docs: MessageDoc[]) {
     return approvalId !== undefined && approvalResponseIds.has(approvalId);
   };
 
+  // Helper: check if tool call has a pending approval request
+  // (auto-deny handles these downstream, so they must survive the filter)
+  const hasApprovalRequest = (toolCallId: string) => {
+    return approvalRequestsByToolCallId.has(toolCallId);
+  };
+
   for (const doc of docs) {
     if (
       doc.message?.role === "assistant" &&
@@ -298,7 +304,8 @@ export function filterOutOrphanedToolMessages(docs: MessageDoc[]) {
         (p) =>
           p.type !== "tool-call" ||
           toolResultIds.has(p.toolCallId) ||
-          hasApprovalResponse(p.toolCallId),
+          hasApprovalResponse(p.toolCallId) ||
+          hasApprovalRequest(p.toolCallId),
       );
       if (content.length) {
         result.push({
@@ -641,13 +648,13 @@ export async function fetchContextWithPrompt(
   const inputPrompt = promptArray.map(toModelMessage);
   const existingResponses = docsToModelMessages(existingResponseDocs);
 
-  const allMessages = mergeApprovalResponseMessages([
+  const allMessages = [
     ...search,
     ...recent,
     ...inputMessages,
     ...inputPrompt,
     ...existingResponses,
-  ]);
+  ];
   let processedMessages = args.contextHandler
     ? await args.contextHandler(ctx, {
         allMessages,
@@ -661,6 +668,11 @@ export async function fetchContextWithPrompt(
       })
     : allMessages;
 
+  // Post-process: auto-deny unresolved approvals so the AI SDK sees a
+  // complete history. Applied after contextHandler so custom handlers
+  // don't need to handle this.
+  processedMessages = autoDenyUnresolvedApprovals(processedMessages);
+
   // Process messages to inline localhost files (if not, file urls pointing to localhost will be sent to LLM providers)
   if (process.env.CONVEX_CLOUD_URL?.startsWith("http://127.0.0.1")) {
     processedMessages = await inlineMessagesFiles(processedMessages);

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.ts

@@ -168,6 +168,15 @@ export async function streamText<
       // finish() was never called, leaving the streaming message stuck in
       // "streaming" state. Clean it up by marking it as aborted.
       await streamer?.fail(e instanceof Error ? e.message : String(e));
+      // Save the deferred final step if it was already generated but not yet persisted
+      if (pendingFinalStep) {
+        try {
+          await call.save({ step: pendingFinalStep }, false);
+        } catch (saveError) {
+          console.error("Failed to save deferred final step:", saveError);
+        }
+        pendingFinalStep = undefined;
+      }
       throw e;
     }
   }