@openclaw/ai 0.0.0 → 2026.7.1-2

package/dist/host-4t713IeR.mjs

@@ -0,0 +1,37 @@
+//#region packages/ai/src/host.ts
+const inertAiTransportHost = {
+	buildModelFetch: () => void 0,
+	resolveSecretSentinel: (value) => value,
+	redactSecrets: (value) => value,
+	redactToolPayloadText: (text) => text,
+	resolveOpenAIStrictToolSetting: (_model, options) => options?.supportsStrictMode ? false : void 0,
+	logDebug: () => {}
+};
+let activeAiTransportHost = inertAiTransportHost;
+/** Installs host implementations for the transport policy ports. */
+function configureAiTransportHost(host) {
+	activeAiTransportHost = {
+		...inertAiTransportHost,
+		...host
+	};
+}
+/** Returns the active transport host (inert defaults unless configured). */
+function getAiTransportHost() {
+	return activeAiTransportHost;
+}
+/** Resolves sentinel substrings in custom headers at a no-fetch adapter boundary. */
+function resolveAiTransportHeaderSentinels(headers) {
+	if (!headers) return;
+	const host = getAiTransportHost();
+	let resolvedHeaders;
+	for (const [name, value] of Object.entries(headers)) {
+		const resolved = host.resolveSecretSentinel(value);
+		if (resolved !== value) {
+			resolvedHeaders ??= { ...headers };
+			resolvedHeaders[name] = resolved;
+		}
+	}
+	return resolvedHeaders ?? headers;
+}
+//#endregion
+export { getAiTransportHost as n, resolveAiTransportHeaderSentinels as r, configureAiTransportHost as t };

package/dist/index-BoTnz8cv.d.mts

@@ -0,0 +1,74 @@
+//#region packages/llm-core/src/model-contracts/anthropic.d.ts
+type ClaudeModelRef = {
+  id?: string;
+  params?: Record<string, unknown>;
+};
+type ClaudeEffortModelRef = ClaudeModelRef & {
+  thinkingLevelMap?: Record<string, string | null | undefined>;
+};
+declare const CLAUDE_FABLE_5_THINKING_PROFILE: {
+  readonly levels: readonly [{
+    readonly id: "off";
+  }, {
+    readonly id: "minimal";
+  }, {
+    readonly id: "low";
+  }, {
+    readonly id: "medium";
+  }, {
+    readonly id: "high";
+  }, {
+    readonly id: "xhigh";
+  }, {
+    readonly id: "adaptive";
+  }, {
+    readonly id: "max";
+  }];
+  readonly defaultLevel: "high";
+  readonly preserveWhenCatalogReasoningFalse: true;
+};
+declare const CLAUDE_SONNET_5_THINKING_PROFILE: {
+  readonly levels: readonly [{
+    readonly id: "off";
+  }, {
+    readonly id: "minimal";
+  }, {
+    readonly id: "low";
+  }, {
+    readonly id: "medium";
+  }, {
+    readonly id: "high";
+  }, {
+    readonly id: "xhigh";
+  }, {
+    readonly id: "adaptive";
+  }, {
+    readonly id: "max";
+  }];
+  readonly defaultLevel: "high";
+};
+/** Resolve the canonical normalized Claude model id for one runtime model ref. */
+declare function resolveClaudeModelIdentity(ref: ClaudeModelRef): string;
+/** Resolve Claude Fable 5 through direct ids, cloud ids, or deployment metadata. */
+declare function resolveClaudeFable5ModelIdentity(ref: ClaudeModelRef): string | undefined;
+/** Resolve Claude Mythos 5 through direct ids, cloud ids, or deployment metadata. */
+declare function resolveClaudeMythos5ModelIdentity(ref: ClaudeModelRef): string | undefined;
+/** Return whether a Claude model requires adaptive thinking instead of manual budgets. */
+declare function requiresClaudeMandatoryAdaptiveThinking(ref: ClaudeModelRef): boolean;
+/** Resolve Claude Sonnet 5 through direct ids, cloud ids, or deployment metadata. */
+declare function resolveClaudeSonnet5ModelIdentity(ref: ClaudeModelRef): string | undefined;
+/** Return whether a Claude model supports adaptive thinking. */
+declare function supportsClaudeAdaptiveThinking(ref: ClaudeModelRef): boolean;
+/** Return whether a Claude model supports native max effort. */
+declare function supportsClaudeNativeMaxEffort(ref: ClaudeModelRef): boolean;
+/** Return whether a Claude model supports native xhigh effort. */
+declare function supportsClaudeNativeXhighEffort(ref: ClaudeModelRef): boolean;
+/** Return whether a Claude model rejects caller-selected sampling parameters. */
+declare function requiresClaudeDefaultSampling(ref: ClaudeModelRef): boolean;
+/**
+ * Fill native Claude effort mappings only when the provider did not publish a
+ * narrower route-specific contract.
+ */
+declare function resolveClaudeNativeThinkingLevelMap(ref: ClaudeEffortModelRef): Record<string, string | null | undefined> | undefined;
+//#endregion
+export { resolveClaudeFable5ModelIdentity as a, resolveClaudeNativeThinkingLevelMap as c, supportsClaudeNativeMaxEffort as d, supportsClaudeNativeXhighEffort as f, requiresClaudeMandatoryAdaptiveThinking as i, resolveClaudeSonnet5ModelIdentity as l, CLAUDE_SONNET_5_THINKING_PROFILE as n, resolveClaudeModelIdentity as o, requiresClaudeDefaultSampling as r, resolveClaudeMythos5ModelIdentity as s, CLAUDE_FABLE_5_THINKING_PROFILE as t, supportsClaudeAdaptiveThinking as u };

package/dist/index.d.mts

@@ -0,0 +1,69 @@
+import { a as resolveClaudeFable5ModelIdentity, c as resolveClaudeNativeThinkingLevelMap, d as supportsClaudeNativeMaxEffort, f as supportsClaudeNativeXhighEffort, i as requiresClaudeMandatoryAdaptiveThinking, l as resolveClaudeSonnet5ModelIdentity, n as CLAUDE_SONNET_5_THINKING_PROFILE, o as resolveClaudeModelIdentity, r as requiresClaudeDefaultSampling, s as resolveClaudeMythos5ModelIdentity, t as CLAUDE_FABLE_5_THINKING_PROFILE, u as supportsClaudeAdaptiveThinking } from "./index-BoTnz8cv.mjs";
+import { a as extractDiagnosticError, i as createAssistantMessageDiagnostic, n as DiagnosticErrorInfo, o as formatThrownValue, r as appendAssistantMessageDiagnostic, t as AssistantMessageDiagnostic } from "./diagnostics-BaTA9eVl.mjs";
+import { $ as VercelGatewayRouting, A as OpenRouterRouting, B as TextContent, C as KnownImagesProvider, D as ModelThinkingLevel, E as Model, F as SimpleStreamOptions, G as ThinkingLevelMap, H as ThinkingBudgets, I as StopReason, J as ToolResultMessage, K as Tool, L as StreamFn, M as ProviderImagesOptions, N as ProviderResponse, O as OpenAICompletionsCompat, P as ProviderStreamOptions, Q as ValidateToolArgumentsFn, R as StreamFunction, S as KnownImagesApi, T as Message, U as ThinkingContent, V as TextSignatureV1, W as ThinkingLevel, X as Usage, Y as Transport, Z as UserMessage, _ as ImagesOptions, a as AssistantMessageEvent, b as ImagesStopReason, c as CacheRetention, d as ImageContent, f as ImagesApi, g as ImagesModel, h as ImagesInputContent, i as AssistantMessage, j as Provider, k as OpenAIResponsesCompat, l as CompleteSimpleFn, m as ImagesFunction, n as Api, o as AssistantMessageEventStreamContract, p as ImagesContext, q as ToolCall, r as AssistantImages, s as AssistantMessageEventStreamLike, t as AnthropicMessagesCompat, u as Context, v as ImagesOutputContent, w as MaybePromise, x as KnownApi, y as ImagesProvider, z as StreamOptions } from "./types-DRgdPqaZ.mjs";
+import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-0nZeBKl2.mjs";
+import { n as validateToolCall, t as validateToolArguments } from "./validation-BDMWOr8d.mjs";
+import { a as RegisteredApiProvider, i as ApiStreamSimpleFunction, n as ApiRegistry, o as createApiRegistry, r as ApiStreamFunction, t as ApiProvider } from "./api-registry-BXYnCOIR.mjs";
+
+//#region packages/ai/src/host.d.ts
+/** Strict-tool policy inputs for OpenAI-compatible routes. */
+interface OpenAIStrictToolSettingOptions {
+  transport?: "stream" | "websocket";
+  supportsStrictMode?: boolean;
+}
+/** Narrow host ports consumed by the built-in provider adapters. */
+interface AiTransportHost {
+  /**
+   * Builds a policy-guarded fetch for one model request.
+   * Returning undefined keeps the provider SDK's default fetch.
+   */
+  buildModelFetch(model: Model, timeoutMs?: number, options?: {
+    sanitizeSse?: boolean;
+  }): typeof fetch | undefined;
+  /** Resolves host-owned process-local secret sentinel substrings immediately before egress. */
+  resolveSecretSentinel(value: string): string;
+  /** Redacts secrets inside structured tool-result payloads. */
+  redactSecrets<T>(value: T): T;
+  /** Redacts secret-bearing text in tool payload strings. */
+  redactToolPayloadText(text: string): string;
+  /**
+   * Resolves the host strict-tool default for OpenAI-compatible routes.
+   * undefined lets the request omit the strict flag entirely.
+   */
+  resolveOpenAIStrictToolSetting(model: Pick<Model, "provider" | "api" | "baseUrl" | "id"> & {
+    compat?: unknown;
+  }, options?: OpenAIStrictToolSettingOptions): boolean | undefined;
+  /**
+   * Emits one transport diagnostic; build runs only when the host logs it and
+   * may return null to suppress the entry (e.g. de-duplication).
+   */
+  logDebug(subsystem: string, build: () => {
+    message: string;
+    data?: Record<string, unknown>;
+  } | null): void;
+}
+/** Installs host implementations for the transport policy ports. */
+declare function configureAiTransportHost(host: Partial<AiTransportHost>): void;
+/** Returns the active transport host (inert defaults unless configured). */
+declare function getAiTransportHost(): AiTransportHost;
+/** Resolves sentinel substrings in custom headers at a no-fetch adapter boundary. */
+declare function resolveAiTransportHeaderSentinels(headers: Record<string, string> | undefined): Record<string, string> | undefined;
+//#endregion
+//#region packages/ai/src/stream.d.ts
+/** Creates an isolated LLM runtime backed by the supplied provider registry. */
+declare function createLlmRuntime(registry?: ApiRegistry): {
+  registry: {
+    registerApiProvider: <TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, sourceId?: string) => void;
+    getApiProvider: (api: Api) => RegisteredApiProvider | undefined;
+    getApiProviders: () => RegisteredApiProvider[];
+    unregisterApiProviders: (sourceId: string) => void;
+    clearApiProviders: () => void;
+  };
+  stream: <TApi extends Api>(model: Model<TApi>, context: Context, options?: ProviderStreamOptions) => AssistantMessageEventStreamContract;
+  complete: <TApi extends Api>(model: Model<TApi>, context: Context, options?: ProviderStreamOptions) => Promise<AssistantMessage>;
+  streamSimple: <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStreamContract;
+  completeSimple: <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => Promise<AssistantMessage>;
+};
+type LlmRuntime = ReturnType<typeof createLlmRuntime>;
+//#endregion
+export { AiTransportHost, AnthropicMessagesCompat, Api, ApiProvider, ApiRegistry, ApiStreamFunction, ApiStreamSimpleFunction, AssistantImages, AssistantMessage, AssistantMessageDiagnostic, AssistantMessageEvent, AssistantMessageEventStream, AssistantMessageEventStreamContract, AssistantMessageEventStreamLike, CLAUDE_FABLE_5_THINKING_PROFILE, CLAUDE_SONNET_5_THINKING_PROFILE, CacheRetention, CompleteSimpleFn, Context, DiagnosticErrorInfo, EventStream, ImageContent, ImagesApi, ImagesContext, ImagesFunction, ImagesInputContent, ImagesModel, ImagesOptions, ImagesOutputContent, ImagesProvider, ImagesStopReason, KnownApi, KnownImagesApi, KnownImagesProvider, LlmRuntime, MaybePromise, Message, Model, ModelThinkingLevel, OpenAICompletionsCompat, OpenAIResponsesCompat, OpenAIStrictToolSettingOptions, OpenRouterRouting, Provider, ProviderImagesOptions, ProviderResponse, ProviderStreamOptions, RegisteredApiProvider, SimpleStreamOptions, StopReason, StreamFn, StreamFunction, StreamOptions, TextContent, TextSignatureV1, ThinkingBudgets, ThinkingContent, ThinkingLevel, ThinkingLevelMap, Tool, ToolCall, ToolResultMessage, Transport, Usage, UserMessage, ValidateToolArgumentsFn, VercelGatewayRouting, appendAssistantMessageDiagnostic, configureAiTransportHost, createApiRegistry, createAssistantMessageDiagnostic, createAssistantMessageEventStream, createLlmRuntime, extractDiagnosticError, formatThrownValue, getAiTransportHost, requiresClaudeDefaultSampling, requiresClaudeMandatoryAdaptiveThinking, resolveAiTransportHeaderSentinels, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeNativeThinkingLevelMap, resolveClaudeSonnet5ModelIdentity, supportsClaudeAdaptiveThinking, supportsClaudeNativeMaxEffort, supportsClaudeNativeXhighEffort, validateToolArguments, validateToolCall };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import { a as resolveClaudeFable5ModelIdentity, c as resolveClaudeNativeThinkingLevelMap, d as supportsClaudeNativeMaxEffort, f as supportsClaudeNativeXhighEffort, i as requiresClaudeMandatoryAdaptiveThinking, l as resolveClaudeSonnet5ModelIdentity, n as CLAUDE_SONNET_5_THINKING_PROFILE, o as resolveClaudeModelIdentity, r as requiresClaudeDefaultSampling, s as resolveClaudeMythos5ModelIdentity, t as CLAUDE_FABLE_5_THINKING_PROFILE, u as supportsClaudeAdaptiveThinking } from "./src-CZ503MYJ.mjs";
+import { i as formatThrownValue, n as createAssistantMessageDiagnostic, r as extractDiagnosticError, t as appendAssistantMessageDiagnostic } from "./diagnostics-COpOtRwq.mjs";
+import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
+import { n as validateToolCall, t as validateToolArguments } from "./validation-FrchoOlv.mjs";
+import { n as createApiRegistry, t as createLlmRuntime } from "./stream-CREqxHgU.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels, t as configureAiTransportHost } from "./host-4t713IeR.mjs";
+export { AssistantMessageEventStream, CLAUDE_FABLE_5_THINKING_PROFILE, CLAUDE_SONNET_5_THINKING_PROFILE, EventStream, appendAssistantMessageDiagnostic, configureAiTransportHost, createApiRegistry, createAssistantMessageDiagnostic, createAssistantMessageEventStream, createLlmRuntime, extractDiagnosticError, formatThrownValue, getAiTransportHost, requiresClaudeDefaultSampling, requiresClaudeMandatoryAdaptiveThinking, resolveAiTransportHeaderSentinels, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeNativeThinkingLevelMap, resolveClaudeSonnet5ModelIdentity, supportsClaudeAdaptiveThinking, supportsClaudeNativeMaxEffort, supportsClaudeNativeXhighEffort, validateToolArguments, validateToolCall };

package/dist/internal/anthropic.d.mts

@@ -0,0 +1,234 @@
+import { a as resolveClaudeFable5ModelIdentity, c as resolveClaudeNativeThinkingLevelMap, d as supportsClaudeNativeMaxEffort, f as supportsClaudeNativeXhighEffort, i as requiresClaudeMandatoryAdaptiveThinking, l as resolveClaudeSonnet5ModelIdentity, o as resolveClaudeModelIdentity, r as requiresClaudeDefaultSampling, s as resolveClaudeMythos5ModelIdentity, u as supportsClaudeAdaptiveThinking } from "../index-BoTnz8cv.mjs";
+import { t as AssistantMessageDiagnostic } from "../diagnostics-BaTA9eVl.mjs";
+import { E as Model, F as SimpleStreamOptions, R as StreamFunction, u as Context, z as StreamOptions } from "../types-DRgdPqaZ.mjs";
+import Anthropic from "@anthropic-ai/sdk";
+
+//#region packages/ai/src/providers/anthropic.d.ts
+type AnthropicEffort = "low" | "medium" | "high" | "xhigh" | "max";
+type AnthropicThinkingDisplay = "summarized" | "omitted";
+interface AnthropicOptions extends StreamOptions {
+  /**
+   * Enable extended thinking.
+   * For Opus 4.6+ and Sonnet 4.6: uses adaptive thinking (model decides when/how much to think).
+   * For older models: uses budget-based thinking with thinkingBudgetTokens.
+   */
+  thinkingEnabled?: boolean;
+  /**
+   * Token budget for extended thinking (older models only).
+   * Ignored for Opus 4.6+ and Sonnet 4.6, which use adaptive thinking.
+   */
+  thinkingBudgetTokens?: number;
+  /**
+   * Effort level for adaptive thinking (Opus 4.6+ and Sonnet 4.6).
+   * Controls how much thinking Claude allocates:
+   * - "max": Always thinks with no constraints (Opus 4.6 only)
+   * - "xhigh": Highest reasoning level (Opus 4.7+)
+   * - "high": Always thinks, deep reasoning (default)
+   * - "medium": Moderate thinking, may skip for simple queries
+   * - "low": Minimal thinking, skips for simple tasks
+   * Ignored for older models.
+   */
+  effort?: AnthropicEffort;
+  /**
+   * Controls how thinking content is returned in API responses.
+   * - "summarized": Thinking blocks contain summarized thinking text (default here).
+   * - "omitted": Thinking blocks return an empty thinking field; the encrypted
+   *   signature still travels back for multi-turn continuity. Use for faster
+   *   time-to-first-text-token when your UI does not surface thinking.
+   *
+   * Note: Anthropic's API default for Claude Opus 4.7+ and Claude Mythos Preview
+   * is "omitted". We default to "summarized" here to keep behavior consistent
+   * with older Claude 4 models. Set this explicitly to "omitted" to opt in.
+   */
+  thinkingDisplay?: AnthropicThinkingDisplay;
+  interleavedThinking?: boolean;
+  toolChoice?: "auto" | "any" | "none" | {
+    type: "tool";
+    name: string;
+  };
+  /**
+   * Pre-built Anthropic client instance. When provided, skips internal client
+   * construction entirely. Use this to inject alternative SDK clients such as
+   * `AnthropicVertex` that shares the same messaging API.
+   */
+  client?: Anthropic;
+}
+declare const streamAnthropic: StreamFunction<"anthropic-messages", AnthropicOptions>;
+type AnthropicSimpleStreamOptions = SimpleStreamOptions & {
+  toolChoice?: AnthropicOptions["toolChoice"];
+};
+declare const streamSimpleAnthropic: StreamFunction<"anthropic-messages", AnthropicSimpleStreamOptions>;
+//#endregion
+//#region packages/ai/src/providers/anthropic-auth-headers.d.ts
+type AnthropicAuthModel = {
+  provider?: string;
+  authHeader?: boolean;
+  headers?: Record<string, string>;
+};
+declare function usesFoundryBearerAuth(model: AnthropicAuthModel): boolean;
+declare function omitFoundryBearerCredentialHeaders(headers?: Record<string, string>): Record<string, string> | undefined;
+//#endregion
+//#region packages/ai/src/providers/anthropic-model-contract.d.ts
+type ReplayModelRef = {
+  provider?: string;
+  api?: string;
+  modelId?: string;
+  responseModelId?: string;
+  modelParams?: Record<string, unknown>;
+};
+declare function usesClaudeFable5MessagesContract(model: {
+  id?: string;
+  params?: Record<string, unknown>;
+  api?: string;
+}): boolean;
+/** Return whether streamed output must wait for the terminal refusal decision. */
+declare function usesClaudeStreamingRefusalContract(model: {
+  id?: string;
+  params?: Record<string, unknown>;
+  api?: string;
+}): boolean;
+declare function requiresClaudeAdaptiveThinking(model: {
+  id?: string;
+  params?: Record<string, unknown>;
+  api?: string;
+}): boolean;
+/** Return whether omitted thinking should default to adaptive/high. */
+declare function defaultsClaudeAdaptiveThinking(model: {
+  id?: string;
+  params?: Record<string, unknown>;
+  api?: string;
+}): boolean;
+/** Remove Sonnet 5 assistant prefills while preserving completed tool-use turns. */
+declare function prepareClaudeSonnet5RequestContext(model: Model, context: Context): Context;
+declare function applyClaudeRequestContract(params: Record<string, unknown>, model: {
+  id?: string;
+  params?: Record<string, unknown>;
+  api?: string;
+}): void;
+declare function resolveModelBoundThinkingReplayMode(params: {
+  source: ReplayModelRef;
+  target: ReplayModelRef;
+}): "default" | "preserve" | "drop";
+//#endregion
+//#region packages/ai/src/providers/anthropic-refusal.d.ts
+type AnthropicRefusalOutput = {
+  stopReason: string;
+  errorMessage?: string;
+  diagnostics?: AssistantMessageDiagnostic[];
+};
+declare function applyAnthropicRefusal(output: AnthropicRefusalOutput, stopDetails: unknown, provider: string): void;
+//#endregion
+//#region packages/ai/src/providers/anthropic-server-fallback.d.ts
+/** Anthropic beta that re-serves safety refusals on an allowed fallback model. */
+declare const ANTHROPIC_SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-06-01";
+declare const CLAUDE_FABLE_5_FALLBACK_MODEL = "claude-opus-4-8";
+declare const CLAUDE_FABLE_5_FALLBACK_MODEL_COST: {
+  readonly input: 5;
+  readonly output: 25;
+  readonly cacheRead: 0.5;
+  readonly cacheWrite: 6.25;
+};
+declare function buildAnthropicServerSideFallbacks(): Array<{
+  model: string;
+}>;
+type AnthropicFallbackBoundary = {
+  fromModel: string | null;
+  toModel: string | null;
+};
+/** Reads a `fallback` content block marking where one model's output gives way to the next. */
+declare function readAnthropicFallbackBoundary(block: unknown): AnthropicFallbackBoundary | null;
+/**
+ * Drops pre-fallback thinking/tool calls while preserving the text prefix that
+ * the serving model continued. Dropped tool calls must never execute or replay.
+ */
+declare function applyAnthropicFallbackBoundary(params: {
+  output: {
+    content: Array<{
+      type: string;
+    }>;
+    responseModel?: string;
+    diagnostics?: AssistantMessageDiagnostic[];
+  };
+  boundary: AnthropicFallbackBoundary;
+  provider: string;
+}): void;
+//#endregion
+//#region packages/ai/src/providers/anthropic-thinking-replay.d.ts
+declare const ANTHROPIC_OMITTED_REASONING_TEXT = "[assistant reasoning omitted]";
+/**
+ * Anthropic tool results continue the preceding assistant turn. Preserve that
+ * turn's signed thinking even when the next request disables new thinking.
+ */
+declare function findActiveAnthropicToolTurnAssistantIndex(messages: readonly unknown[]): number;
+//#endregion
+//#region packages/ai/src/providers/anthropic-tool-projection.d.ts
+type AnthropicToolDescriptor = {
+  readonly name: string;
+  readonly description: string;
+  readonly parameters: unknown;
+};
+type AnthropicProjectedTool = {
+  readonly originalName: string;
+  readonly wireName: string;
+  readonly description?: string;
+  readonly inputSchema: {
+    readonly type: "object";
+    readonly properties: Record<string, unknown>;
+    readonly required: string[];
+  };
+};
+type AnthropicToolProjection = {
+  readonly inputToolCount: number;
+  readonly unavailableOriginalNames: ReadonlySet<string>;
+  readonly tools: readonly AnthropicProjectedTool[];
+};
+type AnthropicParallelToolChoice = {
+  readonly disable_parallel_tool_use?: boolean;
+};
+type AnthropicProjectedToolChoice = ({
+  readonly type: "auto";
+} & AnthropicParallelToolChoice) | ({
+  readonly type: "any";
+} & AnthropicParallelToolChoice) | {
+  readonly type: "none";
+} | ({
+  readonly type: "tool";
+  readonly name: string;
+} & AnthropicParallelToolChoice);
+/** Snapshots direct/custom tool descriptors before Anthropic payload construction. */
+declare function projectAnthropicTools(tools: readonly AnthropicToolDescriptor[], toWireName: (name: string) => string): AnthropicToolProjection;
+/** Keeps forced Anthropic tool choices aligned with the projected wire names. */
+declare function reconcileAnthropicToolChoice(choice: AnthropicProjectedToolChoice, projection: AnthropicToolProjection): AnthropicProjectedToolChoice | undefined;
+/** Maps Claude Code wire names without trusting every direct/custom descriptor. */
+declare function resolveOriginalAnthropicToolName(name: string, projection: AnthropicToolProjection | undefined): string;
+//#endregion
+//#region packages/ai/src/providers/anthropic-usage.d.ts
+type AnthropicUsagePayload = {
+  input_tokens?: unknown;
+  output_tokens?: unknown;
+  cache_read_input_tokens?: unknown;
+  cache_creation_input_tokens?: unknown;
+  iterations?: unknown;
+};
+type AnthropicPromptUsageSnapshot = {
+  input: number;
+  cacheRead: number;
+  cacheWrite: number;
+};
+type AnthropicIterationUsageSnapshot = {
+  contextPromptTokens: number;
+  totalTokens: number;
+};
+type AnthropicIterationUsageResult = {
+  state: "absent";
+} | {
+  state: "invalid";
+} | {
+  state: "valid";
+  usage: AnthropicIterationUsageSnapshot;
+};
+declare function readAnthropicUsageTokenCount(value: unknown): number | undefined;
+declare function readAnthropicPromptUsageSnapshot(usage: AnthropicUsagePayload): AnthropicPromptUsageSnapshot | undefined;
+declare function readLastAnthropicIterationUsage(usage: AnthropicUsagePayload): AnthropicIterationUsageResult;
+//#endregion
+export { ANTHROPIC_OMITTED_REASONING_TEXT, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, AnthropicEffort, AnthropicFallbackBoundary, AnthropicIterationUsageResult, AnthropicIterationUsageSnapshot, AnthropicOptions, AnthropicProjectedToolChoice, AnthropicPromptUsageSnapshot, AnthropicThinkingDisplay, AnthropicToolProjection, CLAUDE_FABLE_5_FALLBACK_MODEL, CLAUDE_FABLE_5_FALLBACK_MODEL_COST, applyAnthropicFallbackBoundary, applyAnthropicRefusal, applyClaudeRequestContract, buildAnthropicServerSideFallbacks, defaultsClaudeAdaptiveThinking, findActiveAnthropicToolTurnAssistantIndex, omitFoundryBearerCredentialHeaders, prepareClaudeSonnet5RequestContext, projectAnthropicTools, readAnthropicFallbackBoundary, readAnthropicPromptUsageSnapshot, readAnthropicUsageTokenCount, readLastAnthropicIterationUsage, reconcileAnthropicToolChoice, requiresClaudeAdaptiveThinking, requiresClaudeDefaultSampling, requiresClaudeMandatoryAdaptiveThinking, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeNativeThinkingLevelMap, resolveClaudeSonnet5ModelIdentity, resolveModelBoundThinkingReplayMode, resolveOriginalAnthropicToolName, streamAnthropic, streamSimpleAnthropic, supportsClaudeAdaptiveThinking, supportsClaudeNativeMaxEffort, supportsClaudeNativeXhighEffort, usesClaudeFable5MessagesContract, usesClaudeStreamingRefusalContract, usesFoundryBearerAuth };

package/dist/internal/anthropic.mjs

@@ -0,0 +1,4 @@
+import { a as resolveClaudeFable5ModelIdentity, c as resolveClaudeNativeThinkingLevelMap, d as supportsClaudeNativeMaxEffort, f as supportsClaudeNativeXhighEffort, i as requiresClaudeMandatoryAdaptiveThinking, l as resolveClaudeSonnet5ModelIdentity, o as resolveClaudeModelIdentity, r as requiresClaudeDefaultSampling, s as resolveClaudeMythos5ModelIdentity, u as supportsClaudeAdaptiveThinking } from "../src-CZ503MYJ.mjs";
+import { d as prepareClaudeSonnet5RequestContext, f as requiresClaudeAdaptiveThinking, h as usesClaudeStreamingRefusalContract, l as applyClaudeRequestContract, m as usesClaudeFable5MessagesContract, p as resolveModelBoundThinkingReplayMode, u as defaultsClaudeAdaptiveThinking } from "../transform-messages-BhGF_fF4.mjs";
+import { _ as readAnthropicFallbackBoundary, a as readAnthropicUsageTokenCount, b as usesFoundryBearerAuth, c as reconcileAnthropicToolChoice, d as findActiveAnthropicToolTurnAssistantIndex, f as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, g as buildAnthropicServerSideFallbacks, h as applyAnthropicFallbackBoundary, i as readAnthropicPromptUsageSnapshot, l as resolveOriginalAnthropicToolName, m as CLAUDE_FABLE_5_FALLBACK_MODEL_COST, n as streamAnthropic, o as readLastAnthropicIterationUsage, p as CLAUDE_FABLE_5_FALLBACK_MODEL, r as streamSimpleAnthropic, s as projectAnthropicTools, u as ANTHROPIC_OMITTED_REASONING_TEXT, v as applyAnthropicRefusal, y as omitFoundryBearerCredentialHeaders } from "../anthropic-B5gZQM5X.mjs";
+export { ANTHROPIC_OMITTED_REASONING_TEXT, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, CLAUDE_FABLE_5_FALLBACK_MODEL, CLAUDE_FABLE_5_FALLBACK_MODEL_COST, applyAnthropicFallbackBoundary, applyAnthropicRefusal, applyClaudeRequestContract, buildAnthropicServerSideFallbacks, defaultsClaudeAdaptiveThinking, findActiveAnthropicToolTurnAssistantIndex, omitFoundryBearerCredentialHeaders, prepareClaudeSonnet5RequestContext, projectAnthropicTools, readAnthropicFallbackBoundary, readAnthropicPromptUsageSnapshot, readAnthropicUsageTokenCount, readLastAnthropicIterationUsage, reconcileAnthropicToolChoice, requiresClaudeAdaptiveThinking, requiresClaudeDefaultSampling, requiresClaudeMandatoryAdaptiveThinking, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeNativeThinkingLevelMap, resolveClaudeSonnet5ModelIdentity, resolveModelBoundThinkingReplayMode, resolveOriginalAnthropicToolName, streamAnthropic, streamSimpleAnthropic, supportsClaudeAdaptiveThinking, supportsClaudeNativeMaxEffort, supportsClaudeNativeXhighEffort, usesClaudeFable5MessagesContract, usesClaudeStreamingRefusalContract, usesFoundryBearerAuth };