@xiaozhiclaw/provider-core 0.1.0

package/dist/provider-variant-resolver.js

@@ -0,0 +1,174 @@
+export class ProviderVariantResolver {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    resolve(input) {
+        const publicModel = input.publicModel.trim();
+        if (!publicModel)
+            return [];
+        const allowedProviders = input.userPreference?.providerIds
+            ? new Set(input.userPreference.providerIds)
+            : undefined;
+        const requestedTransport = normalizeRequestedProtocol(input.requestedProtocol);
+        const requiredCapabilities = input.capabilities ?? [];
+        const matches = [];
+        for (const provider of this.registry.listProviders()) {
+            if (allowedProviders && !allowedProviders.has(provider.id))
+                continue;
+            if (requestedTransport && provider.transport !== requestedTransport)
+                continue;
+            for (const model of this.registry.listModels(provider.id)) {
+                const matchKind = modelMatchKind(model, publicModel);
+                if (!matchKind)
+                    continue;
+                const capabilities = inferCapabilities(provider, model);
+                if (requiredCapabilities.some(capability => !capabilities.includes(capability))) {
+                    continue;
+                }
+                const variantKind = inferVariantKind(provider, model);
+                const billingChannelKind = provider.billingChannelKind ?? inferBillingChannelKind(variantKind);
+                const reasons = buildReasons({
+                    matchKind,
+                    requestedTransport,
+                    requiredCapabilities,
+                    preferProviderId: input.userPreference?.preferProviderId,
+                    preferVariantKind: input.userPreference?.preferVariantKind,
+                    purpose: input.purpose,
+                    provider,
+                    variantKind,
+                    capabilities,
+                });
+                const score = scoreResolution({
+                    matchKind,
+                    requestedTransport,
+                    requiredCapabilities,
+                    preferProviderId: input.userPreference?.preferProviderId,
+                    preferVariantKind: input.userPreference?.preferVariantKind,
+                    purpose: input.purpose,
+                    provider,
+                    variantKind,
+                    capabilities,
+                });
+                matches.push({
+                    provider: provider.id,
+                    group: provider.group ?? provider.id,
+                    publicModel,
+                    nativeModelId: model.id,
+                    displayName: model.name,
+                    transport: provider.transport,
+                    variantKind,
+                    billingChannelKind,
+                    capabilities,
+                    score,
+                    reasons,
+                    providerDef: provider,
+                    modelInfo: model,
+                });
+            }
+        }
+        return matches.sort((a, b) => {
+            if (b.score !== a.score)
+                return b.score - a.score;
+            if (a.group !== b.group)
+                return a.group.localeCompare(b.group);
+            return a.provider.localeCompare(b.provider);
+        });
+    }
+    resolveBest(input) {
+        return this.resolve(input)[0];
+    }
+}
+function normalizeRequestedProtocol(protocol) {
+    if (!protocol)
+        return undefined;
+    if (protocol === "openai")
+        return "openai-chat";
+    if (protocol === "anthropic")
+        return "anthropic-messages";
+    return protocol;
+}
+function modelMatchKind(model, publicModel) {
+    if (sameId(model.id, publicModel))
+        return "exact";
+    return (model.aliases ?? []).some(alias => sameId(alias, publicModel)) ? "alias" : undefined;
+}
+function sameId(a, b) {
+    return a.trim().toLowerCase() === b.trim().toLowerCase();
+}
+function inferVariantKind(provider, model) {
+    if (provider.variantKind)
+        return provider.variantKind;
+    if (model.mediaType === "realtime_audio" || model.mediaType === "realtime_video")
+        return "realtime";
+    if (model.mediaType)
+        return "media-plan";
+    if (provider.id.includes("coding") || model.id.toLowerCase().includes("coder") || model.id.toLowerCase().includes("codegeex"))
+        return "coding-plan";
+    if (provider.transport === "openai-chat" || provider.transport === "openai-responses" || provider.transport === "volcengine-responses")
+        return "openai-compatible";
+    if (provider.transport === "anthropic-messages")
+        return "anthropic-compatible";
+    return "standard";
+}
+function inferBillingChannelKind(variantKind) {
+    return variantKind === "coding-plan" || variantKind === "media-plan" ? "plan" : "paygo";
+}
+function inferCapabilities(provider, model) {
+    const capabilities = new Set(provider.capabilities ?? []);
+    if (model.reasoning)
+        capabilities.add("thinking");
+    if (model.vision)
+        capabilities.add("vision");
+    if (model.mediaType)
+        capabilities.add("media");
+    if (model.mediaType === "realtime_audio" || model.mediaType === "realtime_video")
+        capabilities.add("realtime");
+    if (model.toolCall && provider.quirks?.supportsToolStream)
+        capabilities.add("tool_stream");
+    if (provider.quirks?.supportsReasoningSplit)
+        capabilities.add("reasoning_split");
+    if (provider.quirks?.builtinWebSearch || provider.quirks?.builtinCodeInterpreter || provider.quirks?.builtinUrlContext) {
+        capabilities.add("builtin_tools");
+    }
+    if (provider.id.includes("coding") || model.id.toLowerCase().includes("coder") || model.id.toLowerCase().includes("codegeex")) {
+        capabilities.add("coding");
+    }
+    return [...capabilities].sort();
+}
+function scoreResolution(input) {
+    let score = 100;
+    score += input.matchKind === "exact" ? 25 : 15;
+    if (input.requestedTransport && input.provider.transport === input.requestedTransport)
+        score += 20;
+    score += input.requiredCapabilities.length * 15;
+    if (input.preferProviderId && input.provider.id === input.preferProviderId)
+        score += 50;
+    if (input.preferVariantKind && input.variantKind === input.preferVariantKind)
+        score += 35;
+    if (input.purpose === "textGeneration" && !input.capabilities.includes("media"))
+        score += 5;
+    if (input.purpose === "imageGeneration" && input.capabilities.includes("media"))
+        score += 10;
+    if (input.purpose === "videoGeneration" && input.capabilities.includes("media"))
+        score += 10;
+    if (input.capabilities.includes("tool_stream"))
+        score += 8;
+    if (input.capabilities.includes("reasoning_split"))
+        score += 8;
+    if (input.variantKind === "coding-plan")
+        score += input.provider.id.includes("coding") ? 12 : 5;
+    return score;
+}
+function buildReasons(input) {
+    const reasons = [input.matchKind === "exact" ? "model id matched" : "public alias matched"];
+    if (input.requestedTransport)
+        reasons.push(`protocol ${input.requestedTransport} matched`);
+    for (const capability of input.requiredCapabilities)
+        reasons.push(`capability ${capability} matched`);
+    if (input.preferProviderId && input.provider.id === input.preferProviderId)
+        reasons.push("preferred provider matched");
+    if (input.preferVariantKind && input.variantKind === input.preferVariantKind)
+        reasons.push("preferred variant matched");
+    return reasons;
+}

package/dist/retry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared retry/backoff utilities for LLM transport implementations.
+ *
+ * Provides common constants and helper functions used by all transports
+ * (anthropic-messages, openai-chat, volcengine-responses) to handle
+ * transient errors with exponential backoff.
+ */
+/** Default maximum number of retry attempts */
+export declare const DEFAULT_MAX_RETRIES = 2;
+/** Base delay for exponential backoff (doubles each attempt, capped at 30s) */
+export declare const RETRY_BASE_DELAY_MS = 1000;
+/** Maximum backoff delay */
+export declare const RETRY_MAX_DELAY_MS = 30000;
+/** HTTP status codes considered transient (worth retrying) */
+export declare const TRANSIENT_STATUS_CODES: Set<number>;
+/** Default timeout for idle stream detection (no data received) */
+export declare const STREAM_IDLE_TIMEOUT_MS = 90000;
+/**
+ * Calculate the delay for a given retry attempt using exponential backoff with jitter.
+ * @param attempt 1-based attempt number (1 = first retry)
+ * @returns delay in milliseconds
+ */
+export declare function retryDelay(attempt: number): number;
+/**
+ * Check if an HTTP status code indicates a transient error worth retrying.
+ */
+export declare function isTransientStatus(status: number | null | undefined): boolean;
+/**
+ * Sleep with abort signal support. Resolves after `ms` milliseconds
+ * or rejects if the signal is aborted.
+ */
+export declare function retrySleep(ms: number, signal?: AbortSignal): Promise<void>;
+/**
+ * Extract HTTP status from various error shapes.
+ * Works with fetch Response errors, Axios errors, and generic errors with status property.
+ */
+export declare function extractHttpStatus(error: unknown): number | null;

package/dist/retry.js

@@ -0,0 +1,71 @@
+/**
+ * Shared retry/backoff utilities for LLM transport implementations.
+ *
+ * Provides common constants and helper functions used by all transports
+ * (anthropic-messages, openai-chat, volcengine-responses) to handle
+ * transient errors with exponential backoff.
+ */
+// 鈹€鈹€ Retry Constants 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+/** Default maximum number of retry attempts */
+export const DEFAULT_MAX_RETRIES = 2;
+/** Base delay for exponential backoff (doubles each attempt, capped at 30s) */
+export const RETRY_BASE_DELAY_MS = 1_000;
+/** Maximum backoff delay */
+export const RETRY_MAX_DELAY_MS = 30_000;
+/** HTTP status codes considered transient (worth retrying) */
+export const TRANSIENT_STATUS_CODES = new Set([429, 529, 502, 503, 504]);
+/** Default timeout for idle stream detection (no data received) */
+export const STREAM_IDLE_TIMEOUT_MS = 90_000;
+// 鈹€鈹€ Helpers 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+/**
+ * Calculate the delay for a given retry attempt using exponential backoff with jitter.
+ * @param attempt 1-based attempt number (1 = first retry)
+ * @returns delay in milliseconds
+ */
+export function retryDelay(attempt) {
+    const baseDelay = Math.min(RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1), RETRY_MAX_DELAY_MS);
+    const jitter = Math.random() * 0.25 * baseDelay;
+    return baseDelay + jitter;
+}
+/**
+ * Check if an HTTP status code indicates a transient error worth retrying.
+ */
+export function isTransientStatus(status) {
+    return status !== null && status !== undefined && TRANSIENT_STATUS_CODES.has(status);
+}
+/**
+ * Sleep with abort signal support. Resolves after `ms` milliseconds
+ * or rejects if the signal is aborted.
+ */
+export function retrySleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error("Request aborted"));
+            return;
+        }
+        const timer = setTimeout(resolve, ms);
+        if (signal) {
+            signal.addEventListener("abort", () => {
+                clearTimeout(timer);
+                reject(new Error("Request aborted"));
+            }, { once: true });
+        }
+    });
+}
+/**
+ * Extract HTTP status from various error shapes.
+ * Works with fetch Response errors, Axios errors, and generic errors with status property.
+ */
+export function extractHttpStatus(error) {
+    if (error && typeof error === "object") {
+        const e = error;
+        if (typeof e.status === "number")
+            return e.status;
+        if (typeof e.statusCode === "number")
+            return e.statusCode;
+        if (e.response && typeof e.response.status === "number") {
+            return e.response.status;
+        }
+    }
+    return null;
+}

package/dist/transport.d.ts

@@ -0,0 +1,281 @@
+/**
+ * LLMTransportabstract interface for LLM inference calls.
+ *
+ * Aligned with Hermes `ProviderTransport` ABC:
+ *   stream(request, apiKey, signal) 閳?AsyncGenerator<LLMChunk>
+ *
+ * Two concrete implementations:
+ *   - OpenAI Chat Completions (covers 95% of providers)
+ *   - Anthropic Messages API
+ */
+import type { ChatMessage, ToolDefinition } from "./wire-types.js";
+export type StructuredOutputConfig = {
+    mode: "json_object";
+} | {
+    mode: "json_schema";
+    name: string;
+    schema: Record<string, unknown>;
+    strict?: boolean;
+};
+export interface CachingConfig {
+    type: "enabled" | "disabled";
+    /** Enable prefix caching mode (鎼?0.3). Requires store=true and stream=false. */
+    prefix?: boolean;
+}
+export type ContextEdit = {
+    type: "clear_thinking";
+    keep?: "all" | {
+        type: "thinking_turns";
+        value: number;
+    };
+} | {
+    type: "clear_tool_uses";
+    trigger?: {
+        type: "tool_uses";
+        value: number;
+    };
+    keep?: {
+        type: "tool_uses";
+        value: number;
+    };
+    excludeTools?: string[];
+    clearToolInput?: boolean;
+};
+export interface ContextManagementConfig {
+    edits: ContextEdit[];
+}
+export interface LLMRequest {
+    model: string;
+    messages: ChatMessage[];
+    tools?: ToolDefinition[];
+    toolChoice?: "auto" | "none" | "required" | {
+        type: "function";
+        name: string;
+    };
+    temperature?: number;
+    /** Nucleus sampling: controls diversity via cumulative probability cutoff. */
+    topP?: number;
+    maxTokens?: number;
+    reasoning?: {
+        effort: "minimal" | "low" | "medium" | "high" | "xhigh";
+        /** Request encrypted original reasoning content (Volcengine 鎼?7.7). */
+        includeEncryptedReasoning?: boolean;
+    };
+    /** Volcengine: max builtin tool calls per turn (鎼?9.15). */
+    maxToolCalls?: number;
+    /**
+     * DeepSeek prefix completion: force model to continue from this prefix.
+     * Requires `/beta` endpoint; adds a trailing assistant message with `prefix: true`.
+     */
+    prefixMessage?: string;
+    /**
+     * Model requires streamingdisable non-streaming fallback in transports.
+     * When true, transports must NOT fall back to non-streaming requests on failure.
+     * Set for models like QwQ/Omni where the provider rejects non-streaming calls.
+     */
+    streamRequired?: boolean;
+    /**
+     * Disable injection of provider-native builtin tools (web_search, code_interpreter)
+     * for this specific request. Allows session-level control over GLM/Kimi builtin tools.
+     */
+    disableBuiltinTools?: boolean;
+    /**
+     * Volcengine builtin tools to inject (web_search, image_process, knowledge_search).
+     * Each entry specifies a tool type and optional config.
+     * These are platform-executed tools requiring beta headers.
+     */
+    builtinTools?: Array<{
+        type: "builtin_web_search" | "builtin_image_process" | "builtin_knowledge_search" | "builtin_doubao_app";
+        config?: Record<string, unknown>;
+    }>;
+    /**
+     * Server-side context continuation via response chain (鎼?).
+     * When set, the server automatically includes previous context,
+     * so messages[] only needs to contain the NEW user message.
+     */
+    previousResponseId?: string;
+    /**
+     * Control server-side storage of this request's input/output (鎼?.1).
+     * Default: true (server stores for 3 days).
+     */
+    store?: boolean;
+    /** Expiration time for stored response (Unix seconds, max 7 days from now) */
+    storeExpireAt?: number;
+    /**
+     * Per-turn system instruction augmentation (鎼?).
+     * Temporarily overlays persona or adds constraints for this turn only.
+     * NOTE: Incompatible with cachingdo not use both together.
+     */
+    instructions?: string;
+    /**
+     * Structured output format (鎼?6).
+     * Forces model to produce JSON conforming to the specified schema.
+     */
+    structuredOutput?: StructuredOutputConfig;
+    /**
+     * Caching configuration (鎼?0).
+     * Controls prefix/session caching behavior.
+     * NOTE: Incompatible with instructions, json_schema, and builtin tools.
+     */
+    caching?: CachingConfig;
+    /**
+     * Context management edits (鎼?1, beta).
+     * Server-side trimming of historical thinking chains and tool call traces.
+     */
+    contextManagement?: ContextManagementConfig;
+    /**
+     * Gemini explicit cache reference (gemini-ProviderMax 鎼?).
+     * Passes a pre-created cache name (e.g. "cachedContents/abc123") to
+     * generateContent so the server uses cached tokens instead of re-processing.
+     * Create caches via GeminiCacheAPI.createCache() first.
+     */
+    cachedContent?: string;
+    /**
+     * Predicted output for speculative decoding (openai-ProviderMax 鎼?1).
+     * When editing code, pass the existing content so the model can diff efficiently.
+     * Reduces latency by 3-5x when prediction matches. Falls back when it doesn't.
+     * Works with OpenAI GPT-5.x models via Responses API and Chat Completions.
+     */
+    prediction?: {
+        type: "content";
+        content: string;
+    };
+    /**
+     * Prompt cache bucketing key (openai-ProviderMax 鎼?1).
+     * Replaces the deprecated `user` field. Helps OpenAI group similar requests
+     * for higher cache hit rates.
+     */
+    promptCacheKey?: string;
+    /**
+     * Prompt cache retention policy (openai-ProviderMax 鎼?1).
+     * "in_memory" = default 5-10 min, "24h" = extended up to 24 hours.
+     */
+    promptCacheRetention?: "in_memory" | "24h";
+    /**
+     * Service tier for request scheduling (openai-ProviderMax 鎼?4).
+     * "auto" = project default, "flex" = 50% cheaper / higher latency,
+     * "priority" = guaranteed low latency.
+     */
+    serviceTier?: "auto" | "default" | "flex" | "priority";
+    /**
+     * OpenAI Responses API built-in tools (openai-ProviderMax 鎼?).
+     * Platform-executed tools like web_search, file_search, code_interpreter, etc.
+     */
+    openaiBuiltinTools?: Array<{
+        type: "web_search_preview" | "file_search" | "code_interpreter" | "computer_use_preview";
+        [key: string]: unknown;
+    }>;
+    /**
+     * OpenAI Responses API conversation ID (openai-ProviderMax 鎼?.1).
+     * Alternative to previous_response_idpersistent server-side conversation.
+     * Cannot be used together with previousResponseId.
+     */
+    conversationId?: string;
+    /**
+     * Disable parallel tool calling for this request.
+     * When false, the model must call tools sequentially.
+     */
+    parallelToolCalls?: boolean;
+    /**
+     * Text output verbosity hint (openai-ProviderMax 鎼?).
+     * Controls how detailed the model's textual output should be.
+     */
+    textVerbosity?: "low" | "medium" | "high";
+}
+/**
+ * FIM completion requestDeepSeek Beta Completions API.
+ * POST /beta/v1/completions with prompt + suffix.
+ * Only works with non-thinking mode.
+ */
+export interface FIMRequest {
+    model: string;
+    /** Text before the cursor (prefix context) */
+    prompt: string;
+    /** Text after the cursor (suffix context) */
+    suffix?: string;
+    /** Max tokens to generate for the infill */
+    maxTokens?: number;
+    /** Sampling temperature */
+    temperature?: number;
+    /** Stop sequences */
+    stop?: string[];
+}
+export type FIMChunk = {
+    type: "delta";
+    text: string;
+} | {
+    type: "done";
+    finishReason: string;
+};
+export type LLMChunk = {
+    type: "delta";
+    text: string;
+} | {
+    type: "tool_call_delta";
+    index: number;
+    id?: string;
+    name?: string;
+    arguments: string;
+} | {
+    type: "reasoning_delta";
+    text: string;
+} | {
+    type: "reasoning_block_complete";
+    thinking: string;
+    signature: string;
+} | {
+    type: "usage";
+    promptTokens: number;
+    completionTokens: number;
+    reasoningTokens?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+} | {
+    type: "response_id";
+    id: string;
+} | {
+    /** Informational status from platform-executed builtin tools (web_search, image_process). */
+    type: "builtin_tool_status";
+    toolType: string;
+    event: string;
+    data?: Record<string, unknown>;
+} | {
+    /** Web search citation annotations from provider builtin tools (Volcengine web_search, Gemini grounding). */
+    type: "annotations";
+    annotations: Array<{
+        type: string;
+        url?: string;
+        title?: string;
+        [key: string]: unknown;
+    }>;
+} | {
+    type: "error";
+    message: string;
+} | {
+    type: "done";
+    finishReason: string;
+};
+export interface AccumulatedToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+export interface LLMTransport {
+    /**
+     * Stream an LLM inference request.
+     * apiKey is passed explicitly (from agent.turn.config, not env).
+     */
+    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
+    /**
+     * FIM (Fill-In-Middle) completionoptional capability.
+     * Only implemented by providers that support it (DeepSeek /beta endpoint).
+     */
+    complete?(request: FIMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<FIMChunk>;
+}
+/**
+ * Accumulate tool_call_delta chunks into complete ToolCall objects.
+ * Modeled after admin-infer-proxy-client's Map<index, toolCall> accumulator.
+ */
+export declare function accumulateToolCalls(accumulator: Map<number, AccumulatedToolCall>, chunk: LLMChunk & {
+    type: "tool_call_delta";
+}): void;

package/dist/transport.js

@@ -0,0 +1,27 @@
+/**
+ * LLMTransportabstract interface for LLM inference calls.
+ *
+ * Aligned with Hermes `ProviderTransport` ABC:
+ *   stream(request, apiKey, signal) 閳?AsyncGenerator<LLMChunk>
+ *
+ * Two concrete implementations:
+ *   - OpenAI Chat Completions (covers 95% of providers)
+ *   - Anthropic Messages API
+ */
+// 鈹€鈹€ Convenience: aggregate chunks to tool calls 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+/**
+ * Accumulate tool_call_delta chunks into complete ToolCall objects.
+ * Modeled after admin-infer-proxy-client's Map<index, toolCall> accumulator.
+ */
+export function accumulateToolCalls(accumulator, chunk) {
+    let tc = accumulator.get(chunk.index);
+    if (!tc) {
+        tc = { id: "", name: "", arguments: "" };
+        accumulator.set(chunk.index, tc);
+    }
+    if (chunk.id)
+        tc.id = chunk.id;
+    if (chunk.name)
+        tc.name += chunk.name;
+    tc.arguments += chunk.arguments;
+}

package/dist/transports/anthropic-messages.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Anthropic Messages TransportSSE streaming for Claude API.
+ *
+ * Aligned with CC (claude-code-haha) src/services/api/claude.ts:
+ *   - cache_control ephemeral injection on system prompt blocks
+ *   - ensureToolResultPairing() conversation repair before every request
+ *   - Retry with exponential backoff on transient errors (429/529/overloaded)
+ *   - Non-streaming fallback when stream errors out
+ *   - 90s idle watchdog timeout for silently dropped connections
+ *   - Adaptive/budget thinking with temperature omit
+ *   - Cache token extraction with >0 guard (CC updateUsage parity)
+ *   - signature_delta handling for thinking blocks
+ */
+import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
+import type { ProviderQuirks } from "../provider-def.js";
+import type { FileUploadAdapter } from "../file-upload-service.js";
+export interface AnthropicTransportConfig {
+    baseUrl: string;
+    /** anthropic-version header (default "2023-06-01") */
+    apiVersion?: string;
+    /** Per-request timeout in ms (default 180_000) */
+    timeoutMs?: number;
+    /** Stream idle watchdog timeout in ms (default 90_000, CC parity) */
+    streamIdleTimeoutMs?: number;
+    /** Enable prompt caching via cache_control ephemeral (default true) */
+    enablePromptCaching?: boolean;
+    /** Max retry attempts on transient errors (default 3) */
+    maxRetries?: number;
+    /** Omit temperature when it equals 0MiniMax rejects temperature=0 */
+    omitZeroTemperature?: boolean;
+    /** Provider-specific quirks for conditional logic (CC/altcode parity) */
+    quirks?: ProviderQuirks;
+    /** File upload adapter (Hub OSS relay for Anthropic). */
+    fileUploadAdapter?: FileUploadAdapter;
+}
+export declare class AnthropicMessagesTransport implements LLMTransport {
+    private baseUrl;
+    private apiVersion;
+    private timeoutMs;
+    private streamIdleTimeoutMs;
+    private enablePromptCaching;
+    private maxRetries;
+    private omitZeroTemperature;
+    private quirks;
+    private fileUploadAdapter?;
+    constructor(config: AnthropicTransportConfig);
+    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
+    /**
+     * Stream with idle watchdog timer (CC parity: 90s default).
+     * Throws if no chunks received for streamIdleTimeoutMs.
+     */
+    private streamWithWatchdog;
+    /**
+     * Non-streaming fallback (CC executeNonStreamingRequest parity).
+     * Used when streaming fails after all retries.
+     * Caps max_tokens at 64K and adjusts thinking budget accordingly.
+     */
+    private nonStreamingFallback;
+    /**
+     * Convert a non-streaming API response to LLMChunk sequence.
+     */
+    private mapNonStreamingResponse;
+    private parseSSEStream;
+    private mapEvent;
+}