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

package/src/forward-anthropic-container-id-from-last-step.ts

@@ -1,5 +1,5 @@
-import { JSONObject } from '@ai-sdk/provider';
-import { AnthropicMessageMetadata } from './anthropic-message-metadata';
+import type { JSONObject } from '@ai-sdk/provider';
+import type { AnthropicMessageMetadata } from './anthropic-message-metadata';
 
 /**
  * Sets the Anthropic container ID in the provider options based on

package/src/get-cache-control.ts

@@ -1,5 +1,8 @@
-import { SharedV4Warning, SharedV4ProviderMetadata } from '@ai-sdk/provider';
-import { AnthropicCacheControl } from './anthropic-messages-api';
+import type {
+  SharedV4Warning,
+  SharedV4ProviderMetadata,
+} from '@ai-sdk/provider';
+import type { AnthropicCacheControl } from './anthropic-api';
 
 // Anthropic allows a maximum of 4 cache breakpoints per request
 const MAX_CACHE_BREAKPOINTS = 4;

package/src/index.ts

@@ -6,7 +6,7 @@ export type {
   AnthropicLanguageModelOptions,
   /** @deprecated Use `AnthropicLanguageModelOptions` instead. */
   AnthropicLanguageModelOptions as AnthropicProviderOptions,
-} from './anthropic-messages-options';
+} from './anthropic-language-model-options';
 export type { AnthropicToolOptions } from './anthropic-prepare-tools';
 export { anthropic, createAnthropic } from './anthropic-provider';
 export type {

package/src/internal/index.ts

@@ -1,4 +1,15 @@
-export { AnthropicMessagesLanguageModel } from '../anthropic-messages-language-model';
+export { AnthropicFiles } from '../anthropic-files';
+export {
+  AnthropicLanguageModel,
+  /** @deprecated Use `AnthropicLanguageModel` instead. */
+  AnthropicLanguageModel as AnthropicMessagesLanguageModel,
+  getModelCapabilities,
+} from '../anthropic-language-model';
 export { anthropicTools } from '../anthropic-tools';
-export type { AnthropicMessagesModelId } from '../anthropic-messages-options';
+export type {
+  AnthropicModelId,
+  /** @deprecated Use `AnthropicModelId` instead. */
+  AnthropicModelId as AnthropicMessagesModelId,
+} from '../anthropic-language-model-options';
 export { prepareTools } from '../anthropic-prepare-tools';
+export { AnthropicSkills } from '../skills/anthropic-skills';

package/src/map-anthropic-stop-reason.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV4FinishReason } from '@ai-sdk/provider';
+import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
 /**
  * @see https://docs.anthropic.com/en/api/messages#response-stop-reason

package/src/sanitize-json-schema.ts

@@ -0,0 +1,203 @@
+import type { JSONSchema7, JSONSchema7Definition } from '@ai-sdk/provider';
+
+const SUPPORTED_STRING_FORMATS = new Set([
+  'date-time',
+  'time',
+  'date',
+  'duration',
+  'email',
+  'hostname',
+  'uri',
+  'ipv4',
+  'ipv6',
+  'uuid',
+]);
+
+const DESCRIPTION_CONSTRAINT_KEYS = [
+  'minimum',
+  'maximum',
+  'exclusiveMinimum',
+  'exclusiveMaximum',
+  'multipleOf',
+  'minLength',
+  'maxLength',
+  'pattern',
+  'minItems',
+  'maxItems',
+  'uniqueItems',
+  'minProperties',
+  'maxProperties',
+  'not',
+] satisfies Array<keyof JSONSchema7>;
+
+/**
+ * Removes JSON Schema keywords that Anthropic rejects in
+ * `output_config.format.schema`.
+ *
+ * The full original schema is still used by AI SDK result validation. This
+ * only relaxes the schema sent to Anthropic's constrained decoder.
+ */
+export function sanitizeJsonSchema(schema: JSONSchema7): JSONSchema7 {
+  return sanitizeSchema(schema) as JSONSchema7;
+}
+
+function sanitizeDefinition(
+  definition: JSONSchema7Definition,
+): JSONSchema7Definition {
+  if (typeof definition === 'boolean' || !isPlainObject(definition)) {
+    return definition;
+  }
+
+  return sanitizeSchema(definition as JSONSchema7);
+}
+
+function sanitizeSchema(schema: JSONSchema7): JSONSchema7 {
+  const result: JSONSchema7 = {};
+  const schemaWithDefs = schema as JSONSchema7 & {
+    $defs?: Record<string, JSONSchema7Definition>;
+  };
+
+  if (schema.$ref != null) {
+    return { $ref: schema.$ref };
+  }
+
+  if (schema.$schema != null) {
+    result.$schema = schema.$schema;
+  }
+
+  if (schema.$id != null) {
+    result.$id = schema.$id;
+  }
+
+  if (schema.title != null) {
+    result.title = schema.title;
+  }
+
+  if (schema.description != null) {
+    result.description = schema.description;
+  }
+
+  if (schema.default !== undefined) {
+    result.default = schema.default;
+  }
+
+  if (schema.const !== undefined) {
+    result.const = schema.const;
+  }
+
+  if (schema.enum != null) {
+    result.enum = schema.enum;
+  }
+
+  if (schema.type != null) {
+    result.type = schema.type;
+  }
+
+  if (schema.anyOf != null) {
+    result.anyOf = schema.anyOf.map(sanitizeDefinition);
+  } else if (schema.oneOf != null) {
+    result.anyOf = schema.oneOf.map(sanitizeDefinition);
+  }
+
+  if (schema.allOf != null) {
+    result.allOf = schema.allOf.map(sanitizeDefinition);
+  }
+
+  if (schema.definitions != null) {
+    result.definitions = Object.fromEntries(
+      Object.entries(schema.definitions).map(([name, definition]) => [
+        name,
+        sanitizeDefinition(definition),
+      ]),
+    );
+  }
+
+  if (schemaWithDefs.$defs != null) {
+    const resultWithDefs = result as JSONSchema7 & {
+      $defs?: Record<string, JSONSchema7Definition>;
+    };
+    resultWithDefs.$defs = Object.fromEntries(
+      Object.entries(schemaWithDefs.$defs).map(([name, definition]) => [
+        name,
+        sanitizeDefinition(definition),
+      ]),
+    );
+  }
+
+  if (schema.type === 'object' || schema.properties != null) {
+    if (schema.properties != null) {
+      result.properties = Object.fromEntries(
+        Object.entries(schema.properties).map(([name, definition]) => [
+          name,
+          sanitizeDefinition(definition),
+        ]),
+      );
+    }
+
+    result.additionalProperties = false;
+
+    if (schema.required != null) {
+      result.required = schema.required;
+    }
+  }
+
+  if (schema.items != null) {
+    result.items = Array.isArray(schema.items)
+      ? schema.items.map(sanitizeDefinition)
+      : sanitizeDefinition(schema.items);
+  }
+
+  if (
+    typeof schema.format === 'string' &&
+    SUPPORTED_STRING_FORMATS.has(schema.format)
+  ) {
+    result.format = schema.format;
+  }
+
+  const constraintDescription = getConstraintDescription(schema);
+  if (constraintDescription != null) {
+    result.description =
+      result.description == null
+        ? constraintDescription
+        : `${result.description}\n${constraintDescription}`;
+  }
+
+  return result;
+}
+
+function getConstraintDescription(schema: JSONSchema7): string | undefined {
+  const descriptions = DESCRIPTION_CONSTRAINT_KEYS.flatMap(key => {
+    const value = schema[key];
+
+    if (value == null || value === false) {
+      return [];
+    }
+
+    return `${formatConstraintName(key)}: ${formatConstraintValue(value)}`;
+  });
+
+  if (
+    typeof schema.format === 'string' &&
+    !SUPPORTED_STRING_FORMATS.has(schema.format)
+  ) {
+    descriptions.push(`format: ${schema.format}`);
+  }
+
+  return descriptions.length === 0 ? undefined : `${descriptions.join('; ')}.`;
+}
+
+function formatConstraintName(key: string): string {
+  return key.replace(/[A-Z]/g, match => ` ${match.toLowerCase()}`);
+}
+
+function formatConstraintValue(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  return JSON.stringify(value);
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/src/skills/anthropic-skills-api.ts

@@ -0,0 +1,44 @@
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const anthropicSkillResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      id: z.string(),
+      display_title: z.string().nullish(),
+      name: z.string().nullish(),
+      description: z.string().nullish(),
+      latest_version: z.string().nullish(),
+      source: z.string(),
+      created_at: z.string(),
+      updated_at: z.string(),
+    }),
+  ),
+);
+
+export type AnthropicSkillResponse = ReturnType<
+  typeof anthropicSkillResponseSchema
+>['_type'];
+
+export const anthropicSkillVersionListResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      data: z.array(
+        z.object({
+          version: z.string(),
+        }),
+      ),
+    }),
+  ),
+);
+
+export const anthropicSkillVersionResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      type: z.string(),
+      skill_id: z.string(),
+      name: z.string().nullish(),
+      description: z.string().nullish(),
+    }),
+  ),
+);

package/src/skills/anthropic-skills.ts

@@ -0,0 +1,132 @@
+import type { SkillsV4, SharedV4Warning } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertInlineFileDataToUint8Array,
+  createJsonResponseHandler,
+  getFromApi,
+  postFormDataToApi,
+  resolve,
+  type FetchFunction,
+  type Resolvable,
+} from '@ai-sdk/provider-utils';
+import { anthropicFailedResponseHandler } from '../anthropic-error';
+import {
+  anthropicSkillResponseSchema,
+  anthropicSkillVersionResponseSchema,
+} from './anthropic-skills-api';
+
+interface AnthropicSkillsConfig {
+  provider: string;
+  baseURL: string;
+  headers: Resolvable<Record<string, string | undefined>>;
+  fetch?: FetchFunction;
+}
+
+export class AnthropicSkills implements SkillsV4 {
+  readonly specificationVersion = 'v4';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(private readonly config: AnthropicSkillsConfig) {}
+
+  private async getHeaders(): Promise<Record<string, string | undefined>> {
+    return combineHeaders(await resolve(this.config.headers), {
+      'anthropic-beta': 'skills-2025-10-02',
+    });
+  }
+
+  private async fetchVersionMetadata({
+    skillId,
+    version,
+    headers,
+  }: {
+    skillId: string;
+    version: string;
+    headers: Record<string, string | undefined>;
+  }): Promise<{ name?: string; description?: string }> {
+    const { value: versionResponse } = await getFromApi({
+      url: `${this.config.baseURL}/skills/${skillId}/versions/${version}`,
+      headers,
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        anthropicSkillVersionResponseSchema,
+      ),
+      fetch: this.config.fetch,
+    });
+
+    return {
+      ...(versionResponse.name != null ? { name: versionResponse.name } : {}),
+      ...(versionResponse.description != null
+        ? { description: versionResponse.description }
+        : {}),
+    };
+  }
+
+  async uploadSkill(
+    params: Parameters<SkillsV4['uploadSkill']>[0],
+  ): Promise<Awaited<ReturnType<SkillsV4['uploadSkill']>>> {
+    const warnings: SharedV4Warning[] = [];
+
+    const formData = new FormData();
+
+    if (params.displayTitle != null) {
+      formData.append('display_title', params.displayTitle);
+    }
+
+    for (const file of params.files) {
+      const content = convertInlineFileDataToUint8Array(file.data);
+      formData.append('files[]', new Blob([content]), file.path);
+    }
+
+    const headers = await this.getHeaders();
+
+    const { value: response } = await postFormDataToApi({
+      url: `${this.config.baseURL}/skills`,
+      headers,
+      formData,
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        anthropicSkillResponseSchema,
+      ),
+      fetch: this.config.fetch,
+    });
+
+    const versionMetadata =
+      response.latest_version != null
+        ? await this.fetchVersionMetadata({
+            skillId: response.id,
+            version: response.latest_version,
+            headers,
+          })
+        : {};
+
+    const name = versionMetadata.name ?? response.name;
+    const description = versionMetadata.description ?? response.description;
+
+    return {
+      providerReference: { anthropic: response.id },
+      ...(response.display_title != null
+        ? { displayTitle: response.display_title }
+        : {}),
+      ...(name != null ? { name } : {}),
+      ...(description != null ? { description } : {}),
+      ...(response.latest_version != null
+        ? { latestVersion: response.latest_version }
+        : {}),
+      providerMetadata: {
+        anthropic: {
+          ...(response.source != null ? { source: response.source } : {}),
+          ...(response.created_at != null
+            ? { createdAt: response.created_at }
+            : {}),
+          ...(response.updated_at != null
+            ? { updatedAt: response.updated_at }
+            : {}),
+        },
+      },
+      warnings,
+    };
+  }
+}

package/src/tool/advisor_20260301.ts

@@ -0,0 +1,128 @@
+import {
+  createProviderExecutedToolFactory,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const advisor_20260301ArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      model: z.string(),
+      maxUses: z.number().optional(),
+      caching: z
+        .object({
+          type: z.literal('ephemeral'),
+          ttl: z.union([z.literal('5m'), z.literal('1h')]),
+        })
+        .optional(),
+    }),
+  ),
+);
+
+export const advisor_20260301OutputSchema = lazySchema(() =>
+  zodSchema(
+    z.discriminatedUnion('type', [
+      z.object({
+        type: z.literal('advisor_result'),
+        text: z.string(),
+      }),
+      z.object({
+        type: z.literal('advisor_redacted_result'),
+        encryptedContent: z.string(),
+      }),
+      z.object({
+        type: z.literal('advisor_tool_result_error'),
+        errorCode: z.string(),
+      }),
+    ]),
+  ),
+);
+
+const advisor_20260301InputSchema = lazySchema(() =>
+  zodSchema(z.object({}).strict()),
+);
+
+const factory = createProviderExecutedToolFactory<
+  // Input is always empty: the executor emits server_tool_use with empty input
+  // and the server constructs the advisor's view from the full transcript.
+  {},
+  | {
+      type: 'advisor_result';
+
+      /**
+       * Plaintext advice from the advisor model.
+       */
+      text: string;
+    }
+  | {
+      type: 'advisor_redacted_result';
+
+      /**
+       * Opaque, encrypted advice. Must be round-tripped verbatim on subsequent
+       * turns; the server decrypts it server-side when rendering the advisor's
+       * advice into the executor's prompt.
+       */
+      encryptedContent: string;
+    }
+  | {
+      type: 'advisor_tool_result_error';
+
+      /**
+       * Available options: `max_uses_exceeded`, `too_many_requests`,
+       * `overloaded`, `prompt_too_long`, `execution_time_exceeded`,
+       * `unavailable`.
+       */
+      errorCode: string;
+    },
+  {
+    /**
+     * The advisor model ID, such as `"claude-opus-4-8"`. Billed at this
+     * model's rates for the sub-inference.
+     *
+     * The advisor must be at least as capable as the executor; an invalid
+     * pair returns a `400 invalid_request_error` from the API.
+     */
+    model: string;
+
+    /**
+     * Maximum number of advisor calls allowed in a single request. Once the
+     * executor reaches this cap, further advisor calls return an
+     * `advisor_tool_result_error` with `error_code: "max_uses_exceeded"` and
+     * the executor continues without further advice.
+     *
+     * This is a per-request cap, not a per-conversation cap. To enforce
+     * conversation-level limits, count advisor calls client-side; when you
+     * hit your cap, remove the advisor tool from `tools` AND strip all
+     * `advisor_tool_result` blocks from your message history (otherwise the
+     * API returns `400 invalid_request_error`).
+     */
+    maxUses?: number;
+
+    /**
+     * Enables prompt caching for the advisor's own transcript across calls
+     * within a conversation. Unlike `cache_control` on content blocks, this
+     * is not a breakpoint marker; it is an on/off switch. The server decides
+     * where cache boundaries go.
+     *
+     * The cache write costs more than the reads save when the advisor is
+     * called two or fewer times per conversation; caching breaks even at
+     * roughly three advisor calls. Enable it for long agent loops; keep it
+     * off for short tasks. Keep it consistent across a conversation —
+     * toggling causes cache misses.
+     */
+    caching?: {
+      type: 'ephemeral';
+      ttl: '5m' | '1h';
+    };
+  }
+>({
+  id: 'anthropic.advisor_20260301',
+  inputSchema: advisor_20260301InputSchema,
+  outputSchema: advisor_20260301OutputSchema,
+  supportsDeferredResults: true,
+});
+
+export const advisor_20260301 = (args: Parameters<typeof factory>[0]) => {
+  return factory(args);
+};

package/src/tool/bash_20241022.ts

@@ -1,10 +1,26 @@
 import {
-  createProviderToolFactory,
+  createProviderDefinedToolFactory,
   lazySchema,
+  type Experimental_SandboxSession as SandboxSession,
+  type ProviderDefinedTool,
+  type Tool,
+  type ToolExecuteFunction,
   zodSchema,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
+type Bash20241022Input = {
+  /**
+   * The bash command to run. Required unless the tool is being restarted.
+   */
+  command: string;
+
+  /**
+   * Specifying true will restart this tool. Otherwise, leave this unspecified.
+   */
+  restart?: boolean;
+};
+
 const bash_20241022InputSchema = lazySchema(() =>
   zodSchema(
     z.object({
@@ -14,20 +30,75 @@ const bash_20241022InputSchema = lazySchema(() =>
   ),
 );
 
-export const bash_20241022 = createProviderToolFactory<
-  {
-    /**
-     * The bash command to run. Required unless the tool is being restarted.
-     */
-    command: string;
-
-    /**
-     * Specifying true will restart this tool. Otherwise, leave this unspecified.
-     */
-    restart?: boolean;
-  },
+export const bash_20241022_internal = createProviderDefinedToolFactory<
+  Bash20241022Input,
   {}
 >({
   id: 'anthropic.bash_20241022',
   inputSchema: bash_20241022InputSchema,
 });
+
+type Bash20241022Options<OUTPUT> = {
+  execute?: ToolExecuteFunction<Bash20241022Input, OUTPUT, {}>;
+  needsApproval?: Tool<Bash20241022Input, OUTPUT, {}>['needsApproval'];
+  toModelOutput?: Tool<Bash20241022Input, OUTPUT, {}>['toModelOutput'];
+  onInputStart?: Tool<Bash20241022Input, OUTPUT, {}>['onInputStart'];
+  onInputDelta?: Tool<Bash20241022Input, OUTPUT, {}>['onInputDelta'];
+  onInputAvailable?: Tool<Bash20241022Input, OUTPUT, {}>['onInputAvailable'];
+};
+
+type Bash20241022OptionsWithNullableExecute<OUTPUT> = Omit<
+  Bash20241022Options<OUTPUT>,
+  'execute'
+> & {
+  execute?: Bash20241022Options<OUTPUT>['execute'] | null;
+};
+
+type Bash20241022DefaultOutput = Awaited<ReturnType<SandboxSession['run']>>;
+
+export function bash_20241022(
+  options?: Omit<Bash20241022Options<Bash20241022DefaultOutput>, 'execute'> & {
+    execute?: undefined;
+  },
+): ProviderDefinedTool<Bash20241022Input, Bash20241022DefaultOutput, {}>;
+export function bash_20241022<OUTPUT = never>(
+  options: Omit<Bash20241022Options<OUTPUT>, 'execute'> & {
+    execute: null;
+  },
+): ProviderDefinedTool<Bash20241022Input, OUTPUT, {}>;
+export function bash_20241022<OUTPUT>(
+  options: Omit<Bash20241022Options<OUTPUT>, 'execute'> & {
+    execute: Bash20241022Options<OUTPUT>['execute'];
+  },
+): ProviderDefinedTool<Bash20241022Input, OUTPUT, {}>;
+export function bash_20241022<OUTPUT>(
+  options: Bash20241022OptionsWithNullableExecute<OUTPUT> = {},
+): ProviderDefinedTool<Bash20241022Input, OUTPUT, {}> {
+  const { execute, ...rest } = options;
+
+  if (execute === undefined) {
+    return bash_20241022_internal({
+      ...rest,
+      execute: async (
+        { command },
+        { abortSignal, experimental_sandbox: sandbox },
+      ) => {
+        if (!sandbox) {
+          throw new Error('Sandbox session is not available');
+        }
+
+        return await sandbox.run({
+          command,
+          abortSignal,
+        });
+      },
+    } as Bash20241022Options<Bash20241022DefaultOutput>) as ReturnType<
+      typeof bash_20241022_internal<OUTPUT>
+    >;
+  }
+
+  return bash_20241022_internal({
+    ...rest,
+    ...(execute === null ? {} : { execute }),
+  } as Bash20241022Options<OUTPUT>);
+}