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

package/src/mapping.test.ts

@@ -7,6 +7,7 @@ import {
   toModelMessage,
   serializeContent,
   toModelMessageContent,
+  mergeApprovalResponseMessages,
 } from "./mapping.js";
 import { api } from "./component/_generated/api.js";
 import type { AgentComponent, ActionCtx } from "./client/types.js";
@@ -257,4 +258,80 @@ describe("mapping", () => {
     expect(content).toHaveLength(1);
     expect((content as unknown[])[0]).toMatchObject(approvalResponse);
   });
+
+  test("mergeApprovalResponseMessages merges consecutive tool approval messages", () => {
+    const messages = [
+      { role: "user" as const, content: "hello" },
+      {
+        role: "assistant" as const,
+        content: [
+          { type: "tool-call", toolCallId: "tc1", toolName: "a", input: {} },
+          { type: "tool-call", toolCallId: "tc2", toolName: "b", input: {} },
+          { type: "tool-approval-request", approvalId: "ap1", toolCallId: "tc1" },
+          { type: "tool-approval-request", approvalId: "ap2", toolCallId: "tc2" },
+        ],
+      },
+      {
+        role: "tool" as const,
+        content: [
+          { type: "tool-approval-response", approvalId: "ap1", approved: true },
+        ],
+      },
+      {
+        role: "tool" as const,
+        content: [
+          { type: "tool-approval-response", approvalId: "ap2", approved: false, reason: "denied" },
+        ],
+      },
+    ] as any;
+
+    const merged = mergeApprovalResponseMessages(messages);
+    expect(merged).toHaveLength(3); // user, assistant, single tool
+    expect(merged[2].role).toBe("tool");
+    const toolContent = merged[2].content as Array<{ type: string; approvalId: string }>;
+    expect(toolContent).toHaveLength(2);
+    expect(toolContent[0].approvalId).toBe("ap1");
+    expect(toolContent[1].approvalId).toBe("ap2");
+  });
+
+  test("mergeApprovalResponseMessages does not mutate original message content arrays", () => {
+    const msg1Content = [
+      { type: "tool-approval-response", approvalId: "ap1", approved: true },
+    ];
+    const msg2Content = [
+      { type: "tool-approval-response", approvalId: "ap2", approved: false, reason: "denied" },
+    ];
+    const messages = [
+      { role: "tool" as const, content: msg1Content },
+      { role: "tool" as const, content: msg2Content },
+    ] as any;
+
+    const merged = mergeApprovalResponseMessages(messages);
+    // Merged result should combine both
+    expect(merged).toHaveLength(1);
+    expect((merged[0].content as any[]).length).toBe(2);
+    // Original arrays must be untouched
+    expect(msg1Content).toHaveLength(1);
+    expect(msg2Content).toHaveLength(1);
+  });
+
+  test("mergeApprovalResponseMessages does not merge non-approval tool messages", () => {
+    const messages = [
+      {
+        role: "tool" as const,
+        content: [
+          { type: "tool-result", toolCallId: "tc1", toolName: "a", output: { type: "text", value: "ok" } },
+        ],
+      },
+      {
+        role: "tool" as const,
+        content: [
+          { type: "tool-approval-response", approvalId: "ap1", approved: true },
+        ],
+      },
+    ] as any;
+
+    const merged = mergeApprovalResponseMessages(messages);
+    expect(merged).toHaveLength(2); // not merged since first has tool-result
+  });
 });

package/src/mapping.ts

@@ -139,6 +139,44 @@ export function docsToModelMessages(messages: MessageDoc[]): ModelMessage[] {
     .map(toModelMessage);
 }
 
+/**
+ * Merge consecutive tool messages that contain `tool-approval-response` parts
+ * into a single tool message. The AI SDK's `collectToolApprovals` only examines
+ * the last tool message, so when multiple approvals are saved as separate
+ * messages (e.g. approve tool A, then deny tool B), they must be combined
+ * for the SDK to process them all.
+ */
+export function mergeApprovalResponseMessages(
+  messages: ModelMessage[],
+): ModelMessage[] {
+  const result: ModelMessage[] = [];
+  for (const msg of messages) {
+    const prev = result.at(-1);
+    if (
+      msg.role === "tool" &&
+      prev?.role === "tool" &&
+      Array.isArray(msg.content) &&
+      Array.isArray(prev.content) &&
+      hasApprovalResponse(msg.content) &&
+      hasApprovalResponse(prev.content)
+    ) {
+      // Clone before merging to avoid mutating the original message's content array
+      const cloned = { ...prev, content: [...(prev.content as any[])] };
+      result[result.length - 1] = cloned;
+      (cloned.content as any[]).push(...(msg.content as any[]));
+    } else {
+      result.push(msg);
+    }
+  }
+  return result;
+}
+
+function hasApprovalResponse(content: any[]): boolean {
+  return content.some(
+    (p: any) => p.type === "tool-approval-response",
+  );
+}
+
 export function serializeUsage(usage: LanguageModelUsage): Usage {
   return {
     promptTokens: usage.inputTokens ?? 0,
@@ -211,6 +249,16 @@ export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
   component: AgentComponent,
   step: StepResult<TOOLS>,
   model: ModelOrMetadata | undefined,
+  /**
+   * If provided, these are the new response messages for this step
+   * (pre-sliced by the caller). When not provided, falls back to the
+   * existing heuristic of slicing the last 1-2 messages.
+   *
+   * This is needed for tool approval flows where the SDK adds extra
+   * messages (e.g. approval tool-results) at the beginning of
+   * responseMessages that the old slice(-1/-2) logic would miss.
+   */
+  newResponseMessages?: ModelMessage[],
 ): Promise<{ messages: MessageWithMetadata[] }> {
   // If there are tool results, there's another message with the tool results
   // ref: https://github.com/vercel/ai/blob/main/packages/ai/src/generate-text/to-response-messages.ts#L120
@@ -228,13 +276,21 @@ export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
     sources: hasToolMessage ? undefined : step.sources,
   } satisfies Omit<MessageWithMetadata, "message" | "text" | "fileIds">;
   const toolFields = { sources: step.sources };
+
+  // Determine which messages to serialize for this step
+  let messagesToSerialize: ModelMessage[];
+  if (newResponseMessages) {
+    messagesToSerialize = newResponseMessages;
+  } else if (hasToolMessage) {
+    messagesToSerialize = step.response.messages.slice(-2);
+  } else if (step.content.length) {
+    messagesToSerialize = step.response.messages.slice(-1);
+  } else {
+    messagesToSerialize = [{ role: "assistant" as const, content: [] }];
+  }
+
   const messages: MessageWithMetadata[] = await Promise.all(
-    (hasToolMessage
-      ? step.response.messages.slice(-2)
-      : step.content.length
-        ? step.response.messages.slice(-1)
-        : [{ role: "assistant" as const, content: [] }]
-    ).map(async (msg): Promise<MessageWithMetadata> => {
+    messagesToSerialize.map(async (msg): Promise<MessageWithMetadata> => {
       const { message, fileIds } = await serializeMessage(ctx, component, msg);
       return parse(vMessageWithMetadata, {
         message,

package/src/react/useDeltaStreams.ts

@@ -83,6 +83,12 @@ export function useDeltaStreams<
             ),
           );
 
+  // When no active streams remain, clear the stale state so we stop
+  // returning old streaming UIMessages.
+  if (streamMessages !== undefined && streamMessages.length === 0) {
+    state.deltaStreams = undefined;
+  }
+
   // Get the deltas for all the active streams, if any.
   const cursorQuery = useQuery(
     query,