ai 6.0.42 → 6.0.44

package/src/prompt/__snapshots__/convert-to-language-model-prompt.validation.test.ts.snap

@@ -0,0 +1,76 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`tool validation > should pass validation for provider-executed tools (deferred results) 1`] = `
+[
+  {
+    "content": [
+      {
+        "input": {
+          "code": "print("hello")",
+        },
+        "providerExecuted": true,
+        "providerOptions": undefined,
+        "toolCallId": "call_1",
+        "toolName": "code_interpreter",
+        "type": "tool-call",
+      },
+    ],
+    "providerOptions": undefined,
+    "role": "assistant",
+  },
+]
+`;
+
+exports[`tool validation > should pass validation for tool-approval-response 1`] = `
+[
+  {
+    "content": [
+      {
+        "input": {
+          "action": "delete_db",
+        },
+        "providerExecuted": undefined,
+        "providerOptions": undefined,
+        "toolCallId": "call_to_approve",
+        "toolName": "dangerous_action",
+        "type": "tool-call",
+      },
+    ],
+    "providerOptions": undefined,
+    "role": "assistant",
+  },
+]
+`;
+
+exports[`tool validation > should preserve provider-executed tool-approval-response 1`] = `
+[
+  {
+    "content": [
+      {
+        "input": {
+          "action": "execute",
+        },
+        "providerExecuted": true,
+        "providerOptions": undefined,
+        "toolCallId": "call_provider_executed",
+        "toolName": "mcp_tool",
+        "type": "tool-call",
+      },
+    ],
+    "providerOptions": undefined,
+    "role": "assistant",
+  },
+  {
+    "content": [
+      {
+        "approvalId": "approval_provider",
+        "approved": true,
+        "reason": undefined,
+        "type": "tool-approval-response",
+      },
+    ],
+    "providerOptions": undefined,
+    "role": "tool",
+  },
+]
+`;

package/src/prompt/convert-to-language-model-prompt.ts

@@ -29,6 +29,7 @@ import { convertToLanguageModelV3DataContent } from './data-content';
 import { InvalidMessageRoleError } from './invalid-message-role-error';
 import { StandardizedPrompt } from './standardize-prompt';
 import { asArray } from '../util/as-array';
+import { MissingToolResultsError } from '../error/missing-tool-result-error';
 
 export async function convertToLanguageModelPrompt({
   prompt,
@@ -45,6 +46,38 @@ export async function convertToLanguageModelPrompt({
     supportedUrls,
   );
 
+  const approvalIdToToolCallId = new Map<string, string>();
+  for (const message of prompt.messages) {
+    if (message.role === 'assistant' && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (
+          part.type === 'tool-approval-request' &&
+          'approvalId' in part &&
+          'toolCallId' in part
+        ) {
+          approvalIdToToolCallId.set(
+            part.approvalId as string,
+            part.toolCallId as string,
+          );
+        }
+      }
+    }
+  }
+
+  const approvedToolCallIds = new Set<string>();
+  for (const message of prompt.messages) {
+    if (message.role === 'tool') {
+      for (const part of message.content) {
+        if (part.type === 'tool-approval-response') {
+          const toolCallId = approvalIdToToolCallId.get(part.approvalId);
+          if (toolCallId) {
+            approvedToolCallIds.add(toolCallId);
+          }
+        }
+      }
+    }
+  }
+
   const messages = [
     ...(prompt.system != null
       ? typeof prompt.system === 'string'
@@ -76,7 +109,58 @@ export async function convertToLanguageModelPrompt({
     }
   }
 
-  return combinedMessages;
+  const toolCallIds = new Set<string>();
+
+  for (const message of combinedMessages) {
+    switch (message.role) {
+      case 'assistant': {
+        for (const content of message.content) {
+          if (content.type === 'tool-call' && !content.providerExecuted) {
+            toolCallIds.add(content.toolCallId);
+          }
+        }
+        break;
+      }
+      case 'tool': {
+        for (const content of message.content) {
+          if (content.type === 'tool-result') {
+            toolCallIds.delete(content.toolCallId);
+          }
+        }
+        break;
+      }
+      case 'user':
+      case 'system':
+        // remove approved tool calls from the set before checking:
+        for (const id of approvedToolCallIds) {
+          toolCallIds.delete(id);
+        }
+
+        if (toolCallIds.size > 0) {
+          throw new MissingToolResultsError({
+            toolCallIds: Array.from(toolCallIds),
+          });
+        }
+        break;
+    }
+  }
+
+  // remove approved tool calls from the set before checking:
+  for (const id of approvedToolCallIds) {
+    toolCallIds.delete(id);
+  }
+
+  if (toolCallIds.size > 0) {
+    throw new MissingToolResultsError({ toolCallIds: Array.from(toolCallIds) });
+  }
+
+  return combinedMessages.filter(
+    // Filter out empty tool messages (e.g. if they only contained
+    // tool-approval-response parts that were removed).
+    // This prevents sending invalid empty messages to the provider.
+    // Note: provider-executed tool-approval-response parts are preserved.
+    message => message.role !== 'tool' || message.content.length > 0,
+  );
 }
 
 /**

package/src/prompt/convert-to-language-model-prompt.validation.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import { convertToLanguageModelPrompt } from './convert-to-language-model-prompt';
+import { MissingToolResultsError } from '../error/missing-tool-result-error';
+
+describe('tool validation', () => {
+  it('should pass validation for provider-executed tools (deferred results)', async () => {
+    const result = await convertToLanguageModelPrompt({
+      prompt: {
+        messages: [
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: 'call_1',
+                toolName: 'code_interpreter',
+                input: { code: 'print("hello")' },
+                providerExecuted: true,
+              },
+            ],
+          },
+        ],
+      },
+      supportedUrls: {},
+      download: undefined,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should pass validation for tool-approval-response', async () => {
+    const result = await convertToLanguageModelPrompt({
+      prompt: {
+        messages: [
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: 'call_to_approve',
+                toolName: 'dangerous_action',
+                input: { action: 'delete_db' },
+              },
+              {
+                type: 'tool-approval-request',
+                toolCallId: 'call_to_approve',
+                approvalId: 'approval_123',
+                toolName: 'dangerous_action',
+                input: { action: 'delete_db' },
+              } as any,
+            ],
+          },
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-approval-response',
+                approvalId: 'approval_123',
+                approved: true,
+              } as any,
+            ],
+          },
+        ],
+      },
+      supportedUrls: {},
+      download: undefined,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should preserve provider-executed tool-approval-response', async () => {
+    const result = await convertToLanguageModelPrompt({
+      prompt: {
+        messages: [
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: 'call_provider_executed',
+                toolName: 'mcp_tool',
+                input: { action: 'execute' },
+                providerExecuted: true,
+              },
+              {
+                type: 'tool-approval-request',
+                toolCallId: 'call_provider_executed',
+                approvalId: 'approval_provider',
+                toolName: 'mcp_tool',
+                input: { action: 'execute' },
+              } as any,
+            ],
+          },
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-approval-response',
+                approvalId: 'approval_provider',
+                approved: true,
+                providerExecuted: true,
+              },
+            ],
+          },
+        ],
+      },
+      supportedUrls: {},
+      download: undefined,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should throw error for actual missing results', async () => {
+    await expect(async () => {
+      await convertToLanguageModelPrompt({
+        prompt: {
+          messages: [
+            {
+              role: 'assistant',
+              content: [
+                {
+                  type: 'tool-call',
+                  toolCallId: 'call_missing_result',
+                  toolName: 'regular_tool',
+                  input: {},
+                },
+              ],
+            },
+          ],
+        },
+        supportedUrls: {},
+        download: undefined,
+      });
+    }).rejects.toThrow(MissingToolResultsError);
+  });
+});