@ai-sdk/anthropic 4.0.0-beta.5 → 4.0.0-beta.67

package/src/{convert-to-anthropic-messages-prompt.ts → convert-to-anthropic-prompt.ts}

@@ -1,29 +1,32 @@
 import {
-  SharedV4Warning,
-  LanguageModelV4DataContent,
-  LanguageModelV4Message,
-  LanguageModelV4Prompt,
-  SharedV4ProviderMetadata,
   UnsupportedFunctionalityError,
+  type SharedV4Warning,
+  type LanguageModelV4Message,
+  type LanguageModelV4Prompt,
+  type SharedV4ProviderMetadata,
 } from '@ai-sdk/provider';
 import {
   convertBase64ToUint8Array,
   convertToBase64,
+  getTopLevelMediaType,
   parseProviderOptions,
+  resolveFullMediaType,
+  resolveProviderReference,
   validateTypes,
   isNonNullable,
-  ToolNameMapping,
+  type ToolNameMapping,
 } from '@ai-sdk/provider-utils';
 import {
-  AnthropicAssistantMessage,
-  AnthropicMessagesPrompt,
   anthropicReasoningMetadataSchema,
-  AnthropicToolResultContent,
-  AnthropicUserMessage,
-  AnthropicWebFetchToolResultContent,
-} from './anthropic-messages-api';
-import { anthropicFilePartProviderOptions } from './anthropic-messages-options';
+  type AnthropicAssistantMessage,
+  type AnthropicPrompt,
+  type AnthropicToolResultContent,
+  type AnthropicUserMessage,
+  type AnthropicWebFetchToolResultContent,
+} from './anthropic-api';
+import { anthropicFilePartProviderOptions } from './anthropic-language-model-options';
 import { CacheControlValidator } from './get-cache-control';
+import { advisor_20260301OutputSchema } from './tool/advisor_20260301';
 import { codeExecution_20250522OutputSchema } from './tool/code-execution_20250522';
 import { codeExecution_20250825OutputSchema } from './tool/code-execution_20250825';
 import { codeExecution_20260120OutputSchema } from './tool/code-execution_20260120';
@@ -31,44 +34,37 @@ import { toolSearchRegex_20251119OutputSchema as toolSearchOutputSchema } from '
 import { webFetch_20250910OutputSchema } from './tool/web-fetch-20250910';
 import { webSearch_20250305OutputSchema } from './tool/web-search_20250305';
 
-function convertToString(data: LanguageModelV4DataContent): string {
+function convertBytesDataToString(data: Uint8Array | string): string {
   if (typeof data === 'string') {
     return new TextDecoder().decode(convertBase64ToUint8Array(data));
   }
-
-  if (data instanceof Uint8Array) {
-    return new TextDecoder().decode(data);
-  }
-
-  if (data instanceof URL) {
-    throw new UnsupportedFunctionalityError({
-      functionality: 'URL-based text documents are not supported for citations',
-    });
-  }
-
-  throw new UnsupportedFunctionalityError({
-    functionality: `unsupported data type for text documents: ${typeof data}`,
-  });
+  return new TextDecoder().decode(data);
 }
 
 /**
- * Checks if data is a URL (either a URL object or a URL string).
+ * Extract error information from a provider tool error result value.
+ * Handles both stringified JSON and plain object forms.
  */
-function isUrlData(
-  data: LanguageModelV4DataContent,
-): data is URL | (string & { __brand: 'url-string' }) {
-  return data instanceof URL || isUrlString(data);
-}
-
-function isUrlString(data: LanguageModelV4DataContent): boolean {
-  return typeof data === 'string' && /^https?:\/\//i.test(data);
-}
-
-function getUrlString(data: LanguageModelV4DataContent): string {
-  return data instanceof URL ? data.toString() : (data as string);
+function extractErrorValue(value: unknown): { errorCode?: string } {
+  try {
+    if (typeof value === 'string') {
+      return JSON.parse(value);
+    } else if (typeof value === 'object' && value !== null) {
+      return value as { errorCode?: string };
+    }
+  } catch {
+    const extractedErrorCode = (value as Record<string, unknown>)?.errorCode;
+    return {
+      errorCode:
+        typeof extractedErrorCode === 'string'
+          ? extractedErrorCode
+          : 'unavailable',
+    };
+  }
+  return {};
 }
 
-export async function convertToAnthropicMessagesPrompt({
+export async function convertToAnthropicPrompt({
   prompt,
   sendReasoning,
   warnings,
@@ -81,15 +77,15 @@ export async function convertToAnthropicMessagesPrompt({
   cacheControlValidator?: CacheControlValidator;
   toolNameMapping: ToolNameMapping;
 }): Promise<{
-  prompt: AnthropicMessagesPrompt;
+  prompt: AnthropicPrompt;
   betas: Set<string>;
 }> {
   const betas = new Set<string>();
   const blocks = groupIntoBlocks(prompt);
   const validator = cacheControlValidator || new CacheControlValidator();
 
-  let system: AnthropicMessagesPrompt['system'] = undefined;
-  const messages: AnthropicMessagesPrompt['messages'] = [];
+  let system: AnthropicPrompt['system'] = undefined;
+  const messages: AnthropicPrompt['messages'] = [];
 
   async function shouldEnableCitations(
     providerMetadata: SharedV4ProviderMetadata | undefined,
@@ -103,6 +99,18 @@ export async function convertToAnthropicMessagesPrompt({
     return anthropicOptions?.citations?.enabled ?? false;
   }
 
+  async function shouldUseContainerUpload(
+    providerMetadata: SharedV4ProviderMetadata | undefined,
+  ): Promise<boolean> {
+    const anthropicOptions = await parseProviderOptions({
+      provider: 'anthropic',
+      providerOptions: providerMetadata,
+      schema: anthropicFilePartProviderOptions,
+    });
+
+    return anthropicOptions?.containerUpload ?? false;
+  }
+
   async function getDocumentMetadata(
     providerMetadata: SharedV4ProviderMetadata | undefined,
   ): Promise<{ title?: string; context?: string }> {
@@ -125,15 +133,8 @@ export async function convertToAnthropicMessagesPrompt({
 
     switch (type) {
       case 'system': {
-        if (system != null) {
-          throw new UnsupportedFunctionalityError({
-            functionality:
-              'Multiple system messages that are separated by user/assistant messages',
-          });
-        }
-
-        system = block.messages.map(({ content, providerOptions }) => ({
-          type: 'text',
+        const content = block.messages.map(({ content, providerOptions }) => ({
+          type: 'text' as const,
           text: content,
           cache_control: validator.getCacheControl(providerOptions, {
             type: 'system message',
@@ -141,6 +142,13 @@ export async function convertToAnthropicMessagesPrompt({
           }),
         }));
 
+        if (system == null) {
+          system = content;
+        } else {
+          messages.push({ role: 'system', content });
+          betas.add('mid-conversation-system-2026-04-07');
+        }
+
         break;
       }
 
@@ -183,86 +191,163 @@ export async function convertToAnthropicMessagesPrompt({
                   }
 
                   case 'file': {
-                    if (part.mediaType.startsWith('image/')) {
-                      anthropicContent.push({
-                        type: 'image',
-                        source: isUrlData(part.data)
-                          ? {
-                              type: 'url',
-                              url: getUrlString(part.data),
-                            }
-                          : {
-                              type: 'base64',
-                              media_type:
-                                part.mediaType === 'image/*'
-                                  ? 'image/jpeg'
-                                  : part.mediaType,
-                              data: convertToBase64(part.data),
-                            },
-                        cache_control: cacheControl,
-                      });
-                    } else if (part.mediaType === 'application/pdf') {
-                      betas.add('pdfs-2024-09-25');
-
-                      const enableCitations = await shouldEnableCitations(
-                        part.providerOptions,
-                      );
-
-                      const metadata = await getDocumentMetadata(
-                        part.providerOptions,
-                      );
-
-                      anthropicContent.push({
-                        type: 'document',
-                        source: isUrlData(part.data)
-                          ? {
-                              type: 'url',
-                              url: getUrlString(part.data),
-                            }
-                          : {
-                              type: 'base64',
-                              media_type: 'application/pdf',
-                              data: convertToBase64(part.data),
-                            },
-                        title: metadata.title ?? part.filename,
-                        ...(metadata.context && { context: metadata.context }),
-                        ...(enableCitations && {
-                          citations: { enabled: true },
-                        }),
-                        cache_control: cacheControl,
-                      });
-                    } else if (part.mediaType === 'text/plain') {
-                      const enableCitations = await shouldEnableCitations(
-                        part.providerOptions,
-                      );
-
-                      const metadata = await getDocumentMetadata(
-                        part.providerOptions,
-                      );
-
-                      anthropicContent.push({
-                        type: 'document',
-                        source: isUrlData(part.data)
-                          ? {
-                              type: 'url',
-                              url: getUrlString(part.data),
-                            }
-                          : {
-                              type: 'text',
-                              media_type: 'text/plain',
-                              data: convertToString(part.data),
-                            },
-                        title: metadata.title ?? part.filename,
-                        ...(metadata.context && { context: metadata.context }),
-                        ...(enableCitations && {
-                          citations: { enabled: true },
-                        }),
-                        cache_control: cacheControl,
-                      });
-                    } else {
-                      throw new UnsupportedFunctionalityError({
-                        functionality: `media type: ${part.mediaType}`,
-                      });
+                    switch (part.data.type) {
+                      case 'reference': {
+                        const fileId = resolveProviderReference({
+                          reference: part.data.reference,
+                          provider: 'anthropic',
+                        });
+                        betas.add('files-api-2025-04-14');
+
+                        if (
+                          await shouldUseContainerUpload(part.providerOptions)
+                        ) {
+                          anthropicContent.push({
+                            type: 'container_upload',
+                            file_id: fileId,
+                          });
+                        } else if (
+                          getTopLevelMediaType(part.mediaType) === 'image'
+                        ) {
+                          anthropicContent.push({
+                            type: 'image',
+                            source: { type: 'file', file_id: fileId },
+                            cache_control: cacheControl,
+                          });
+                        } else {
+                          anthropicContent.push({
+                            type: 'document',
+                            source: { type: 'file', file_id: fileId },
+                            cache_control: cacheControl,
+                          });
+                        }
+                        break;
+                      }
+                      case 'text': {
+                        const enableCitations = await shouldEnableCitations(
+                          part.providerOptions,
+                        );
+
+                        const metadata = await getDocumentMetadata(
+                          part.providerOptions,
+                        );
+
+                        anthropicContent.push({
+                          type: 'document',
+                          source: {
+                            type: 'text',
+                            media_type: 'text/plain',
+                            data: part.data.text,
+                          },
+                          title: metadata.title ?? part.filename,
+                          ...(metadata.context && {
+                            context: metadata.context,
+                          }),
+                          ...(enableCitations && {
+                            citations: { enabled: true },
+                          }),
+                          cache_control: cacheControl,
+                        });
+                        break;
+                      }
+                      case 'url':
+                      case 'data': {
+                        const topLevel = getTopLevelMediaType(part.mediaType);
+                        if (topLevel === 'image') {
+                          anthropicContent.push({
+                            type: 'image',
+                            source:
+                              part.data.type === 'url'
+                                ? {
+                                    type: 'url',
+                                    url: part.data.url.toString(),
+                                  }
+                                : {
+                                    type: 'base64',
+                                    media_type: resolveFullMediaType({ part }),
+                                    data: convertToBase64(part.data.data),
+                                  },
+                            cache_control: cacheControl,
+                          });
+                        } else if (
+                          topLevel === 'application' &&
+                          (part.data.type === 'url'
+                            ? part.mediaType === 'application/pdf'
+                            : resolveFullMediaType({ part }) ===
+                              'application/pdf')
+                        ) {
+                          betas.add('pdfs-2024-09-25');
+
+                          const enableCitations = await shouldEnableCitations(
+                            part.providerOptions,
+                          );
+
+                          const metadata = await getDocumentMetadata(
+                            part.providerOptions,
+                          );
+
+                          anthropicContent.push({
+                            type: 'document',
+                            source:
+                              part.data.type === 'url'
+                                ? {
+                                    type: 'url',
+                                    url: part.data.url.toString(),
+                                  }
+                                : {
+                                    type: 'base64',
+                                    media_type: 'application/pdf',
+                                    data: convertToBase64(part.data.data),
+                                  },
+                            title: metadata.title ?? part.filename,
+                            ...(metadata.context && {
+                              context: metadata.context,
+                            }),
+                            ...(enableCitations && {
+                              citations: { enabled: true },
+                            }),
+                            cache_control: cacheControl,
+                          });
+                        } else if (part.mediaType === 'text/plain') {
+                          const enableCitations = await shouldEnableCitations(
+                            part.providerOptions,
+                          );
+
+                          const metadata = await getDocumentMetadata(
+                            part.providerOptions,
+                          );
+
+                          anthropicContent.push({
+                            type: 'document',
+                            source:
+                              part.data.type === 'url'
+                                ? {
+                                    type: 'url',
+                                    url: part.data.url.toString(),
+                                  }
+                                : {
+                                    type: 'text',
+                                    media_type: 'text/plain',
+                                    data: convertBytesDataToString(
+                                      part.data.data,
+                                    ),
+                                  },
+                            title: metadata.title ?? part.filename,
+                            ...(metadata.context && {
+                              context: metadata.context,
+                            }),
+                            ...(enableCitations && {
+                              citations: { enabled: true },
+                            }),
+                            cache_control: cacheControl,
+                          });
+                        } else {
+                          throw new UnsupportedFunctionalityError({
+                            functionality: `media type: ${part.mediaType}`,
+                          });
+                        }
+                        break;
+                      }
                     }
 
                     break;
@@ -280,9 +365,19 @@ export async function convertToAnthropicMessagesPrompt({
                   continue;
                 }
 
+                const output = part.output;
+                const outputProviderOptions =
+                  'providerOptions' in output
+                    ? output.providerOptions
+                    : output.type === 'content'
+                      ? output.value.find(
+                          contentPart => contentPart.providerOptions != null,
+                        )?.providerOptions
+                      : undefined;
+
                 // cache control: first add cache control from part.
-                // for the last part of a message,
-                // check also if the message has cache control.
+                // then from tool result output, and for the last part of a
+                // message, check also if the message has cache control.
                 const isLastPart = i === content.length - 1;
 
                 const cacheControl =
@@ -290,6 +385,10 @@ export async function convertToAnthropicMessagesPrompt({
                     type: 'tool result part',
                     canCache: true,
                   }) ??
+                  validator.getCacheControl(outputProviderOptions, {
+                    type: 'tool result output',
+                    canCache: true,
+                  }) ??
                   (isLastPart
                     ? validator.getCacheControl(message.providerOptions, {
                         type: 'tool result message',
@@ -297,7 +396,6 @@ export async function convertToAnthropicMessagesPrompt({
                       })
                     : undefined);
 
-                const output = part.output;
                 let contentValue: AnthropicToolResultContent['content'];
                 switch (output.type) {
                   case 'content':
@@ -309,50 +407,73 @@ export async function convertToAnthropicMessagesPrompt({
                               type: 'text' as const,
                               text: contentPart.text,
                             };
-                          case 'image-data': {
-                            return {
-                              type: 'image' as const,
-                              source: {
-                                type: 'base64' as const,
-                                media_type: contentPart.mediaType,
-                                data: contentPart.data,
-                              },
-                            };
-                          }
-                          case 'image-url': {
-                            return {
-                              type: 'image' as const,
-                              source: {
-                                type: 'url' as const,
-                                url: contentPart.url,
-                              },
-                            };
-                          }
-                          case 'file-url': {
-                            return {
-                              type: 'document' as const,
-                              source: {
-                                type: 'url' as const,
-                                url: contentPart.url,
-                              },
-                            };
-                          }
-                          case 'file-data': {
-                            if (contentPart.mediaType === 'application/pdf') {
-                              betas.add('pdfs-2024-09-25');
+                          case 'file': {
+                            const topLevel = getTopLevelMediaType(
+                              contentPart.mediaType,
+                            );
+
+                            if (contentPart.data.type === 'url') {
+                              if (topLevel === 'image') {
+                                return {
+                                  type: 'image' as const,
+                                  source: {
+                                    type: 'url' as const,
+                                    url: contentPart.data.url.toString(),
+                                  },
+                                };
+                              }
                               return {
                                 type: 'document' as const,
                                 source: {
-                                  type: 'base64' as const,
-                                  media_type: contentPart.mediaType,
-                                  data: contentPart.data,
+                                  type: 'url' as const,
+                                  url: contentPart.data.url.toString(),
                                 },
                               };
                             }
 
+                            if (contentPart.data.type === 'data') {
+                              if (topLevel === 'image') {
+                                return {
+                                  type: 'image' as const,
+                                  source: {
+                                    type: 'base64' as const,
+                                    media_type: resolveFullMediaType({
+                                      part: contentPart,
+                                    }),
+                                    data: convertToBase64(
+                                      contentPart.data.data,
+                                    ),
+                                  },
+                                };
+                              }
+                              if (
+                                resolveFullMediaType({ part: contentPart }) ===
+                                'application/pdf'
+                              ) {
+                                betas.add('pdfs-2024-09-25');
+                                return {
+                                  type: 'document' as const,
+                                  source: {
+                                    type: 'base64' as const,
+                                    media_type: 'application/pdf',
+                                    data: convertToBase64(
+                                      contentPart.data.data,
+                                    ),
+                                  },
+                                };
+                              }
+
+                              warnings.push({
+                                type: 'other',
+                                message: `unsupported tool content part type: ${contentPart.type} with media type: ${contentPart.mediaType}`,
+                              });
+
+                              return undefined;
+                            }
+
                             warnings.push({
                               type: 'other',
-                              message: `unsupported tool content part type: ${contentPart.type} with media type: ${contentPart.mediaType}`,
+                              message: `unsupported tool content part type: ${contentPart.type} with data type: ${contentPart.data.type}`,
                             });
 
                             return undefined;
@@ -377,7 +498,7 @@ export async function convertToAnthropicMessagesPrompt({
                           default: {
                             warnings.push({
                               type: 'other',
-                              message: `unsupported tool content part type: ${contentPart.type}`,
+                              message: `unsupported tool content part type: ${(contentPart as { type: string }).type}`,
                             });
 
                             return undefined;
@@ -391,7 +512,8 @@ export async function convertToAnthropicMessagesPrompt({
                     contentValue = output.value;
                     break;
                   case 'execution-denied':
-                    contentValue = output.reason ?? 'Tool execution denied.';
+                    contentValue =
+                      output.reason ?? 'Tool call execution denied.';
                     break;
                   case 'json':
                   case 'error-json':
@@ -634,6 +756,15 @@ export async function convertToAnthropicMessagesPrompt({
                         input: part.input,
                         cache_control: cacheControl,
                       });
+                    } else if (providerToolName === 'advisor') {
+                      // The advisor server_tool_use.input is always {}.
+                      anthropicContent.push({
+                        type: 'server_tool_use',
+                        id: part.toolCallId,
+                        name: 'advisor',
+                        input: {},
+                        cache_control: cacheControl,
+                      });
                     } else {
                       warnings.push({
                         type: 'other',
@@ -865,35 +996,14 @@ export async function convertToAnthropicMessagesPrompt({
                   const output = part.output;
 
                   if (output.type === 'error-json') {
-                    let errorValue: { errorCode?: string } = {};
-                    try {
-                      if (typeof output.value === 'string') {
-                        errorValue = JSON.parse(output.value);
-                      } else if (
-                        typeof output.value === 'object' &&
-                        output.value !== null
-                      ) {
-                        errorValue = output.value as typeof errorValue;
-                      }
-                    } catch {
-                      // If parsing fails, treat the value as-is
-                      const extractedErrorCode = (
-                        output.value as Record<string, unknown>
-                      )?.errorCode;
-                      errorValue = {
-                        errorCode:
-                          typeof extractedErrorCode === 'string'
-                            ? extractedErrorCode
-                            : 'unavailable',
-                      };
-                    }
-
                     anthropicContent.push({
                       type: 'web_fetch_tool_result',
                       tool_use_id: part.toolCallId,
                       content: {
                         type: 'web_fetch_tool_result_error',
-                        error_code: errorValue.errorCode ?? 'unavailable',
+                        error_code:
+                          extractErrorValue(output.value).errorCode ??
+                          'unavailable',
                       },
                       cache_control: cacheControl,
                     });
@@ -948,6 +1058,22 @@ export async function convertToAnthropicMessagesPrompt({
                 if (providerToolName === 'web_search') {
                   const output = part.output;
 
+                  if (output.type === 'error-json') {
+                    anthropicContent.push({
+                      type: 'web_search_tool_result',
+                      tool_use_id: part.toolCallId,
+                      content: {
+                        type: 'web_search_tool_result_error',
+                        error_code:
+                          extractErrorValue(output.value).errorCode ??
+                          'unavailable',
+                      },
+                      cache_control: cacheControl,
+                    });
+
+                    break;
+                  }
+
                   if (output.type !== 'json') {
                     warnings.push({
                       type: 'other',
@@ -1020,6 +1146,58 @@ export async function convertToAnthropicMessagesPrompt({
                   break;
                 }
 
+                if (providerToolName === 'advisor') {
+                  const output = part.output;
+
+                  if (output.type !== 'json' && output.type !== 'error-json') {
+                    warnings.push({
+                      type: 'other',
+                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`,
+                    });
+
+                    break;
+                  }
+
+                  const advisorOutput = await validateTypes({
+                    value: output.value,
+                    schema: advisor_20260301OutputSchema,
+                  });
+
+                  if (advisorOutput.type === 'advisor_result') {
+                    anthropicContent.push({
+                      type: 'advisor_tool_result',
+                      tool_use_id: part.toolCallId,
+                      content: {
+                        type: 'advisor_result',
+                        text: advisorOutput.text,
+                      },
+                      cache_control: cacheControl,
+                    });
+                  } else if (advisorOutput.type === 'advisor_redacted_result') {
+                    anthropicContent.push({
+                      type: 'advisor_tool_result',
+                      tool_use_id: part.toolCallId,
+                      content: {
+                        type: 'advisor_redacted_result',
+                        encrypted_content: advisorOutput.encryptedContent,
+                      },
+                      cache_control: cacheControl,
+                    });
+                  } else {
+                    anthropicContent.push({
+                      type: 'advisor_tool_result',
+                      tool_use_id: part.toolCallId,
+                      content: {
+                        type: 'advisor_tool_result_error',
+                        error_code: advisorOutput.errorCode,
+                      },
+                      cache_control: cacheControl,
+                    });
+                  }
+
+                  break;
+                }
+
                 warnings.push({
                   type: 'other',
                   message: `provider executed tool result for tool ${part.toolName} is not supported`,