@cerebriline/llms 0.0.0-stage → 4.100.240

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

@@ -0,0 +1,37 @@
+import type { LanguageModelV4 } from "@ai-sdk/provider";
+import type { GatewayProviderContext, GatewayResolvedProviderConfig } from "@cerebriline/shared";
+import type { ProviderFactoryResult } from "./types";
+export interface ClineWebSearchInput {
+    query: string;
+    allowed_domains?: string[];
+    blocked_domains?: string[];
+}
+export interface ClineWebSearchResult {
+    results: Array<{
+        title?: string;
+        url?: string;
+    }>;
+}
+export interface ClineWebSearchOptions {
+    allowedDomains?: string[];
+    blockedDomains?: string[];
+}
+export interface ClineProviderOptions {
+    apiKey?: string;
+    baseURL: string;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+    onResponseError?: (response: Response) => Promise<void> | void;
+}
+declare const webSearchFactory: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<ClineWebSearchInput, ClineWebSearchOptions, {}>;
+export interface ClineProvider {
+    (modelId: string): LanguageModelV4;
+    tools: {
+        webSearch(options?: ClineWebSearchOptions): ReturnType<typeof webSearchFactory<ClineWebSearchResult>>;
+    };
+}
+/** Create the Cline AI SDK provider, including Cline-native client tools. */
+export declare function createCline(options: ClineProviderOptions): ClineProvider;
+export declare function createClineProviderModule(config: GatewayResolvedProviderConfig, context: GatewayProviderContext): Promise<ProviderFactoryResult>;
+export {};
+//# sourceMappingURL=cline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cline.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/cline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,eAAe,EAGf,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EACX,sBAAsB,EACtB,6BAA6B,EAC7B,MAAM,eAAe,CAAC;AAcvB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD,MAAM,WAAW,mBAAmB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACpC,OAAO,EAAE,KAAK,CAAC;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,qBAAqB;IACrC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC/D;AA+BD,QAAA,MAAM,gBAAgB,6GAMpB,CAAC;AA8FH,MAAM,WAAW,aAAa;IAC7B,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAAC;IACnC,KAAK,EAAE;QACN,SAAS,CACR,OAAO,CAAC,EAAE,qBAAqB,GAC7B,UAAU,CAAC,OAAO,gBAAgB,CAAC,oBAAoB,CAAC,CAAC,CAAC;KAC7D,CAAC;CACF;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CAgCxE;AAWD,wBAAsB,yBAAyB,CAC9C,MAAM,EAAE,6BAA6B,EACrC,OAAO,EAAE,sBAAsB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAsDhC"}

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

@@ -0,0 +1,8 @@
+import type { GatewayResolvedProviderConfig } from "@cerebriline/shared";
+import type { ProviderFactoryResult } from "./types";
+export declare function createClaudeCodeProviderModule(config: GatewayResolvedProviderConfig): Promise<ProviderFactoryResult>;
+export declare function createOpenAICodexProviderModule(config: GatewayResolvedProviderConfig): Promise<ProviderFactoryResult>;
+export declare function createOpenCodeProviderModule(config: GatewayResolvedProviderConfig): Promise<ProviderFactoryResult>;
+export declare function createDifyProviderModule(config: GatewayResolvedProviderConfig): Promise<ProviderFactoryResult>;
+export declare function createSapAiCoreProviderModule(config: GatewayResolvedProviderConfig): Promise<ProviderFactoryResult>;
+//# sourceMappingURL=community.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"community.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/community.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC;AAQnE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAsErD,wBAAsB,8BAA8B,CACnD,MAAM,EAAE,6BAA6B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAyDhC;AAED,wBAAsB,+BAA+B,CACpD,MAAM,EAAE,6BAA6B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAmBhC;AA+BD,wBAAsB,4BAA4B,CACjD,MAAM,EAAE,6BAA6B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAgBhC;AAED,wBAAsB,wBAAwB,CAC7C,MAAM,EAAE,6BAA6B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAgBhC;AAuID,wBAAsB,6BAA6B,CAClD,MAAM,EAAE,6BAA6B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CA+BhC"}

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

@@ -0,0 +1,12 @@
+import type { GatewayProviderContext, GatewayResolvedProviderConfig } from "@cerebriline/shared";
+import type { ProviderFactoryResult } from "./types";
+/**
+ * The legacy Gemini base-URL setting (and Google's own `@google/genai`
+ * client) treat the base URL as a host root and append the API version
+ * themselves, while `@ai-sdk/google` expects the version segment to be part
+ * of `baseURL` (its default is `.../v1beta`). Preserve the legacy semantics:
+ * append `/v1beta` unless the URL already ends with a version segment.
+ */
+export declare function normalizeGeminiBaseUrl(baseUrl: string | undefined): string | undefined;
+export declare function createGoogleProviderModule(config: GatewayResolvedProviderConfig, context: GatewayProviderContext): Promise<ProviderFactoryResult>;
+//# sourceMappingURL=google.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/google.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,sBAAsB,EACtB,6BAA6B,EAC7B,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAIrD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,GAAG,SAAS,CAOpB;AAED,wBAAsB,0BAA0B,CAC/C,MAAM,EAAE,6BAA6B,EACrC,OAAO,EAAE,sBAAsB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CA0BhC"}

package/dist/providers/vendors/llamacpp-sampling.d.ts

@@ -0,0 +1,130 @@
+import type { GatewayResolvedProviderConfig } from "@cerebriline/shared";
+import type { ProviderSamplingOptions } from "../config";
+/**
+ * The per-request sampler and thinking budget a llama.cpp server accepts.
+ *
+ * llama.cpp is reached through the generic `openai-compatible` vendor — there
+ * is no provider id for it, and nothing identifies one before a response comes
+ * back (`request-timings.ts` recognises it only by the `timings` object on the
+ * final frame). So everything here is written to be inert unless the user
+ * configured it: an unset field is never sent, and a hosted OpenAI-style
+ * endpoint on this same path therefore sees a request byte-identical to the one
+ * it saw before. That is the same rule the Ollama vendor states for the same
+ * reason — a local model carries a sampler that was tuned against that quant,
+ * and a client sending a complete set on every request silently replaces it.
+ *
+ * Both this and `opencoti` are llama.cpp underneath, which is why one table
+ * serves both.
+ */
+/**
+ * Configured sampler field to the name llama.cpp's request schema uses.
+ *
+ * Verified against `tools/server/server-schema.cpp`. Deliberately absent:
+ * `numGpu`, which is Ollama's `num_gpu` and has no per-request form here —
+ * llama.cpp decides layer placement with `-ngl` at startup, so sending it would
+ * be a field the server does not read, which is the shape of bug this table
+ * exists to avoid.
+ */
+export declare const LLAMACPP_SAMPLING_WIRE_NAMES: {
+    readonly temperature: "temperature";
+    readonly topK: "top_k";
+    readonly topP: "top_p";
+    readonly minP: "min_p";
+    readonly typicalP: "typical_p";
+    readonly repeatLastN: "repeat_last_n";
+    readonly repeatPenalty: "repeat_penalty";
+    readonly presencePenalty: "presence_penalty";
+    readonly frequencyPenalty: "frequency_penalty";
+    readonly seed: "seed";
+    readonly numPredict: "n_predict";
+    readonly numKeep: "n_keep";
+    readonly stop: "stop";
+    readonly thinkBudgetMessage: "reasoning_budget_message";
+};
+/**
+ * The share of the window an effort level is allowed to spend thinking.
+ *
+ * Ported verbatim from the Ollama server's own table (`api/types.go`,
+ * `thinkBudgetFraction`) so that `high` means the same thing on both engines.
+ * llama.cpp has no notion of an effort level — `reasoning_budget_tokens` is an
+ * absolute count — so the level has to be resolved to a number on this side,
+ * and resolving it with different arithmetic would make the same setting mean
+ * two different budgets depending on which server answered.
+ *
+ * The steps halve rather than crowding the top of the range: how long a model
+ * thinks depends on the prompt, not on how much room it was given, so shares
+ * near the whole window stop bounding anything once the window is large.
+ */
+export declare const LLAMACPP_THINK_BUDGET_FRACTION: Readonly<Record<string, readonly [number, number]>>;
+/**
+ * The room a level is a share of.
+ *
+ * Ported from the Ollama server's `ThinkBudgetWindow`. A level bounds thinking
+ * so the model still has room left to answer, which makes the response length
+ * the thing to divide: when the caller caps it with `n_predict`, a share of the
+ * context length can equal or exceed that cap and then bounds nothing — the
+ * model spends the whole response thinking and stops at the cap with no answer.
+ * So prefer the output cap when it is set, and never exceed the context.
+ */
+export declare function resolveLlamaCppThinkBudgetWindow(contextWindow: number | undefined, numPredict: number | undefined): number;
+/**
+ * Resolve a configured `thinkBudget` to the absolute token count llama.cpp
+ * wants, or `undefined` when it does not resolve to one.
+ *
+ * The field is tri-valued by design, matching Ollama's: a bare token count, an
+ * effort level, or absent. A level with no window to take a share of yields
+ * nothing rather than a guess — sending `0` would read as "no thinking at all"
+ * to the server, which is the opposite of what an effort level asks for.
+ */
+export declare function resolveLlamaCppThinkBudgetTokens(thinkBudget: string | undefined, window: number): number | undefined;
+/**
+ * Translate the configured sampler onto llama.cpp's request body.
+ *
+ * Only fields the user actually set are sent; see the note at the top of this
+ * file for why that matters on a shared code path. An empty `stop` list is
+ * dropped for the same reason — it is not an instruction to clear the server's.
+ */
+export declare function buildLlamaCppSamplingOptions(sampling: ProviderSamplingOptions | undefined, budget?: {
+    contextWindow?: number;
+    numPredict?: number;
+    /**
+     * The level the request asks for, which is what the provider panel's
+     * dropdown actually writes.
+     *
+     * This used to be missing, and the omission is the whole defect: the
+     * builder bailed out above when no *sampler* was configured, so a user
+     * who set nothing but an effort level sent no budget at all. Measured
+     * live on an opencoti server 2026-09-18, `reasoning_effort` -- the field
+     * the AI SDK emits for the level -- is discarded outright, so the
+     * thinking was unbounded for every one of those requests.
+     */
+    effort?: string;
+    /** `false` means reason as little as possible, which here is a budget of 0. */
+    enabled?: boolean;
+}): Record<string, unknown>;
+/**
+ * The one budget this provider will be sent, from the two places it can come
+ * from.
+ *
+ * Precedence mirrors what the panel makes mutually exclusive: an explicit count
+ * is "Custom (reasoning_budget_tokens)" and is the number the user typed, so it
+ * outranks a level, which is only ever a share. Neither set means **unbounded**
+ * -- and unlike Ollama, where an absent budget hands the decision to the model's
+ * own `think_budget`, absent here means the engine bounds nothing at all. So
+ * nothing is sent rather than a computed default, and a budget then comes only
+ * from the server's own command-line flag if one was given.
+ */
+export declare function resolveLlamaCppReasoningBudget(source: {
+    thinkBudget?: string;
+    effort?: string;
+    enabled?: boolean;
+}, window: number): number | undefined;
+/**
+ * The sampler the user configured for this provider entry.
+ *
+ * Read from the same place every vendor reads it — `providers.json`'s
+ * `sampling` — so a value typed into the settings panel reaches a llama.cpp
+ * server by the same route it reaches Ollama.
+ */
+export declare function readLlamaCppSamplingOptions(config: GatewayResolvedProviderConfig | undefined): ProviderSamplingOptions | undefined;
+//# sourceMappingURL=llamacpp-sampling.d.ts.map

package/dist/providers/vendors/llamacpp-sampling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llamacpp-sampling.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/llamacpp-sampling.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEzD;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;CAekC,CAAC;AAE5E;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAOzC,CAAC;AAkBF;;;;;;;;;GASG;AACH,wBAAgB,gCAAgC,CAC/C,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,UAAU,EAAE,MAAM,GAAG,SAAS,GAC5B,MAAM,CAOR;AAMD;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAC/C,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,MAAM,EAAE,MAAM,GACZ,MAAM,GAAG,SAAS,CAmBpB;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC3C,QAAQ,EAAE,uBAAuB,GAAG,SAAS,EAC7C,MAAM,CAAC,EAAE;IACR,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB,GACC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiDzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAC7C,MAAM,EAAE;IACP,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB,EACD,MAAM,EAAE,MAAM,GACZ,MAAM,GAAG,SAAS,CAYpB;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAC1C,MAAM,EAAE,6BAA6B,GAAG,SAAS,GAC/C,uBAAuB,GAAG,SAAS,CAKrC"}

package/dist/providers/vendors/llamacpp-timings.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Keep llama.cpp's `timings` object, which the compatible provider drops.
+ *
+ * The server puts it on the last frame of every streamed response --
+ * `prompt_n`/`prompt_ms`, `predicted_n`/`predicted_ms`, the rates it computed
+ * itself, `cache_n` for the prefix it did not have to re-read, and the
+ * speculative-decoding counters when a draft model is attached. None of that
+ * is standard OpenAI, so `@ai-sdk/openai-compatible` parses past it; a metadata
+ * extractor is that package's supported way to keep a field it does not know,
+ * which is why this path needs no patched dependency the way Ollama's does.
+ *
+ * Its own module rather than opencoti's because both the PolyKV vendor and the
+ * generic OpenAI-compatible one use it, and the generic path must not pull in
+ * opencoti's pool bookkeeping to get a timings reader.
+ *
+ * Keyed `llamacpp` because the shape belongs to the engine: llama.cpp's own
+ * server answers with exactly this, so anything built on it is read by the
+ * same code.
+ */
+export declare const llamaCppTimingsMetadataExtractor: {
+    extractMetadata: ({ parsedBody }: {
+        parsedBody: unknown;
+    }) => Promise<{
+        llamacpp: Record<string, unknown>;
+    } | undefined>;
+    createStreamExtractor: () => {
+        processChunk(parsedChunk: unknown): void;
+        buildMetadata: () => {
+            llamacpp: Record<string, unknown>;
+        } | undefined;
+    };
+};
+//# sourceMappingURL=llamacpp-timings.d.ts.map

package/dist/providers/vendors/llamacpp-timings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llamacpp-timings.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/llamacpp-timings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAeH,eAAO,MAAM,gCAAgC;sCACJ;QAAE,UAAU,EAAE,OAAO,CAAA;KAAE;kBAZjD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;kCAiBT,OAAO;;;;;CAYnC,CAAC"}

package/dist/providers/vendors/minimax-thinking.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageModelV4Middleware } from "@ai-sdk/provider";
+export declare const MINIMAX_THINKING_DISABLED_HEADER = "x-cline-minimax-thinking-disabled";
+export declare const miniMaxThinkingDisabledMiddleware: LanguageModelV4Middleware;
+export declare function createMiniMaxThinkingFetch(baseFetch?: typeof fetch): typeof fetch;
+//# sourceMappingURL=minimax-thinking.d.ts.map

package/dist/providers/vendors/minimax-thinking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimax-thinking.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/minimax-thinking.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEX,yBAAyB,EACzB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,gCAAgC,sCACT,CAAC;AAsBrC,eAAO,MAAM,iCAAiC,EAAE,yBAe/C,CAAC;AAqBF,wBAAgB,0BAA0B,CAAC,SAAS,GAAE,OAAO,KAAa,gBAsCzE"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"mistral.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/mistral.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC;AAInE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD,wBAAsB,2BAA2B,CAChD,MAAM,EAAE,6BAA6B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAsBhC"}

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

@@ -0,0 +1,128 @@
+import type { BasicLogger } from "@cerebriline/shared";
+/** The plan an account is on, or a model requires. Open-ended on purpose: the
+ * server sends a string and a plan tier this build has never heard of must
+ * still render. */
+export type OllamaPlan = string;
+export interface OllamaAccount {
+    /** Whether `/api/me` answered at all. Not signed in and not reachable are
+     * different conditions and the panel says which. */
+    readonly reachable: boolean;
+    readonly signedIn: boolean;
+    readonly plan?: OllamaPlan;
+    readonly name?: string;
+    readonly email?: string;
+    /** Where to sign in, as the server itself computed it. */
+    readonly signinUrl?: string;
+}
+export interface OllamaRecommendation {
+    readonly model: string;
+    readonly description?: string;
+    readonly contextLength?: number;
+    readonly maxOutputTokens?: number;
+    readonly requiredPlan?: OllamaPlan;
+    /**
+     * The thinking settings the model accepts, normalized to strings.
+     *
+     * The wire mixes booleans and levels in one array -- `[false, "low",
+     * "high", "max"]` for one model and `[false, true]` for another -- so
+     * `false` renders as `off` and `true` as `on`. A model whose values are
+     * `off`/`on` has a switch; one with levels has a picker.
+     */
+    readonly thinkingValues?: readonly string[];
+    readonly thinkingDefault?: string;
+    /** Present on local recommendations only; the cloud ones carry no size. */
+    readonly vramBytes?: number;
+}
+export interface OllamaCatalogEntry {
+    readonly name: string;
+    /** True when `/api/tags` gave it a `remote_host` or a `remote_model`. */
+    readonly cloud: boolean;
+    readonly remoteHost?: string;
+    readonly remoteModel?: string;
+    readonly family?: string;
+    readonly capabilities: readonly string[];
+    /**
+     * `false` for a cloud model the server offers but has not pulled: listed
+     * by its recommendations and absent from `/api/tags`. Ollama fetches its
+     * manifest on the first request, so it is as usable as a pulled one.
+     * Absent for every entry `/api/tags` itself lists.
+     */
+    readonly pulled?: false;
+}
+export interface OllamaAccountStatus {
+    /** Whether the server answered `/api/tags`. */
+    readonly reachable: boolean;
+    readonly account: OllamaAccount;
+    readonly recommendations: readonly OllamaRecommendation[];
+    readonly models: readonly OllamaCatalogEntry[];
+}
+/**
+ * Read `POST /api/me`.
+ *
+ * The response uses Go's exported field names (`Name`, `Plan`, `Email`), not
+ * the snake_case every other Ollama endpoint uses; both spellings are accepted
+ * so a future rename does not silently empty the strip.
+ */
+export declare function parseOllamaWhoami(status: number, payload: unknown): OllamaAccount;
+/** Read `GET /api/experimental/model-recommendations`. */
+export declare function parseOllamaRecommendations(payload: unknown): OllamaRecommendation[];
+/**
+ * The cloud models a server offers without having pulled them.
+ *
+ * pandorum, 2026-09-30: `glm-5.3-flash:cloud` headed the recommendations, ran
+ * a session with its 1M window, and was not among the 166 tags -- so the chat
+ * box said the server did not have it, the settings strip had nothing to say
+ * about it, and the picker could not offer it. A cloud recommendation needs no
+ * pull: the server fetches its manifest on first use.
+ *
+ * Cloud recommendations only. A local one (it carries a `vram_bytes`) does
+ * need a pull, and its absence from the tags is the truth. The name suffix is
+ * the only mark a recommendation has, so it decides here; `remote_host`, the
+ * real discriminator, exists only once a model is pulled.
+ */
+export declare function unpulledCloudModels(recommendations: readonly OllamaRecommendation[], catalog: readonly OllamaCatalogEntry[]): OllamaCatalogEntry[];
+/** Read `GET /api/tags`. */
+export declare function parseOllamaCatalog(payload: unknown): OllamaCatalogEntry[];
+/**
+ * The fallback when the catalog could not be read.
+ *
+ * Deliberately last-resort: it is right about `kimi-k2.6:cloud` and wrong about
+ * `glm-5.3-flash-tpl2:latest`, and a `-cloud` in the middle of a name is not a
+ * suffix.
+ */
+export declare function looksLikeCloudName(modelId: string): boolean;
+/**
+ * Find the recommendation that describes a tag.
+ *
+ * A tag built FROM a cloud model keeps its own name — `glm-5.3-flash-tpl2:latest`
+ * is `glm-5.3-flash` underneath — so `remote_model` is tried before the tag's
+ * own name. Without that, every re-templated cloud model reads as unlisted.
+ */
+export declare function matchOllamaRecommendation(recommendations: readonly OllamaRecommendation[], model: {
+    readonly name: string;
+    readonly remoteModel?: string;
+}): OllamaRecommendation | undefined;
+/**
+ * Read everything the settings panel shows about an Ollama endpoint.
+ *
+ * Nothing here may fail a caller. Each read stands alone: a server that does
+ * not proxy `/api/me` still reports its models, and an account read that says
+ * "not signed in" does not suppress the recommendations, which need no auth.
+ */
+export declare function readOllamaAccountStatus(baseUrl: string | undefined, fetchImpl?: typeof fetch): Promise<OllamaAccountStatus>;
+/** Test seam, and the reset a base-URL change needs. */
+export declare function resetOllamaAccountStatus(): void;
+/** What has been primed for this server, if anything. */
+export declare function readOllamaAccountCache(baseUrl: string | undefined): OllamaAccountStatus | undefined;
+/** Prime {@link readOllamaAccountCache} for a server, at most once. */
+export declare function primeOllamaAccountStatus(baseUrl: string | undefined, fetchImpl?: typeof fetch, logger?: BasicLogger): Promise<void>;
+/**
+ * Whether a model is served from the cloud.
+ *
+ * `undefined` when the catalog has not been primed — which is not the same as
+ * `false`, and callers that care about the difference must ask for it.
+ */
+export declare function readOllamaCloudFlag(baseUrl: string | undefined, modelId: string | undefined): boolean | undefined;
+/** The recommendation describing a model on a primed server, if it has one. */
+export declare function readOllamaRecommendation(baseUrl: string | undefined, modelId: string | undefined): OllamaRecommendation | undefined;
+//# sourceMappingURL=ollama-account.d.ts.map

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

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

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

@@ -0,0 +1,42 @@
+/**
+ * Whether an Ollama or xOllama endpoint answers, for the chat input.
+ *
+ * The chat box is where a dead server is found out, and until now it was found
+ * out by sending a message and reading the error. This is one `GET /api/tags`
+ * with a short bound: cheap enough to repeat while the panel is open, and the
+ * one read that also says whether the selected model is there at all.
+ *
+ * Deliberately not {@link readOllamaAccountStatus}: that one also asks
+ * ollama.com who the host is signed in as, a signed round trip that has no
+ * business on a poll.
+ *
+ * An unset base URL is resolved the way the chat request resolves it -- the
+ * package's own default for Ollama, {@link XOLLAMA_DEFAULT_BASE_URL} for
+ * xOllama -- so the probe asks the server the chat would have asked.
+ */
+/** Where `ollama-ai-provider-v2` sends a request with no base URL. */
+export declare const OLLAMA_PACKAGE_DEFAULT_BASE_URL = "http://127.0.0.1:11434";
+/** Long enough for a busy server's `/api/tags`, short enough to say "down" promptly. */
+export declare const OLLAMA_REACHABILITY_TIMEOUT_MS = 4000;
+export interface OllamaReachability {
+    readonly reachable: boolean;
+    /** The origin asked, as the user would type it. */
+    readonly baseUrl: string;
+    /** Why it did not answer: an HTTP status, a timeout, or the network's word. */
+    readonly error?: string;
+    /**
+     * It answered, and refused the request for want of a key (401). xOllama
+     * with a local key set answers every route so; the server is up and the
+     * fix is in the provider's settings, not on the server.
+     */
+    readonly unauthorized?: boolean;
+    /**
+     * Whether the model is in `/api/tags`. Absent when no model was named or
+     * the server did not answer -- not the same as `false`.
+     */
+    readonly modelFound?: boolean;
+}
+/** The origin a chat request on this provider goes to. */
+export declare function resolveOllamaOrigin(providerId: string, baseUrl: string | undefined): string;
+export declare function probeOllamaReachability(providerId: string, baseUrl: string | undefined, modelId?: string, fetchImpl?: typeof fetch): Promise<OllamaReachability>;
+//# sourceMappingURL=ollama-reachability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ollama-reachability.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/ollama-reachability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,sEAAsE;AACtE,eAAO,MAAM,+BAA+B,2BAA2B,CAAC;AAExE,wFAAwF;AACxF,eAAO,MAAM,8BAA8B,OAAO,CAAC;AAEnD,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,0DAA0D;AAC1D,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,CAQR;AA2CD,wBAAsB,uBAAuB,CAC5C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,CAAC,EAAE,MAAM,EAChB,SAAS,GAAE,OAAO,KAAa,GAC7B,OAAO,CAAC,kBAAkB,CAAC,CAgD7B"}

package/dist/providers/vendors/ollama-stall-watchdog.d.ts

@@ -0,0 +1,86 @@
+/**
+ * A stall bound that asks the server before it gives up.
+ *
+ * Every fixed timeout on a local model is a guess about hardware. undici's
+ * five-minute `bodyTimeout` is the one that keeps ending runs, but replacing it
+ * with a bigger constant only moves the guess: prompt prefill at a hundred
+ * thousand tokens is minutes of silence on a healthy socket, and the same
+ * silence is what a crashed server looks like from the client side. The two are
+ * indistinguishable from the stream alone — but not from the server, which will
+ * answer a second connection in milliseconds if it is alive.
+ *
+ * So silence is not the failure condition here; silence *from a server that has
+ * stopped answering* is. On each quiet interval this asks Ollama whether it is
+ * up, and a server that answers buys the request another interval, from zero,
+ * as many times as it keeps answering. What is left is a real bound — the
+ * request dies when the server does, and only then.
+ *
+ * The interval is therefore a polling period rather than a patience budget, and
+ * is set short enough to notice a dead server quickly rather than long enough
+ * to outlast a slow one.
+ */
+import type { BasicLogger } from "@cerebriline/shared";
+/** How long a quiet stream may stay quiet before the server is asked about it. */
+export declare const OLLAMA_STALL_PROBE_INTERVAL_MS = 30000;
+/** How long the health probe itself may take before it counts as no answer. */
+export declare const OLLAMA_HEALTH_PROBE_TIMEOUT_MS = 10000;
+/**
+ * How many probes in a row must go unanswered before the request is failed.
+ *
+ * More than one because a single refused connection is not yet evidence: a
+ * server under a heavy generation can drop a probe, and killing a run that was
+ * about to produce its first token is worse than waiting one more interval.
+ */
+export declare const OLLAMA_HEALTH_PROBE_FAILURES_BEFORE_GIVING_UP = 3;
+export type OllamaHealthProbe = () => Promise<boolean>;
+/**
+ * Ask an Ollama server whether it is alive.
+ *
+ * `/api/ps` rather than `/api/version` because the answer carries something
+ * worth logging — whether the model this request is for is still resident. That
+ * does not decide the verdict: a model evicted mid-queue will be reloaded and
+ * the request still completes, so treating eviction as death would fail
+ * requests that were going to succeed. It is the difference between "the
+ * server is busy with us" and "the server is busy with something else", which
+ * is exactly what someone reading the log after a stall wants to know.
+ */
+export declare function createOllamaHealthProbe(options: {
+    url: string;
+    fetch: typeof fetch;
+    model?: string;
+    dispatcher?: unknown;
+    timeoutMs?: number;
+    logger?: BasicLogger;
+}): OllamaHealthProbe;
+export interface StallWatchdogOptions {
+    probe: OllamaHealthProbe;
+    intervalMs?: number;
+    failuresBeforeGivingUp?: number;
+    logger?: BasicLogger;
+    /** Names the thing being watched in logs and in the failure message. */
+    label: string;
+}
+/**
+ * Run `probe` every quiet interval until something else finishes.
+ *
+ * Returns a stop function and calls `onDead` once, with the elapsed time, when
+ * the server has failed enough probes in a row to be called dead. Restarting
+ * the interval after a successful probe is the whole point: a live server
+ * resets the clock rather than spending a budget.
+ */
+export declare function watchForStall(options: StallWatchdogOptions & {
+    onDead: (elapsedMs: number) => void;
+}): {
+    stop: () => void;
+    noteActivity: () => void;
+};
+/**
+ * Wrap a streaming response so a stalled body is measured against the server
+ * rather than against a stopwatch.
+ *
+ * The reader's pending read is kept and re-raced rather than re-issued: a
+ * `ReadableStreamDefaultReader` allows one outstanding `read()`, so the timeout
+ * has to lose the race without cancelling the thing it raced.
+ */
+export declare function withStallWatchdog(response: Response, options: StallWatchdogOptions): Response;
+//# sourceMappingURL=ollama-stall-watchdog.d.ts.map

package/dist/providers/vendors/ollama-stall-watchdog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama-stall-watchdog.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/ollama-stall-watchdog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,kFAAkF;AAClF,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAErD,+EAA+E;AAC/E,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,6CAA6C,IAAI,CAAC;AAE/D,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;AAWvD;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB,GAAG,iBAAiB,CA0CpB;AA0BD,MAAM,WAAW,oBAAoB;IACpC,KAAK,EAAE,iBAAiB,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC5B,OAAO,EAAE,oBAAoB,GAAG;IAAE,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,MAAM,IAAI,CAAC;IAAC,YAAY,EAAE,MAAM,IAAI,CAAA;CAAE,CAwDhD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,oBAAoB,GAC3B,QAAQ,CAiEV"}

package/dist/providers/vendors/ollama-tool-images.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Put tool-result images back on the tool message, on the way out.
+ *
+ * `splitToolImagesMiddleware` moves image bytes out of a `role:"tool"` message
+ * and into a synthetic `role:"user"` message placed immediately after it. That
+ * is the only shape chat-completions can carry, and for those wire formats it
+ * is correct. Ollama's native `/api/chat` is not one of them: `images` is a
+ * field on every message, tool messages included, and every renderer that
+ * handles images at all routes tool responses through the same content path.
+ *
+ * Leaving the synthetic user message in place is not merely redundant there —
+ * it is destructive. Chat templates decide how much of the assistant's own
+ * reasoning to replay from the position of the last user turn:
+ *
+ *     if message.Role == "assistant" && message.Thinking != "" && i > lastUserIdx
+ *         (ollama, model/renderers/gemma4.go)
+ *
+ * A user message injected after every screenshot moves `lastUserIdx` to the end
+ * of the conversation, so *every* thinking block before it stops being
+ * rendered. Measured on a live session: 209,028 characters of prompt became
+ * 104,026 — the model's entire reasoning history, three blocks of it over
+ * 20,000 characters each, gone from a request that otherwise looked fine. The
+ * model then reads fourteen turns of assistants that did not think, and stops
+ * thinking. It recovers only when compaction happens to drop the screenshots.
+ *
+ * So this runs at the wire layer rather than as another middleware: the
+ * conversion that loses the images (`convertToOllamaChatMessages`, whose `tool`
+ * branch writes `content` and nothing else) sits between the typed prompt and
+ * here, and this is the first point where the images and the tool message they
+ * belong to exist in the same object again.
+ */
+/** What the splitting middleware leaves behind in the tool result. */
+export declare const OLLAMA_SPLIT_IMAGE_PLACEHOLDER = "(see following user message for image)";
+export interface MergeToolImagesResult {
+    messages: unknown[];
+    /** How many synthetic user messages were folded away. */
+    merged: number;
+}
+/**
+ * Fold each synthetic image message into the tool message it follows.
+ *
+ * A synthetic message that does not follow a tool message is left exactly
+ * where it is: that is either a real user turn or a shape this function does
+ * not recognise, and dropping an image is worse than the prompt cost of one
+ * extra message.
+ */
+export declare function mergeOllamaToolImages(messages: unknown): MergeToolImagesResult;
+export interface RewrittenOllamaBody {
+    /** The body to send, unchanged when there was nothing to do. */
+    body: string;
+    /** The model this request is for, when the body names one. */
+    model?: string;
+    merged: number;
+}
+/**
+ * Rewrite a serialized `/api/chat` body, and read the model name while it is
+ * parsed.
+ *
+ * Both callers want something out of the same parse, and a request body at
+ * these sizes is not something to parse twice: the transcripts that trigger
+ * this are a quarter of a megabyte, most of it base64.
+ *
+ * Never throws. A body that is not JSON, or not a chat body, is something this
+ * has no opinion about — it goes out as it came in.
+ */
+export declare function rewriteOllamaChatBody(body: unknown): RewrittenOllamaBody | undefined;
+//# sourceMappingURL=ollama-tool-images.d.ts.map

package/dist/providers/vendors/ollama-tool-images.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama-tool-images.d.ts","sourceRoot":"","sources":["../../../src/providers/vendors/ollama-tool-images.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,sEAAsE;AACtE,eAAO,MAAM,8BAA8B,2CACF,CAAC;AA6C1C,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,QAAQ,EAAE,OAAO,GACf,qBAAqB,CA4BvB;AAED,MAAM,WAAW,mBAAmB;IACnC,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,OAAO,GACX,mBAAmB,GAAG,SAAS,CAuBjC"}