@cerebriline/llms 0.0.0-stage → 4.100.241

package/dist/providers/agent-slots.d.ts

@@ -0,0 +1,100 @@
+/**
+ * How many requests an endpoint will serve at once, and what that means for
+ * how many delegated agents may run.
+ *
+ * A local server has a fixed number of slots -- `OLLAMA_NUM_PARALLEL` for
+ * Ollama, `--parallel N` for llama.cpp and opencoti -- and a request that finds
+ * none free is not refused, it is *queued*. Nothing reports that. The run looks
+ * slow rather than blocked, and the more agents are spawned the worse it gets,
+ * because they are queueing behind each other on one server. A hosted provider
+ * has the same shape with a different cause: a plan allows so many concurrent
+ * requests and the rest wait or fail.
+ *
+ * The number cannot be discovered in general -- a plan's allowance is not on
+ * the wire, and Ollama does not report `OLLAMA_NUM_PARALLEL` -- so it is
+ * configured per profile beside the context window. One is the honest default:
+ * it is what `--parallel` and a basic plan give you, and it is the value under
+ * which nothing queues unexpectedly.
+ */
+/** Below this a profile could serve nothing. */
+export declare const MIN_PARALLEL_SESSIONS = 1;
+/**
+ * A guard against a typo, not a statement about what a server can do.
+ *
+ * This was 10, chosen on 2026-08-10 on the reasoning that "ten concurrent
+ * agents on one endpoint is already past where any local server holds its
+ * per-session throughput". That was a claim about local llama.cpp servers, and
+ * it stopped being the whole picture twice over:
+ *
+ * - A **hosted** provider's concurrency is whatever the plan allows, which is
+ *   routinely more than ten and is not ours to cap.
+ * - An **elastic** opencoti grows `slots_live` past `--parallel` on demand, so
+ *   there is no fixed local count to be past in the first place.
+ *
+ * And it was binding in practice: a tester's profile sat at exactly 10, which
+ * is what a cap looks like when it is the thing choosing the number.
+ *
+ * So the bound is now only wide enough to catch a slipped digit. The real
+ * refusal belongs to the endpoint, which knows its own admission; ours is a
+ * ceiling the user opted into, and leaving the field empty asks for none.
+ */
+export declare const MAX_PARALLEL_SESSIONS = 64;
+/** What a profile that has never been told otherwise is worth. */
+export declare const DEFAULT_PARALLEL_SESSIONS = 1;
+/**
+ * Reads a stored `parallelSessions` into the range a server could honour.
+ *
+ * `undefined` for anything unusable rather than the default, so a caller can
+ * tell "not configured" from "configured as 1" -- the settings panel shows an
+ * empty field for the first and a 1 for the second.
+ */
+export declare function normalizeParallelSessions(value: unknown): number | undefined;
+export interface AgentSlotLimit {
+    /**
+     * Most delegated agents that may run at once.
+     *
+     * `0` means no cap of ours -- which is not "as many as you like" but
+     * "something else decides", and the only thing that says it today is PolyKV.
+     * Zero rather than `undefined` on purpose: this value is stored on the
+     * session config, where `undefined` has to keep meaning "no host resolved
+     * one, leave every previous behaviour alone".
+     */
+    limit: number;
+    /**
+     * With `limit: 0`, what lifted the cap. `"polykv"` is the engine admitting
+     * each agent itself, which is where agents take turns asking (one waiting
+     * for admission per node). `"elastic"` is elastic slots without pools: no
+     * admission to wait on, and agents join together.
+     */
+    admission?: "polykv" | "elastic";
+    /** Why, in one line, for the log. Never a value the caller branches on. */
+    reason: string;
+}
+/**
+ * How many delegated agents may run at once against this endpoint.
+ *
+ * The exception is an *elastic* opencoti, by either of the two mechanisms that
+ * make it one. Under PolyKV, agents attach to a KV pool and share a slot, and
+ * whether one more may start is decided by the engine's admission control
+ * against measured KV headroom -- `can_admit`, and a 429 with a `retry-after`
+ * when the answer is no. Under the elastic slot controller the server grows
+ * `slots_live` toward `slots_max` as load arrives. Either way the slot count is
+ * not a number this side can compute, and counting would refuse work the server
+ * would have taken.
+ *
+ * Which is why the configured count changes meaning rather than being ignored
+ * there. On a fixed server it *describes* the server, and its absence has to
+ * mean one, because a request that finds no free slot queues silently and
+ * nothing reports that. On an elastic one nothing needs describing, so the
+ * field becomes a ceiling the user asked for -- the engine may well be willing
+ * to take more, and a number in that box says don't. Absent, the engine decides
+ * alone. Discarding the number because the engine has an opinion would make the
+ * field unusable on exactly the servers someone would reach for it on.
+ */
+export declare function resolveAgentSlotLimit(input: {
+    providerId: string | undefined;
+    baseUrl?: string;
+    parallelSessions?: unknown;
+    fetch?: typeof fetch;
+}): Promise<AgentSlotLimit>;
+//# sourceMappingURL=agent-slots.d.ts.map

package/dist/providers/agent-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-slots.d.ts","sourceRoot":"","sources":["../../src/providers/agent-slots.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,gDAAgD;AAChD,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC,kEAAkE;AAClE,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAS5E;AAED,MAAM,WAAW,cAAc;IAC9B;;;;;;;;OAQG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,SAAS,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IACjC,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IAClD,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACrB,GAAG,OAAO,CAAC,cAAc,CAAC,CA6B1B"}

package/dist/providers/ai-sdk.d.ts

@@ -0,0 +1,158 @@
+import type { AgentModelEvent, GatewayProviderContext, GatewayProviderFactory, GatewayResolvedProviderConfig, GatewayStreamRequest } from "@cerebriline/shared";
+import { type CallSettings } from "ai";
+import type { AiSdkStreamTotalUsage, AiSdkStreamUsage, ProviderFactoryResult } from "./vendors/types";
+interface GatewayNormalizedUsage {
+    inputTokens: number;
+    /**
+     * The prompt of the request that was actually accepted, when a turn made
+     * more than one.
+     *
+     * `inputTokens` is the billed sum across every attempt, because a
+     * discarded attempt was charged. It is not the size of the context, and
+     * the token calibration, the compaction trigger and the context meter all
+     * read the size of the context. See `withAggregatedUsage` in
+     * `middleware/retry-empty-response.ts` for what the two numbers cost when
+     * they are conflated.
+     *
+     * Absent on a turn that did not retry, where the two are the same number.
+     */
+    requestInputTokens?: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    reasoningTokenCount?: number;
+    totalCost?: number;
+}
+/**
+ * Map the gateway's reasoning intent onto the AI SDK's own per-request
+ * `reasoning` call option.
+ *
+ * The two vocabularies are the same except for `max`, which the SDK does not
+ * have and which means the same thing as `xhigh` here. `enabled: false` is
+ * `none` — an explicit instruction to reason as little as possible, which is
+ * different from expressing no preference.
+ *
+ * Returns `undefined` when the request expresses no preference, leaving the
+ * SDK on `provider-default` so a model configured with a reasoning setting
+ * keeps it.
+ */
+export declare function toAiSdkReasoning(reasoning: GatewayStreamRequest["reasoning"]): CallSettings["reasoning"];
+export declare function buildAiSdkStreamConfig(request: GatewayStreamRequest, _context: GatewayProviderContext): Partial<CallSettings>;
+interface RepairableToolCall {
+    toolCallId: string;
+    toolName: string;
+    input: string;
+}
+/**
+ * The tool name hiding at the end of a name the provider mis-sliced.
+ *
+ * Measured (mann1x/cline#60, GLM 5.3-Flash through Ollama Cloud): a ~2,000
+ * character "tool name" consisting of a code block the model had written,
+ * then the sentence `Let me re-read the current state of modifySkill and the
+ * rest:`, then `<tool_call>`, then `read_files` — a real tool, called
+ * correctly, that the turn was failed over.
+ *
+ * Only the tail after the last marker is considered, and only when it is a
+ * bare identifier that names a tool this run actually has. Anything else and
+ * we have not found the call, we have found more of the same text.
+ */
+export declare function recoverToolNameFromMarker(toolName: string, isAvailable: (name: string) => boolean): string | undefined;
+/**
+ * Last-chance repair for tool calls whose arguments are not valid JSON
+ * (truncated payloads, single quotes, unescaped newlines — common with
+ * weaker models). Runs the raw argument text through the shared jsonrepair
+ * strategies; already-valid JSON is not repairable here, and returning null
+ * preserves the AI SDK's original error behavior.
+ *
+ * An unknown tool name gets one narrower treatment first — see
+ * {@link repairLeakedToolName} — and is otherwise still left to fail.
+ */
+export declare function repairMalformedToolCall<T extends RepairableToolCall>({ toolCall, tools, error, }: {
+    toolCall: T;
+    tools?: Record<string, unknown>;
+    error: unknown;
+}): Promise<T | null>;
+/**
+ * How often a streaming tool call's progress is reported. Each report travels
+ * to every agent row and the hub's event stream, so per-token would be a flood;
+ * this is often enough that a live call never reads as idle.
+ */
+export declare const TOOL_INPUT_PROGRESS_MS = 500;
+export declare function normalizeUsage(usageValue: AiSdkStreamUsage | AiSdkStreamTotalUsage | Record<string, unknown> | undefined, providerMetadata?: unknown, pricingValue?: unknown): GatewayNormalizedUsage;
+/**
+ * Wrap a vendor-constructed model with the transient-failure retry
+ * middleware (empty responses + pre-content network interruptions).
+ *
+ * All-empty turns (no text, no reasoning, no tool call) are a cross-provider
+ * phenomenon: production telemetry shows them on hosted backends (openrouter,
+ * cline, generic OpenAI-compatible endpoints), not just local Ollama. An
+ * empty assistant turn is a hard failure in the agent runtime ("Model
+ * returned empty response"), so a single transient flake kills the task.
+ * The same telemetry shows mid-stream network deaths (UND_ERR_SOCKET,
+ * body/headers timeouts, ECONNRESET) as the dominant network-class run
+ * killer — the AI SDK's own retry covers only request initiation, so once a
+ * stream has started nothing else retries. Retrying here — the one
+ * composition point every AI SDK vendor flows through — turns those flakes
+ * into non-events while leaving the runtime's loud failure in place for
+ * models that are persistently empty or connections that are truly down.
+ *
+ * Applied as the *outermost* wrap so each retry re-runs the vendor's full
+ * request pipeline, including any vendor-level middleware attached inside
+ * `provider.operations.language(...)`. Vendors opt out or tune attempts through
+ * `ProviderFactoryResult.retryEmptyResponses`.
+ */
+export declare function withEmptyResponseRetry(model: unknown, retryEmptyResponses: ProviderFactoryResult["retryEmptyResponses"], logger: GatewayProviderContext["logger"]): unknown;
+/**
+ * Wrap a model so an admission refusal waits rather than failing the turn.
+ *
+ * Applied *inside* `withEmptyResponseRetry`, so a refusal that lands on one of
+ * that middleware's own re-dials is paced too. Inert unless the server refuses:
+ * a provider that never sends `429` sees a request byte-identical to the one it
+ * saw before, and the wrapper costs one function call.
+ *
+ * `maxRetryAfterMs` is read from the provider's PolyKV section because that is
+ * where the user can see and change it, but the middleware itself is not
+ * opencoti-specific -- `429` + `Retry-After` is ordinary HTTP, and every
+ * llama.cpp endpoint reaches us through the same `openai-compatible` vendor,
+ * which sets no `isRetryable` and so gets no retry from the AI SDK at all.
+ */
+export declare function withRateLimitRetry(model: unknown, config: GatewayResolvedProviderConfig | undefined, logger: GatewayProviderContext["logger"]): unknown;
+/**
+ * The upstream request, aborted whenever its response is abandoned unfinished.
+ *
+ * Reading a response to its end or its error is not the same as closing the
+ * connection it came on. `streamText` tees its base stream for every consumer,
+ * and a tee cancels its source only when BOTH branches are cancelled: when
+ * {@link emitAiSdkEvents} stops at an error part -- or the agent loop stops
+ * reading, on a failed turn or a watchdog -- the branch it read is cancelled
+ * and the other one, which nobody reads, keeps the HTTP response open. The
+ * server never sees a disconnect and generates to the end. Measured on a
+ * 75-agent swarm (4.100.195): five slots decoding 13k+ tokens at ~30 tok/s
+ * for agents already marked failed, each holding a 262k-cell KV booking that
+ * starved every other agent.
+ *
+ * So each turn gets its own signal, following the caller's, and aborted here
+ * when the turn ends in anything but a clean `finish`: an error finish, a
+ * throw, or a consumer that returns early. Aborting the fetch is what closes
+ * the connection (undici destroys the socket), which is what stops the server.
+ * Every provider built here gets it, and every opencoti request path with it
+ * -- lead, worker, keepalive or not -- since each passes `init.signal` on.
+ */
+export declare function abortWhenAbandoned(request: GatewayStreamRequest, run: (request: GatewayStreamRequest) => AsyncIterable<AgentModelEvent> | Promise<AsyncIterable<AgentModelEvent>>): AsyncGenerator<AgentModelEvent>;
+export declare const createOpenAIProvider: GatewayProviderFactory;
+export declare const createClineProvider: GatewayProviderFactory;
+export declare const createOpenAICompatibleProvider: GatewayProviderFactory;
+export declare const createAnthropicProvider: GatewayProviderFactory;
+export declare const createGoogleProvider: GatewayProviderFactory;
+export declare const createVertexProvider: GatewayProviderFactory;
+export declare const createBedrockProvider: GatewayProviderFactory;
+export declare const createMistralProvider: GatewayProviderFactory;
+export declare const createClaudeCodeProvider: GatewayProviderFactory;
+export declare const createOpenAICodexProvider: GatewayProviderFactory;
+export declare const createOpenCodeProvider: GatewayProviderFactory;
+export declare const createDifyProvider: GatewayProviderFactory;
+export declare const createOllamaProvider: GatewayProviderFactory;
+export declare const createOpencotiProvider: GatewayProviderFactory;
+export declare const createSapAiCoreProvider: GatewayProviderFactory;
+export {};
+//# sourceMappingURL=ai-sdk.d.ts.map

package/dist/providers/ai-sdk.d.ts.map

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

package/dist/providers/async.d.ts

@@ -0,0 +1,2 @@
+export declare function toAsyncIterable<T>(value: AsyncIterable<T> | Iterable<T>): AsyncIterable<T>;
+//# sourceMappingURL=async.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../src/providers/async.ts"],"names":[],"mappings":"AAAA,wBAAuB,eAAe,CAAC,CAAC,EACvC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GACnC,aAAa,CAAC,CAAC,CAAC,CAIlB"}

package/dist/providers/billing.d.ts

@@ -0,0 +1,5 @@
+import { type GatewayUsageCostDisplay } from "@cerebriline/shared";
+export type ProviderUsageCostDisplay = GatewayUsageCostDisplay;
+export declare function resolveProviderUsageCostDisplay(providerId: string): ProviderUsageCostDisplay;
+export declare function shouldShowProviderUsageCost(providerId: string): boolean;
+//# sourceMappingURL=billing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"billing.d.ts","sourceRoot":"","sources":["../../src/providers/billing.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,uBAAuB,EAE5B,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,wBAAwB,GAAG,uBAAuB,CAAC;AAqB/D,wBAAgB,+BAA+B,CAC9C,UAAU,EAAE,MAAM,GAChB,wBAAwB,CAK1B;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAEvE"}

package/dist/providers/builtin-types.d.ts

@@ -0,0 +1,34 @@
+import type { GatewayModelOperationCapability, GatewayModelToolCapability, GatewayProviderMetadata, GatewayProviderSettings, ProviderCapability, ProviderConfigField } from "@cerebriline/shared";
+import type { ModelInfo, ProviderClient, ProviderProtocol } from "../catalog/types";
+export type ProviderFamily = "cline" | "openai" | "openai-compatible" | "anthropic" | "google" | "vertex" | "bedrock" | "mistral" | "claude-code" | "openai-codex" | "opencode" | "dify" | "ollama" | "opencoti" | "sap-ai-core";
+export type ProviderApiLine = "china" | "international";
+export interface BuiltinSpec {
+    id: string;
+    name: string;
+    description: string;
+    family: ProviderFamily;
+    protocol?: ProviderProtocol;
+    client?: ProviderClient;
+    modelToolCapabilities?: readonly GatewayModelToolCapability[];
+    modelOperationCapabilities?: readonly GatewayModelOperationCapability[];
+    capabilities?: ProviderCapability[];
+    popular?: number;
+    modelsProviderId?: string;
+    defaultModelId?: string;
+    modelsFactory?: () => Record<string, ModelInfo>;
+    env?: readonly ("browser" | "node")[];
+    apiKeyEnv?: readonly string[];
+    modelsSourceUrl?: string;
+    docsUrl?: string;
+    defaults?: GatewayProviderSettings;
+    /**
+     * Regional endpoint routing facts: base URL per API line. Used when the
+     * caller selects an `apiLine` without an explicit base URL. The line that
+     * matches `defaults.baseUrl` is included so the mapping is exhaustive and
+     * self-documenting.
+     */
+    apiLineBaseUrls?: Readonly<Partial<Record<ProviderApiLine, string>>>;
+    configFields?: readonly ProviderConfigField[];
+    metadata?: GatewayProviderMetadata;
+}
+//# sourceMappingURL=builtin-types.d.ts.map

package/dist/providers/builtin-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-types.d.ts","sourceRoot":"","sources":["../../src/providers/builtin-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,+BAA+B,EAC/B,0BAA0B,EAC1B,uBAAuB,EACvB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,EACnB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACX,SAAS,EACT,cAAc,EACd,gBAAgB,EAChB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,MAAM,cAAc,GACvB,OAAO,GACP,QAAQ,GACR,mBAAmB,GACnB,WAAW,GACX,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,GACT,aAAa,GACb,cAAc,GACd,UAAU,GACV,MAAM,GACN,QAAQ,GACR,UAAU,GACV,aAAa,CAAC;AAEjB,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,eAAe,CAAC;AAExD,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,qBAAqB,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC9D,0BAA0B,CAAC,EAAE,SAAS,+BAA+B,EAAE,CAAC;IACxE,YAAY,CAAC,EAAE,kBAAkB,EAAE,CAAC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAChD,GAAG,CAAC,EAAE,SAAS,CAAC,SAAS,GAAG,MAAM,CAAC,EAAE,CAAC;IACtC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,uBAAuB,CAAC;IACnC;;;;;OAKG;IACH,eAAe,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACrE,YAAY,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC9C,QAAQ,CAAC,EAAE,uBAAuB,CAAC;CACnC"}

package/dist/providers/builtins-runtime.d.ts

@@ -0,0 +1,3 @@
+import type { GatewayProviderRegistration } from "@cerebriline/shared";
+export declare const BUILTIN_PROVIDER_REGISTRATIONS: GatewayProviderRegistration[];
+//# sourceMappingURL=builtins-runtime.d.ts.map

package/dist/providers/builtins-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtins-runtime.d.ts","sourceRoot":"","sources":["../../src/providers/builtins-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEX,2BAA2B,EAC3B,MAAM,eAAe,CAAC;AAsGvB,eAAO,MAAM,8BAA8B,EAAE,2BAA2B,EAsBpE,CAAC"}

package/dist/providers/builtins.d.ts

@@ -0,0 +1,30 @@
+import { type GatewayProviderManifest } from "@cerebriline/shared";
+import type { ModelCollection } from "../catalog/types";
+import type { BuiltinSpec, ProviderApiLine } from "./builtin-types";
+export declare const DEFAULT_INTERNAL_OCA_BASE_URL = "https://code-internal.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+export declare const DEFAULT_EXTERNAL_OCA_BASE_URL = "https://code.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+/**
+ * Context window requested from Ollama when neither the resolved model nor
+ * the user's configuration supplies one. Matches the pre-SDK-migration
+ * handler default; deliberately larger than Ollama's 4096 server default,
+ * which cannot fit Cline's agentic prompts. Single source of truth — the
+ * vendor, the VS Code session factory, and the settings UI all import this.
+ */
+export declare const OLLAMA_DEFAULT_CONTEXT_WINDOW = 32768;
+export type { BuiltinSpec, ProviderApiLine, ProviderFamily, } from "./builtin-types";
+export declare const BUILTIN_SPECS: BuiltinSpec[];
+export declare function isProviderApiLine(value: unknown): value is ProviderApiLine;
+/**
+ * Resolve the regional base URL for a provider's selected API line (e.g.
+ * Qwen/Moonshot/Z.AI/MiniMax "china" vs "international" endpoints). Returns
+ * undefined when the provider has no regional endpoints or the api line is
+ * not a recognized value. Callers must let an explicit user-configured base
+ * URL win over this resolution.
+ */
+export declare function resolveProviderApiLineBaseUrl(providerId: string, apiLine: unknown): string | undefined;
+export declare function toManifest(spec: BuiltinSpec): GatewayProviderManifest;
+/** Static manifests used for synchronous capability checks before providers load. */
+export declare const BUILTIN_PROVIDER_MANIFESTS_BY_ID: Readonly<Record<string, GatewayProviderManifest>>;
+export declare const BUILTIN_PROVIDER_COLLECTION_LIST: ModelCollection[];
+export declare const BUILTIN_PROVIDER_COLLECTIONS_BY_ID: Record<string, ModelCollection>;
+//# sourceMappingURL=builtins.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../../src/providers/builtins.ts"],"names":[],"mappings":"AAAA,OAAO,EAKN,KAAK,uBAAuB,EAO5B,MAAM,eAAe,CAAC;AAQvB,OAAO,KAAK,EACX,eAAe,EAIf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EACX,WAAW,EACX,eAAe,EAEf,MAAM,iBAAiB,CAAC;AA4BzB,eAAO,MAAM,6BAA6B,0FAC8C,CAAC;AACzF,eAAO,MAAM,6BAA6B,iFACqC,CAAC;AA+BhF;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,QAAQ,CAAC;AAEnD,YAAY,EACX,WAAW,EACX,eAAe,EACf,cAAc,GACd,MAAM,iBAAiB,CAAC;AAypCzB,eAAO,MAAM,aAAa,EAAE,WAAW,EAGtC,CAAC;AAWF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAE1E;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC5C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,GACd,MAAM,GAAG,SAAS,CAOpB;AAiDD,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,uBAAuB,CAuDrE;AAED,qFAAqF;AACrF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CACtD,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAGvC,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,eAAe,EACzB,CAAC;AAEtC,eAAO,MAAM,kCAAkC,EAAE,MAAM,CACtD,MAAM,EACN,eAAe,CAMf,CAAC"}

package/dist/providers/compat.d.ts

@@ -0,0 +1,75 @@
+import type { GatewayModelDefinition, GatewayStreamRequest } from "@cerebriline/shared";
+import { type ApiHandler, type Message, type ProviderConfig } from "./types";
+export declare function toGatewayRequestMessages(messages: Message[]): GatewayStreamRequest["messages"];
+declare function buildGatewayModels(providerId: string, config: ProviderConfig): Omit<GatewayModelDefinition, "providerId">[] | undefined;
+export declare function buildGatewayConfig(config: ProviderConfig): {
+    providerId: string;
+    apiKey: string | undefined;
+    baseUrl: string | undefined;
+    headers: Record<string, string> | undefined;
+    timeoutMs: number | undefined;
+    fetch: typeof fetch | undefined;
+    defaultModelId: string;
+    models: Omit<GatewayModelDefinition, "providerId">[] | undefined;
+    reasoningHistory: import("@cerebriline/shared").ReasoningHistorySetting | undefined;
+    reasoningInline: boolean | undefined;
+    options: {
+        clientId?: string;
+        clientSecret?: string;
+        tokenUrl?: string;
+        resourceGroup?: string;
+        deploymentId?: string;
+        useOrchestrationMode?: boolean;
+        api?: "orchestration" | "foundation-models";
+        defaultSettings?: Record<string, unknown>;
+        hostname?: string;
+        port?: number;
+        autoStartServer?: boolean;
+        serverTimeout?: number;
+        modelSettings?: Record<string, unknown>;
+        region: string | undefined;
+        project: string | undefined;
+        projectId: string | undefined;
+        location: string | undefined;
+        accessKeyId: string | undefined;
+        secretAccessKey: string | undefined;
+        sessionToken: string | undefined;
+        authentication: "iam" | "profile" | "api-key" | "apikey" | undefined;
+        profile: string | undefined;
+        endpoint: string | undefined;
+        customModelBaseId: string | undefined;
+        apiVersion: string | undefined;
+        useIdentity: boolean | undefined;
+        mode: "external" | "internal" | undefined;
+        usePromptCache: boolean | undefined;
+        polykvLeadPool?: boolean | undefined;
+        polykvBooking?: {
+            numCtx: number;
+        } | undefined;
+        polykvWorker?: {
+            sessionId: string;
+            group: string;
+            layers: number;
+            attachOnly?: boolean;
+            owner?: string;
+        } | undefined;
+        polykvSessionId?: string | undefined;
+        agentWindow?: {
+            sharePercent?: number;
+        } | undefined;
+        sampling: import("./config").ProviderSamplingOptions | undefined;
+        polykv: import("./config").PolykvOptions | undefined;
+    };
+};
+export declare function createGatewayApiHandler(config: ProviderConfig): ApiHandler;
+export declare function createGatewayApiHandlerAsync(config: ProviderConfig): Promise<ApiHandler>;
+/**
+ * Internal test hook. Not part of the public API; production callers go
+ * through `createGatewayApiHandler(Async)`.
+ */
+export declare const _testing: {
+    buildGatewayConfig: typeof buildGatewayConfig;
+    buildGatewayModels: typeof buildGatewayModels;
+};
+export {};
+//# sourceMappingURL=compat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compat.d.ts","sourceRoot":"","sources":["../../src/providers/compat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEX,sBAAsB,EAGtB,oBAAoB,EACpB,MAAM,eAAe,CAAC;AA6BvB,OAAO,EACN,KAAK,UAAU,EAIf,KAAK,OAAO,EAEZ,KAAK,cAAc,EAGnB,MAAM,SAAS,CAAC;AAkOjB,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,OAAO,EAAE,GACjB,oBAAoB,CAAC,UAAU,CAAC,CAiGlC;AA6CD,iBAAS,kBAAkB,CAC1B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACpB,IAAI,CAAC,sBAAsB,EAAE,YAAY,CAAC,EAAE,GAAG,SAAS,CAkE1D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiExD;AAgKD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,cAAc,GAAG,UAAU,CAE1E;AAED,wBAAsB,4BAA4B,CACjD,MAAM,EAAE,cAAc,GACpB,OAAO,CAAC,UAAU,CAAC,CAqCrB;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;CAGpB,CAAC"}