@cognipeer/agent-sdk 0.10.6 → 0.13.0

package/dist/model-rules-Bg9nSqyN.d.cts

@@ -0,0 +1,658 @@
+type RuleFamily = "openai" | "anthropic" | "gemini" | "other";
+type ReasoningStyle = "effort" | "adaptive" | "budget" | "toggle" | "none";
+/** How "reasoning off" is spelled on the wire (`none` = the effort value itself). */
+type OffMechanism = "none" | "disabled" | "between_tools";
+type TemperatureRule = "any" | "default-only" | "unsupported" | "thinking-requires-1";
+type MaxTokensParam = "max_tokens" | "max_completion_tokens";
+type RuleSource = "verified-2026-10-14" | "docs" | "learned";
+type ModelRule = {
+    id: string;
+    family: RuleFamily;
+    /** Case-insensitive regex tested against the normalised candidate ids. */
+    match: string;
+    reasoning: {
+        style: ReasoningStyle;
+        /** Effort values the wire accepts (Chat Completions / Messages). Empty = no reasoning control. */
+        efforts: ReasoningEffort[];
+        /** Efforts the OpenAI Responses endpoint accepts, when they differ from `efforts`. */
+        responsesEfforts?: ReasoningEffort[];
+        off: OffMechanism | null;
+    };
+    sampling: {
+        temperature: TemperatureRule;
+        topP: boolean;
+        topK: boolean;
+        penalties: boolean;
+        logprobs: boolean;
+    };
+    maxTokensParam: MaxTokensParam;
+    chatTools: {
+        reasoning: "any" | "force-none";
+    };
+    /** Request fields to leave out, learned from a provider 400 (not used in the shipped JSON). */
+    dropParams?: string[];
+    source: RuleSource;
+    note: string;
+};
+type ModelRules = {
+    version: number;
+    effortLadder: ReasoningEffort[];
+    /** Thinking-token budgets for budget-style engines (Anthropic 3.7/4.x, Bedrock). */
+    budgets: Record<Exclude<ReasoningEffort, "none">, number>;
+    geminiBudgets: Record<Exclude<ReasoningEffort, "none">, number>;
+    rules: ModelRule[];
+};
+/** A sparse override merged over a rule (what a provider 400 teaches us). */
+type RulePatch = {
+    reasoning?: Partial<ModelRule["reasoning"]>;
+    sampling?: Partial<ModelRule["sampling"]>;
+    maxTokensParam?: MaxTokensParam;
+    chatTools?: Partial<ModelRule["chatTools"]>;
+    dropParams?: string[];
+};
+type ResolvedModelRule = ModelRule & {
+    /** Id of the rule that matched (e.g. `openai-gpt-6-plus`). */
+    matchedRuleId: string;
+    /** True when only the family's permissive default matched: the model is not in the JSON. */
+    isDefault: boolean;
+    /** True when a learned adjustment is merged into this rule. */
+    learned: boolean;
+};
+declare const MODEL_RULES: ModelRules;
+/** Normalised ids a rule is matched against: lowercase, last path segment, gateway prefixes stripped. */
+declare function modelIdCandidates(model: string | undefined): string[];
+declare function mergeRulePatch<T extends RulePatch>(base: T, patch: RulePatch | undefined): T;
+/** Records (merges) a learned patch; the oldest entry is evicted past 500. */
+declare function rememberModelRulePatch(provider: string, model: string, patch: RulePatch, scope?: string): void;
+declare function getLearnedModelRulePatch(provider: string, model: string, scope?: string): RulePatch | undefined;
+/** Snapshot of everything learned so far (hosts can persist it and re-seed with `rememberModelRulePatch`). */
+declare function listLearnedModelRules(): Array<{
+    provider: string;
+    model: string;
+    scope?: string;
+    patch: RulePatch;
+}>;
+declare function clearLearnedModelRules(): void;
+/**
+ * Finds the rule for a model: the first matching rule of the provider's family
+ * (or families, for gateways such as Bedrock), else the family's permissive
+ * default. Learned adjustments for (provider, model) are merged in; `patch`
+ * lets a caller layer one more override on top (used by the retry loop).
+ */
+declare function resolveModelRule(opts: {
+    provider?: string;
+    model?: string;
+    patch?: RulePatch;
+    scope?: string;
+}): ResolvedModelRule;
+type EffortMapping = {
+    /** The effort value to put on the wire. */
+    effort?: ReasoningEffort;
+    /** The off mechanism to use instead (`disabled` / `between_tools`). */
+    off?: Exclude<OffMechanism, "none">;
+    /** False only when the requested value goes through untouched. */
+    mapped: boolean;
+};
+/**
+ * Maps a requested effort onto what the rule accepts. A supported value passes;
+ * an unsupported one goes to the nearest LOWER supported value (nearest higher
+ * if nothing lower exists). `none` uses the rule's off mechanism, else the
+ * lowest supported value. A requested non-`none` effort never maps to `none`
+ * (asking for "minimal" must not switch thinking off). A rule without reasoning
+ * control returns `{ mapped: true }` with no value.
+ */
+declare function mapReasoningEffort(rule: ModelRule, effort: ReasoningEffort, endpoint?: "chat" | "responses"): EffortMapping;
+type SamplingField = "temperature" | "topP" | "topK" | "presencePenalty" | "frequencyPenalty" | "logprobs";
+/** Whether the rule lets a sampling field through. `thinkingOn` matters for `thinking-requires-1`. */
+declare function allowsSampling(rule: ModelRule, field: SamplingField, value?: unknown, thinkingOn?: boolean): boolean;
+/** Removes `rule.dropParams` (top-level keys) from a request body. */
+declare function applyDropParams(body: Record<string, any>, rule: ModelRule): void;
+/** Token budget for a budget-style engine; 0 for `none`. */
+declare function effortBudget(effort: ReasoningEffort, table?: "anthropic" | "gemini"): number;
+
+declare const MAX_ADJUSTMENTS = 3;
+type ParsedModelErrorKind = "unsupported_parameter" | "unsupported_value" | "max_tokens_rename" | "default_only" | "chat_tools_effort" | "thinking_enabled_unsupported" | "thinking_adaptive_unsupported" | "thinking_off_between_tools" | "thinking_disabled_unsupported" | "temperature_thinking";
+type ParsedModelError = {
+    kind: ParsedModelErrorKind;
+    param?: string;
+    value?: string;
+    supportedValues?: string[];
+    /** `max_tokens` / `max_completion_tokens` for `max_tokens_rename`. */
+    renameTo?: "max_tokens" | "max_completion_tokens";
+    message: string;
+};
+type ModelRuleLearnedEvent = {
+    provider: string;
+    model: string;
+    /** Short label, e.g. `drop:temperature`, `max_tokens->max_completion_tokens`. */
+    adjustment: string;
+    patch: RulePatch;
+    /** The provider's error message that triggered it. */
+    reason: string;
+};
+/** Recognises the 400 shapes OpenAI-wire servers and Anthropic use for a bad parameter or value. */
+declare function parseModelError(text: string): ParsedModelError | undefined;
+type AdjustmentRun<T> = {
+    provider: string;
+    model: string;
+    /** `chat` (default), `responses`, `messages` or `converse`; selects which effort list a value error teaches. */
+    endpoint?: string;
+    onLearned?: (event: ModelRuleLearnedEvent) => void;
+    /** Keeps learned patches apart per backend (e.g. the base URL): same model id, different deployment. */
+    scope?: string;
+    /** Request fields the caller set itself (`request.extra` keys): corrected for this call, never learned for the model. */
+    callerParams?: string[];
+    /**
+     * Performs the call for the given overlay. `guard(body)` must be called with
+     * the request body just before sending: a retry whose body is identical to
+     * the previous attempt's is pointless and ends the loop with the typed error.
+     */
+    run: (overlay: RulePatch, guard: (body: unknown) => void) => Promise<T>;
+};
+/** Runs a request, correcting it from the provider's own 400s (see file header). */
+declare function runWithModelAdjustments<T>(opts: AdjustmentRun<T>): Promise<T>;
+/** Converts a 400 ProviderError into the typed error without retrying (Vertex and other single-shot paths). */
+declare function asModelRequestError(err: unknown, provider: string, model: string): unknown;
+
+type MessageRole = "system" | "user" | "assistant" | "tool";
+type TextContent = {
+    type: "text";
+    text: string;
+};
+type ImageContent = {
+    type: "image";
+    source: {
+        type: "base64";
+        mediaType: string;
+        data: string;
+    } | {
+        type: "url";
+        url: string;
+        mediaType?: string;
+    };
+};
+/**
+ * A document attachment (PDF, DOCX, CSV, …). Providers map this to their
+ * native document blocks: Gemini `inlineData`/`fileData`, Anthropic
+ * `document`, OpenAI Chat Completions `file` / Responses `input_file`,
+ * Bedrock Converse `document`. Providers without document support degrade
+ * to a text placeholder referencing the file name/URL.
+ */
+type FileContent = {
+    type: "file";
+    source: {
+        type: "base64";
+        mediaType: string;
+        data: string;
+    } | {
+        type: "url";
+        url: string;
+        mediaType?: string;
+    };
+    /** Original file name, when known (required by some providers, e.g. Bedrock). */
+    fileName?: string;
+};
+/**
+ * An audio attachment. Gemini accepts it as `inlineData`/`fileData`; OpenAI
+ * audio-capable models as `input_audio`. Providers without audio support
+ * degrade to a text placeholder.
+ */
+type AudioContent = {
+    type: "audio";
+    source: {
+        type: "base64";
+        mediaType: string;
+        data: string;
+    } | {
+        type: "url";
+        url: string;
+        mediaType?: string;
+    };
+};
+type ContentPart = TextContent | ImageContent | FileContent | AudioContent;
+type ToolCall = {
+    id: string;
+    name: string;
+    arguments: string;
+    /** Gemini `thoughtSignature` attached to a functionCall part; must be echoed back on the next turn. */
+    thoughtSignature?: string;
+    /** Position of the call within the assistant turn. Set on streamed deltas so a consumer can frame them (OpenAI `tool_calls[].index`). */
+    index?: number;
+};
+/**
+ * A provider-native reasoning/thinking block. Captured from the model response
+ * and replayed verbatim on subsequent turns (required by Anthropic extended
+ * thinking when tools are involved — the `signature` must round-trip intact).
+ */
+type ReasoningBlock = {
+    type: "thinking" | "redacted_thinking";
+    /** Plain-text thinking content (absent for redacted blocks). */
+    text?: string;
+    /** Cryptographic signature Anthropic requires to be echoed back verbatim. */
+    signature?: string;
+    /** Opaque payload for redacted_thinking blocks. */
+    data?: string;
+};
+/** Captured reasoning payload attached to assistant turns / responses. */
+type ReasoningPayload = {
+    /** Verbatim provider blocks to replay on the next turn. */
+    blocks?: ReasoningBlock[];
+    /** Human-readable reasoning summary, when the provider exposes one. */
+    summary?: string;
+};
+type UnifiedMessage = {
+    role: MessageRole;
+    content: string | ContentPart[];
+    name?: string;
+    toolCalls?: ToolCall[];
+    toolCallId?: string;
+    /** Native reasoning blocks to replay verbatim (Anthropic/Bedrock thinking). */
+    reasoning?: ReasoningPayload;
+};
+type ToolDefinition = {
+    name: string;
+    description: string;
+    parameters: Record<string, any>;
+    strict?: boolean;
+};
+type ChatCompletionRequest = {
+    model: string;
+    messages: UnifiedMessage[];
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    stop?: string[];
+    /** OpenAI-family only; other providers ignore it. */
+    presencePenalty?: number;
+    /** OpenAI-family only; other providers ignore it. */
+    frequencyPenalty?: number;
+    tools?: ToolDefinition[];
+    toolChoice?: "auto" | "required" | "none" | {
+        name: string;
+    };
+    responseFormat?: {
+        type: "json_schema" | "json_object" | "text";
+        schema?: Record<string, any>;
+        name?: string;
+    };
+    stream?: boolean;
+    /**
+     * Streaming only. `false` opts out of `stream_options.include_usage` on
+     * OpenAI-shaped endpoints (some servers reject the option). Default true.
+     */
+    streamUsage?: boolean;
+    /** OpenAI-family: deterministic sampling seed. Passed through. */
+    seed?: number;
+    /** OpenAI-family: number of choices. Pass-through only; only choice 0 is parsed. */
+    n?: number;
+    /** OpenAI-family: allow/forbid parallel tool calls. Passed through when set. */
+    parallelToolCalls?: boolean;
+    /** OpenAI-family: return token log probabilities. Passed through. */
+    logprobs?: boolean;
+    /** OpenAI-family: how many top log probabilities per token. Passed through. */
+    topLogprobs?: number;
+    extra?: Record<string, any>;
+    /**
+     * Unified native-reasoning request config. Each provider maps this to its
+     * own shape:
+     *  - OpenAI o-series:   body.reasoning_effort = effort
+     *  - OpenAI Responses:  body.reasoning = { effort }
+     *  - Anthropic:         body.thinking  = { type: "enabled", budget_tokens }
+     *  - Google / Vertex:   body.generationConfig.thinkingConfig = { thinkingBudget, includeThoughts }
+     *
+     * Providers silently ignore unsupported fields.
+     */
+    reasoning?: ReasoningRequestConfig;
+    /**
+     * Cancels the HTTP request (and an in-flight stream) when it aborts. The agent
+     * loop sets it from the run's cancellation token / abort signal; a caller using
+     * a provider directly can pass its own. It is never serialised into the body.
+     */
+    signal?: AbortSignal;
+};
+/**
+ * `none` is OFF, and it is a value rather than the absence of one.
+ *
+ * On a thinking-by-default model — every Qwen3 under vLLM, gpt-5.1 and newer on
+ * OpenAI — sending no reasoning field leaves the model thinking. So "do not
+ * think" is an instruction that has to travel: `reasoning_effort:"none"` on
+ * OpenAI, `thinkingBudget:0` on Gemini, and no thinking block at all on
+ * Anthropic (where thinking is opt-in and the absence IS off). Omitting
+ * `effort` still means "say nothing about reasoning", which is the different
+ * and equally necessary state.
+ *
+ * `xhigh` / `max` are only accepted by some models. The SDK takes every ladder
+ * value for every model and maps it to the nearest lower value that model's rule
+ * accepts (see `mapReasoningEffort` and model-rules.json).
+ */
+type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+type ReasoningRequestConfig = {
+    /** Qualitative effort hint (mapped per-provider). */
+    effort?: ReasoningEffort;
+    /** Explicit per-call token budget for reasoning/thinking. */
+    budgetTokens?: number;
+    /**
+     * Gemini 3 style discrete thinking level (e.g. "low" | "high"). Sent as
+     * `thinkingConfig.thinkingLevel` and replaces the derived `thinkingBudget`
+     * (the API rejects both together). Ignored by other providers.
+     */
+    thinkingLevel?: string;
+    /** Whether the provider should expose its reasoning/thought summary to the caller. Gemini: default false. Claude adaptive thinking (5.x): default summarized (`thinking.display = "summarized"`) unless this is `false`; never added when the caller passes an explicit `extra.thinking`. */
+    includeThoughts?: boolean;
+    /** Provider-specific passthrough merged on top of the mapped shape. */
+    providerExtras?: Record<string, any>;
+};
+type TokenUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedInputTokens: number;
+    cachedWriteTokens: number;
+    cachedOutputTokens: number;
+    reasoningTokens: number;
+};
+declare function emptyUsage(): TokenUsage;
+type FinishReason = "stop" | "tool_calls" | "length" | "content_filter" | "error";
+type ProviderResponseFields = {
+    system_fingerprint?: string;
+    service_tier?: string;
+    annotations?: any[];
+    refusal?: string | null;
+    logprobs?: any;
+    [key: string]: any;
+};
+type ChatCompletionResponse = {
+    id: string;
+    model: string;
+    content: string | null;
+    toolCalls: ToolCall[];
+    usage: TokenUsage;
+    finishReason: FinishReason;
+    /** The provider's own finish/stop reason string, unnormalised (e.g. "end_turn", "function_call"). */
+    rawFinishReason?: string;
+    /**
+     * Provider response fields the unified shape has no slot for, kept when present:
+     * `system_fingerprint`, `service_tier`, `annotations`, `refusal`, `logprobs`.
+     */
+    providerFields?: ProviderResponseFields;
+    /** Native reasoning blocks + summary captured from the response, if any. */
+    reasoning?: ReasoningPayload;
+    raw: any;
+};
+type ChatCompletionChunk = {
+    id: string;
+    model: string;
+    delta: {
+        content?: string;
+        toolCalls?: Partial<ToolCall>[];
+        /** Incremental reasoning text / signature deltas (Anthropic thinking). */
+        reasoning?: ReasoningPayload;
+    };
+    usage?: TokenUsage;
+    finishReason?: FinishReason;
+    /** The provider's own finish reason string, unnormalised. Present on the chunk that carries it. */
+    rawFinishReason?: string;
+    /** See ChatCompletionResponse.providerFields; per-chunk (fingerprint, tier, delta refusal/annotations, logprobs). */
+    providerFields?: ProviderResponseFields;
+};
+/** Why the text is being embedded; mapped to each provider's own task/input type. */
+type EmbeddingInputType = "search_document" | "search_query" | "classification" | "clustering" | "semantic_similarity" | "question_answering" | "fact_verification" | "code_retrieval_query" | (string & {});
+type EmbeddingRequest = {
+    /** Model id (OpenAI/compatible), deployment name (Azure), model id (Bedrock), model name (Vertex). */
+    model: string;
+    /** Texts to embed. One vector per entry, in the same order. */
+    input: string[];
+    /** Requested output dimensions, for models that support shortening (OpenAI v3, Titan v2, Cohere v4, Gemini). */
+    dimensions?: number;
+    /** OpenAI-shaped endpoints: wire encoding. Vectors are always returned as number[] either way. */
+    encodingFormat?: "float" | "base64";
+    /** Task hint (Cohere on Bedrock, Gemini on Vertex). Ignored by providers without one. */
+    inputType?: EmbeddingInputType;
+    /** Max texts per HTTP request. Defaults per provider (OpenAI 2048, Vertex 100, Gemini-embedding 1, Titan 1). */
+    batchSize?: number;
+    /** Provider-specific fields merged into each request body (escape hatch). */
+    extra?: Record<string, any>;
+    signal?: AbortSignal;
+};
+type EmbeddingUsage = {
+    inputTokens: number;
+    totalTokens: number;
+};
+type EmbeddingResponse = {
+    model: string;
+    /** One vector per input, in input order. */
+    vectors: number[][];
+    usage: EmbeddingUsage;
+    /** Raw provider responses, one per HTTP request made. */
+    raw: any[];
+};
+type ProviderRetryConfig = {
+    /** Maximum retries on 429/5xx (default 3). */
+    maxRetries?: number;
+    /** Initial delay between retries in ms (default 500, doubled each attempt). */
+    baseDelayMs?: number;
+    /** Hard cap on a single retry delay in ms (default 8000). */
+    maxDelayMs?: number;
+    /** Custom predicate to opt in/out of a specific retry. */
+    shouldRetry?: (error: any, attempt: number) => boolean;
+};
+/** Transport options shared by every provider config. */
+type ProviderTransportConfig = {
+    /**
+     * Custom `fetch` used at EVERY HTTP call site of the provider (chat, stream,
+     * Responses, token exchange). Lets a host inject an SSRF-safe or proxied
+     * fetch. Defaults to the global `fetch`.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Per-request timeout in ms, measured until the response headers arrive
+     * (an established stream is not cut by it). Default: none.
+     */
+    timeoutMs?: number;
+    /**
+     * Called when a provider 400 taught the SDK something about a model that is
+     * not in (or drifted from) model-rules.json — e.g. "drop temperature",
+     * "max_tokens -> max_completion_tokens". The adjustment is already
+     * remembered in-process; hosts can log or persist it.
+     */
+    onModelRuleLearned?: (event: ModelRuleLearnedEvent) => void;
+};
+type OpenAIProviderConfig = ProviderTransportConfig & {
+    /**
+     * Which token-limit field to send: `max_tokens` or `max_completion_tokens`.
+     * `auto` (default) uses `max_completion_tokens` for o-series / gpt-5 models
+     * and `max_tokens` otherwise.
+     */
+    maxTokensParam?: "auto" | "max_tokens" | "max_completion_tokens";
+    provider: "openai";
+    apiKey: string;
+    baseURL?: string;
+    organization?: string;
+    defaultModel?: string;
+    defaultHeaders?: Record<string, string>;
+    retry?: ProviderRetryConfig;
+    /**
+     * @deprecated Use `api: "chat" | "responses" | "auto"`. Kept as an alias:
+     * `never` = chat, `always` = responses, `auto` = the name-based heuristic.
+     * When `api` is also set, `api` wins.
+     *
+     * WHICH API a reasoning-carrying request is addressed to.
+     *
+     *  auto    (the default for OpenAI and Azure) route to the Responses API when
+     *          the request carries `reasoning` AND the model name looks like an
+     *          o-series/gpt-5 reasoning model.
+     *  never   always Chat Completions. `reasoning` is still mapped, as
+     *          `reasoning_effort` plus any `providerExtras`.
+     *  always  always Responses, whatever the model is called.
+     *
+     * `auto` is a name-based guess, and it decides far more than where reasoning
+     * goes: Responses is a different request shape (`input` not `messages`,
+     * `text.format` not `response_format`, flat tool objects) and a different
+     * response parse. A caller with its own measurements of the Chat Completions
+     * body — a gateway, a proxy, an on-prem server that serves one and not the
+     * other, or anything that has tuned `extra` — must be able to say so, rather
+     * than discover that asking for less thinking silently changed the transport.
+     *
+     * Applies to any OpenAI-shaped endpoint, which is also why the guess is weak
+     * where it matters most: a self-hosted model is named by whoever served it.
+     */
+    responsesApi?: "auto" | "never" | "always";
+    /** @internal Set by OpenAICompatibleProvider: `auto` then means Chat Completions. */
+    _autoMeansChat?: boolean;
+    /**
+     * Which upstream API requests are sent to. `"auto"` (default) keeps the
+     * 0.11 behaviour of each class: OpenAI and Azure use Responses when the
+     * request carries `reasoning` and the model name looks like an o-series /
+     * gpt-5 model, otherwise Chat Completions; OpenAI-compatible always uses
+     * Chat Completions (the model name is the server operator's). `"chat"` always
+     * sends Chat Completions. `"responses"`
+     * sends every request to the Responses API (`POST /responses`) and streams it
+     * over real SSE (text, tool-call arguments and reasoning-summary deltas;
+     * set `responsesStreaming: false` to get one non-streaming call instead).
+     * Works on `OpenAIProvider`, `AzureProvider` and `OpenAICompatibleProvider`.
+     * When set, it wins over the deprecated `responsesApi`.
+     */
+    api?: "chat" | "responses" | "auto";
+    /**
+     * Models that go to the Responses API, named explicitly. Opt-in; unset by
+     * default.
+     *
+     * A string matches the request's model (or `defaultModel`) exactly; a RegExp
+     * is tested against it. A match routes the request to Responses whether or
+     * not it carries `reasoning` — the case this exists for is a model that
+     * reasons by default and rejects function tools on Chat Completions, where
+     * sending no reasoning field does not help. `responsesApi: "never"` still
+     * wins; under `"always"` the routing is unchanged.
+     *
+     * Requests for a matched model also get, on the Responses body only:
+     *  - Chat Completions spellings arriving through `extra`, which /responses
+     *    rejects with a 400, re-spelled with their values unchanged:
+     *    `reasoning_effort` → `reasoning.effort` (a request `reasoning` effort
+     *    still wins), `max_tokens` / `max_completion_tokens` →
+     *    `max_output_tokens`, `response_format` → `text.format`, and
+     *    `stream_options.include_usage` dropped.
+     *  - real SSE streaming, when `responsesStreaming` is also true.
+     *
+     * Honoured by `OpenAIProvider`, `AzureProvider` and
+     * `OpenAICompatibleProvider` alike.
+     */
+    responsesApiModels?: Array<string | RegExp>;
+    /**
+     * Stream Responses API output as it arrives (text, tool-call argument and
+     * reasoning-summary deltas) for `api: "responses"` and for models in
+     * `responsesApiModels`. Default true with `api: "responses"`, false
+     * otherwise (one non-streaming Responses call emitted as a single chunk).
+     * Has no effect on Chat Completions requests.
+     */
+    responsesStreaming?: boolean;
+};
+type AnthropicProviderConfig = ProviderTransportConfig & {
+    provider: "anthropic";
+    apiKey: string;
+    baseURL?: string;
+    defaultModel?: string;
+    defaultHeaders?: Record<string, string>;
+    anthropicVersion?: string;
+    retry?: ProviderRetryConfig;
+    /**
+     * Prompt caching configuration. When enabled, places cache_control:
+     * ephemeral breakpoints on the system prompt and the final tool definition,
+     * which is the recommended Anthropic recipe for static system + tools.
+     */
+    prompt_caching?: {
+        enabled: boolean;
+    };
+    /**
+     * Thinking request shape. `auto` (default) picks per model id: Claude 5.x
+     * and newer use `thinking:{type:"adaptive"}` + `output_config.effort`, older
+     * models use `thinking:{type:"enabled", budget_tokens}`. Force one with
+     * `adaptive` / `budget`. On the specific 400 for the wrong shape the
+     * provider retries once with the other form.
+     */
+    thinkingMode?: "auto" | "adaptive" | "budget";
+};
+type AzureProviderConfig = ProviderTransportConfig & {
+    provider: "azure";
+    retry?: ProviderRetryConfig;
+    /** See OpenAIProviderConfig.maxTokensParam. */
+    maxTokensParam?: "auto" | "max_tokens" | "max_completion_tokens";
+    apiKey: string;
+    endpoint: string;
+    apiVersion?: string;
+    deploymentName?: string;
+    defaultModel?: string;
+    defaultHeaders?: Record<string, string>;
+    /** See OpenAIProviderConfig.api. Default "auto". */
+    api?: "chat" | "responses" | "auto";
+    /** @deprecated Use `api`. */
+    responsesApi?: "auto" | "never" | "always";
+    responsesApiModels?: Array<string | RegExp>;
+    responsesStreaming?: boolean;
+};
+type OpenAICompatibleProviderConfig = ProviderTransportConfig & {
+    provider: "openai-compatible";
+    organization?: string;
+    retry?: ProviderRetryConfig;
+    /** @deprecated Use `api`. Default: see `api`. */
+    responsesApi?: "auto" | "never" | "always";
+    /** See OpenAIProviderConfig.api. Default "auto". */
+    api?: "chat" | "responses" | "auto";
+    responsesApiModels?: Array<string | RegExp>;
+    responsesStreaming?: boolean;
+    /** See OpenAIProviderConfig.maxTokensParam. Compatible servers default to `auto`. */
+    maxTokensParam?: "auto" | "max_tokens" | "max_completion_tokens";
+    apiKey: string;
+    baseURL: string;
+    defaultModel?: string;
+    defaultHeaders?: Record<string, string>;
+};
+type BedrockProviderConfig = ProviderTransportConfig & {
+    provider: "bedrock";
+    region: string;
+    /** Thinking request shape for Claude models: `auto` (by model id), `adaptive` or `budget`. */
+    thinkingMode?: "auto" | "adaptive" | "budget";
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    defaultModel?: string;
+    defaultHeaders?: Record<string, string>;
+    retry?: ProviderRetryConfig;
+    /**
+     * Insert Bedrock Converse `cachePoint` blocks at the end of the system
+     * prompt and tools list. Only supported by models that implement Converse
+     * prompt caching (most Anthropic Claude variants on Bedrock).
+     */
+    prompt_caching?: {
+        enabled: boolean;
+    };
+};
+type VertexProviderConfig = ProviderTransportConfig & {
+    provider: "vertex";
+    projectId: string;
+    location?: string;
+    accessToken?: string;
+    serviceAccountJson?: string | Record<string, any>;
+    defaultModel?: string;
+    defaultHeaders?: Record<string, string>;
+    /** Retry policy for 429/5xx (default 3 retries, exponential backoff). */
+    retry?: ProviderRetryConfig;
+};
+type JevProviderConfig = ProviderTransportConfig & {
+    provider: "jev";
+    apiKey: string;
+    /** Defaults to https://api.typesafe.ai. */
+    baseURL?: string;
+    defaultModel?: string;
+    defaultHeaders?: Record<string, string>;
+    retry?: ProviderRetryConfig;
+};
+type ProviderConfig = OpenAIProviderConfig | AnthropicProviderConfig | AzureProviderConfig | OpenAICompatibleProviderConfig | BedrockProviderConfig | VertexProviderConfig | JevProviderConfig;
+type ProviderType = ProviderConfig["provider"];
+declare class ProviderError extends Error {
+    readonly provider: string;
+    readonly statusCode?: number | undefined;
+    readonly responseBody?: any | undefined;
+    constructor(message: string, provider: string, statusCode?: number | undefined, responseBody?: any | undefined);
+}
+
+export { type EmbeddingUsage as $, type AnthropicProviderConfig as A, type BedrockProviderConfig as B, type ChatCompletionRequest as C, type ModelRule as D, type EmbeddingRequest as E, type ModelRules as F, type ResolvedModelRule as G, type ReasoningEffort as H, type EffortMapping as I, type JevProviderConfig as J, type RuleFamily as K, type RuleSource as L, type ModelRuleLearnedEvent as M, type ReasoningStyle as N, type OpenAICompatibleProviderConfig as O, type ProviderType as P, type OffMechanism as Q, type RulePatch as R, type TemperatureRule as S, type ToolDefinition as T, type UnifiedMessage as U, type VertexProviderConfig as V, type MaxTokensParam as W, type SamplingField as X, type ParsedModelError as Y, type FinishReason as Z, type ProviderResponseFields as _, type EmbeddingResponse as a, type EmbeddingInputType as a0, type TextContent as a1, type ImageContent as a2, type FileContent as a3, type AudioContent as a4, type ToolCall as a5, type ProviderTransportConfig as a6, type ChatCompletionResponse as b, type ChatCompletionChunk as c, type OpenAIProviderConfig as d, type TokenUsage as e, type AzureProviderConfig as f, type ReasoningRequestConfig as g, type ProviderConfig as h, ProviderError as i, emptyUsage as j, MODEL_RULES as k, modelIdCandidates as l, mapReasoningEffort as m, allowsSampling as n, applyDropParams as o, effortBudget as p, mergeRulePatch as q, resolveModelRule as r, parseModelError as s, runWithModelAdjustments as t, asModelRequestError as u, MAX_ADJUSTMENTS as v, listLearnedModelRules as w, getLearnedModelRulePatch as x, rememberModelRulePatch as y, clearLearnedModelRules as z };