ai 6.0.33 → 6.0.34

package/src/generate-text/collect-tool-approvals.test.ts

@@ -0,0 +1,553 @@
+import { describe, expect, it } from 'vitest';
+import { collectToolApprovals } from './collect-tool-approvals';
+
+describe('collectToolApprovals', () => {
+  it('should not return any tool approvals when the last message is not a tool message', () => {
+    const result = collectToolApprovals({
+      messages: [{ role: 'user', content: 'Hello, world!' }],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "approvedToolApprovals": [],
+        "deniedToolApprovals": [],
+      }
+    `);
+  });
+
+  it('should ignore approval request without response', () => {
+    const result = collectToolApprovals({
+      messages: [
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: 'tool-call',
+              toolCallId: 'call-1',
+              toolName: 'tool1',
+              input: { value: 'test-input' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-1',
+              toolCallId: 'call-1',
+            },
+          ],
+        },
+        {
+          role: 'tool',
+          content: [],
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "approvedToolApprovals": [],
+        "deniedToolApprovals": [],
+      }
+    `);
+  });
+
+  it('should return approved approval with approved response', () => {
+    const result = collectToolApprovals({
+      messages: [
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: 'tool-call',
+              toolCallId: 'call-1',
+              toolName: 'tool1',
+              input: { value: 'test-input' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-1',
+              toolCallId: 'call-1',
+            },
+          ],
+        },
+        {
+          role: 'tool',
+          content: [
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-1',
+              approved: true,
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "approvedToolApprovals": [
+          {
+            "approvalRequest": {
+              "approvalId": "approval-id-1",
+              "toolCallId": "call-1",
+              "type": "tool-approval-request",
+            },
+            "approvalResponse": {
+              "approvalId": "approval-id-1",
+              "approved": true,
+              "type": "tool-approval-response",
+            },
+            "toolCall": {
+              "input": {
+                "value": "test-input",
+              },
+              "toolCallId": "call-1",
+              "toolName": "tool1",
+              "type": "tool-call",
+            },
+          },
+        ],
+        "deniedToolApprovals": [],
+      }
+    `);
+  });
+
+  it('should return processed approval with approved response and tool result', () => {
+    const result = collectToolApprovals({
+      messages: [
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: 'tool-call',
+              toolCallId: 'call-1',
+              toolName: 'tool1',
+              input: { value: 'test-input' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-1',
+              toolCallId: 'call-1',
+            },
+          ],
+        },
+        {
+          role: 'tool',
+          content: [
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-1',
+              approved: true,
+            },
+            {
+              type: 'tool-result',
+              toolCallId: 'call-1',
+              toolName: 'tool1',
+              output: { type: 'text', value: 'test-output' },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "approvedToolApprovals": [],
+        "deniedToolApprovals": [],
+      }
+    `);
+  });
+
+  it('should return denied approval with denied response', () => {
+    const result = collectToolApprovals({
+      messages: [
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: 'tool-call',
+              toolCallId: 'call-1',
+              toolName: 'tool1',
+              input: { value: 'test-input' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-1',
+              toolCallId: 'call-1',
+            },
+          ],
+        },
+        {
+          role: 'tool',
+          content: [
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-1',
+              approved: false,
+              reason: 'test-reason',
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "approvedToolApprovals": [],
+        "deniedToolApprovals": [
+          {
+            "approvalRequest": {
+              "approvalId": "approval-id-1",
+              "toolCallId": "call-1",
+              "type": "tool-approval-request",
+            },
+            "approvalResponse": {
+              "approvalId": "approval-id-1",
+              "approved": false,
+              "reason": "test-reason",
+              "type": "tool-approval-response",
+            },
+            "toolCall": {
+              "input": {
+                "value": "test-input",
+              },
+              "toolCallId": "call-1",
+              "toolName": "tool1",
+              "type": "tool-call",
+            },
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should return processed approval with denied response and tool result', () => {
+    const result = collectToolApprovals({
+      messages: [
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: 'tool-call',
+              toolCallId: 'call-1',
+              toolName: 'tool1',
+              input: { value: 'test-input' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-1',
+              toolCallId: 'call-1',
+            },
+          ],
+        },
+        {
+          role: 'tool',
+          content: [
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-1',
+              approved: false,
+              reason: 'test-reason',
+            },
+            {
+              type: 'tool-result',
+              toolCallId: 'call-1',
+              toolName: 'tool1',
+              output: { type: 'execution-denied', reason: 'test-reason' },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "approvedToolApprovals": [],
+        "deniedToolApprovals": [],
+      }
+    `);
+  });
+
+  it('should throw when approval response has unknown approvalId', () => {
+    expect(() =>
+      collectToolApprovals({
+        messages: [
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: 'call-1',
+                toolName: 'tool1',
+                input: { value: 'test-input' },
+              },
+              {
+                type: 'tool-approval-request',
+                approvalId: 'approval-id-1',
+                toolCallId: 'call-1',
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-approval-response',
+                approvalId: 'unknown-approval-id', // doesn't match any request
+                approved: true,
+              },
+            ],
+          },
+        ],
+      }),
+    ).toThrow(
+      'Tool approval response references unknown approvalId: "unknown-approval-id"',
+    );
+  });
+
+  it('should throw when referenced tool call does not exist', () => {
+    expect(() =>
+      collectToolApprovals({
+        messages: [
+          {
+            role: 'assistant',
+            content: [
+              // No tool-call part, only the approval request
+              {
+                type: 'tool-approval-request',
+                approvalId: 'approval-id-1',
+                toolCallId: 'call-that-does-not-exist',
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-approval-response',
+                approvalId: 'approval-id-1',
+                approved: true,
+              },
+            ],
+          },
+        ],
+      }),
+    ).toThrow(
+      'Tool call "call-that-does-not-exist" not found for approval request "approval-id-1".',
+    );
+  });
+
+  it('should work for 2 approvals, 2 rejections, 1 approval with tool result, 1 rejection with tool result', () => {
+    const result = collectToolApprovals({
+      messages: [
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: 'tool-call',
+              toolCallId: 'call-approval-1',
+              toolName: 'tool1',
+              input: { value: 'test-input-1' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-1',
+              toolCallId: 'call-approval-1',
+            },
+            {
+              type: 'tool-call',
+              toolCallId: 'call-approval-2',
+              toolName: 'tool1',
+              input: { value: 'test-input-2' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-2',
+              toolCallId: 'call-approval-2',
+            },
+            {
+              type: 'tool-call',
+              toolCallId: 'call-approval-3',
+              toolName: 'tool1',
+              input: { value: 'test-input-3' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-3',
+              toolCallId: 'call-approval-3',
+            },
+            {
+              type: 'tool-call',
+              toolCallId: 'call-approval-4',
+              toolName: 'tool1',
+              input: { value: 'test-input-4' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-4',
+              toolCallId: 'call-approval-4',
+            },
+            {
+              type: 'tool-call',
+              toolCallId: 'call-approval-5',
+              toolName: 'tool1',
+              input: { value: 'test-input-5' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-5',
+              toolCallId: 'call-approval-5',
+            },
+            {
+              type: 'tool-call',
+              toolCallId: 'call-approval-6',
+              toolName: 'tool1',
+              input: { value: 'test-input-6' },
+            },
+            {
+              type: 'tool-approval-request',
+              approvalId: 'approval-id-6',
+              toolCallId: 'call-approval-6',
+            },
+          ],
+        },
+        {
+          role: 'tool',
+          content: [
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-1',
+              approved: true,
+            },
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-2',
+              approved: true,
+            },
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-3',
+              approved: false,
+              reason: 'test-reason',
+            },
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-4',
+              approved: false,
+            },
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-5',
+              approved: true,
+            },
+            {
+              type: 'tool-result',
+              toolCallId: 'call-approval-5',
+              toolName: 'tool1',
+              output: { type: 'text', value: 'test-output-5' },
+            },
+            {
+              type: 'tool-approval-response',
+              approvalId: 'approval-id-6',
+              approved: false,
+            },
+            {
+              type: 'tool-result',
+              toolCallId: 'call-approval-6',
+              toolName: 'tool1',
+              output: { type: 'execution-denied' },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "approvedToolApprovals": [
+          {
+            "approvalRequest": {
+              "approvalId": "approval-id-1",
+              "toolCallId": "call-approval-1",
+              "type": "tool-approval-request",
+            },
+            "approvalResponse": {
+              "approvalId": "approval-id-1",
+              "approved": true,
+              "type": "tool-approval-response",
+            },
+            "toolCall": {
+              "input": {
+                "value": "test-input-1",
+              },
+              "toolCallId": "call-approval-1",
+              "toolName": "tool1",
+              "type": "tool-call",
+            },
+          },
+          {
+            "approvalRequest": {
+              "approvalId": "approval-id-2",
+              "toolCallId": "call-approval-2",
+              "type": "tool-approval-request",
+            },
+            "approvalResponse": {
+              "approvalId": "approval-id-2",
+              "approved": true,
+              "type": "tool-approval-response",
+            },
+            "toolCall": {
+              "input": {
+                "value": "test-input-2",
+              },
+              "toolCallId": "call-approval-2",
+              "toolName": "tool1",
+              "type": "tool-call",
+            },
+          },
+        ],
+        "deniedToolApprovals": [
+          {
+            "approvalRequest": {
+              "approvalId": "approval-id-3",
+              "toolCallId": "call-approval-3",
+              "type": "tool-approval-request",
+            },
+            "approvalResponse": {
+              "approvalId": "approval-id-3",
+              "approved": false,
+              "reason": "test-reason",
+              "type": "tool-approval-response",
+            },
+            "toolCall": {
+              "input": {
+                "value": "test-input-3",
+              },
+              "toolCallId": "call-approval-3",
+              "toolName": "tool1",
+              "type": "tool-call",
+            },
+          },
+          {
+            "approvalRequest": {
+              "approvalId": "approval-id-4",
+              "toolCallId": "call-approval-4",
+              "type": "tool-approval-request",
+            },
+            "approvalResponse": {
+              "approvalId": "approval-id-4",
+              "approved": false,
+              "type": "tool-approval-response",
+            },
+            "toolCall": {
+              "input": {
+                "value": "test-input-4",
+              },
+              "toolCallId": "call-approval-4",
+              "toolName": "tool1",
+              "type": "tool-call",
+            },
+          },
+        ],
+      }
+    `);
+  });
+});

package/src/generate-text/collect-tool-approvals.ts

@@ -0,0 +1,116 @@
+import {
+  ModelMessage,
+  ToolApprovalRequest,
+  ToolApprovalResponse,
+} from '@ai-sdk/provider-utils';
+import { InvalidToolApprovalError } from '../error/invalid-tool-approval-error';
+import { ToolCallNotFoundForApprovalError } from '../error/tool-call-not-found-for-approval-error';
+import { TypedToolCall } from './tool-call';
+import { TypedToolResult } from './tool-result';
+import { ToolSet } from './tool-set';
+
+export type CollectedToolApprovals<TOOLS extends ToolSet> = {
+  approvalRequest: ToolApprovalRequest;
+  approvalResponse: ToolApprovalResponse;
+  toolCall: TypedToolCall<TOOLS>;
+};
+
+/**
+ * If the last message is a tool message, this function collects all tool approvals
+ * from that message.
+ */
+export function collectToolApprovals<TOOLS extends ToolSet>({
+  messages,
+}: {
+  messages: ModelMessage[];
+}): {
+  approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
+  deniedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
+} {
+  const lastMessage = messages.at(-1);
+
+  if (lastMessage?.role != 'tool') {
+    return {
+      approvedToolApprovals: [],
+      deniedToolApprovals: [],
+    };
+  }
+
+  // gather tool calls and prepare lookup
+  const toolCallsByToolCallId: Record<string, TypedToolCall<TOOLS>> = {};
+  for (const message of messages) {
+    if (message.role === 'assistant' && typeof message.content !== 'string') {
+      const content = message.content;
+      for (const part of content) {
+        if (part.type === 'tool-call') {
+          toolCallsByToolCallId[part.toolCallId] = part as TypedToolCall<TOOLS>;
+        }
+      }
+    }
+  }
+
+  // gather approval responses and prepare lookup
+  const toolApprovalRequestsByApprovalId: Record<string, ToolApprovalRequest> =
+    {};
+  for (const message of messages) {
+    if (message.role === 'assistant' && typeof message.content !== 'string') {
+      const content = message.content;
+      for (const part of content) {
+        if (part.type === 'tool-approval-request') {
+          toolApprovalRequestsByApprovalId[part.approvalId] = part;
+        }
+      }
+    }
+  }
+
+  // gather tool results from the last tool message
+  const toolResults: Record<string, TypedToolResult<TOOLS>> = {};
+  for (const part of lastMessage.content) {
+    if (part.type === 'tool-result') {
+      toolResults[part.toolCallId] = part as TypedToolResult<TOOLS>;
+    }
+  }
+
+  const approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>> = [];
+  const deniedToolApprovals: Array<CollectedToolApprovals<TOOLS>> = [];
+
+  const approvalResponses = lastMessage.content.filter(
+    part => part.type === 'tool-approval-response',
+  );
+  for (const approvalResponse of approvalResponses) {
+    const approvalRequest =
+      toolApprovalRequestsByApprovalId[approvalResponse.approvalId];
+
+    if (approvalRequest == null) {
+      throw new InvalidToolApprovalError({
+        approvalId: approvalResponse.approvalId,
+      });
+    }
+
+    if (toolResults[approvalRequest.toolCallId] != null) {
+      continue;
+    }
+
+    const toolCall = toolCallsByToolCallId[approvalRequest.toolCallId];
+    if (toolCall == null) {
+      throw new ToolCallNotFoundForApprovalError({
+        toolCallId: approvalRequest.toolCallId,
+        approvalId: approvalRequest.approvalId,
+      });
+    }
+
+    const approval: CollectedToolApprovals<TOOLS> = {
+      approvalRequest,
+      approvalResponse,
+      toolCall,
+    };
+
+    if (approvalResponse.approved) {
+      approvedToolApprovals.push(approval);
+    } else {
+      deniedToolApprovals.push(approval);
+    }
+  }
+
+  return { approvedToolApprovals, deniedToolApprovals };
+}

package/src/generate-text/content-part.ts

@@ -0,0 +1,25 @@
+import { ProviderMetadata } from '../types';
+import { Source } from '../types/language-model';
+import { GeneratedFile } from './generated-file';
+import { ToolApprovalRequestOutput } from './tool-approval-request-output';
+import { ReasoningOutput } from './reasoning-output';
+import { TypedToolCall } from './tool-call';
+import { TypedToolError } from './tool-error';
+import { TypedToolResult } from './tool-result';
+import { ToolSet } from './tool-set';
+
+export type ContentPart<TOOLS extends ToolSet> =
+  | { type: 'text'; text: string; providerMetadata?: ProviderMetadata }
+  | ReasoningOutput
+  | ({ type: 'source' } & Source)
+  | { type: 'file'; file: GeneratedFile; providerMetadata?: ProviderMetadata } // different because of GeneratedFile object
+  | ({ type: 'tool-call' } & TypedToolCall<TOOLS> & {
+        providerMetadata?: ProviderMetadata;
+      })
+  | ({ type: 'tool-result' } & TypedToolResult<TOOLS> & {
+        providerMetadata?: ProviderMetadata;
+      })
+  | ({ type: 'tool-error' } & TypedToolError<TOOLS> & {
+        providerMetadata?: ProviderMetadata;
+      })
+  | ToolApprovalRequestOutput<TOOLS>;