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

package/src/client/streaming.ts

@@ -293,7 +293,8 @@ 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)
+    if (!this.#finishedExternally && !this.abortController.signal.aborted) {
       await this.finish();
     }
   }
@@ -339,7 +340,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 +376,13 @@ export class DeltaStreamer<T> {
       return;
     }
     await this.#ongoingWrite;
+    if (this.abortController.signal.aborted) {
+      return;
+    }
     await this.#sendDelta();
+    if (this.abortController.signal.aborted) {
+      return;
+    }
     await this.ctx.runMutation(this.component.streams.finish, {
       streamId: this.streamId,
     });

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 {

package/dist/UIMessages.d.ts

@@ -1,46 +0,0 @@
-import { type UIMessage as AIUIMessage, type UIDataTypes, type UITools } from "ai";
-import type { MessageDoc, MessageStatus, ProviderOptions } from "./validators.js";
-export type UIStatus = "streaming" | MessageStatus;
-export type UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = AIUIMessage<METADATA, DATA_PARTS, TOOLS> & {
-    key: string;
-    order: number;
-    stepOrder: number;
-    status: UIStatus;
-    agentName?: string;
-    userId?: string;
-    text: string;
-    _creationTime: number;
-};
-/**
- * Converts a list of UIMessages to MessageDocs, along with extra metadata that
- * may be available to associate with the MessageDocs.
- * @param messages - The UIMessages to convert to MessageDocs.
- * @param meta - The metadata to add to the MessageDocs.
- * @returns
- */
-export declare function fromUIMessages<METADATA = unknown>(messages: UIMessage<METADATA>[], meta: {
-    threadId: string;
-    userId?: string;
-    model?: string;
-    provider?: string;
-    providerOptions?: ProviderOptions;
-    metadata?: METADATA;
-}): Promise<(MessageDoc & {
-    streaming: boolean;
-    metadata?: METADATA;
-})[]>;
-type ExtraFields<METADATA = unknown> = {
-    streaming?: boolean;
-    metadata?: METADATA;
-};
-/**
- * Converts a list of MessageDocs to UIMessages.
- * This is somewhat lossy, as many fields are not supported by UIMessages, e.g.
- * the model, provider, userId, etc.
- * The UIMessage type is the augmented type that includes more fields such as
- * key, order, stepOrder, status, agentName, text, etc.
- */
-export declare function toUIMessages<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools>(messages: (MessageDoc & ExtraFields<METADATA>)[]): UIMessage<METADATA, DATA_PARTS, TOOLS>[];
-export declare function combineUIMessages(messages: UIMessage[]): UIMessage[];
-export {};
-//# sourceMappingURL=UIMessages.d.ts.map

package/dist/UIMessages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UIMessages.d.ts","sourceRoot":"","sources":["../src/UIMessages.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,IAAI,WAAW,EAU7B,KAAK,WAAW,EAChB,KAAK,OAAO,EACb,MAAM,IAAI,CAAC;AAUZ,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,eAAe,EAGhB,MAAM,iBAAiB,CAAC;AAGzB,MAAM,MAAM,QAAQ,GAAG,WAAW,GAAG,aAAa,CAAC;AAEnD,MAAM,MAAM,SAAS,CACnB,QAAQ,GAAG,OAAO,EAClB,UAAU,SAAS,WAAW,GAAG,WAAW,EAC5C,KAAK,SAAS,OAAO,GAAG,OAAO,IAC7B,WAAW,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,CAAC,GAAG;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,QAAQ,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,QAAQ,GAAG,OAAO,EACrD,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,EAAE,EAC/B,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,GACA,OAAO,CAAC,CAAC,UAAU,GAAG;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAE,CAAC,EAAE,CAAC,CAiEvE;AA8BD,KAAK,WAAW,CAAC,QAAQ,GAAG,OAAO,IAAI;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,GAAG,OAAO,EAClB,UAAU,SAAS,WAAW,GAAG,WAAW,EAC5C,KAAK,SAAS,OAAO,GAAG,OAAO,EAE/B,QAAQ,EAAE,CAAC,UAAU,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,EAAE,GAC/C,SAAS,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,CAiB1C;AA+dD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CA2CpE"}