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

package/package.json

@@ -7,7 +7,7 @@
     "email": "support@convex.dev",
     "url": "https://github.com/get-convex/agent/issues"
   },
-  "version": "0.6.0-alpha.1",
+  "version": "0.6.0",
   "license": "Apache-2.0",
   "keywords": [
     "convex",

package/src/UIMessages.ts

@@ -396,6 +396,54 @@ 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 }
+    | {
+        type: "tool-approval-response";
+        approvalId: string;
+        approved: boolean;
+        reason?: string;
+      };
+  const approvalParts: ApprovalPart[] = [];
+
+  // Extract execution-denied tool results from raw content for UI rendering
+  // (these are converted to text format for provider compatibility in start.ts)
+  type ExecutionDeniedInfo = {
+    toolCallId: string;
+    reason?: string;
+  };
+  const executionDeniedResults: ExecutionDeniedInfo[] = [];
+
+  for (const message of group) {
+    const rawContent = message.message?.content;
+    if (Array.isArray(rawContent)) {
+      for (const part of rawContent) {
+        if (
+          part.type === "tool-approval-request" ||
+          part.type === "tool-approval-response"
+        ) {
+          approvalParts.push(part as ApprovalPart);
+        }
+        // Check for execution-denied in tool-result outputs
+        if (
+          part.type === "tool-result" &&
+          typeof part.output === "object" &&
+          part.output !== null &&
+          (part.output as { type?: string }).type === "execution-denied"
+        ) {
+          executionDeniedResults.push({
+            toolCallId: part.toolCallId as string,
+            reason: (part.output as { reason?: string }).reason,
+          });
+        }
+      }
+    }
+  }
+
+>>>>>>> Stashed changes
   // Collect all parts from all messages
   const allParts: UIMessage<METADATA, DATA_PARTS, TOOLS>["parts"] = [];
 
@@ -477,6 +525,12 @@ 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 };
           };
@@ -642,6 +696,87 @@ function createAssistantUIMessage<
     }
   }
 
+<<<<<<< Updated upstream
+=======
+  // Final output states that should not be overwritten by approval processing
+  const finalStates = new Set([
+    "output-available",
+    "output-error",
+    "output-denied",
+  ]);
+
+  // Process approval parts to update tool call states
+  for (const approvalPart of approvalParts) {
+    if (approvalPart.type === "tool-approval-request") {
+      const toolCallPart = allParts.find(
+        (part) =>
+          "toolCallId" in part && part.toolCallId === approvalPart.toolCallId,
+      ) as ToolUIPart | undefined;
+
+      if (toolCallPart) {
+        // Always set approval info (needed for response matching), but only
+        // update state if not in a final state
+        (toolCallPart as ToolUIPart & { approval?: object }).approval = {
+          id: approvalPart.approvalId,
+        };
+        if (!finalStates.has(toolCallPart.state)) {
+          toolCallPart.state = "approval-requested";
+        }
+      }
+    } else if (approvalPart.type === "tool-approval-response") {
+      const toolCallPart = allParts.find(
+        (part) =>
+          "approval" in part &&
+          (part as ToolUIPart & { approval?: { id: string } }).approval?.id ===
+            approvalPart.approvalId,
+      ) as ToolUIPart | undefined;
+
+      if (toolCallPart) {
+        // Always update approval info, but only update state if not in a final state
+        (toolCallPart as ToolUIPart & { approval?: object }).approval = {
+          id: approvalPart.approvalId,
+          approved: approvalPart.approved,
+          reason: approvalPart.reason,
+        };
+        if (!finalStates.has(toolCallPart.state)) {
+          if (approvalPart.approved) {
+            toolCallPart.state = "approval-responded";
+          } else {
+            toolCallPart.state = "output-denied";
+          }
+        }
+      }
+    }
+  }
+
+  // Process execution-denied results to update tool call states
+  for (const denied of executionDeniedResults) {
+    const toolCallPart = allParts.find(
+      (part) =>
+        "toolCallId" in part && part.toolCallId === denied.toolCallId,
+    ) as ToolUIPart | undefined;
+
+    if (toolCallPart) {
+      toolCallPart.state = "output-denied";
+      if (!("approval" in toolCallPart) || !toolCallPart.approval) {
+        (toolCallPart as ToolUIPart & { approval?: object }).approval = {
+          id: "",
+          approved: false,
+          reason: denied.reason,
+        };
+      } else {
+        const approval = (
+          toolCallPart as ToolUIPart & {
+            approval: { approved?: boolean; reason?: string };
+          }
+        ).approval;
+        approval.approved = false;
+        approval.reason = denied.reason;
+      }
+    }
+  }
+
+>>>>>>> Stashed changes
   return {
     ...common,
     role: "assistant",

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,28 +1106,25 @@ 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;
+    let existingResponseMessage: MessageDoc | undefined;
     do {
       const page = await this.listMessages(ctx, {
         threadId: args.threadId,
@@ -1111,6 +1133,19 @@ export class Agent<
       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.
+        if (
+          message.message?.role === "assistant" &&
+          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,11 +1154,18 @@ 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 };
           }
         }
       }

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,11 +30,33 @@ import type {
 } from "./types.js";
 import { inlineMessagesFiles } from "./files.js";
 import {
+  autoDenyUnresolvedApprovals,
   docsToModelMessages,
-  mergeApprovalResponseMessages,
   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.
@@ -234,7 +256,11 @@ 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 };
 }
@@ -289,6 +315,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 +330,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 +674,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,11 +694,19 @@ 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);
   }
 
+  // Filter out approval parts before sending to AI providers
+  processedMessages = filterApprovalPartsForProvider(processedMessages);
+
   return {
     messages: processedMessages,
     order: promptMessage?.order,