@openclaw/ai 2026.8.1-beta.2 → 2026.8.1

package/dist/internal/anthropic.d.mts

@@ -1,34 +1,36 @@
-import { a as requiresClaudeMandatoryAdaptiveThinking, c as resolveClaudeMythos5ModelIdentity, d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, h as supportsClaudeNativeMaxEffort, i as requiresClaudeDefaultSampling, l as resolveClaudeNativeThinkingLevelMap, o as resolveClaudeFable5ModelIdentity, p as supportsClaudeAdaptiveThinking, s as resolveClaudeModelIdentity, u as resolveClaudeOpus5ModelIdentity } from "../anthropic-SrGtwsJu.mjs";
+import { _ as supportsClaudeNativeXhighEffort, a as requiresClaudeDefaultSampling, c as resolveClaudeModelIdentity, d as resolveClaudeOpus5ModelIdentity, f as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeMaxEffort, l as resolveClaudeMythos5ModelIdentity, m as supportsClaudeAdaptiveThinking, o as requiresClaudeMandatoryAdaptiveThinking, s as resolveClaudeFable5ModelIdentity, u as resolveClaudeNativeThinkingLevelMap } from "../index-N3zr6__t.mjs";
 import { t as AssistantMessageDiagnostic } from "../diagnostics-BaTA9eVl.mjs";
-import { $ as Usage, E as Model, R as SimpleStreamOptions, V as StreamFunction, u as Context, z as StopReason } from "../types-BHNrPS1l.mjs";
-import { n as AnthropicOptions, r as AnthropicThinkingDisplay, t as AnthropicEffort } from "../provider-options-B96RdNpH.mjs";
-import { o as resolveAnthropicServerCompactionPlan } from "../anthropic-payload-policy-CiEuQS72.mjs";
-
+import { B as StopReason, D as Model, H as StreamFunction, d as Context, et as Usage, z as SimpleStreamOptions } from "../types-h38Azne1.mjs";
+import { n as AnthropicOptions, r as AnthropicThinkingDisplay, t as AnthropicEffort } from "../provider-options-HvA_slFa.mjs";
+import "../types-DtGu2d3C.mjs";
+import { o as resolveAnthropicServerCompactionPlan } from "../anthropic-payload-policy-i_5_inWe.mjs";
 //#region packages/ai/src/providers/anthropic.d.ts
 type AnthropicCompactionOptions = AnthropicOptions & {
   anthropicServerCompaction?: boolean;
   authProfileId?: string;
 };
-declare const streamAnthropic: StreamFunction<"anthropic-messages", AnthropicCompactionOptions>;
+export declare const streamAnthropic: StreamFunction<"anthropic-messages", AnthropicCompactionOptions>;
 type AnthropicSimpleStreamOptions = SimpleStreamOptions & {
   anthropicServerCompaction?: boolean;
   authProfileId?: string;
   toolChoice?: AnthropicCompactionOptions["toolChoice"];
 };
-declare const streamSimpleAnthropic: StreamFunction<"anthropic-messages", AnthropicSimpleStreamOptions>;
+export declare const streamSimpleAnthropic: StreamFunction<"anthropic-messages", AnthropicSimpleStreamOptions>;
 //#endregion
 //#region packages/ai/src/providers/anthropic-auth-headers.d.ts
+/** Inspect resolved credential shape for auth routing without exposing its value. */
+export declare function isAnthropicOAuthApiKey(apiKey: unknown): boolean;
 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;
+export declare function usesFoundryBearerAuth(model: AnthropicAuthModel): boolean;
+export declare function omitFoundryBearerCredentialHeaders(headers?: Record<string, string>): Record<string, string> | undefined;
 //#endregion
 //#region packages/ai/src/providers/anthropic-model-contract.d.ts
-declare const ANTHROPIC_CLAUDE_CODE_VERSION = "2.1.75";
-declare const ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK = "x-anthropic-billing-header: cc_version=2.1.75; cc_entrypoint=sdk-cli;";
+export declare const ANTHROPIC_CLAUDE_CODE_VERSION = "2.1.75";
+export declare const ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK = "x-anthropic-billing-header: cc_version=2.1.75; cc_entrypoint=sdk-cli;";
 type ReplayModelRef = {
   provider?: string;
   api?: string;
@@ -36,40 +38,46 @@ type ReplayModelRef = {
   responseModelId?: string;
   modelParams?: Record<string, unknown>;
 };
-declare function usesClaudeFable5MessagesContract(model: {
+export 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: {
+export declare function usesClaudeStreamingRefusalContract(model: {
   id?: string;
   params?: Record<string, unknown>;
   api?: string;
 }): boolean;
-declare function requiresClaudeAdaptiveThinking(model: {
+export 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: {
+export declare function defaultsClaudeAdaptiveThinking(model: {
   id?: string;
   params?: Record<string, unknown>;
   api?: string;
 }): boolean;
 /** Resolve provider-native effort once for direct and managed Claude requests. */
-declare function resolveAnthropicThinkingEffort(model: Model<"anthropic-messages">, level: SimpleStreamOptions["reasoning"]): AnthropicEffort;
+export declare function resolveAnthropicThinkingEffort(model: Model<"anthropic-messages">, level: SimpleStreamOptions["reasoning"]): AnthropicEffort;
 /** Normalize Anthropic and Anthropic-compatible terminal reasons identically. */
-declare function mapAnthropicStopReason(reason: string | undefined): StopReason;
+export declare function mapAnthropicStopReason(reason: string | undefined): StopReason;
 /** Remove unsupported assistant prefills while preserving completed tool-use turns. */
-declare function prepareClaudeNoPrefillRequestContext(model: Model, context: Context): Context;
-declare function applyClaudeRequestContract(params: Record<string, unknown>, model: {
+export declare function prepareClaudeNoPrefillRequestContext(model: Model, context: Context): Context;
+type ClaudeSamplingRequestParams = {
+  temperature?: unknown;
+  top_p?: unknown;
+  top_k?: unknown;
+  service_tier?: unknown;
+};
+export declare function applyClaudeRequestContract(params: ClaudeSamplingRequestParams, model: {
   id?: string;
   params?: Record<string, unknown>;
   api?: string;
 }): void;
-declare function resolveModelBoundThinkingReplayMode(params: {
+export declare function resolveModelBoundThinkingReplayMode(params: {
   source: ReplayModelRef;
   target: ReplayModelRef;
 }): "default" | "preserve" | "drop";
@@ -80,36 +88,36 @@ type AnthropicRefusalOutput = {
   errorMessage?: string;
   diagnostics?: AssistantMessageDiagnostic[];
 };
-declare function applyAnthropicRefusal(output: AnthropicRefusalOutput, stopDetails: unknown, provider: string): void;
+export 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-07-01";
+export declare const ANTHROPIC_SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
 /** Let Anthropic select the recommended model for each refusal category. */
-declare const ANTHROPIC_SERVER_SIDE_FALLBACKS: "default";
-declare const CLAUDE_OPUS_FALLBACK_MODEL_COST: {
+export declare const ANTHROPIC_SERVER_SIDE_FALLBACKS: "default";
+export declare const CLAUDE_OPUS_FALLBACK_MODEL_COST: {
   readonly input: 5;
   readonly output: 25;
   readonly cacheRead: 0.5;
   readonly cacheWrite: 6.25;
 };
-type AnthropicFallbackBoundary = {
+export type AnthropicFallbackBoundary = {
   fromModel: string | null;
   toModel: string | null;
 };
 /** Resolve billed rates from the serving model reported by Anthropic's fallback stream. */
-declare function resolveAnthropicFallbackServingModelCost(params: {
+export declare function resolveAnthropicFallbackServingModelCost(params: {
   requestedModelId: string;
   servingModelId: string | null;
   requestedCost: Model["cost"];
 }): Model["cost"];
 /** Reads a `fallback` content block marking where one model's output gives way to the next. */
-declare function readAnthropicFallbackBoundary(block: unknown): AnthropicFallbackBoundary | null;
+export 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: {
+export declare function applyAnthropicFallbackBoundary(params: {
   output: {
     content: Array<{
       type: string;
@@ -122,12 +130,12 @@ declare function applyAnthropicFallbackBoundary(params: {
 }): void;
 //#endregion
 //#region packages/ai/src/providers/anthropic-thinking-replay.d.ts
-declare const ANTHROPIC_OMITTED_REASONING_TEXT = "[assistant reasoning omitted]";
+export 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;
+export declare function findActiveAnthropicToolTurnAssistantIndex(messages: readonly unknown[]): number;
 //#endregion
 //#region packages/ai/src/providers/anthropic-tool-projection.d.ts
 type AnthropicToolDescriptor = {
@@ -145,7 +153,7 @@ type AnthropicProjectedTool = {
     readonly required: string[];
   };
 };
-type AnthropicToolProjection = {
+export type AnthropicToolProjection = {
   readonly inputToolCount: number;
   readonly unavailableOriginalNames: ReadonlySet<string>;
   readonly tools: readonly AnthropicProjectedTool[];
@@ -153,7 +161,7 @@ type AnthropicToolProjection = {
 type AnthropicParallelToolChoice = {
   readonly disable_parallel_tool_use?: boolean;
 };
-type AnthropicProjectedToolChoice = ({
+export type AnthropicProjectedToolChoice = ({
   readonly type: "auto";
 } & AnthropicParallelToolChoice) | ({
   readonly type: "any";
@@ -164,17 +172,17 @@ type AnthropicProjectedToolChoice = ({
   readonly name: string;
 } & AnthropicParallelToolChoice);
 /** Preserve Claude Code's canonical tool casing for subscription OAuth requests. */
-declare function toClaudeCodeToolName(name: string): string;
+export declare function toClaudeCodeToolName(name: string): string;
 /** Anthropic rejects forced tools while extended thinking is enabled. */
-declare function normalizeAnthropicToolChoice(thinkingEnabled: boolean, toolChoice: NonNullable<AnthropicOptions["toolChoice"]>): AnthropicProjectedToolChoice;
+export declare function normalizeAnthropicToolChoice(thinkingEnabled: boolean, toolChoice: NonNullable<AnthropicOptions["toolChoice"]>): AnthropicProjectedToolChoice;
 /** Anthropic tool identifiers accept only ASCII word characters and dashes. */
-declare function normalizeAnthropicToolCallId(id: string): string;
+export declare function normalizeAnthropicToolCallId(id: string): string;
 /** Snapshots direct/custom tool descriptors before Anthropic payload construction. */
-declare function projectAnthropicTools(tools: readonly AnthropicToolDescriptor[], toWireName: (name: string) => string): AnthropicToolProjection;
+export 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;
+export 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;
+export declare function resolveOriginalAnthropicToolName(name: string, projection: AnthropicToolProjection | undefined): string;
 //#endregion
 //#region packages/ai/src/providers/anthropic-usage.d.ts
 type AnthropicUsagePayload = {
@@ -185,20 +193,20 @@ type AnthropicUsagePayload = {
   cache_creation?: unknown;
   iterations?: unknown;
 };
-type AnthropicCacheWriteUsage = {
+export type AnthropicCacheWriteUsage = {
   cacheWrite5m?: number;
   cacheWrite1h?: number;
 };
-type AnthropicPromptUsageSnapshot = {
+export type AnthropicPromptUsageSnapshot = {
   input: number;
   cacheRead: number;
   cacheWrite: number;
 };
-type AnthropicIterationUsageSnapshot = {
+export type AnthropicIterationUsageSnapshot = {
   contextPromptTokens: number;
   totalTokens: number;
 };
-type AnthropicIterationUsageResult = {
+export type AnthropicIterationUsageResult = {
   state: "absent";
 } | {
   state: "invalid";
@@ -206,13 +214,13 @@ type AnthropicIterationUsageResult = {
   state: "valid";
   usage: AnthropicIterationUsageSnapshot;
 };
-declare function readAnthropicUsageTokenCount(value: unknown): number | undefined;
-declare function readAnthropicCacheWriteUsage(usage: AnthropicUsagePayload): AnthropicCacheWriteUsage;
-declare function readAnthropicPromptUsageSnapshot(usage: AnthropicUsagePayload): AnthropicPromptUsageSnapshot | undefined;
-declare function readLastAnthropicIterationUsage(usage: AnthropicUsagePayload): AnthropicIterationUsageResult;
+export declare function readAnthropicUsageTokenCount(value: unknown): number | undefined;
+export declare function readAnthropicCacheWriteUsage(usage: AnthropicUsagePayload): AnthropicCacheWriteUsage;
+export declare function readAnthropicPromptUsageSnapshot(usage: AnthropicUsagePayload): AnthropicPromptUsageSnapshot | undefined;
+export declare function readLastAnthropicIterationUsage(usage: AnthropicUsagePayload): AnthropicIterationUsageResult;
 /** Record independent billing buckets without treating zero placeholders as context proof. */
-declare function applyAnthropicMessageStartUsage(target: Usage, payload: AnthropicUsagePayload): AnthropicPromptUsageSnapshot | undefined;
+export declare function applyAnthropicMessageStartUsage(target: Usage, payload: AnthropicUsagePayload): AnthropicPromptUsageSnapshot | undefined;
 /** Keep cumulative billing separate from the final server-side iteration context. */
-declare function applyAnthropicMessageDeltaUsage(target: Usage, payload: AnthropicUsagePayload | undefined, messageStartPromptUsage: AnthropicPromptUsageSnapshot | undefined): void;
+export declare function applyAnthropicMessageDeltaUsage(target: Usage, payload: AnthropicUsagePayload | undefined, messageStartPromptUsage: AnthropicPromptUsageSnapshot | undefined): void;
 //#endregion
-export { ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, ANTHROPIC_CLAUDE_CODE_VERSION, ANTHROPIC_OMITTED_REASONING_TEXT, ANTHROPIC_SERVER_SIDE_FALLBACKS, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, AnthropicCacheWriteUsage, type AnthropicEffort, AnthropicFallbackBoundary, AnthropicIterationUsageResult, AnthropicIterationUsageSnapshot, type AnthropicOptions, AnthropicProjectedToolChoice, AnthropicPromptUsageSnapshot, type AnthropicThinkingDisplay, AnthropicToolProjection, CLAUDE_OPUS_FALLBACK_MODEL_COST, applyAnthropicFallbackBoundary, applyAnthropicMessageDeltaUsage, applyAnthropicMessageStartUsage, applyAnthropicRefusal, applyClaudeRequestContract, defaultsClaudeAdaptiveThinking, findActiveAnthropicToolTurnAssistantIndex, mapAnthropicStopReason, normalizeAnthropicToolCallId, normalizeAnthropicToolChoice, omitFoundryBearerCredentialHeaders, prepareClaudeNoPrefillRequestContext, projectAnthropicTools, readAnthropicCacheWriteUsage, readAnthropicFallbackBoundary, readAnthropicPromptUsageSnapshot, readAnthropicUsageTokenCount, readLastAnthropicIterationUsage, reconcileAnthropicToolChoice, requiresClaudeAdaptiveThinking, requiresClaudeDefaultSampling, requiresClaudeMandatoryAdaptiveThinking, resolveAnthropicFallbackServingModelCost, resolveAnthropicServerCompactionPlan, resolveAnthropicThinkingEffort, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeNativeThinkingLevelMap, resolveClaudeOpus5ModelIdentity, resolveClaudeSonnet5ModelIdentity, resolveModelBoundThinkingReplayMode, resolveOriginalAnthropicToolName, streamAnthropic, streamSimpleAnthropic, supportsClaudeAdaptiveThinking, supportsClaudeNativeMaxEffort, supportsClaudeNativeXhighEffort, toClaudeCodeToolName, usesClaudeFable5MessagesContract, usesClaudeStreamingRefusalContract, usesFoundryBearerAuth };
+export { type AnthropicEffort, type AnthropicOptions, type AnthropicThinkingDisplay, requiresClaudeDefaultSampling, requiresClaudeMandatoryAdaptiveThinking, resolveAnthropicServerCompactionPlan, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeNativeThinkingLevelMap, resolveClaudeOpus5ModelIdentity, resolveClaudeSonnet5ModelIdentity, supportsClaudeAdaptiveThinking, supportsClaudeNativeMaxEffort, supportsClaudeNativeXhighEffort };

package/dist/internal/anthropic.mjs

@@ -1,5 +1,5 @@
-import { a as requiresClaudeMandatoryAdaptiveThinking, c as resolveClaudeMythos5ModelIdentity, d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, h as supportsClaudeNativeMaxEffort, i as requiresClaudeDefaultSampling, l as resolveClaudeNativeThinkingLevelMap, o as resolveClaudeFable5ModelIdentity, p as supportsClaudeAdaptiveThinking, s as resolveClaudeModelIdentity, u as resolveClaudeOpus5ModelIdentity } from "../anthropic-JsNA5KCu.mjs";
-import { _ as resolveAnthropicThinkingEffort, b as usesClaudeStreamingRefusalContract, d as ANTHROPIC_CLAUDE_CODE_VERSION, f as applyClaudeRequestContract, g as requiresClaudeAdaptiveThinking, h as prepareClaudeNoPrefillRequestContext, m as mapAnthropicStopReason, p as defaultsClaudeAdaptiveThinking, u as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, v as resolveModelBoundThinkingReplayMode, y as usesClaudeFable5MessagesContract } from "../host-DTqNc7ad.mjs";
-import { C as readAnthropicFallbackBoundary, D as usesFoundryBearerAuth, E as omitFoundryBearerCredentialHeaders, I as resolveAnthropicServerCompactionPlan, S as applyAnthropicFallbackBoundary, T as applyAnthropicRefusal, _ as ANTHROPIC_OMITTED_REASONING_TEXT, a as applyAnthropicMessageDeltaUsage, b as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, c as readAnthropicPromptUsageSnapshot, d as normalizeAnthropicToolCallId, f as normalizeAnthropicToolChoice, g as toClaudeCodeToolName, h as resolveOriginalAnthropicToolName, l as readAnthropicUsageTokenCount, m as reconcileAnthropicToolChoice, o as applyAnthropicMessageStartUsage, p as projectAnthropicTools, s as readAnthropicCacheWriteUsage, u as readLastAnthropicIterationUsage, v as findActiveAnthropicToolTurnAssistantIndex, w as resolveAnthropicFallbackServingModelCost, x as CLAUDE_OPUS_FALLBACK_MODEL_COST, y as ANTHROPIC_SERVER_SIDE_FALLBACKS } from "../anthropic-compaction-replay-8lJNKXOE.mjs";
-import { n as streamAnthropic, r as streamSimpleAnthropic } from "../anthropic-B6dLpq5L.mjs";
-export { ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, ANTHROPIC_CLAUDE_CODE_VERSION, ANTHROPIC_OMITTED_REASONING_TEXT, ANTHROPIC_SERVER_SIDE_FALLBACKS, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, CLAUDE_OPUS_FALLBACK_MODEL_COST, applyAnthropicFallbackBoundary, applyAnthropicMessageDeltaUsage, applyAnthropicMessageStartUsage, applyAnthropicRefusal, applyClaudeRequestContract, defaultsClaudeAdaptiveThinking, findActiveAnthropicToolTurnAssistantIndex, mapAnthropicStopReason, normalizeAnthropicToolCallId, normalizeAnthropicToolChoice, omitFoundryBearerCredentialHeaders, prepareClaudeNoPrefillRequestContext, projectAnthropicTools, readAnthropicCacheWriteUsage, readAnthropicFallbackBoundary, readAnthropicPromptUsageSnapshot, readAnthropicUsageTokenCount, readLastAnthropicIterationUsage, reconcileAnthropicToolChoice, requiresClaudeAdaptiveThinking, requiresClaudeDefaultSampling, requiresClaudeMandatoryAdaptiveThinking, resolveAnthropicFallbackServingModelCost, resolveAnthropicServerCompactionPlan, resolveAnthropicThinkingEffort, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeNativeThinkingLevelMap, resolveClaudeOpus5ModelIdentity, resolveClaudeSonnet5ModelIdentity, resolveModelBoundThinkingReplayMode, resolveOriginalAnthropicToolName, streamAnthropic, streamSimpleAnthropic, supportsClaudeAdaptiveThinking, supportsClaudeNativeMaxEffort, supportsClaudeNativeXhighEffort, toClaudeCodeToolName, usesClaudeFable5MessagesContract, usesClaudeStreamingRefusalContract, usesFoundryBearerAuth };
+import { a as requiresClaudeMandatoryAdaptiveThinking, c as resolveClaudeMythos5ModelIdentity, d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, h as supportsClaudeNativeMaxEffort, i as requiresClaudeDefaultSampling, l as resolveClaudeNativeThinkingLevelMap, o as resolveClaudeFable5ModelIdentity, p as supportsClaudeAdaptiveThinking, s as resolveClaudeModelIdentity, u as resolveClaudeOpus5ModelIdentity } from "../src-Bu3FiFAG.mjs";
+import { S as usesClaudeStreamingRefusalContract, _ as prepareClaudeNoPrefillRequestContext, b as resolveModelBoundThinkingReplayMode, f as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, g as mapAnthropicStopReason, h as defaultsClaudeAdaptiveThinking, m as applyClaudeRequestContract, p as ANTHROPIC_CLAUDE_CODE_VERSION, v as requiresClaudeAdaptiveThinking, x as usesClaudeFable5MessagesContract, y as resolveAnthropicThinkingEffort } from "../host-D51fmkH6.mjs";
+import { C as applyAnthropicFallbackBoundary, E as applyAnthropicRefusal, F as resolveAnthropicServerCompactionPlan, I as isAnthropicOAuthApiKey, L as omitFoundryBearerCredentialHeaders, R as usesFoundryBearerAuth, S as CLAUDE_OPUS_FALLBACK_MODEL_COST, T as resolveAnthropicFallbackServingModelCost, _ as toClaudeCodeToolName, b as ANTHROPIC_SERVER_SIDE_FALLBACKS, c as readAnthropicCacheWriteUsage, d as readLastAnthropicIterationUsage, f as normalizeAnthropicToolCallId, g as resolveOriginalAnthropicToolName, h as reconcileAnthropicToolChoice, l as readAnthropicPromptUsageSnapshot, m as projectAnthropicTools, o as applyAnthropicMessageDeltaUsage, p as normalizeAnthropicToolChoice, s as applyAnthropicMessageStartUsage, u as readAnthropicUsageTokenCount, v as ANTHROPIC_OMITTED_REASONING_TEXT, w as readAnthropicFallbackBoundary, x as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, y as findActiveAnthropicToolTurnAssistantIndex } from "../anthropic-compaction-replay-CY4tkD4V.mjs";
+import { n as streamAnthropic, r as streamSimpleAnthropic } from "../anthropic-Djj7L1rx.mjs";
+export { ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, ANTHROPIC_CLAUDE_CODE_VERSION, ANTHROPIC_OMITTED_REASONING_TEXT, ANTHROPIC_SERVER_SIDE_FALLBACKS, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, CLAUDE_OPUS_FALLBACK_MODEL_COST, applyAnthropicFallbackBoundary, applyAnthropicMessageDeltaUsage, applyAnthropicMessageStartUsage, applyAnthropicRefusal, applyClaudeRequestContract, defaultsClaudeAdaptiveThinking, findActiveAnthropicToolTurnAssistantIndex, isAnthropicOAuthApiKey, mapAnthropicStopReason, normalizeAnthropicToolCallId, normalizeAnthropicToolChoice, omitFoundryBearerCredentialHeaders, prepareClaudeNoPrefillRequestContext, projectAnthropicTools, readAnthropicCacheWriteUsage, readAnthropicFallbackBoundary, readAnthropicPromptUsageSnapshot, readAnthropicUsageTokenCount, readLastAnthropicIterationUsage, reconcileAnthropicToolChoice, requiresClaudeAdaptiveThinking, requiresClaudeDefaultSampling, requiresClaudeMandatoryAdaptiveThinking, resolveAnthropicFallbackServingModelCost, resolveAnthropicServerCompactionPlan, resolveAnthropicThinkingEffort, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeNativeThinkingLevelMap, resolveClaudeOpus5ModelIdentity, resolveClaudeSonnet5ModelIdentity, resolveModelBoundThinkingReplayMode, resolveOriginalAnthropicToolName, streamAnthropic, streamSimpleAnthropic, supportsClaudeAdaptiveThinking, supportsClaudeNativeMaxEffort, supportsClaudeNativeXhighEffort, toClaudeCodeToolName, usesClaudeFable5MessagesContract, usesClaudeStreamingRefusalContract, usesFoundryBearerAuth };

package/dist/internal/openai-responses-payload-policy.d.mts

@@ -1,3 +1,3 @@
-import { t as OPENAI_RESPONSES_APIS } from "../openai-responses-contracts-XpZJxrRG.mjs";
-import { i as resolveOpenAIResponsesServerCompactionPlan } from "../openai-responses-payload-policy-BSs371VM.mjs";
-export { OPENAI_RESPONSES_APIS, resolveOpenAIResponsesServerCompactionPlan };
+import { c as OpenAIResponsesCompactionOutput, l as readOpenAIResponsesCompactionWindow, t as OPENAI_RESPONSES_APIS } from "../openai-responses-contracts-DgaR3t5T.mjs";
+import { i as resolveOpenAIResponsesServerCompactionPlan } from "../openai-responses-payload-policy-rLRPsSmB.mjs";
+export { OPENAI_RESPONSES_APIS, type OpenAIResponsesCompactionOutput, readOpenAIResponsesCompactionWindow, resolveOpenAIResponsesServerCompactionPlan };

package/dist/internal/openai-responses-payload-policy.mjs

@@ -1,3 +1,2 @@
-import { i as OPENAI_RESPONSES_APIS } from "../openai-responses-contracts-CyfIkQi5.mjs";
-import { i as resolveOpenAIResponsesServerCompactionPlan } from "../openai-responses-payload-policy-BDxV-W0c.mjs";
-export { OPENAI_RESPONSES_APIS, resolveOpenAIResponsesServerCompactionPlan };
+import { c as resolveOpenAIResponsesServerCompactionPlan, f as OPENAI_RESPONSES_APIS, r as readOpenAIResponsesCompactionWindow } from "../openai-responses-compaction-window-DwydGZI8.mjs";
+export { OPENAI_RESPONSES_APIS, readOpenAIResponsesCompactionWindow, resolveOpenAIResponsesServerCompactionPlan };

package/dist/internal/openai.d.mts

@@ -1,47 +1,47 @@
-import { $ as Usage, E as Model, R as SimpleStreamOptions, V as StreamFunction, u as Context, z as StopReason } from "../types-BHNrPS1l.mjs";
-import { _ as normalizeOpenAIReasoningEffort, a as OpenAICompletionsOptions, b as supportsOpenAIReasoningEffort, c as OpenAIToolProjection, d as reconcileOpenAIResponsesToolChoice, f as OpenAIApiReasoningEffort, g as isOpenAIGpt56Model, h as isOpenAIGpt55Model, i as BaseOpenAIStreamOptions, l as projectOpenAITools, m as isOpenAIGpt54MiniModel, p as OpenAIReasoningEffort, s as OpenAICompletionsToolChoice, u as reconcileOpenAICompletionsToolChoice, v as resolveOpenAIReasoningEffortForModel, x as supportsOpenAITemperature, y as resolveOpenAISupportedReasoningEfforts } from "../provider-options-B96RdNpH.mjs";
-import { o as ResponsesPromptObservation, s as responsesPromptObserver } from "../openai-responses-contracts-XpZJxrRG.mjs";
-import { t as ResolvedOpenAICompletionsCompat } from "../openai-completions-compat-Dt3dcawL.mjs";
+import { B as StopReason, D as Model, H as StreamFunction, d as Context, et as Usage, z as SimpleStreamOptions } from "../types-h38Azne1.mjs";
+import { C as supportsOpenAIReasoningEffort, S as resolveOpenAISupportedReasoningEfforts, _ as isOpenAIGpt54MiniModel, a as CodeModeToolSurfaceObservation, b as normalizeOpenAIReasoningEffort, c as codeModeToolSurfaceObserver, d as OpenAIToolProjection, f as projectOpenAITools, g as OpenAIReasoningEffort, h as OpenAIApiReasoningEffort, i as BaseOpenAIStreamOptions, l as reasoningTagTextPolicy, m as reconcileOpenAIResponsesToolChoice, o as OpenAICompletionsOptions, p as reconcileOpenAICompletionsToolChoice, u as OpenAICompletionsToolChoice, v as isOpenAIGpt55Model, w as supportsOpenAITemperature, x as resolveOpenAIReasoningEffortForModel, y as isOpenAIGpt56Model } from "../provider-options-HvA_slFa.mjs";
+import "../types-DtGu2d3C.mjs";
+import { o as ResponsesPromptObservation, s as responsesPromptObserver } from "../openai-responses-contracts-DgaR3t5T.mjs";
+import { t as ResolvedOpenAICompletionsCompat } from "../openai-completions-compat-DB7FFq7k.mjs";
 import { n as clampOpenAIPromptCacheKey, t as OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH } from "../openai-prompt-cache-2uo_1OR1.mjs";
 import OpenAI from "openai";
 import { TSchema } from "typebox";
 import { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
 import { ChatCompletionMessageParam } from "openai/resources/chat/completions.js";
-
 //#region packages/ai/src/providers/agent-tools-parameter-schema.d.ts
 /**
  * Narrow structural view of the host's model compat config. packages/ai must stay
  * config-agnostic, so only tool-schema-relevant fields are modeled here; the host's
  * ModelCompatConfig remains structurally assignable.
  */
-type ToolSchemaModelCompat = {
+export type ToolSchemaModelCompat = {
   toolSchemaProfile?: string;
   unsupportedToolSchemaKeywords?: string[];
   omitEmptyArrayItems?: boolean;
 };
 /** Extracts the compat record whether callers pass a model (`{ compat }`) or the compat itself. */
-declare function extractToolSchemaModelCompat(modelOrCompat: {
+export declare function extractToolSchemaModelCompat(modelOrCompat: {
   compat?: unknown;
 } | ToolSchemaModelCompat | undefined): ToolSchemaModelCompat | undefined;
 /** JSON Schema keywords this model/provider rejects in tool schemas. */
-declare function resolveUnsupportedToolSchemaKeywords(modelOrCompat: {
+export declare function resolveUnsupportedToolSchemaKeywords(modelOrCompat: {
   compat?: unknown;
 } | ToolSchemaModelCompat | undefined): ReadonlySet<string>;
 /** Whether empty `items: {}` on array schemas must be omitted for this model/provider. */
-declare function shouldOmitEmptyArrayItems(modelOrCompat: {
+export declare function shouldOmitEmptyArrayItems(modelOrCompat: {
   compat?: unknown;
 } | ToolSchemaModelCompat | undefined): boolean;
-type ToolParameterSchemaOptions = {
+export type ToolParameterSchemaOptions = {
   modelProvider?: string;
   modelId?: string;
   modelCompat?: ToolSchemaModelCompat;
 };
 /** Return a provider-compatible JSON schema for a model-facing tool. */
-declare function normalizeToolParameterSchema(schema: unknown, options?: ToolParameterSchemaOptions): TSchema;
+export declare function normalizeToolParameterSchema(schema: unknown, options?: ToolParameterSchemaOptions): TSchema;
 //#endregion
 //#region packages/ai/src/providers/azure-deployment-map.d.ts
 /** Parses AZURE_OPENAI_DEPLOYMENT_MAP-style model=deployment entries. */
-declare function parseAzureDeploymentNameMap(value: string | undefined): Map<string, string>;
+export declare function parseAzureDeploymentNameMap(value: string | undefined): Map<string, string>;
 /**
  * Resolves the Azure deployment name for a model id, falling back to the model id.
  *
@@ -49,40 +49,40 @@ declare function parseAzureDeploymentNameMap(value: string | undefined): Map<str
  * case keep their exact mappings; a case-insensitive match is only used as a fallback
  * (e.g. `GPT-4o` against a `gpt-4o=...` map) to avoid 404s from casing differences.
  */
-declare function resolveAzureDeploymentNameFromMap(params: {
+export declare function resolveAzureDeploymentNameFromMap(params: {
   modelId: string;
   deploymentMap?: string;
 }): string;
 //#endregion
 //#region packages/ai/src/providers/azure-openai-responses-client-compat.d.ts
-declare function isTraditionalAzureOpenAIHost(hostname: string): boolean;
-declare function isOpenAICompatibleAzureResponsesBaseUrl(baseUrl: string): boolean;
+export declare function isTraditionalAzureOpenAIHost(hostname: string): boolean;
+export declare function isOpenAICompatibleAzureResponsesBaseUrl(baseUrl: string): boolean;
 //#endregion
 //#region packages/ai/src/providers/clean-for-gemini.d.ts
-declare const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS: Set<string>;
-declare function cleanSchemaForGemini(schema: unknown): TSchema;
+export declare const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS: Set<string>;
+export declare function cleanSchemaForGemini(schema: unknown): TSchema;
 //#endregion
 //#region packages/ai/src/providers/clean-for-llamacpp-gbnf.d.ts
 /** llama.cpp rejects grammar repetitions whose expanded rule count reaches 2000. */
-declare const LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD = 2000;
+export declare const LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD = 2000;
 /** Removes JSON Schema constraints that llama.cpp cannot compile into GBNF. */
-declare function cleanSchemaForLlamacppGbnf(schema: unknown): unknown;
+export declare function cleanSchemaForLlamacppGbnf(schema: unknown): unknown;
 /** Reports schema paths that llama.cpp cannot compile into GBNF. */
-declare function findLlamacppGbnfSchemaViolations(schema: unknown, path: string): string[];
+export declare function findLlamacppGbnfSchemaViolations(schema: unknown, path: string): string[];
 //#endregion
 //#region packages/ai/src/openai-completions-messages.d.ts
 /** Convert a normalized transcript to OpenAI Chat Completions messages. */
-declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompletionsCompat, options?: {
+export declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompletionsCompat, options?: {
   cacheOptOutIndexes?: Set<number>;
   preserveSystemPromptCacheBoundary?: boolean;
 }): ChatCompletionMessageParam[];
 //#endregion
 //#region packages/ai/src/providers/openai-completions.d.ts
-declare const streamOpenAICompletions: StreamFunction<"openai-completions", OpenAICompletionsOptions>;
-declare const streamSimpleOpenAICompletions: StreamFunction<"openai-completions", SimpleStreamOptions>;
+export declare const streamOpenAICompletions: StreamFunction<"openai-completions", OpenAICompletionsOptions>;
+export declare const streamSimpleOpenAICompletions: StreamFunction<"openai-completions", SimpleStreamOptions>;
 //#endregion
 //#region packages/ai/src/providers/openai-responses.d.ts
-interface OpenAIResponsesOptions extends BaseOpenAIStreamOptions {
+export interface OpenAIResponsesOptions extends BaseOpenAIStreamOptions {
   reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
   reasoningSummary?: "auto" | "detailed" | "concise" | null;
   replayResponsesItemIds?: boolean;
@@ -91,38 +91,38 @@ interface OpenAIResponsesOptions extends BaseOpenAIStreamOptions {
 /**
  * Generate function for OpenAI Responses API
  */
-declare const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIResponsesOptions>;
-declare const streamSimpleOpenAIResponses: StreamFunction<"openai-responses", SimpleStreamOptions>;
+export declare const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIResponsesOptions>;
+export declare const streamSimpleOpenAIResponses: StreamFunction<"openai-responses", SimpleStreamOptions>;
 //#endregion
 //#region packages/ai/src/providers/openai-responses-stream-compat.d.ts
-declare const OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE = "output_text";
-declare const AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE = "text";
-declare const OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE = "response.output_text.delta";
-declare const AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE = "response.text.delta";
-type ResponsesTextContentPartType = typeof OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE | typeof AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE;
-type ResponsesTextDeltaEventType = typeof OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE | typeof AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
-type AzureResponsesTextContentPart = {
+export declare const OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE = "output_text";
+export declare const AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE = "text";
+export declare const OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE = "response.output_text.delta";
+export declare const AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE = "response.text.delta";
+export type ResponsesTextContentPartType = typeof OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE | typeof AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE;
+export type ResponsesTextDeltaEventType = typeof OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE | typeof AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
+export type AzureResponsesTextContentPart = {
   type: typeof AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE;
   text: string;
 };
-type AzureResponsesTextDeltaEvent = {
+export type AzureResponsesTextDeltaEvent = {
   type: typeof AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
   delta: string;
 };
-declare function isResponsesTextContentPartType(type: unknown): type is ResponsesTextContentPartType;
-declare function isResponsesTextDeltaEventType(type: unknown): type is ResponsesTextDeltaEventType;
-declare function isAzureResponsesTextDeltaEventType(type: unknown): type is typeof AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
-declare function isAzureResponsesTextDeltaEvent(event: {
+export declare function isResponsesTextContentPartType(type: unknown): type is ResponsesTextContentPartType;
+export declare function isResponsesTextDeltaEventType(type: unknown): type is ResponsesTextDeltaEventType;
+export declare function isAzureResponsesTextDeltaEventType(type: unknown): type is typeof AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
+export declare function isAzureResponsesTextDeltaEvent(event: {
   type?: unknown;
   delta?: unknown;
 }): event is AzureResponsesTextDeltaEvent;
-type ResponsesMessageSnapshotCollapse = {
+export type ResponsesMessageSnapshotCollapse = {
   kind: "extend";
   text: string;
 } | {
   kind: "keep";
 };
-declare function resolveResponsesMessageSnapshotCollapse(params: {
+export declare function resolveResponsesMessageSnapshotCollapse(params: {
   prior: {
     text: string;
     phase: string | undefined;
@@ -133,7 +133,7 @@ declare function resolveResponsesMessageSnapshotCollapse(params: {
 //#endregion
 //#region packages/ai/src/providers/openai-responses-terminal-usage.d.ts
 /** Terminal usage payload, modeled structurally so untyped callers can pass raw records. */
-type ResponsesTerminalUsagePayload = {
+export type ResponsesTerminalUsagePayload = {
   input_tokens?: number | null;
   output_tokens?: number | null;
   total_tokens?: number | null;
@@ -154,15 +154,15 @@ type ResponsesTerminalUsagePayload = {
  * whose `cached_tokens` exceeds `input_tokens` clamps the input bucket, leaving the reported total
  * short of what the buckets actually price.
  */
-declare function mapResponsesTerminalUsage(usage: ResponsesTerminalUsagePayload | undefined | null): Pick<Usage, "input" | "output" | "cacheRead" | "cacheWrite" | "totalTokens"> | undefined;
+export declare function mapResponsesTerminalUsage(usage: ResponsesTerminalUsagePayload | undefined | null): Pick<Usage, "input" | "output" | "cacheRead" | "cacheWrite" | "contextUsage" | "totalTokens"> | undefined;
 /** Reasoning tokens are reported by the agent path only; the package path does not track them. */
-declare function readResponsesReasoningTokens(usage: ResponsesTerminalUsagePayload | undefined | null): number | undefined;
+export declare function readResponsesReasoningTokens(usage: ResponsesTerminalUsagePayload | undefined | null): number | undefined;
 /**
  * Resolve the terminal stop reason, including the two overrides every Responses path shares: a
  * content-filtered turn is a provider error rather than a truncated answer, and a turn that
  * produced tool calls reports `toolUse` instead of a plain stop.
  */
-declare function resolveResponsesTerminalStopReason(params: {
+export declare function resolveResponsesTerminalStopReason(params: {
   status: OpenAI.Responses.ResponseStatus | undefined;
   terminalEventType?: "response.completed" | "response.incomplete";
   incompleteReason?: string;
@@ -173,43 +173,45 @@ declare function resolveResponsesTerminalStopReason(params: {
 };
 //#endregion
 //#region packages/ai/src/providers/openai-responses-tool-call-tracker.d.ts
-type ResponsesToolCallIdentity = {
+export type ResponsesToolCallIdentity = {
   itemId?: string;
   callId?: string;
 };
-type ResponsesToolCallState = ResponsesToolCallIdentity & {
+export type ResponsesToolCallState = ResponsesToolCallIdentity & {
   argumentStreamReliable: boolean;
+  outputIndex?: number;
 };
 type ResponsesToolCallEvent = {
   output_index?: unknown;
   item_id?: unknown;
 };
-declare function readResponsesToolCallItemIdentity(item: {
+export declare function readResponsesToolCallItemIdentity(item: {
   id?: unknown;
   call_id?: unknown;
 }): ResponsesToolCallIdentity;
-declare function createResponsesToolCallTracker<TState extends ResponsesToolCallState>(): {
+export declare function createResponsesToolCallTracker<TState extends ResponsesToolCallState>(): {
   register(event: ResponsesToolCallEvent, state: TState): void;
-  resolve(event: ResponsesToolCallEvent, identity?: ResponsesToolCallIdentity): TState | undefined;
+  resolve(event: ResponsesToolCallEvent, identity?: ResponsesToolCallIdentity, allowUnmatchedIdentity?: boolean): TState | undefined;
   forget(toolCall: TState): void;
   markArgumentsUnreliable(): void;
   hasActive(): boolean;
+  hasExactlyActive(expected: readonly TState[]): boolean;
 };
 //#endregion
 //#region packages/ai/src/providers/openai-stop-reason.d.ts
-type OpenAIStopReasonResult = {
+export type OpenAIStopReasonResult = {
   stopReason: StopReason;
   errorMessage?: string;
 };
-declare function mapOpenAIStopReason(reason: string | null, options?: {
+export declare function mapOpenAIStopReason(reason: string | null, options?: {
   allowSingularToolCall?: boolean;
 }): OpenAIStopReasonResult;
 //#endregion
 //#region packages/ai/src/providers/openai-tool-schema-compat.d.ts
 /** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
-declare function normalizeOpenAIStrictCompatSchema(schema: unknown): TSchema;
+export declare function normalizeOpenAIStrictCompatSchema(schema: unknown): TSchema;
 /** Finds schema paths that violate OpenAI strict tool-schema requirements. */
-declare function findOpenAIStrictSchemaViolations(schema: unknown, path: string, options?: {
+export declare function findOpenAIStrictSchemaViolations(schema: unknown, path: string, options?: {
   requireObjectRoot?: boolean;
 }): string[];
 //#endregion
@@ -225,36 +227,36 @@ type ToolSchemaCompatInput = {
   omitEmptyArrayItems?: unknown;
 };
 /** Normalizes a tool parameter schema into the OpenAI strict JSON-schema subset. */
-declare function normalizeStrictOpenAIJsonSchema(schema: unknown, modelCompat?: ToolSchemaCompatInput | null): unknown;
+export declare function normalizeStrictOpenAIJsonSchema(schema: unknown, modelCompat?: ToolSchemaCompatInput | null): unknown;
 /** Normalizes tool parameters using strict OpenAI rules only when strict mode is active. */
-declare function normalizeOpenAIStrictToolParameters<T>(schema: T, strict: boolean, modelCompat?: ToolSchemaCompatInput | null): T;
+export declare function normalizeOpenAIStrictToolParameters<T>(schema: T, strict: boolean, modelCompat?: ToolSchemaCompatInput | null): T;
 /** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
-declare function isStrictOpenAIJsonSchemaCompatible(schema: unknown): boolean;
+export declare function isStrictOpenAIJsonSchemaCompatible(schema: unknown): boolean;
 type OpenAIStrictToolSchemaDiagnostic = {
   toolIndex: number;
   toolName?: string;
   violations: string[];
 };
 /** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
-declare function findOpenAIStrictToolProjectionDiagnostics(projection: OpenAIToolProjection): OpenAIStrictToolSchemaDiagnostic[];
+export declare function findOpenAIStrictToolProjectionDiagnostics(projection: OpenAIToolProjection): OpenAIStrictToolSchemaDiagnostic[];
 /** Resolves strict mode for the projected tools that will be emitted in the request payload. */
-declare function resolveOpenAIProjectedToolsStrictToolFlag(projection: OpenAIToolProjection, strict: boolean | null | undefined): boolean | undefined;
+export declare function resolveOpenAIProjectedToolsStrictToolFlag(projection: OpenAIToolProjection, strict: boolean | null | undefined): boolean | undefined;
 //#endregion
 //#region packages/ai/src/providers/schema-keyword-strip.d.ts
 /** Recursively remove schema keywords unsupported by a target provider/tool surface. */
-declare function stripUnsupportedSchemaKeywords(schema: unknown, unsupportedKeywords: ReadonlySet<string>): unknown;
+export declare function stripUnsupportedSchemaKeywords(schema: unknown, unsupportedKeywords: ReadonlySet<string>): unknown;
 //#endregion
 //#region packages/ai/src/providers/tool-schema-json-projection.d.ts
 /** JSON-safe schema value used when projecting runtime tool parameters. */
-type RuntimeToolInputSchemaJson = null | boolean | number | string | RuntimeToolInputSchemaJson[] | {
+export type RuntimeToolInputSchemaJson = null | boolean | number | string | RuntimeToolInputSchemaJson[] | {
   [key: string]: RuntimeToolInputSchemaJson;
 };
 /** Projected runtime tool schema plus validation violations. */
-type RuntimeToolInputSchemaProjection = {
+export type RuntimeToolInputSchemaProjection = {
   readonly schema: RuntimeToolInputSchemaJson;
   readonly violations: readonly string[];
 };
 /** Projects one runtime tool input schema to JSON and reports runtime incompatibilities. */
-declare function projectRuntimeToolInputSchema(schema: unknown, path?: string): RuntimeToolInputSchemaProjection;
+export declare function projectRuntimeToolInputSchema(schema: unknown, path?: string): RuntimeToolInputSchemaProjection;
 //#endregion
-export { AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE, AzureResponsesTextContentPart, AzureResponsesTextDeltaEvent, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE, OpenAIApiReasoningEffort, type OpenAICompletionsOptions, OpenAICompletionsToolChoice, OpenAIReasoningEffort, OpenAIResponsesOptions, OpenAIStopReasonResult, OpenAIToolProjection, ResponsesMessageSnapshotCollapse, type ResponsesPromptObservation, ResponsesTerminalUsagePayload, ResponsesTextContentPartType, ResponsesTextDeltaEventType, ResponsesToolCallIdentity, ResponsesToolCallState, RuntimeToolInputSchemaJson, RuntimeToolInputSchemaProjection, ToolParameterSchemaOptions, ToolSchemaModelCompat, clampOpenAIPromptCacheKey, cleanSchemaForGemini, cleanSchemaForLlamacppGbnf, convertMessages, createResponsesToolCallTracker, extractToolSchemaModelCompat, findLlamacppGbnfSchemaViolations, findOpenAIStrictSchemaViolations, findOpenAIStrictToolProjectionDiagnostics, isAzureResponsesTextDeltaEvent, isAzureResponsesTextDeltaEventType, isOpenAICompatibleAzureResponsesBaseUrl, isOpenAIGpt54MiniModel, isOpenAIGpt55Model, isOpenAIGpt56Model, isResponsesTextContentPartType, isResponsesTextDeltaEventType, isStrictOpenAIJsonSchemaCompatible, isTraditionalAzureOpenAIHost, mapOpenAIStopReason, mapResponsesTerminalUsage, normalizeOpenAIReasoningEffort, normalizeOpenAIStrictCompatSchema, normalizeOpenAIStrictToolParameters, normalizeStrictOpenAIJsonSchema, normalizeToolParameterSchema, parseAzureDeploymentNameMap, projectOpenAITools, projectRuntimeToolInputSchema, readResponsesReasoningTokens, readResponsesToolCallItemIdentity, reconcileOpenAICompletionsToolChoice, reconcileOpenAIResponsesToolChoice, resolveAzureDeploymentNameFromMap, resolveOpenAIProjectedToolsStrictToolFlag, resolveOpenAIReasoningEffortForModel, resolveOpenAISupportedReasoningEfforts, resolveResponsesMessageSnapshotCollapse, resolveResponsesTerminalStopReason, resolveUnsupportedToolSchemaKeywords, responsesPromptObserver, shouldOmitEmptyArrayItems, streamOpenAICompletions, streamOpenAIResponses, streamSimpleOpenAICompletions, streamSimpleOpenAIResponses, stripUnsupportedSchemaKeywords, supportsOpenAIReasoningEffort, supportsOpenAITemperature };
+export { type CodeModeToolSurfaceObservation, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH, OpenAIApiReasoningEffort, type OpenAICompletionsOptions, OpenAICompletionsToolChoice, OpenAIReasoningEffort, OpenAIToolProjection, type ResponsesPromptObservation, clampOpenAIPromptCacheKey, codeModeToolSurfaceObserver, isOpenAIGpt54MiniModel, isOpenAIGpt55Model, isOpenAIGpt56Model, normalizeOpenAIReasoningEffort, projectOpenAITools, reasoningTagTextPolicy, reconcileOpenAICompletionsToolChoice, reconcileOpenAIResponsesToolChoice, resolveOpenAIReasoningEffortForModel, resolveOpenAISupportedReasoningEfforts, responsesPromptObserver, supportsOpenAIReasoningEffort, supportsOpenAITemperature };