@cerebriline/llms 0.0.0-stage → 4.100.241

package/dist/providers/vendors/ollama.d.ts

@@ -0,0 +1,256 @@
+import type { BasicLogger, GatewayProviderContext, GatewayResolvedProviderConfig, GatewayStreamRequest } from "@cerebriline/shared";
+import { type CallSettings } from "ai";
+import type { ProviderSamplingOptions } from "../config";
+import type { ProviderFactoryResult } from "./types";
+/** See {@link OLLAMA_DEFAULT_CONTEXT_WINDOW} — re-exported under the wire-format name. */
+export declare const OLLAMA_DEFAULT_NUM_CTX = 32768;
+/**
+ * Normalize a configured base URL to the `baseURL` this provider expects.
+ *
+ * The API prefix belongs *in* the base URL here: the package appends bare
+ * paths (`/chat`, `/show`) and its own default is
+ * `http://127.0.0.1:11434/api`. This is the opposite of the `ollama` client
+ * the previous provider used, which took a bare origin as its `host` and
+ * appended `/api/...` itself — so returning an origin sends every request to
+ * `/chat`, which Ollama answers with a plain `404 page not found`.
+ *
+ * Users configure hosts like `http://localhost:11434` or `https://ollama.com`;
+ * configs saved by the 4.0.0 OpenAI-compatible routing may carry a `/v1`
+ * suffix, and native-API configs an `/api` one. All three normalize to the
+ * same origin, and `/api` is then appended exactly once.
+ */
+export declare function normalizeOllamaBaseUrl(baseUrl: string | undefined): string | undefined;
+/**
+ * Resolve the `num_ctx` to request from the resolved model's context window.
+ * `num_ctx` stays an Ollama wire-format detail: callers express intent through
+ * the provider-neutral model `contextWindow` (from the model catalog or the
+ * user's configured context window), and this boundary maps it onto the wire.
+ */
+export declare function readOllamaNumCtx(context: GatewayProviderContext): number;
+/** The model's own `num_ctx`, if it has been looked up and it has one. */
+export declare function readDeclaredNumCtx(baseUrl: string | undefined, modelId: string | undefined): number | undefined;
+/** The architecture the model declares, if it has been looked up. */
+export declare function readDeclaredFamily(baseUrl: string | undefined, modelId: string | undefined): string | undefined;
+/** The trained window, if it has been looked up and the model declares one. */
+export declare function readDeclaredTrainedCtx(baseUrl: string | undefined, modelId: string | undefined): number | undefined;
+/** Parse the architecture's `*.context_length` out of `/api/show`. */
+export declare function parseDeclaredTrainedCtx(payload: unknown): number | undefined;
+/**
+ * The window to load a model with, from every source the server offers.
+ *
+ * In order, and the order is the point:
+ *
+ * 1. `parameters.num_ctx` -- the Modelfile's own value. It is what the runner
+ *    will use, so nothing may overrule it.
+ * 2. For a **cloud** model only, the `context_length` the recommendations list
+ *    publishes, then the trained window from `/api/show`. A cloud model has no
+ *    `num_ctx` to read and no local memory to run out of; the 32k default was
+ *    costing a 262k model seven eighths of its context and compacting against a
+ *    window eight times too small.
+ * 3. Nothing, and the caller falls back to {@link OLLAMA_DEFAULT_NUM_CTX}
+ *    exactly as it did before.
+ *
+ * Both host applications must read this rather than `readDeclaredNumCtx`: the
+ * wire's `num_ctx` and the compaction budget are derived from one value in this
+ * fork, and they have drifted apart once per host every time they were not.
+ */
+export declare function readResolvedOllamaWindow(baseUrl: string | undefined, modelId: string | undefined): number | undefined;
+/** Parse `details.family` out of what `/api/show` returns. */
+export declare function parseDeclaredFamily(payload: unknown): string | undefined;
+/** The model's own `temperature` parameter, if it has been looked up and it has one. */
+export declare function readDeclaredTemperature(baseUrl: string | undefined, modelId: string | undefined): number | undefined;
+/** Parse `temperature` out of the `parameters` block `/api/show` returns. */
+export declare function parseDeclaredTemperature(payload: unknown): number | undefined;
+/**
+ * The model's own `think_budget_message`, if it has been looked up and it has
+ * one: what the server appends to reasoning it cuts at the budget. The
+ * capped-thinking detector matches it at the end of a think to tell a turn the
+ * server cut from one that simply thought for a long time.
+ */
+export declare function readDeclaredThinkBudgetMessage(baseUrl: string | undefined, modelId: string | undefined): string | undefined;
+/**
+ * Parse `think_budget_message` out of the `parameters` block. The value is
+ * prose, so it is quoted, with the Modelfile's backslash escapes.
+ */
+export declare function parseDeclaredThinkBudgetMessage(payload: unknown): string | undefined;
+/** The think budget the server resolves for a request, from `/api/show`. */
+export interface OllamaThinkBudget {
+    /** The level or count the server reported it from. */
+    level: string;
+    budgetTokens: number;
+}
+/**
+ * Ask the server what think budget it will hold a request to.
+ *
+ * `/api/show` given the request's `think` and options answers with
+ * `think_budget_tokens` on the think-budget builds, which is the number the
+ * server enforces -- a level's share of `min(num_predict, num_ctx)`, or the
+ * model's own `think_budget` where no level outranks it. Asked rather than
+ * computed so every host states the number the server enforces. An older
+ * build answers without the field: nothing to report, which is `undefined`
+ * rather than a guess.
+ */
+export declare function probeOllamaThinkBudget(baseUrl: string | undefined, modelId: string, query: {
+    think?: string;
+    numPredict?: number;
+    numCtx?: number;
+}, fetchImpl: typeof fetch, attempts?: number): Promise<OllamaThinkBudget | undefined>;
+/** Parse `num_ctx` out of the `parameters` block `/api/show` returns. */
+export declare function parseDeclaredNumCtx(payload: unknown): number | undefined;
+/**
+ * Ask the server what the model's own context window is, once per model.
+ *
+ * Awaited by the factory rather than left to the first request: resolving it
+ * late would send turn one at the default and every later turn at the real
+ * value, and a changed `num_ctx` makes Ollama reload the model mid-task.
+ *
+ * Failure is not an error. A server that does not answer, or answers something
+ * this cannot read, leaves the entry null and the caller falls back exactly as
+ * it did before.
+ */
+export declare function primeDeclaredNumCtx(baseUrl: string | undefined, modelId: string | undefined, fetchImpl: typeof fetch, logger?: BasicLogger): Promise<void>;
+/** Test seam: forget every looked-up window and family. */
+export declare function resetDeclaredNumCtx(): void;
+/**
+ * Resolve the `num_predict` to request from the resolved model's output cap.
+ *
+ * `ollama-ai-provider-v2` names `num_predict` in its provider-options schema
+ * and nowhere else: it never derives one from the request's
+ * `maxOutputTokens`. So the per-turn cap the agent computes — and states in the
+ * system prompt — reached Ollama on no request at all, and two things followed
+ * from that.
+ *
+ * The cap itself was not enforced. Worse, Ollama sizes the thinking budget from
+ * `min(num_predict, num_ctx)`: with no `num_predict` the whole context window is
+ * the base, so a 128k-context model on effort `medium` (one quarter) was
+ * allowed 32,000 thinking tokens while the prompt told it 8,000 — the figure
+ * `/api/show` reports when asked with the cap the session believes it is
+ * sending. Measured on a real session: single thinking blocks of ~16,000
+ * tokens, twice the stated bound, and runs ending on "reached the maximum
+ * output token limit" with the entire allowance spent reasoning and no tool
+ * call emitted.
+ *
+ * Sending it makes both numbers true at once, which is the point: the bound in
+ * the prompt is only worth stating if the server holds the model to it.
+ */
+export declare function readOllamaNumPredict(request: Pick<GatewayStreamRequest, "maxTokens">, context: GatewayProviderContext): number | undefined;
+/**
+ * Time to wait for the response to start when no timeout is configured.
+ *
+ * Deliberately generous: Ollama holds `/api/chat` open while it cold-loads
+ * the model and only sends response headers once loading finishes, so with a
+ * large model (or a large `num_ctx`, which this vendor requests) the first
+ * request of a session routinely takes minutes before the stream starts.
+ * A tight budget here turns every cold load into a user-facing timeout error
+ * (see cline/cline#12829 — the legacy handler's 30s default was only
+ * tolerable because its retry decorator silently re-issued the request until
+ * the model was loaded). Unreachable servers are not this timeout's job:
+ * connection-level failures (refused, DNS) reject on their own immediately,
+ * and users can always cancel a request from the UI. This only bounds the
+ * accepted-but-silent case, and 5 minutes matches the header-timeout default
+ * other AI SDK-based agents use.
+ */
+export declare const OLLAMA_DEFAULT_TIMEOUT_MS = 300000;
+/**
+ * Read the configured request timeout (the legacy `requestTimeoutMs`
+ * setting); zero/invalid values fall back to the default.
+ */
+export declare function readOllamaTimeoutMs(config: GatewayResolvedProviderConfig): number;
+/**
+ * Supply the dispatcher instead of having this module find one.
+ *
+ * For hosts that bundle: the injected value is used as-is and no import is
+ * attempted. Passing `undefined` clears an earlier injection and lets the
+ * import run again, which is what tests need between cases.
+ */
+export declare function setOllamaNoStreamTimeoutDispatcher(dispatcher: unknown): void;
+/**
+ * Whether a dispatcher is in force, for hosts that want to say so in a log.
+ *
+ * Exported because the absence of one is invisible from the outside and was
+ * invisible for four releases: the wrapper works either way, and the only
+ * symptom is a timeout minutes later that looks like a network fault.
+ */
+export declare function hasOllamaNoStreamTimeoutDispatcher(): boolean;
+export declare function setOllamaFetch(value: typeof fetch | undefined): void;
+export declare function hasOllamaFetch(): boolean;
+/**
+ * The same two facts, for the other vendors that talk to a local server.
+ *
+ * The undici problem is not Ollama's -- it belongs to any endpoint whose
+ * prefill can outrun a five-minute header timeout, which is every local engine
+ * serving a long agentic prompt. The state stays here rather than being
+ * duplicated: one dispatcher, one fetch, one place a host installs them. The
+ * names are the debt from this having been an Ollama-only concern first.
+ */
+export declare function resolveLocalStreamDispatcher(): Promise<unknown>;
+/** The fetch known to honour `init.dispatcher`, if a host handed one over. */
+export declare function localStreamFetch(): typeof fetch | undefined;
+export declare function withOllamaResponseTimeout(baseFetch: typeof fetch, timeoutMs: number, dispatcher?: unknown, options?: {
+    logger?: BasicLogger;
+}): typeof fetch;
+/**
+ * Translate configured sampling parameters onto the wire.
+ *
+ * Only fields the user actually set are sent. An unset field is not a zero: a
+ * local model carries a sampler in its Modelfile — often one that was tuned and
+ * measured against that quant — and a client that sends a complete set on every
+ * request silently replaces it. An empty `stop` list is dropped for the same
+ * reason.
+ */
+export declare function buildOllamaSamplingOptions(sampling: ProviderSamplingOptions | undefined): Record<string, unknown>;
+/** Read the sampling parameters carried on the resolved provider config. */
+export declare function readOllamaSamplingOptions(config: GatewayResolvedProviderConfig): ProviderSamplingOptions | undefined;
+export declare function createOllamaProviderModule(config: GatewayResolvedProviderConfig, context: GatewayProviderContext): Promise<ProviderFactoryResult>;
+/**
+ * The effort to offer where a level has to be named and none was chosen.
+ *
+ * `medium` rather than the strongest: asking a model to think is not asking it
+ * to think as hard as it can. On Ollama an effort level also bounds how much of
+ * the response the model may spend inside the thinking block, so the middle of
+ * the scale is the reading that leaves room for an answer.
+ *
+ * It is deliberately **not** sent for a request that named no level. A level is
+ * a budget here, and it outranks the model's own `PARAMETER think_budget`, so
+ * naming one on the user's behalf silently overrides the model — see
+ * `provider.ollama.native-options`, which sends a bare `think: true` instead.
+ */
+export declare const OLLAMA_DEFAULT_REASONING_EFFORT: "medium";
+/**
+ * Ollama's stream config: the shared one, plus a level whenever the request did
+ * not settle on one.
+ *
+ * The AI SDK's vocabulary is a scale of efforts — `none`, `minimal`, `low`,
+ * `medium`, `high`, `xhigh` — with no plain "on". `provider-default` is the
+ * nearest thing, but it means "whatever the model was constructed with", and
+ * this vendor constructs models with no reasoning setting precisely so
+ * reasoning stays a per-request decision.
+ *
+ * A request that named no level gets no level from here. It used to get
+ * `medium`, on the reasoning that an absent config means "never asked" rather
+ * than "off" — which is still true, and still matters: with `think` absent a
+ * reasoning model thinks into `content` instead, measured as a turn at ~51k
+ * input with 32,000 output tokens available ending on "Model reached the
+ * maximum output token limit before completing the turn".
+ *
+ * What was wrong was answering that with a level. On Ollama a level *is* a
+ * budget and it outranks the model's own `PARAMETER think_budget`, so the
+ * default capped an unbounded model at 2,000 tokens and halved a model that
+ * declared `high`. Saying "think" without saying how much is now
+ * `provider.ollama.native-options`'s job, as a bare `think: true`; the
+ * measurements are in the comment there.
+ *
+ * This function keeps only the half that is genuinely top-level: a level the
+ * user chose, passed through untouched, and `"none"` for an explicit off. The
+ * portable resolver's `medium`-for-`enabled: true` is cleared, because that is
+ * the synthesis this exists to undo.
+ *
+ * An explicit `enabled: false` still means off — it reaches
+ * `buildAiSdkStreamConfig` as `"none"`, so `config.reasoning` is already set
+ * and this leaves it alone. Only the unset case is filled in, and only here:
+ * Ollama is the provider whose wire format has a `think` field, so it is the
+ * provider that has to say what silence means.
+ *
+ */
+export declare function buildOllamaStreamConfig(request: GatewayStreamRequest, context: GatewayProviderContext): Partial<CallSettings>;
+//# sourceMappingURL=ollama.d.ts.map

package/dist/providers/vendors/ollama.d.ts.map

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

package/dist/providers/vendors/openai-compatible.d.ts

@@ -0,0 +1,16 @@
+import type { GatewayProviderContext, GatewayResolvedProviderConfig } from "@cerebriline/shared";
+import type { ProviderFactoryResult } from "./types";
+/**
+ * OpenAI's chat-completions API rejects `max_tokens` for reasoning-era
+ * models ("Unsupported parameter: 'max_tokens' is not supported with this
+ * model. Use 'max_completion_tokens' instead."). Rename the parameter only
+ * for model ids that require it: OpenAI, Azure OpenAI, and the major
+ * OpenAI-compatible gateways (OpenRouter, LiteLLM) all accept
+ * `max_completion_tokens`, while older third-party servers that only know
+ * `max_tokens` do not serve o-series/gpt-5 model ids — so every other
+ * request keeps its exact current wire format.
+ */
+export declare function withMaxCompletionTokensForReasoningModels(body: Record<string, unknown>): Record<string, unknown>;
+export declare function createSuccessDataResponseFetch(baseFetch: typeof fetch): typeof fetch;
+export declare function createOpenAICompatibleProviderModule(config: GatewayResolvedProviderConfig, context: GatewayProviderContext): Promise<ProviderFactoryResult>;
+//# sourceMappingURL=openai-compatible.d.ts.map

package/dist/providers/vendors/openai-compatible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-compatible.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/openai-compatible.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACX,sBAAsB,EACtB,6BAA6B,EAC7B,MAAM,eAAe,CAAC;AAQvB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AA8HrD;;;;;;;;;GASG;AACH,wBAAgB,yCAAyC,CACxD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAezB;AAaD,wBAAgB,8BAA8B,CAC7C,SAAS,EAAE,OAAO,KAAK,GACrB,OAAO,KAAK,CA0Cd;AAED,wBAAsB,oCAAoC,CACzD,MAAM,EAAE,6BAA6B,EACrC,OAAO,EAAE,sBAAsB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAmFhC"}

package/dist/providers/vendors/openai.d.ts

@@ -0,0 +1,4 @@
+import type { GatewayProviderContext, GatewayResolvedProviderConfig } from "@cerebriline/shared";
+import type { ProviderFactoryResult } from "./types";
+export declare function createOpenAIProviderModule(config: GatewayResolvedProviderConfig, context: GatewayProviderContext): Promise<ProviderFactoryResult>;
+//# sourceMappingURL=openai.d.ts.map

package/dist/providers/vendors/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/openai.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,sBAAsB,EACtB,6BAA6B,EAC7B,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAcrD,wBAAsB,0BAA0B,CAC/C,MAAM,EAAE,6BAA6B,EACrC,OAAO,EAAE,sBAAsB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAyEhC"}

package/dist/providers/vendors/opencoti-agent-window.d.ts

@@ -0,0 +1,44 @@
+/**
+ * "Agent window": the floor an agent's opencoti session accepts, per node.
+ *
+ * Ruled 2026-09-25. A node's slider is a share between two ends -- 100% is the
+ * node's context window, 0% the minimum one turn needs (system prompt + tool
+ * schemas + the output cap, thinking included) -- so "50%" means the same
+ * thing whatever window the node is set to. The session asks for the node's
+ * window (`num_ctx`) and floors at that share (`num_ctx_min`); the engine
+ * grants the largest window that fits, never below the floor
+ * (`ctx_min_negotiation_v1`), and below it the refusal is waited out.
+ *
+ * The floor is computed here, at the wire, because this is the one place both
+ * halves of the minimum are exact: the system turn and the tool schemas are in
+ * the body as they will be charged, and the output cap is the `max_tokens` the
+ * gateway resolved for this request. The arithmetic is `@cerebriline/shared`'s, the
+ * same the settings panel shows.
+ */
+/** What a node says about its agents' windows, carried on the provider config. */
+export interface OpencotiAgentWindowOptions {
+    /** 0..100; see `normalizeAgentWindowShare`. */
+    sharePercent?: number;
+}
+/** The node's window and its share, once both are known. */
+export interface OpencotiAgentWindow {
+    contextWindow: number;
+    sharePercent?: number;
+}
+/**
+ * The agent window for this request, or `undefined` when the provider config
+ * carries none or there is no window to take a share of.
+ *
+ * The window is the model's as the connection resolved it -- for an agent
+ * node, the node's own (the host puts it there, ahead of any catalog figure).
+ */
+export declare function readOpencotiAgentWindow(section: unknown, contextWindow: number | undefined): OpencotiAgentWindow | undefined;
+/** The cap on the wire: `max_tokens`, its newer spelling, or llama.cpp's. */
+export declare function wireOutputCap(body: Record<string, unknown>): number | undefined;
+/**
+ * The floor for this request: `minimum + share × (window − minimum)`, with the
+ * minimum measured off the body -- its system turn, its tool schemas, and its
+ * output cap (`fallbackOutputCap` when the body declares none).
+ */
+export declare function agentWindowFloorForBody(body: Record<string, unknown>, window: OpencotiAgentWindow, fallbackOutputCap?: number): number | undefined;
+//# sourceMappingURL=opencoti-agent-window.d.ts.map

package/dist/providers/vendors/opencoti-agent-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencoti-agent-window.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/opencoti-agent-window.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,kFAAkF;AAClF,MAAM,WAAW,0BAA0B;IAC1C,+CAA+C;IAC/C,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,4DAA4D;AAC5D,MAAM,WAAW,mBAAmB;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAKD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACtC,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,MAAM,GAAG,SAAS,GAC/B,mBAAmB,GAAG,SAAS,CAWjC;AAkBD,6EAA6E;AAC7E,wBAAgB,aAAa,CAC5B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,MAAM,GAAG,SAAS,CAQpB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,MAAM,EAAE,mBAAmB,EAC3B,iBAAiB,CAAC,EAAE,MAAM,GACxB,MAAM,GAAG,SAAS,CA2BpB"}