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

package/src/client/streaming.ts

@@ -244,16 +244,25 @@ export class DeltaStreamer<T> {
     this.abortController = new AbortController();
     if (config.abortSignal) {
       config.abortSignal.addEventListener("abort", async () => {
-        if (this.abortController.signal.aborted) {
-          return;
-        }
-        if (this.streamId) {
+        try {
+          if (this.abortController.signal.aborted) {
+            return;
+          }
           this.abortController.abort();
-          await this.#ongoingWrite;
-          await this.ctx.runMutation(this.component.streams.abort, {
-            streamId: this.streamId,
-            reason: "abortSignal",
-          });
+          // Wait for in-flight stream creation before trying to abort it
+          if (this.#creatingStreamIdPromise) {
+            await this.#creatingStreamIdPromise;
+          }
+          if (this.streamId) {
+            await this.#ongoingWrite;
+            await this.ctx.runMutation(this.component.streams.abort, {
+              streamId: this.streamId,
+              reason: "abortSignal",
+            });
+          }
+        } catch {
+          // Best-effort cleanup — the stream will be garbage-collected
+          // by the 10-minute timeout if this fails.
         }
       });
     }
@@ -293,7 +302,10 @@ export class DeltaStreamer<T> {
       await this.addParts([chunk]);
     }
     // Skip finish if it will be handled externally (atomically with message save)
-    if (!this.#finishedExternally) {
+    // or if the stream was aborted (e.g., due to a failed delta write).
+    // Aborted streams are cleaned up via streams.abort (called by the abort
+    // signal handler), so we don't need to call finish() for them.
+    if (!this.#finishedExternally && !this.abortController.signal.aborted) {
       await this.finish();
     }
   }
@@ -339,7 +351,7 @@ export class DeltaStreamer<T> {
         e instanceof Error ? e.message : "unknown error",
       );
       this.abortController.abort();
-      throw e;
+      return;
     }
     // Now that we've sent the delta, check if we need to send another one.
     if (
@@ -375,7 +387,10 @@ export class DeltaStreamer<T> {
       return;
     }
     await this.#ongoingWrite;
-    await this.#sendDelta();
+    await this.#sendDelta(); // #sendDelta checks aborted internally
+    if (this.abortController.signal.aborted) {
+      return;
+    }
     await this.ctx.runMutation(this.component.streams.finish, {
       streamId: this.streamId,
     });
@@ -432,16 +447,15 @@ export function compressTextStreamParts(
       } else {
         compressed.push(part);
       }
+    } else if (part.type === "file") {
+      compressed.push({
+        type: "file",
+        file: {
+          ...part.file,
+          uint8Array: undefined as unknown as Uint8Array,
+        },
+      });
     } else {
-      if (part.type === "file") {
-        compressed.push({
-          type: "file",
-          file: {
-            ...part.file,
-            uint8Array: undefined as unknown as Uint8Array,
-          },
-        });
-      }
       compressed.push(part);
     }
   }

package/src/mapping.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "vitest";
+import { describe, test, expect, vi } from "vitest";
 import {
   guessMimeType,
   serializeDataOrUrl,
@@ -7,7 +7,7 @@ import {
   toModelMessage,
   serializeContent,
   toModelMessageContent,
-  mergeApprovalResponseMessages,
+  autoDenyUnresolvedApprovals,
 } from "./mapping.js";
 import { api } from "./component/_generated/api.js";
 import type { AgentComponent, ActionCtx } from "./client/types.js";
@@ -259,79 +259,144 @@ describe("mapping", () => {
     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;
+  describe("autoDenyUnresolvedApprovals", () => {
+    test("returns messages unchanged when no unresolved approvals", () => {
+      const messages = [
+        { role: "user" as const, content: "hello" },
+        {
+          role: "assistant" as const,
+          content: [
+            { type: "tool-call", toolCallId: "tc1", toolName: "a", input: {} },
+            { type: "tool-approval-request", approvalId: "ap1", toolCallId: "tc1" },
+          ],
+        },
+        {
+          role: "tool" as const,
+          content: [
+            { type: "tool-approval-response", approvalId: "ap1", approved: true },
+          ],
+        },
+      ] 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");
-  });
+      const result = autoDenyUnresolvedApprovals(messages);
+      expect(result).toBe(messages); // same reference, no changes
+    });
 
-  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;
+    test("injects synthetic denial for a single unresolved approval", () => {
+      const messages = [
+        { role: "user" as const, content: "hello" },
+        {
+          role: "assistant" as const,
+          content: [
+            { type: "tool-call", toolCallId: "tc1", toolName: "a", input: {} },
+            { type: "tool-approval-request", approvalId: "ap1", toolCallId: "tc1" },
+          ],
+        },
+        { role: "user" as const, content: "new message" },
+      ] 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);
-  });
+      const result = autoDenyUnresolvedApprovals(messages);
+      expect(result).toHaveLength(4); // original 3 + 1 synthetic tool message
+      // Synthetic denial should be inserted right after the assistant message (index 1)
+      expect(result[2].role).toBe("tool");
+      const denialContent = result[2].content as any[];
+      expect(denialContent).toHaveLength(1);
+      expect(denialContent[0].type).toBe("tool-approval-response");
+      expect(denialContent[0].approvalId).toBe("ap1");
+      expect(denialContent[0].approved).toBe(false);
+      expect(denialContent[0].reason).toBe("auto-denied: new generation started");
+      // The new user message should follow
+      expect(result[3].role).toBe("user");
+      expect(result[3].content).toBe("new message");
+    });
 
-  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;
+    test("groups multiple unresolved approvals from the same step into a single synthetic message", () => {
+      const messages = [
+        {
+          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" },
+          ],
+        },
+      ] as any;
+
+      const result = autoDenyUnresolvedApprovals(messages);
+      expect(result).toHaveLength(2); // assistant + 1 synthetic tool message
+      expect(result[1].role).toBe("tool");
+      const denialContent = result[1].content as any[];
+      expect(denialContent).toHaveLength(2);
+      expect(denialContent[0].approvalId).toBe("ap1");
+      expect(denialContent[0].approved).toBe(false);
+      expect(denialContent[1].approvalId).toBe("ap2");
+      expect(denialContent[1].approved).toBe(false);
+    });
+
+    test("only auto-denies unresolved approvals, leaves resolved ones alone", () => {
+      const messages = [
+        {
+          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: "user" as const, content: "next question" },
+      ] as any;
+
+      const result = autoDenyUnresolvedApprovals(messages);
+      // Should inject a denial for ap2 (unresolved) after the assistant message
+      expect(result).toHaveLength(4); // assistant + existing tool + synthetic denial + user
+      // The synthetic denial is inserted after the assistant (index 0)
+      expect(result[0].role).toBe("assistant");
+      expect(result[1].role).toBe("tool"); // synthetic denial for ap2
+      const denialContent = result[1].content as any[];
+      expect(denialContent).toHaveLength(1);
+      expect(denialContent[0].approvalId).toBe("ap2");
+      expect(denialContent[0].approved).toBe(false);
+      // Original tool message (ap1 response) follows
+      expect(result[2].role).toBe("tool");
+      const originalToolContent = result[2].content as any[];
+      expect(originalToolContent[0].approvalId).toBe("ap1");
+      expect(originalToolContent[0].approved).toBe(true);
+      // User message last
+      expect(result[3].role).toBe("user");
+    });
+
+    test("emits console.warn for each auto-denied approval", () => {
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const messages = [
+        {
+          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" },
+          ],
+        },
+      ] as any;
+
+      autoDenyUnresolvedApprovals(messages);
 
-    const merged = mergeApprovalResponseMessages(messages);
-    expect(merged).toHaveLength(2); // not merged since first has tool-result
+      expect(warnSpy).toHaveBeenCalledTimes(2);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("ap1"),
+      );
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("ap2"),
+      );
+      warnSpy.mockRestore();
+    });
   });
 });

package/src/mapping.ts

@@ -140,41 +140,94 @@ export function docsToModelMessages(messages: MessageDoc[]): ModelMessage[] {
 }
 
 /**
- * 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.
+ * Scan messages for unresolved `tool-approval-request` parts and inject
+ * synthetic `tool-approval-response` denials so that the AI SDK receives
+ * a complete history (every tool-call has a corresponding result or denial).
+ *
+ * This handles the case where a user sends a new message instead of
+ * resolving pending approvals — the old approvals are auto-denied rather
+ * than silently dropped.
  */
-export function mergeApprovalResponseMessages(
+export function autoDenyUnresolvedApprovals(
   messages: ModelMessage[],
 ): ModelMessage[] {
+  // Collect all approval requests: approvalId → { toolCallId, messageIndex }
+  const requests = new Map<
+    string,
+    { toolCallId: string; messageIndex: number }
+  >();
+  // Collect all resolved approval IDs
+  const resolvedIds = new Set<string>();
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content as any[]) {
+      if (part.type === "tool-approval-request") {
+        requests.set(part.approvalId, {
+          toolCallId: part.toolCallId,
+          messageIndex: i,
+        });
+      } else if (part.type === "tool-approval-response") {
+        resolvedIds.add(part.approvalId);
+      }
+    }
+  }
+
+  // Find unresolved approvals
+  const unresolved: Array<{
+    approvalId: string;
+    toolCallId: string;
+    messageIndex: number;
+  }> = [];
+  for (const [approvalId, info] of requests) {
+    if (!resolvedIds.has(approvalId)) {
+      unresolved.push({ approvalId, ...info });
+    }
+  }
+
+  if (unresolved.length === 0) {
+    return messages;
+  }
+
+  // Group unresolved approvals by the assistant message index they came from
+  const byMessageIndex = new Map<
+    number,
+    Array<{ approvalId: string; toolCallId: string }>
+  >();
+  for (const entry of unresolved) {
+    console.warn(
+      `Auto-denying unresolved tool approval ${entry.approvalId} ` +
+        `(toolCallId: ${entry.toolCallId}): new generation started`,
+    );
+    let group = byMessageIndex.get(entry.messageIndex);
+    if (!group) {
+      group = [];
+      byMessageIndex.set(entry.messageIndex, group);
+    }
+    group.push(entry);
+  }
+
+  // Build result by inserting synthetic denial messages after each relevant
+  // assistant message
   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);
+  for (let i = 0; i < messages.length; i++) {
+    result.push(messages[i]);
+    const group = byMessageIndex.get(i);
+    if (group) {
+      result.push({
+        role: "tool",
+        content: group.map((entry) => ({
+          type: "tool-approval-response" as const,
+          approvalId: entry.approvalId,
+          approved: false,
+          reason: "auto-denied: new generation started",
+        })),
+      });
     }
   }
-  return result;
-}
 
-function hasApprovalResponse(content: any[]): boolean {
-  return content.some(
-    (p: any) => p.type === "tool-approval-response",
-  );
+  return result;
 }
 
 export function serializeUsage(usage: LanguageModelUsage): Usage {
@@ -244,21 +297,49 @@ export function toModelMessageWarnings(
   }) as any;
 }
 
+/**
+ * Serialize explicitly provided response messages for a step.
+ * Used by the streaming/generation loop where the caller tracks which
+ * messages are new via slicing.
+ */
+export async function serializeResponseMessages<TOOLS extends ToolSet>(
+  ctx: ActionCtx,
+  component: AgentComponent,
+  step: StepResult<TOOLS>,
+  model: ModelOrMetadata | undefined,
+  responseMessages: ModelMessage[],
+): Promise<{ messages: MessageWithMetadata[] }> {
+  return serializeStepMessages(ctx, component, step, model, responseMessages);
+}
+
+/**
+ * Serialize the new messages from a step using a heuristic to determine
+ * which response messages are new (last 1-2 messages).
+ */
 export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
   ctx: ActionCtx,
   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[] }> {
+  const hasToolMessage = step.response.messages.at(-1)?.role === "tool";
+  let messagesToSerialize: ModelMessage[];
+  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: [] }];
+  }
+  return serializeStepMessages(ctx, component, step, model, messagesToSerialize);
+}
+
+async function serializeStepMessages<TOOLS extends ToolSet>(
+  ctx: ActionCtx,
+  component: AgentComponent,
+  step: StepResult<TOOLS>,
+  model: ModelOrMetadata | undefined,
+  messagesToSerialize: 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
@@ -277,18 +358,6 @@ export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
   } 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(
     messagesToSerialize.map(async (msg): Promise<MessageWithMetadata> => {
       const { message, fileIds } = await serializeMessage(ctx, component, msg);