@caeliq/llms 1.0.56 → 1.0.58

package/dist/transformer/index.d.ts

@@ -0,0 +1,65 @@
+import { AnthropicTransformer } from "./anthropic.transformer";
+import { GeminiTransformer } from "./gemini.transformer";
+import { VertexGeminiTransformer } from "./vertex-gemini.transformer";
+import { DeepseekTransformer } from "./deepseek.transformer";
+import { TooluseTransformer } from "./tooluse.transformer";
+import { OpenrouterTransformer } from "./openrouter.transformer";
+import { MaxTokenTransformer } from "./maxtoken.transformer";
+import { GroqTransformer } from "./groq.transformer";
+import { CleancacheTransformer } from "./cleancache.transformer";
+import { EnhanceToolTransformer } from "./enhancetool.transformer";
+import { ReasoningTransformer } from "./reasoning.transformer";
+import { SamplingTransformer } from "./sampling.transformer";
+import { MaxCompletionTokens } from "./maxcompletiontokens.transformer";
+import { VertexClaudeTransformer } from "./vertex-claude.transformer";
+import { VertexOpenaiTransformer } from "./vertex-openai.transformer";
+import { CerebrasTransformer } from "./cerebras.transformer";
+import { StreamOptionsTransformer } from "./streamoptions.transformer";
+import { OpenAITransformer } from "./openai.transformer";
+import { CustomParamsTransformer } from "./customparams.transformer";
+import { VercelTransformer } from "./vercel.transformer";
+import { OpenAIResponsesTransformer } from "./openai.responses.transformer";
+import { CodexTransformer } from "./codex.transformer";
+import { QwenAuthTransformer } from "./qwen-auth.transformer";
+import { ForceReasoningTransformer } from "./forcereasoning.transformer";
+import { ExtraThinkTagTransformer } from "./extrathinktag.transformer";
+import { MistralTransformer } from "./mistral.transformer";
+import { ChromeOnDeviceTransformer } from "./chrome-on-device.transformer";
+import { OpencodeHeadersTransformer } from "./opencode-headers.transformer";
+import { ClaudeAuthTransformer } from "./claude-auth.transformer";
+import { CursorSdkTransformer } from "./cursor-sdk.transformer";
+import { AntigravityAuthTransformer } from "./antigravity-auth.transformer";
+declare const _default: {
+    AnthropicTransformer: typeof AnthropicTransformer;
+    GeminiTransformer: typeof GeminiTransformer;
+    VertexGeminiTransformer: typeof VertexGeminiTransformer;
+    VertexClaudeTransformer: typeof VertexClaudeTransformer;
+    VertexOpenaiTransformer: typeof VertexOpenaiTransformer;
+    DeepseekTransformer: typeof DeepseekTransformer;
+    TooluseTransformer: typeof TooluseTransformer;
+    OpenrouterTransformer: typeof OpenrouterTransformer;
+    OpenAITransformer: typeof OpenAITransformer;
+    MaxTokenTransformer: typeof MaxTokenTransformer;
+    GroqTransformer: typeof GroqTransformer;
+    CleancacheTransformer: typeof CleancacheTransformer;
+    EnhanceToolTransformer: typeof EnhanceToolTransformer;
+    ReasoningTransformer: typeof ReasoningTransformer;
+    SamplingTransformer: typeof SamplingTransformer;
+    MaxCompletionTokens: typeof MaxCompletionTokens;
+    CerebrasTransformer: typeof CerebrasTransformer;
+    StreamOptionsTransformer: typeof StreamOptionsTransformer;
+    CustomParamsTransformer: typeof CustomParamsTransformer;
+    VercelTransformer: typeof VercelTransformer;
+    OpenAIResponsesTransformer: typeof OpenAIResponsesTransformer;
+    CodexTransformer: typeof CodexTransformer;
+    QwenAuthTransformer: typeof QwenAuthTransformer;
+    ForceReasoningTransformer: typeof ForceReasoningTransformer;
+    ExtraThinkTagTransformer: typeof ExtraThinkTagTransformer;
+    MistralTransformer: typeof MistralTransformer;
+    ChromeOnDeviceTransformer: typeof ChromeOnDeviceTransformer;
+    OpencodeHeadersTransformer: typeof OpencodeHeadersTransformer;
+    ClaudeAuthTransformer: typeof ClaudeAuthTransformer;
+    CursorSdkTransformer: typeof CursorSdkTransformer;
+    AntigravityAuthTransformer: typeof AntigravityAuthTransformer;
+};
+export default _default;

package/dist/transformer/maxcompletiontokens.transformer.d.ts

@@ -0,0 +1,6 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class MaxCompletionTokens implements Transformer {
+    static TransformerName: string;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/maxtoken.transformer.d.ts

@@ -0,0 +1,9 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class MaxTokenTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    max_tokens: number;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/mistral.transformer.d.ts

@@ -0,0 +1,25 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerContext } from "../types/transformer";
+import { transformRequestOut } from "../utils/mistral.util";
+/**
+ * Mistral Transformer for Claude Code Router
+ *
+ * Transforms Anthropic-style requests to Mistral's OpenAI-compatible API format.
+ */
+export declare class MistralTransformer implements Transformer {
+    name: string;
+    logger?: any;
+    /**
+     * Transform incoming request to Mistral-compatible format
+     */
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider, context: TransformerContext): Promise<Record<string, any>>;
+    /**
+     * Transform Mistral-specific request back to UnifiedChatRequest
+     */
+    transformRequestOut: typeof transformRequestOut;
+    /**
+     * Transform response back — convert Mistral's content-array thinking format
+     * to the delta.thinking / delta.content shape expected by @caeliq/llms.
+     */
+    transformResponseOut(response: Response, _context: TransformerContext): Promise<Response>;
+}

package/dist/transformer/openai.responses.transformer.d.ts

@@ -0,0 +1,13 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class OpenAIResponsesTransformer implements Transformer {
+    logger?: any;
+    name: string;
+    endPoint: string;
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+    private convertStreamEvent;
+    private normalizeRequestContent;
+    private convertResponseToChat;
+    private buildImageContent;
+}

package/dist/transformer/openai.transformer.d.ts

@@ -0,0 +1,52 @@
+import { Transformer } from "../types/transformer";
+import { UnifiedChatRequest } from "../types/llm";
+/**
+ * Server-side route handler for the OpenAI Chat Completions API.
+ *
+ * ## How endPoint works
+ *
+ * At startup, `registerApiRoutes` (see `api/routes.ts`) scans all registered
+ * transformers for ones that define `endPoint`. For each, it registers a
+ * `POST` route at that path. When a request hits the route,
+ * `handleTransformerEndpoint` is invoked with the matching transformer as
+ * the "endpoint transformer" — the one responsible for converting between
+ * the external wire format and the internal Unified format.
+ *
+ * ## Request handling
+ *
+ * The Unified format IS the OpenAI Chat Completions format. The conversion
+ * from Anthropic → Unified already happened in
+ * `AnthropicTransformer.transformRequestOut()` (which runs first in the
+ * pipeline). So by the time the provider chain executes, the body is already
+ * in the right shape — no further conversion is needed.
+ *
+ * `transformRequestIn` also translates Claude Code cache intent to the
+ * selected provider's native Chat Completions behavior. The provider identity
+ * is checked before adding request-level fields so OpenAI-compatible services
+ * do not receive OpenAI-only parameters.
+ *
+ * ## Relationship to OpenAIResponsesTransformer
+ *
+ * `OpenAIResponsesTransformer` (in `openai.responses.transformer.ts`) is the
+ * counterpart for the Responses API (`/v1/responses`). Unlike this
+ * transformer, it defines `transformRequestIn` / `transformResponseOut`
+ * because the Responses API uses a different wire format (e.g. `messages`
+ * → `input`, function tools → flat tool definitions). It also uses the
+ * shared utilities in `openai.util.ts` (`validateOpenAIToolCalls`,
+ * `injectPromptCaching`) to sanitize the Unified body before converting it.
+ *
+ * ## Full request pipeline (for context)
+ *
+ *     Client → POST /v1/messages
+ *       → AnthropicTransformer.transformRequestOut()        // Anthropic → Unified (OpenAI)
+ *       → provider.transformer.use[].transformRequestIn()   // provider middleware
+ *       → sendRequestToProvider()                           // HTTP call upstream
+ *       → provider.transformer.use[].transformResponseOut() // provider middleware (reversed)
+ *       → AnthropicTransformer.transformResponseIn()        // Unified (OpenAI) → Anthropic
+ *       → Client
+ */
+export declare class OpenAITransformer implements Transformer {
+    name: string;
+    endPoint: string;
+    transformRequestIn(request: UnifiedChatRequest, provider: any, context: any): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/opencode-headers.transformer.d.ts

@@ -0,0 +1,30 @@
+import { Transformer } from "../types/transformer";
+export declare class OpencodeHeadersTransformer implements Transformer {
+    name: string;
+    private sessionCache;
+    private readonly MAX_SESSIONS;
+    private lastTimestamp;
+    private counter;
+    transformRequestIn(request: any, provider: any, context: any): Promise<Record<string, any>>;
+    /**
+     * Own the full upstream call so a `No provider available` 401 can be retried
+     * with a fresh session in isolation. Any other non-ok response is re-thrown in
+     * the exact shape sendRequestToProvider would have produced, so genuine
+     * auth/rate/server errors keep flowing through the normal error + fallback
+     * path unchanged.
+     */
+    private sendWithSessionRetry;
+    private buildHeaders;
+    /**
+     * True only for the two Zen session-hash routing failures — a re-roll can
+     * recover these. Kept deliberately narrow (exact status + message) so genuine
+     * auth errors (401 invalid key) and request errors (400 validation) are never
+     * mistaken for routing failures and pass straight through.
+     */
+    private isZenRoutingFailure;
+    private retryAfterHeaders;
+    private fingerprintConversation;
+    private getOrCreateSessionId;
+    private invalidateSession;
+    private generateId;
+}

package/dist/transformer/openrouter.transformer.d.ts

@@ -0,0 +1,10 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class OpenrouterTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    logger?: any;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/qwen-auth.transformer.d.ts

@@ -0,0 +1,9 @@
+import { Transformer } from "../types/transformer";
+export declare class QwenAuthTransformer implements Transformer {
+    name: string;
+    logger?: any;
+    private buildAuthConfig;
+    transformRequestIn(request: any, provider: any): Promise<Record<string, any>>;
+    auth(_request: any, provider: any): Promise<any>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/reasoning.transformer.d.ts

@@ -0,0 +1,10 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class ReasoningTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    enable: any;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response, context?: any): Promise<Response>;
+}

package/dist/transformer/sampling.transformer.d.ts

@@ -0,0 +1,13 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class SamplingTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    max_tokens: number;
+    temperature: number;
+    top_p: number;
+    top_k: number;
+    repetition_penalty: number;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/streamoptions.transformer.d.ts

@@ -0,0 +1,6 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class StreamOptionsTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+}

package/dist/transformer/tooluse.transformer.d.ts

@@ -0,0 +1,7 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class TooluseTransformer implements Transformer {
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<any>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/vercel.transformer.d.ts

@@ -0,0 +1,11 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export declare class VercelTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    logger?: any;
+    endPoint: string;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: any): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/vertex-claude.transformer.d.ts

@@ -0,0 +1,9 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer } from "../types/transformer";
+export declare class VertexClaudeTransformer implements Transformer {
+    logger?: any;
+    name: string;
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider): Promise<Record<string, any>>;
+    transformRequestOut(request: Record<string, any>): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/vertex-gemini.transformer.d.ts

@@ -0,0 +1,12 @@
+import { LLMProvider, UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerContext, TransformerOptions } from "../types/transformer";
+export declare class VertexGeminiTransformer implements Transformer {
+    static TransformerName: string;
+    logger?: any;
+    name: string;
+    private readonly thoughtSignatureFallback;
+    constructor(options?: TransformerOptions);
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider, context?: any): Promise<Record<string, any>>;
+    transformRequestOut(request: Record<string, any>): Promise<UnifiedChatRequest>;
+    transformResponseOut(response: Response, context?: TransformerContext): Promise<Response>;
+}

package/dist/transformer/vertex-openai.transformer.d.ts

@@ -0,0 +1,19 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export interface VertexOpenaiOptions extends TransformerOptions {
+    client_email?: string;
+    private_key?: string;
+}
+/**
+ * Auth-only transformer for Vertex AI OpenAI-compatible endpoints.
+ * Injects a Google service-account Bearer token into outbound requests.
+ */
+export declare class VertexOpenaiTransformer implements Transformer {
+    static TransformerName: string;
+    private client?;
+    private readonly client_email?;
+    private readonly private_key?;
+    constructor(options?: VertexOpenaiOptions);
+    private getClient;
+    transformRequestIn(request: UnifiedChatRequest): Promise<Record<string, any>>;
+}

package/dist/types/llm.d.ts

@@ -0,0 +1,255 @@
+import type { ChatCompletionMessageParam as OpenAIMessage } from "openai/resources/chat/completions";
+import type { MessageParam as AnthropicMessage } from "@anthropic-ai/sdk/resources/messages";
+import type { ChatCompletionChunk } from "openai/resources/chat/completions";
+import type { MessageStreamEvent } from "@anthropic-ai/sdk/resources/messages";
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
+import { Transformer } from "./transformer";
+import type { ProviderTokenizerConfig } from "./tokenizer";
+export type TransformerConfigEntry = string | [string, Record<string, any>?];
+export interface UrlCitation {
+    url: string;
+    title: string;
+    content: string;
+    start_index: number;
+    end_index: number;
+}
+export interface Annotation {
+    type: "url_citation";
+    url_citation?: UrlCitation;
+}
+export interface TextContent {
+    type: "text";
+    text: string;
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+}
+export interface ImageContent {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+    media_type: string;
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+}
+export type MessageContent = TextContent | ImageContent;
+export interface UnifiedMessage {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string | null | MessageContent[];
+    reasoning_content?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+        /** Gemini/Antigravity thought signature; must round-trip on functionCall parts. */
+        thought_signature?: string;
+        cache_control?: {
+            type?: string;
+            ttl?: "5m" | "1h";
+        };
+    }>;
+    tool_call_id?: string;
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+    thinking?: {
+        content: string;
+        signature?: string;
+    };
+}
+export interface UnifiedTool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: "object";
+            properties: Record<string, any>;
+            required?: string[];
+            additionalProperties?: boolean;
+            $schema?: string;
+        };
+    };
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+}
+export type ThinkLevel = "none" | "low" | "medium" | "high" | "xhigh" | "max";
+export interface UnifiedChatRequest {
+    messages: UnifiedMessage[];
+    model: string;
+    system?: string | MessageContent[];
+    max_tokens?: number;
+    max_completion_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    repetition_penalty?: number;
+    stream?: boolean;
+    stream_options?: {
+        include_usage?: boolean;
+        [key: string]: any;
+    };
+    tools?: UnifiedTool[];
+    tool_choice?: "auto" | "none" | "required" | string | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+    reasoning?: {
+        effort?: ThinkLevel;
+        max_tokens?: number;
+        enabled?: boolean;
+    };
+    enable_thinking?: boolean;
+    thinking?: {
+        type: "enabled" | "disabled";
+        budget_tokens?: number;
+    };
+    parallel_tool_calls?: boolean;
+    cache_control?: {
+        type?: string;
+        ttl?: "5m" | "1h";
+    };
+    anthropic_thinking?: Record<string, any>;
+    anthropic_output_config?: Record<string, any>;
+    anthropic_metadata?: Record<string, any>;
+    anthropic_stop_sequences?: string[];
+    reasoning_effort?: string;
+}
+export interface UnifiedChatResponse {
+    id: string;
+    model: string;
+    content: string | null;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    annotations?: Annotation[];
+}
+export interface StreamChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices?: Array<{
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+            thinking?: {
+                content?: string;
+                signature?: string;
+            };
+            tool_calls?: Array<{
+                id?: string;
+                type?: "function";
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+                thought_signature?: string;
+            }>;
+            annotations?: Annotation[];
+        };
+        finish_reason?: string | null;
+    }>;
+}
+export type AnthropicStreamEvent = MessageStreamEvent;
+export type OpenAIStreamChunk = ChatCompletionChunk;
+export interface OpenAIChatRequest {
+    messages: OpenAIMessage[];
+    model: string;
+    max_tokens?: number;
+    temperature?: number;
+    stream?: boolean;
+    tools?: ChatCompletionTool[];
+    tool_choice?: "auto" | "none" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+}
+export interface AnthropicChatRequest {
+    messages: AnthropicMessage[];
+    model: string;
+    max_tokens: number;
+    temperature?: number;
+    stream?: boolean;
+    system?: string;
+    tools?: AnthropicTool[];
+    tool_choice?: {
+        type: "auto";
+    } | {
+        type: "tool";
+        name: string;
+    };
+}
+export interface ConversionOptions {
+    targetProvider: "openai" | "anthropic";
+    sourceProvider: "openai" | "anthropic";
+}
+export interface LLMProvider {
+    name: string;
+    baseUrl: string;
+    apiKey: string;
+    models: string[];
+    /** Optional GCP / Antigravity project id (provider-specific). */
+    project_id?: string;
+    transformer?: {
+        [key: string]: {
+            use?: Transformer[];
+        } | any;
+    } & {
+        use?: Transformer[];
+        passthrough?: any;
+    };
+}
+export type RegisterProviderRequest = LLMProvider;
+export interface ModelRoute {
+    provider: string;
+    model: string;
+    fullModel: string;
+}
+export interface RequestRouteInfo {
+    provider: LLMProvider;
+    originalModel: string;
+    targetModel: string;
+}
+export interface ConfigProvider {
+    name: string;
+    api_base_url: string;
+    api_key: string;
+    models: string[];
+    /** Optional GCP / Antigravity project id (kept as `$ENV` placeholders in config). */
+    project_id?: string;
+    transformer: {
+        use?: TransformerConfigEntry[];
+    } & {
+        [key: string]: {
+            use?: TransformerConfigEntry[];
+        } | any;
+    };
+    tokenizer?: ProviderTokenizerConfig;
+}

package/dist/types/transformer.d.ts

@@ -0,0 +1,29 @@
+import { LLMProvider, UnifiedChatRequest } from "./llm";
+import type { UnifiedRequestRuntime } from "./turn-intent";
+export interface TransformerOptions {
+    [key: string]: any;
+}
+interface TransformerWithStaticName {
+    new (options?: TransformerOptions): Transformer;
+    TransformerName?: string;
+}
+export type TransformerConstructor = TransformerWithStaticName;
+export interface TransformerContext {
+    req?: any;
+    provider?: any;
+    signal?: AbortSignal;
+    /** Protocol semantics that must not be serialized into the provider body. */
+    unifiedRequest?: UnifiedRequestRuntime;
+    [key: string]: any;
+}
+export type Transformer = {
+    transformRequestIn?: (request: UnifiedChatRequest, provider: LLMProvider, context: TransformerContext) => Promise<Record<string, any>>;
+    transformResponseIn?: (response: Response, context?: TransformerContext) => Promise<Response>;
+    transformRequestOut?: (request: any, context: TransformerContext) => Promise<UnifiedChatRequest>;
+    transformResponseOut?: (response: Response, context: TransformerContext) => Promise<Response>;
+    endPoint?: string;
+    name?: string;
+    auth?: (request: any, provider: LLMProvider, context: TransformerContext) => Promise<any>;
+    logger?: any;
+};
+export {};

package/dist/types/turn-intent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Request-local semantics recovered by a wire-protocol transformer.
+ *
+ * This state belongs on TransformerContext, not UnifiedChatRequest: the latter
+ * is also the OpenAI-compatible outbound body and is serialized for providers.
+ */
+export type UnifiedTrailingToolResult = {
+    toolCallId: string;
+    content: string;
+    isError: boolean;
+};
+export type UnifiedTurnIntent = {
+    source: "anthropic" | "unified-fallback";
+    trailingToolResults: UnifiedTrailingToolResult[];
+    interruption: "none" | "synthetic_client_interrupt";
+    steering: "none" | "meaningful";
+};
+export type UnifiedRequestRuntime = {
+    source: "anthropic";
+    sourceSessionIdentity?: string;
+    turnIntent: UnifiedTurnIntent;
+};
+export declare const ANTHROPIC_SYNTHETIC_INTERRUPT_MARKERS: readonly ["[Request interrupted by user]", "[Request interrupted by user for tool use]"];
+export declare function classifyAnthropicTurnIntent(requestMessages: unknown): UnifiedTurnIntent;
+export declare function extractAnthropicSourceSessionIdentity(metadata: unknown): string | undefined;
+export declare function buildAnthropicRequestRuntime(request: Record<string, any>): UnifiedRequestRuntime;