@cerebriline/llms 0.0.0-stage → 4.100.240

package/dist/providers/factory-registry.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Custom Handler Registry
+ *
+ * Allows users to register their own custom handlers that extend BaseHandler.
+ * This is useful for providers that require dependencies not included in this package
+ * (e.g., VSCode LM handler that requires the vscode package).
+ *
+ * @example
+ * ```typescript
+ * import { registerHandler, BaseHandler, type ProviderConfig, type ApiStream, type Message } from "@cline/providers"
+ * import * as vscode from "vscode"
+ *
+ * class VSCodeLmHandler extends BaseHandler {
+ *   async *createMessage(systemPrompt: string, messages: Message[]): ApiStream {
+ *     // Implementation using vscode.lm API
+ *   }
+ * }
+ *
+ * // Register the handler
+ * registerHandler("vscode-lm", (config) => new VSCodeLmHandler(config))
+ *
+ * // Now createHandler will use your custom handler for "vscode-lm"
+ * const handler = createHandler({ providerId: "vscode-lm", modelId: "copilot" })
+ * ```
+ */
+import type { ApiHandler, HandlerFactory, LazyHandlerFactory, ProviderConfig } from "./types";
+/**
+ * Register a custom handler factory for a provider ID
+ *
+ * Use this to add handlers for providers that require external dependencies
+ * not bundled with this package, or to override built-in handlers.
+ *
+ * @param providerId - The provider ID to register (can be existing or new)
+ * @param factory - Factory function that creates the handler
+ *
+ * @example
+ * ```typescript
+ * // Simple registration
+ * registerHandler("my-provider", (config) => new MyHandler(config))
+ *
+ * // Override built-in handler
+ * registerHandler("anthropic", (config) => new MyCustomAnthropicHandler(config))
+ * ```
+ */
+export declare function registerHandler(providerId: string, factory: HandlerFactory<ProviderConfig>): void;
+/**
+ * Register an async handler factory for lazy loading
+ *
+ * Use this when your handler has heavy dependencies that should be
+ * loaded only when needed.
+ *
+ * @param providerId - The provider ID to register
+ * @param factory - Async factory function that creates the handler
+ *
+ * @example
+ * ```typescript
+ * registerAsyncHandler("heavy-provider", async (config) => {
+ *   const { HeavyHandler } = await import("./heavy-handler")
+ *   return new HeavyHandler(config)
+ * })
+ * ```
+ */
+export declare function registerAsyncHandler(providerId: string, factory: LazyHandlerFactory<ProviderConfig>): void;
+/**
+ * Check if a custom handler is registered for a provider ID
+ *
+ * @param providerId - The provider ID to check
+ */
+export declare function hasRegisteredHandler(providerId: string): boolean;
+/**
+ * Get a registered handler (internal use)
+ *
+ * @param providerId - The provider ID to get
+ * @param config - The config to pass to the factory
+ * @returns The handler instance, or undefined if not registered
+ */
+export declare function getRegisteredHandler(providerId: string, config: ProviderConfig): ApiHandler | undefined;
+/**
+ * Get a registered handler asynchronously (internal use)
+ *
+ * @param providerId - The provider ID to get
+ * @param config - The config to pass to the factory
+ * @returns The handler instance, or undefined if not registered
+ */
+export declare function getRegisteredHandlerAsync(providerId: string, config: ProviderConfig): Promise<ApiHandler | undefined>;
+/**
+ * Check if a registered handler is async
+ *
+ * @param providerId - The provider ID to check
+ */
+export declare function isRegisteredHandlerAsync(providerId: string): boolean;
+//# sourceMappingURL=factory-registry.d.ts.map

package/dist/providers/factory-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-registry.d.ts","sourceRoot":"","sources":["../../src/providers/factory-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EACX,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,MAAM,SAAS,CAAC;AAejB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAC9B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,cAAc,CAAC,cAAc,CAAC,GACrC,IAAI,CAEN;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CACnC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,kBAAkB,CAAC,cAAc,CAAC,GACzC,IAAI,CAEN;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CACnC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACpB,UAAU,GAAG,SAAS,CAaxB;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC9C,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACpB,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAWjC;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGpE"}

package/dist/providers/format.d.ts

@@ -0,0 +1,2 @@
+export declare function extractErrorMessage(error: unknown): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/providers/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/providers/format.ts"],"names":[],"mappings":"AAEA,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAyJ1D"}

package/dist/providers/gateway.d.ts

@@ -0,0 +1,123 @@
+import type { AgentModel, AgentModelEvent, GatewayConfig, GatewayModelDefinition, GatewayModelHandleOptions, GatewayModelSelection, GatewayProviderRegistration, GatewayStreamRequest, OutputCapReport } from "@cerebriline/shared";
+import { GatewayRegistry } from "./registry";
+export type * from "@cerebriline/shared";
+/**
+ * The synthesized per-turn cap at the window this default was written for.
+ *
+ * Kept as the anchor of {@link DEFAULT_GATEWAY_OUTPUT_WINDOW_SHARE} rather than
+ * as the answer: 32,000 is the right cap for a 128k model and for no other.
+ */
+export declare const DEFAULT_GATEWAY_MAX_OUTPUT_TOKENS = 32000;
+/**
+ * The per-turn cap to synthesize when the caller asked for none.
+ *
+ * Only ever a default: an explicitly requested cap (the `num_predict` in the
+ * provider settings, or a `maxTokensPerTurn` on the session) is used as-is, and
+ * the room left in the window still clamps this.
+ *
+ * The share applies only where the model publishes no output ceiling of its
+ * own, which is where the flat number did the damage: local models declare a
+ * window and nothing else, so 32,000 was the whole answer at every window size.
+ * A model that does publish one already has a bound its own designers set, and
+ * the default's job there is to stay under it rather than to ask for all of it
+ * — on Anthropic, `max_tokens` is charged against the per-minute output limit
+ * whether or not the reply uses it, so raising a 32,000 request to a model's
+ * full 64,000 ceiling would cost throughput and buy nothing.
+ */
+export declare function resolveDefaultMaxOutputTokens(model?: Pick<GatewayModelDefinition, "contextWindow" | "maxOutputTokens">): number;
+/**
+ * The ceiling a provider named, if the failure was about the output cap.
+ *
+ * Deliberately narrow: it matches only messages that state a number, so a
+ * refusal for any other reason returns undefined and is rethrown untouched.
+ */
+export declare function extractRejectedOutputCeiling(error: unknown): number | undefined;
+/** Test seam; also lets a host drop what it learned when settings change. */
+export declare function resetLearnedOutputCeilings(): void;
+/**
+ * The smallest remaining-context cap worth sending as an output limit.
+ *
+ * That term is `contextWindow - estimatedInputTokens - reserve`: a difference of
+ * two large numbers, so it carries the estimate's error magnified. When it comes
+ * out below a floor, the estimate is the likelier explanation than a genuinely
+ * exhausted window -- compaction reads what the provider counted rather than an
+ * estimate, and would have fired first if the window were really full.
+ *
+ * Sending the tiny number anyway is worse than sending none. Observed live: an
+ * estimate running 1.7x high walked the cap down to 60 tokens; Ollama sizes an
+ * effort-level thinking budget as a share of `num_predict`, so the budget came
+ * out at 15 tokens, the forced end-of-thinking sequence spliced into a tool call
+ * the model had already started, and the turn died on "expected '{' in tool
+ * call" -- reported to the user as reaching the output limit.
+ */
+export declare const GATEWAY_MIN_OUTPUT_TOKENS = 1024;
+export interface Gateway {
+    registerProvider(registration: GatewayProviderRegistration): this;
+    configureProvider(config: NonNullable<GatewayConfig["providerConfigs"]>[number]): this;
+    listProviders(): ReturnType<GatewayRegistry["listProviders"]>;
+    listModels(providerId?: string): ReturnType<GatewayRegistry["listModels"]>;
+    createAgentModel(selection: GatewayModelSelection, options?: GatewayModelHandleOptions): AgentModel;
+    stream(request: GatewayStreamRequest): Promise<AsyncIterable<AgentModelEvent>>;
+}
+interface GatewayOutputCapInput {
+    /**
+     * Skip the process-wide overflow record. Set for every request that is not
+     * the conversation's own, whose budget arithmetic says nothing about the
+     * conversation's.
+     */
+    suppressGlobalNotes?: boolean;
+    /** The session the overflow record would describe. */
+    sessionId?: string;
+    requestedMaxTokens?: number;
+    model: Pick<GatewayModelDefinition, "contextWindow" | "maxOutputTokens">;
+    /**
+     * A ceiling the provider named while refusing a cap, for a model whose
+     * catalog entry publishes none.
+     *
+     * A clamp and not a published ceiling, which is why it is its own term
+     * rather than a `maxOutputTokens` written onto the model. Writing it there
+     * would also tell {@link resolveDefaultMaxOutputTokens} the model declares
+     * its own limit, and it would fall back to the flat 32,000 default -- so a
+     * model that had just said it accepts 131,072 would be held to a quarter of
+     * that. As a clamp the share still sets the number and this only bounds it.
+     */
+    outputCeilingTokens?: number;
+    estimatedInputTokens: number;
+    defaultMaxOutputTokens?: number;
+    outputReserveTokens?: number;
+    minOutputTokens?: number;
+    reasoningBudgetTokens?: number;
+    onContextOverflow?: (details: {
+        contextWindow: number;
+        estimatedInputTokens: number;
+        reserveTokens: number;
+        remainingContext: number;
+        minOutputTokens: number;
+    }) => void;
+}
+export declare function resolveGatewayRequestMaxTokens(input: GatewayOutputCapInput): number | undefined;
+/**
+ * The cap and the term that set it.
+ *
+ * The cap alone is ambiguous in the one place it has to be acted on: a turn
+ * truncated at 32,000 tokens says nothing about whether 32,000 was the window's
+ * doing or the request's, and only the first is worth compacting for. The
+ * arithmetic that knows is this function's, so the answer is returned rather
+ * than reconstructed by a caller comparing numbers it would have to guess at.
+ */
+export declare function resolveGatewayOutputCap(input: GatewayOutputCapInput): OutputCapReport;
+export declare class DefaultGateway implements Gateway {
+    #private;
+    private readonly registry;
+    private readonly logger;
+    private readonly telemetry;
+    constructor(config?: GatewayConfig);
+    registerProvider(registration: GatewayProviderRegistration): this;
+    configureProvider(config: NonNullable<GatewayConfig["providerConfigs"]>[number]): this;
+    listProviders(): import("@cerebriline/shared").GatewayProviderManifest[];
+    listModels(providerId?: string): GatewayModelDefinition[];
+    createAgentModel(selection: GatewayModelSelection, options?: GatewayModelHandleOptions): AgentModel;
+    stream(request: GatewayStreamRequest): Promise<AsyncIterable<AgentModelEvent>>;
+}
+export declare function createGateway(config?: GatewayConfig): DefaultGateway;
+//# sourceMappingURL=gateway.d.ts.map

package/dist/providers/gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../../src/providers/gateway.ts"],"names":[],"mappings":"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"}

package/dist/providers/handler.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Handler Interface Types
+ *
+ * Core interfaces that all provider handlers must implement.
+ */
+import type { Message, ModelInfo, ToolDefinition } from "@cerebriline/shared";
+import type { ApiStream, ApiStreamUsageChunk } from "./stream";
+/**
+ * Model information returned by handlers
+ */
+export interface HandlerModelInfo {
+    /** Model identifier */
+    id: string;
+    /** Model capabilities and pricing info */
+    info: ModelInfo;
+}
+/**
+ * Core API Handler interface
+ *
+ * All providers must implement this interface.
+ */
+export interface ApiHandler {
+    /**
+     * Convert Cline messages into provider-specific message format
+     *
+     * @param systemPrompt - The system prompt to use
+     * @param messages - Conversation history
+     * @returns Provider-specific messages payload
+     */
+    getMessages(systemPrompt: string, messages: Message[]): unknown;
+    /**
+     * Create a streaming message completion
+     *
+     * @param systemPrompt - The system prompt to use
+     * @param messages - Conversation history
+     * @param tools - Optional tool definitions for native tool calling
+     * @returns An async generator yielding stream chunks
+     */
+    createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
+    /**
+     * Get the current model configuration
+     */
+    getModel(): HandlerModelInfo;
+    /**
+     * Get usage information for the last API call (optional)
+     * Some providers can fetch this from a separate endpoint
+     */
+    getApiStreamUsage?(): Promise<ApiStreamUsageChunk | undefined>;
+    /**
+     * Abort the current request (optional)
+     */
+    abort?(): void;
+    /**
+     * Update the abort signal used for subsequent requests (optional).
+     */
+    setAbortSignal?(signal: AbortSignal | undefined): void;
+}
+/**
+ * Handler for simple single-turn completions
+ */
+export interface SingleCompletionHandler {
+    /**
+     * Complete a single prompt without streaming
+     */
+    completePrompt(prompt: string): Promise<string>;
+}
+/**
+ * Factory function type for creating handlers
+ */
+export type HandlerFactory<TConfig = unknown> = (config: TConfig) => ApiHandler;
+/**
+ * Async factory for lazy-loaded handlers
+ */
+export type LazyHandlerFactory<TConfig = unknown> = (config: TConfig) => Promise<ApiHandler>;
+//# sourceMappingURL=handler.d.ts.map

package/dist/providers/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/providers/handler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,uBAAuB;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,0CAA0C;IAC1C,IAAI,EAAE,SAAS,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAC1B;;;;;;OAMG;IACH,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IAEhE;;;;;;;OAOG;IACH,aAAa,CACZ,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,CAAC,EAAE,cAAc,EAAE,GACtB,SAAS,CAAC;IAEb;;OAEG;IACH,QAAQ,IAAI,gBAAgB,CAAC;IAE7B;;;OAGG;IACH,iBAAiB,CAAC,IAAI,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAAC;IAE/D;;OAEG;IACH,KAAK,CAAC,IAAI,IAAI,CAAC;IAEf;;OAEG;IACH,cAAc,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC;CACvD;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAChD;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,OAAO,GAAG,OAAO,IAAI,CAAC,MAAM,EAAE,OAAO,KAAK,UAAU,CAAC;AAEhF;;GAEG;AACH,MAAM,MAAM,kBAAkB,CAAC,OAAO,GAAG,OAAO,IAAI,CACnD,MAAM,EAAE,OAAO,KACX,OAAO,CAAC,UAAU,CAAC,CAAC"}

package/dist/providers/http.d.ts

@@ -0,0 +1,10 @@
+import type { GatewayProviderSettings } from "@cerebriline/shared";
+export declare function ensureFetch(fetchImpl?: typeof fetch): typeof fetch;
+export declare function resolveApiKey(settings: GatewayProviderSettings): Promise<string | undefined>;
+export declare function fetchJson(url: string, init: RequestInit, options: {
+    fetch: typeof fetch;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<unknown>;
+export declare function compactObject<T extends Record<string, unknown>>(value: T): T;
+//# sourceMappingURL=http.d.ts.map

package/dist/providers/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/providers/http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,wBAAgB,WAAW,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,GAAG,OAAO,KAAK,CAQlE;AAED,wBAAsB,aAAa,CAClC,QAAQ,EAAE,uBAAuB,GAC/B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAoB7B;AAED,wBAAsB,SAAS,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE;IACR,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB,GACC,OAAO,CAAC,OAAO,CAAC,CA+BlB;AA0BD,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAI5E"}

package/dist/providers/ids.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Built-in provider IDs
+ *
+ * Single source of truth for all built-in provider identifiers.
+ * Use BUILT_IN_PROVIDER_IDS for runtime operations (validation, iteration)
+ * Use BuiltInProviderId type for compile-time type safety
+ */
+import { GENERATED_PROVIDER_IDS } from "./provider-ids.generated";
+export declare enum BUILT_IN_PROVIDER {
+    ANTHROPIC = "anthropic",
+    CLAUDE_CODE = "claude-code",
+    CLINE = "cline",
+    CLINE_PASS = "cline-pass",
+    ELEVENLABS = "elevenlabs",
+    OPENAI_COMPATIBLE = "openai-compatible",
+    OPENAI_NATIVE = "openai-native",
+    OPENAI_CODEX = "openai-codex",
+    OPENAI_CODEX_CLI = "openai-codex-cli",
+    OPENCODE = "opencode",
+    BEDROCK = "bedrock",
+    VERTEX = "vertex",
+    GEMINI = "gemini",
+    OLLAMA = "ollama",
+    XOLLAMA = "xollama",
+    OPENCOTI = "opencoti",
+    LMSTUDIO = "lmstudio",
+    DEEPSEEK = "deepseek",
+    XAI = "xai",
+    TOGETHER = "together",
+    FIREWORKS = "fireworks",
+    GROQ = "groq",
+    POOLSIDE = "poolside",
+    CEREBRAS = "cerebras",
+    SAMBANOVA = "sambanova",
+    NEBIUS = "nebius",
+    BASETEN = "baseten",
+    REQUESTY = "requesty",
+    LITELLM = "litellm",
+    HUGGINGFACE = "huggingface",
+    VERCEL_AI_GATEWAY = "vercel-ai-gateway",
+    V0 = "v0",
+    AIHUBMIX = "aihubmix",
+    HICAP = "hicap",
+    NOUS_RESEARCH = "nousResearch",
+    HUAWEI_CLOUD_MAAS = "huawei-cloud-maas",
+    WANDB = "wandb",
+    XIAOMI = "xiaomi",
+    TENCENT_TOKENHUB = "tencent-tokenhub",
+    KILO = "kilo",
+    ZAI = "zai",
+    ZAI_CODING_PLAN = "zai-coding-plan",
+    QWEN = "qwen",
+    QWEN_CODE = "qwen-code",
+    DOUBAO = "doubao",
+    MISTRAL = "mistral",
+    MOONSHOT = "moonshot",
+    ASKSAGE = "asksage",
+    MINIMAX = "minimax",
+    DIFY = "dify",
+    OCA = "oca",
+    SAPAICORE = "sapaicore",
+    OPENROUTER = "openrouter"
+}
+/**
+ * Provider ID aliases normalized to canonical built-in IDs.
+ *
+ * Keep this map as the single source of truth for alias handling.
+ */
+export type GeneratedBuiltInProviderId = (typeof GENERATED_PROVIDER_IDS)[number];
+export type BuiltInProviderId = BUILT_IN_PROVIDER | GeneratedBuiltInProviderId;
+export declare const PROVIDER_ID_ALIASES: Record<string, BuiltInProviderId>;
+export declare const BUILT_IN_PROVIDER_IDS: readonly BuiltInProviderId[];
+/** Check if a string is a valid built-in provider ID */
+export declare function isBuiltInProviderId(id: string): id is BuiltInProviderId;
+/** Normalize provider aliases to canonical IDs */
+export declare function normalizeProviderId(providerId: string): string;
+//# sourceMappingURL=ids.d.ts.map

package/dist/providers/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/providers/ids.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,oBAAY,iBAAiB;IAE5B,SAAS,cAAc;IACvB,WAAW,gBAAgB;IAC3B,KAAK,UAAU;IACf,UAAU,eAAe;IACzB,UAAU,eAAe;IAEzB,iBAAiB,sBAAsB;IACvC,aAAa,kBAAkB;IAC/B,YAAY,iBAAiB;IAC7B,gBAAgB,qBAAqB;IAErC,QAAQ,aAAa;IAErB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,MAAM,WAAW;IAEjB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IAErB,QAAQ,aAAa;IACrB,GAAG,QAAQ;IACX,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,iBAAiB,sBAAsB;IACvC,EAAE,OAAO;IACT,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,aAAa,iBAAiB;IAC9B,iBAAiB,sBAAsB;IACvC,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,gBAAgB,qBAAqB;IACrC,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,eAAe,oBAAoB;IAEnC,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,SAAS,cAAc;IAEvB,UAAU,eAAe;CACzB;AAED;;;;GAIG;AACH,MAAM,MAAM,0BAA0B,GACrC,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzC,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,GAAG,0BAA0B,CAAC;AAE/E,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAIjE,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAE7B,SAAS,iBAAiB,EAAE,CAAC;AAElC,wDAAwD;AACxD,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,IAAI,iBAAiB,CAEvE;AAED,kDAAkD;AAClD,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAG9D"}

package/dist/providers/messages.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Message Types — re-exported from @cline/shared
+ */
+export type { ContentBlock, FileContent, ImageContent, Message, MessageRole, MessageWithMetadata, RedactedThinkingContent, TextContent, ThinkingContent, ToolDefinition, ToolResultContent, ToolUseContent, } from "@cerebriline/shared";
+//# sourceMappingURL=messages.d.ts.map

package/dist/providers/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/providers/messages.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,YAAY,EACX,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,OAAO,EACP,WAAW,EACX,mBAAmB,EACnB,uBAAuB,EACvB,WAAW,EACX,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,cAAc,GACd,MAAM,eAAe,CAAC"}

package/dist/providers/middleware/backoff.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The one sleep the retry middlewares wait on.
+ *
+ * Abort-aware, and it *resolves* on abort rather than throwing: a cancelled
+ * backoff is not itself an error, and the caller is in a better position to
+ * decide what to surface -- the user's abort reason, or the failure that put it
+ * into the backoff in the first place. Every caller checks the signal again on
+ * the other side for exactly that reason.
+ */
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+//# sourceMappingURL=backoff.d.ts.map

package/dist/providers/middleware/backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../../src/providers/middleware/backoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBrE"}

package/dist/providers/middleware/retry-empty-response.d.ts

@@ -0,0 +1,74 @@
+import type { LanguageModelV4Middleware, LanguageModelV4Usage } from "@ai-sdk/provider";
+/** Minimal logger surface (a subset of `BasicLogger`). */
+interface RetryLogger {
+    log?(message: string, meta?: Record<string, unknown>): void;
+}
+export interface RetryEmptyResponseOptions {
+    /** Total attempts including the first (so `3` means up to 2 retries). */
+    maxAttempts?: number;
+    /** Delay before each empty-response retry, in milliseconds. */
+    retryDelayMs?: number;
+    /**
+     * Delay before the first network-interruption retry, in milliseconds;
+     * doubles for each subsequent one (2s → 4s with the defaults, matching
+     * the legacy extension's backoff).
+     */
+    networkRetryDelayMs?: number;
+    logger?: RetryLogger;
+}
+/** Default total attempts (first try + 2 retries). */
+export declare const DEFAULT_EMPTY_RESPONSE_MAX_ATTEMPTS = 3;
+/** Default delay before a retry. */
+export declare const DEFAULT_EMPTY_RESPONSE_RETRY_DELAY_MS = 250;
+/** Default delay before the first network-interruption retry. */
+export declare const DEFAULT_NETWORK_RETRY_DELAY_MS = 2000;
+/**
+ * Whether an error (anywhere in its `cause` chain) identifies a transient
+ * transport interruption — the connection died or timed out underneath a
+ * request the provider never rejected. An abort anywhere in the chain
+ * vetoes the match: cancelled requests surface the same socket vocabulary,
+ * and a user cancel must never be retried. Everything else — HTTP business
+ * errors, context-window errors, provider-reported payloads — does not
+ * match.
+ */
+export declare function isTransientNetworkError(error: unknown): boolean;
+/** Sum two standardized v4 usage records field by field. */
+export declare function addUsage(a: LanguageModelV4Usage, b: LanguageModelV4Usage): LanguageModelV4Usage;
+/**
+ * Fold the usage of discarded attempts into the finish part that is actually
+ * emitted, so hosted-provider billing reflects every request the turn made
+ * (including cache and reasoning detail), not just the accepted one.
+ *
+ * The sum is right for money and wrong for context, and both are read off the
+ * same field. A discarded attempt really was charged, so billing has to see
+ * it -- but the prompt did not double, and `inputTokens` is what the token
+ * calibration anchors to, what the compaction trigger compares against its
+ * threshold, and what the context meter draws.
+ *
+ * Measured on pandorum session 1789852877349_7bbnd: four turns in 71 reported
+ * two or three times their real prompt, the worst 151,608 tokens against a
+ * 65,536-token window -- a number no request could have been served at. One
+ * inflated count beat the compaction trigger outright; another became the
+ * calibration anchor, collapsed the next request's output cap to 6,099 and
+ * fired a compaction at 41% of the window.
+ *
+ * So the accepted attempt's own prompt travels beside the billed total rather
+ * than replacing it. It is set only when something was discarded: on an
+ * ordinary turn the two numbers are the same, and a field that is always
+ * present invites a reader to prefer it without asking why it exists.
+ */
+/**
+ * Provider-metadata namespace for the one number this middleware has to tell
+ * the rest of the pipeline. Named for the product rather than a vendor because
+ * it is ours, and it sits beside the vendors' own keys (`ollama`, `llamacpp`)
+ * in the same bag.
+ */
+export declare const RETRY_METADATA_NAMESPACE = "cerebriline";
+/**
+ * Create a middleware that retries empty model responses. Apply it as the
+ * outermost middleware (first in the `wrapLanguageModel` array) so each retry
+ * re-runs the full request.
+ */
+export declare function createRetryEmptyResponseMiddleware(options?: RetryEmptyResponseOptions): LanguageModelV4Middleware;
+export {};
+//# sourceMappingURL=retry-empty-response.d.ts.map

package/dist/providers/middleware/retry-empty-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-empty-response.d.ts","sourceRoot":"","sources":["../../../src/providers/middleware/retry-empty-response.ts"],"names":[],"mappings":"AAoEA,OAAO,KAAK,EACX,yBAAyB,EAGzB,oBAAoB,EACpB,MAAM,kBAAkB,CAAC;AAI1B,0DAA0D;AAC1D,UAAU,WAAW;IACpB,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC5D;AAED,MAAM,WAAW,yBAAyB;IACzC,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAED,sDAAsD;AACtD,eAAO,MAAM,mCAAmC,IAAI,CAAC;AACrD,oCAAoC;AACpC,eAAO,MAAM,qCAAqC,MAAM,CAAC;AACzD,iEAAiE;AACjE,eAAO,MAAM,8BAA8B,OAAQ,CAAC;AA+BpD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAsC/D;AAsBD,4DAA4D;AAC5D,wBAAgB,QAAQ,CACvB,CAAC,EAAE,oBAAoB,EACvB,CAAC,EAAE,oBAAoB,GACrB,oBAAoB,CAuBtB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,gBAAgB,CAAC;AA8CtD;;;;GAIG;AACH,wBAAgB,kCAAkC,CACjD,OAAO,GAAE,yBAA8B,GACrC,yBAAyB,CAiM3B"}

package/dist/providers/middleware/retry-rate-limit.d.ts

@@ -0,0 +1,49 @@
+import type { LanguageModelV4Middleware } from "@ai-sdk/provider";
+/** Minimal logger surface (a subset of `BasicLogger`). */
+interface RetryLogger {
+    log?(message: string, meta?: Record<string, unknown>): void;
+}
+export interface RetryRateLimitOptions {
+    /** Total attempts including the first (so `4` means up to 3 retries). */
+    maxAttempts?: number;
+    /**
+     * Longest this will wait for one retry, whatever the server asked for.
+     *
+     * The engine's own answer is a flat `2`, but a proxy in front of it -- or a
+     * later release -- may name minutes, and an agent that disappears for ten
+     * of them is indistinguishable from one that hung.
+     */
+    maxRetryAfterMs?: number;
+    /** Wait when the refusal named no delay at all. */
+    defaultRetryAfterMs?: number;
+    logger?: RetryLogger;
+    /** Seam for tests; the real one is abort-aware. */
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+/** Default total attempts (first try + 3 retries). */
+export declare const DEFAULT_RATE_LIMIT_MAX_ATTEMPTS = 4;
+/** Default ceiling on one wait. */
+export declare const DEFAULT_MAX_RETRY_AFTER_MS = 30000;
+/** Default wait when the server named none. */
+export declare const DEFAULT_RATE_LIMIT_RETRY_DELAY_MS = 2000;
+/**
+ * The delay the server asked for, in milliseconds, or `undefined` when it
+ * asked for none.
+ *
+ * RFC 7231 allows either a delta in seconds or an HTTP-date, and a date already
+ * past reads as no wait rather than a negative one. Walked through the error's
+ * `cause` chain because a rejection may arrive wrapped -- the AI SDK's
+ * `APICallError` carries `responseHeaders`, but a transport that re-throws puts
+ * it one or two levels down.
+ */
+export declare function readRetryAfterMs(error: unknown): number | undefined;
+/**
+ * Create a middleware that waits out admission refusals.
+ *
+ * Applied inside `withEmptyResponseRetry` so every request the turn makes --
+ * the first and any empty-response re-dial -- is paced by the server's own
+ * answer.
+ */
+export declare function createRetryRateLimitMiddleware(options?: RetryRateLimitOptions): LanguageModelV4Middleware;
+export {};
+//# sourceMappingURL=retry-rate-limit.d.ts.map

package/dist/providers/middleware/retry-rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-rate-limit.d.ts","sourceRoot":"","sources":["../../../src/providers/middleware/retry-rate-limit.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAIlE,0DAA0D;AAC1D,UAAU,WAAW;IACpB,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC5D;AAED,MAAM,WAAW,qBAAqB;IACrC,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,mDAAmD;IACnD,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5D;AAED,sDAAsD;AACtD,eAAO,MAAM,+BAA+B,IAAI,CAAC;AACjD,mCAAmC;AACnC,eAAO,MAAM,0BAA0B,QAAS,CAAC;AACjD,+CAA+C;AAC/C,eAAO,MAAM,iCAAiC,OAAQ,CAAC;AA0BvD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAsCnE;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC7C,OAAO,GAAE,qBAA0B,GACjC,yBAAyB,CAmE3B"}

package/dist/providers/middleware/split-tool-images.d.ts

@@ -0,0 +1,32 @@
+import type { LanguageModelV4Message, LanguageModelV4Middleware } from "@ai-sdk/provider";
+/**
+ * Walk a `LanguageModelV4Prompt` and rewrite every `role:"tool"` message
+ * containing image/file parts inside its tool-result `output`s. See the
+ * file-level comment for the rewrite shape.
+ *
+ * Returns the (possibly new) prompt array and a `mutated` flag for
+ * test/observation use.
+ */
+export declare function rewritePromptToolImages(prompt: LanguageModelV4Message[], options?: {
+    relocate?: boolean;
+}): {
+    prompt: LanguageModelV4Message[];
+    mutated: boolean;
+};
+export declare const splitToolImagesMiddleware: LanguageModelV4Middleware;
+/**
+ * The same checks, without the relocation.
+ *
+ * For a converter that can carry images on a tool message — Ollama's native
+ * API is the one in this codebase — the images stay where the tool put them.
+ * What is shared is everything that protects the request: the per-image and
+ * per-request byte budgets, base64 validation, and the omission placeholder
+ * for anything that fails them. What is not shared is the synthetic user
+ * message, which on that path costs the model its reasoning history.
+ *
+ * The vision-describer path is upstream of all of this and unaffected: when a
+ * second model reads the images, it has already replaced them with text in the
+ * transcript, and there is nothing here left to place.
+ */
+export declare const keepToolImagesMiddleware: LanguageModelV4Middleware;
+//# sourceMappingURL=split-tool-images.d.ts.map

package/dist/providers/middleware/split-tool-images.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-tool-images.d.ts","sourceRoot":"","sources":["../../../src/providers/middleware/split-tool-images.ts"],"names":[],"mappings":"AA0DA,OAAO,KAAK,EAGX,sBAAsB,EACtB,yBAAyB,EAIzB,MAAM,kBAAkB,CAAC;AAoT1B;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,sBAAsB,EAAE,EAChC,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9B;IACF,MAAM,EAAE,sBAAsB,EAAE,CAAC;IACjC,OAAO,EAAE,OAAO,CAAC;CACjB,CAyCA;AAsCD,eAAO,MAAM,yBAAyB,EAAE,yBACP,CAAC;AAElC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,EAAE,yBACL,CAAC"}

package/dist/providers/middleware/stream-part-classification.d.ts

@@ -0,0 +1,33 @@
+import type { LanguageModelV4StreamPart } from "@ai-sdk/provider";
+export type ModelStreamPartClass = 
+/**
+ * Output that `emitAiSdkEvents()` converts into `AgentModelEvent`s and
+ * that therefore reaches the assistant message. A turn containing any of
+ * these is not empty.
+ */
+"converted-content"
+/**
+ * Real model output that Cline does not (yet) convert into agent events.
+ * The model responded, so retrying would waste billable requests and
+ * likely reproduce the same output — never retried. If a turn contains
+ * ONLY unsupported output the assistant message can still come out
+ * empty; that is an explicit contract gap of this bucket, preferred over
+ * silently re-billing a turn the model did answer.
+ */
+ | "unsupported-output"
+/** Markers and metadata that do not constitute model output. */
+ | "structural"
+/** `stream-start` — carries warnings; one per attempt. */
+ | "stream-start"
+/** Terminal accounting part — carries usage and the finish reason. */
+ | "finish"
+/** An upstream error surfaced as a stream part. */
+ | "error";
+export declare function classifyModelStreamPart(part: LanguageModelV4StreamPart): ModelStreamPartClass;
+/**
+ * Whether a completed attempt that contained only parts for which this
+ * returns `false` (plus `stream-start`/`finish`) counts as a genuinely empty
+ * turn. Both converted and unsupported output mean "the model responded".
+ */
+export declare function isModelOutputPart(part: LanguageModelV4StreamPart): boolean;
+//# sourceMappingURL=stream-part-classification.d.ts.map

package/dist/providers/middleware/stream-part-classification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-part-classification.d.ts","sourceRoot":"","sources":["../../../src/providers/middleware/stream-part-classification.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAElE,MAAM,MAAM,oBAAoB;AAC/B;;;;GAIG;AACD,mBAAmB;AACrB;;;;;;;GAOG;GACD,oBAAoB;AACtB,gEAAgE;GAC9D,YAAY;AACd,0DAA0D;GACxD,cAAc;AAChB,sEAAsE;GACpE,QAAQ;AACV,mDAAmD;GACjD,OAAO,CAAC;AAEX,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,yBAAyB,GAC7B,oBAAoB,CAoDtB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAG1E"}