dsh-subscriptions 0.1.4 → 0.2.0

package/lib/providers/ollama.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Ollama Cloud provider: a key-based OpenAI-completions route with no OAuth
+ * session. The credential arrives per request as a bearer key; chat posts to
+ * the configured native baseURL's `/v1` sibling. The route ships no catalog:
+ * only models the user stored on the Settings card are served, so an empty
+ * store hides the picker entry and rejects every chat model.
+ */
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { DiscoveredModel, FetchFn } from './common.js';
+import type { OllamaModelSetting } from './ollama-settings.js';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+/** Route id owned by this adapter. Not a member of the OAuth `PROVIDER_IDS`. */
+export declare const OLLAMA_CLOUD_ROUTE = "ollama-cloud";
+/** Default credential reference naming the Ollama Cloud API key. */
+export declare const DEFAULT_OLLAMA_API_KEY_REF = "OLLAMA_API_KEY";
+/** Default native base URL; chat maps it to its `/v1` sibling. */
+export declare const DEFAULT_OLLAMA_BASE_URL = "https://ollama.com/api";
+/** Fallback per-request output cap; Ollama publishes no per-model limit. */
+export declare const OLLAMA_DEFAULT_MAX_TOKENS = 32768;
+/** Fallback context window for a row the endpoint never described. */
+export declare const OLLAMA_DEFAULT_CONTEXT_WINDOW = 262144;
+/**
+ * Budget for the Settings card's explicit cloud listing. Longer than the
+ * picker's discovery bound because a user waits on this one and `/api/show`
+ * runs once per model.
+ */
+export declare const OLLAMA_PULL_TIMEOUT_MS = 20000;
+/**
+ * The window the session plans against: the user's override, capped at what
+ * the endpoint advertises (or, without discovery, the stored snapshot). The
+ * cap keeps a stale or mistyped override from planning past the model.
+ */
+export declare function effectiveContextWindow(row: {
+    contextWindow: number;
+    contextOverride: number | undefined;
+}, discovered: number | undefined): number;
+export interface OllamaAdapterOptions {
+    /** Resolve the API key per request; `undefined` means unconfigured. */
+    apiKey: () => Promise<string | undefined>;
+    /**
+     * Live native base URL (`https://ollama.com/api`); chat maps it to `/v1`.
+     * Read per request so a Settings save takes effect without a restart.
+     */
+    baseURL: () => string;
+    /**
+     * Live catalog snapshot, in picker order. The Settings store (or a
+     * non-empty config override) is the only source; an empty list means the
+     * route serves no model.
+     */
+    catalog: () => readonly OllamaModelSetting[];
+    /** Per-model default-effort override, winning over the stored row. */
+    defaultEffortOf?: (model: string) => string | undefined;
+    /** Live discovery via `/api/tags` + `/api/show` (default true). */
+    discovery?: boolean;
+    fetchFn?: FetchFn;
+    resolveAttachments?: () => AttachmentStore | undefined;
+    streamIdleTimeoutMs?: number;
+    onWarn?: (message: string) => void;
+}
+/** Map a native base URL to its OpenAI-compatible chat sibling. */
+export declare function ollamaChatBaseURL(baseURL: string): string;
+/**
+ * Normalize one listing id to the wire id the chat endpoint accepts. The
+ * Cloud listing advertises bare names (`glm-5.3`) while its chat wire wants
+ * the `:cloud` tag; a local daemon reached through a custom base URL takes
+ * the bare name, so only the official host gets the tag. An id that already
+ * carries a tag is returned unchanged.
+ * @param id - the id as listed by `/api/tags`.
+ * @param baseURL - the native base URL the listing came from.
+ * @returns the id to store and send on the chat wire.
+ */
+export declare function normalizeOllamaModelId(id: string, baseURL: string): string;
+export interface OllamaDiscoveryOptions {
+    baseURL: string;
+    apiKey: string | undefined;
+    fetchFn?: FetchFn | undefined;
+    signal?: AbortSignal | undefined;
+}
+/** One discovered Cloud model, with the capability flags the card badges. */
+export interface OllamaDiscoveredModel extends DiscoveredModel {
+    /** The id exactly as `/api/tags` published it, before wire normalization. */
+    rawId: string;
+    /** The endpoint advertised the `thinking` capability. */
+    thinking: boolean;
+}
+/**
+ * List Cloud models via `/api/tags`, enriching through `/api/show`. A failed
+ * enrichment degrades to an id-only row; a failed listing fails. Listing ids
+ * are normalized to their wire form ({@link normalizeOllamaModelId}) while
+ * `/api/show` still receives the id the endpoint published.
+ */
+export declare function fetchOllamaModels(options: OllamaDiscoveryOptions): Promise<OllamaDiscoveredModel[]>;
+export declare function ollamaChatRequestBody(options: GenerateOptions, messages: Record<string, unknown>[], maxTokens: number | undefined): Record<string, unknown>;
+export declare class OllamaAdapter extends LlmAdapter {
+    private readonly options;
+    private readonly catalogCache;
+    constructor(options: OllamaAdapterOptions);
+    /** Drop the discovery snapshot so the next picker pass re-reads the endpoint. */
+    invalidateModels(): void;
+    private rows;
+    providerInfo(provider: string): LlmProviderInfo;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    private staticList;
+    resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}

package/lib/providers/ollama.js

@@ -0,0 +1,545 @@
+/**
+ * Ollama Cloud provider: a key-based OpenAI-completions route with no OAuth
+ * session. The credential arrives per request as a bearer key; chat posts to
+ * the configured native baseURL's `/v1` sibling. The route ships no catalog:
+ * only models the user stored on the Settings card are served, so an empty
+ * store hides the picker entry and rejects every chat model.
+ */
+import { attributionHeaders, EMPTY_RESPONSE_CODE, errorChain, LlmAdapter, LlmError, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
+import { DISCOVERY_TIMEOUT_MS, effortDisplayName, httpLlmError, idleWatchdog, isDiscoveryAborted, isMissingOrInvalidCredential, mapFetchFailure, ModelCatalogCache, readBoundedJson, withTimeout, } from './common.js';
+import { hostFetch } from '../http.js';
+import { resolveImages } from '../translate/resolved.js';
+import { streamChatCompletions, toChatMessages, toChatTools } from '../translate/chat-completions.js';
+/** Route id owned by this adapter. Not a member of the OAuth `PROVIDER_IDS`. */
+export const OLLAMA_CLOUD_ROUTE = 'ollama-cloud';
+/** Default credential reference naming the Ollama Cloud API key. */
+export const DEFAULT_OLLAMA_API_KEY_REF = 'OLLAMA_API_KEY';
+/** Default native base URL; chat maps it to its `/v1` sibling. */
+export const DEFAULT_OLLAMA_BASE_URL = 'https://ollama.com/api';
+/** Fallback per-request output cap; Ollama publishes no per-model limit. */
+export const OLLAMA_DEFAULT_MAX_TOKENS = 32_768;
+/** Fallback context window for a row the endpoint never described. */
+export const OLLAMA_DEFAULT_CONTEXT_WINDOW = 262_144;
+/**
+ * Budget for the Settings card's explicit cloud listing. Longer than the
+ * picker's discovery bound because a user waits on this one and `/api/show`
+ * runs once per model.
+ */
+export const OLLAMA_PULL_TIMEOUT_MS = 20_000;
+/** Concurrency bound for `/api/show` enrichment. */
+const SHOW_CONCURRENCY = 6;
+/** Response body bound for discovery payloads. */
+const MAX_DISCOVERY_BYTES = 4 * 1024 * 1024;
+/**
+ * Fallback reasoning levels for known Cloud model families. `/api/show`
+ * publishes each thinking model's accepted levels under `thinking.values`
+ * with a `thinking.default`, so the vendor is the primary source; this table
+ * only answers a model whose `thinking` capability is reported without a
+ * level list. It is capability knowledge, not a catalog: a stored row's own
+ * `efforts` always win, and a row outside these families with no stored
+ * levels carries no reasoning block.
+ */
+const OLLAMA_REASONING_FAMILIES = [
+    // Recorded before the endpoint's level list was read: the thinking values
+    // ride as `off`/`low`/`high`/`max` (`off` maps to the wire spelling
+    // `none`), and the vendor publishes no `medium` level.
+    { prefix: 'deepseek-v4.1-flash', efforts: ['off', 'low', 'high', 'max'], defaultEffort: 'high' },
+    { prefix: 'glm-5.3', efforts: ['low', 'high', 'max'], defaultEffort: 'max' },
+];
+function reasoningFamily(id) {
+    return OLLAMA_REASONING_FAMILIES.find(family => id.startsWith(family.prefix));
+}
+/**
+ * The window the session plans against: the user's override, capped at what
+ * the endpoint advertises (or, without discovery, the stored snapshot). The
+ * cap keeps a stale or mistyped override from planning past the model.
+ */
+export function effectiveContextWindow(row, discovered) {
+    const advertised = discovered ?? row.contextWindow;
+    return Math.min(row.contextOverride ?? advertised, advertised);
+}
+/** Map a native base URL to its OpenAI-compatible chat sibling. */
+export function ollamaChatBaseURL(baseURL) {
+    const trimmed = baseURL.replace(/\/+$/, '');
+    if (trimmed.endsWith('/v1'))
+        return trimmed;
+    if (trimmed.endsWith('/api'))
+        return `${trimmed.slice(0, -'/api'.length)}/v1`;
+    return `${trimmed}/v1`;
+}
+/**
+ * Normalize one listing id to the wire id the chat endpoint accepts. The
+ * Cloud listing advertises bare names (`glm-5.3`) while its chat wire wants
+ * the `:cloud` tag; a local daemon reached through a custom base URL takes
+ * the bare name, so only the official host gets the tag. An id that already
+ * carries a tag is returned unchanged.
+ * @param id - the id as listed by `/api/tags`.
+ * @param baseURL - the native base URL the listing came from.
+ * @returns the id to store and send on the chat wire.
+ */
+export function normalizeOllamaModelId(id, baseURL) {
+    if (id.includes(':'))
+        return id;
+    let host;
+    try {
+        host = new URL(baseURL).hostname;
+    }
+    catch {
+        return id;
+    }
+    return /(^|\.)ollama\.com$/.test(host) ? `${id}:cloud` : id;
+}
+/** Whether the failure is a rejected key. Only a 401 hides the route: a
+ * 403 may be a transient scope denial, so it falls back to the stored
+ * catalog like any other discovery miss. */
+function isUnauthorized(error) {
+    return error instanceof LlmError && error.code === 'AUTH'
+        && error.failure?.status === 401;
+}
+/**
+ * Find a discovered row for a catalog id, tolerating a listing endpoint that
+ * still reports bare names (`glm-5.3` for catalogued `glm-5.3:cloud`).
+ */
+function discoveredFor(catalogId, discovered) {
+    return discovered?.find(row => row.id === catalogId)
+        ?? discovered?.find(row => row.id === catalogId.replace(/:cloud$/, ''));
+}
+function reasoningFor(row, configuredDefault) {
+    const family = reasoningFamily(row.id);
+    const familyDefault = row.efforts.includes(family?.defaultEffort ?? '')
+        ? family?.defaultEffort
+        : undefined;
+    if (row.efforts.length === 0)
+        return undefined;
+    // Every level here comes from the row or a family that named it; a
+    // stored default the row does not list cannot ride the wire.
+    const efforts = row.efforts.map(effort => ({ id: ReasoningEffortId(effort), name: effortDisplayName(effort) }));
+    const storedDefault = row.efforts.includes(row.defaultEffort ?? '')
+        ? row.defaultEffort
+        : undefined;
+    const priority = [
+        configuredDefault,
+        // The family default is the last resort, mirroring the discovery
+        // path's priority; the stored row no longer bakes it in.
+        familyDefault,
+        storedDefault,
+    ];
+    const defaultEffort = priority.find(entry => entry !== undefined && row.efforts.includes(entry));
+    return {
+        efforts,
+        ...defaultEffort === undefined ? {} : { defaultEffort: ReasoningEffortId(defaultEffort) },
+    };
+}
+/**
+ * Merge a discovered reasoning block into the stored row. The endpoint is
+ * the truth about the live model: a published level set is closed (a level
+ * the gateway stopped offering would only fail the request), and the
+ * default priority is the user's stored choice, then the endpoint's, then
+ * the family table — always within the offered set. Without a published
+ * set, the same priority chain runs against the stored row's levels.
+ * @param row - the stored catalog row, with the family fallback already applied.
+ * @param discovered - the endpoint's reasoning block.
+ * @param configuredDefault - the per-model configured default, when set.
+ * @returns the merged block, with a default that is always one of its levels.
+ */
+function mergeDiscoveredReasoning(row, discovered, configuredDefault) {
+    const vendorLevels = discovered.efforts.map(entry => String(entry.id));
+    // A published vendor set is closed: the stored row and the family table
+    // must not widen it. When the endpoint names no levels, the stored row
+    // supplies them and only a still-empty list falls to the family table.
+    const efforts = vendorLevels.length > 0
+        ? vendorLevels
+        : [...row.efforts, ...(row.efforts.length > 0 ? [] : reasoningFamily(row.id)?.efforts ?? [])];
+    const vendorDefault = discovered.defaultEffort === undefined ? undefined : String(discovered.defaultEffort);
+    // The user's explicit choice wins only within the levels the model still
+    // offers: a stored default outside a retracted vendor set must not ride
+    // the wire, so it falls through to the vendor or stored fallback.
+    const priority = [
+        configuredDefault,
+        vendorDefault,
+        // The family default is the last resort, not a user preference.
+        ...configuredDefault !== undefined || vendorDefault !== undefined
+            ? [undefined, reasoningFamily(row.id)?.defaultEffort]
+            : [row.defaultEffort, reasoningFamily(row.id)?.defaultEffort],
+    ];
+    const defaultEffort = priority.find(entry => entry !== undefined && efforts.includes(entry));
+    return {
+        efforts: efforts.map(effort => ({ id: ReasoningEffortId(effort), name: effortDisplayName(effort) })),
+        ...defaultEffort === undefined ? {} : { defaultEffort: ReasoningEffortId(defaultEffort) },
+    };
+}
+/** Strip image blocks for models that cannot accept vision input. Runs before
+ * image resolution so a text-only model never requires the attachment store. */
+function withoutImages(messages) {
+    return messages.map(message => ({
+        ...message,
+        content: message.content.filter(block => block.type !== 'image'),
+    }));
+}
+function discoveryHeaders(apiKey) {
+    return {
+        'accept': 'application/json',
+        ...apiKey === undefined ? {} : { 'authorization': `Bearer ${apiKey}` },
+        ...attributionHeaders(),
+    };
+}
+function recordOf(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function parseNumCtx(parameters) {
+    if (typeof parameters !== 'string')
+        return undefined;
+    const match = /(?:^|\s)num_ctx\s+(\d+)/.exec(parameters);
+    if (match === null)
+        return undefined;
+    const value = Number(match[1]);
+    return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+/** Prefer an explicit `num_ctx`, else any `*.context_length` in model info. */
+function extractContextWindow(show) {
+    const numCtx = parseNumCtx(show['parameters']);
+    if (numCtx !== undefined)
+        return numCtx;
+    const info = recordOf(show['model_info']);
+    if (info !== undefined) {
+        for (const [key, value] of Object.entries(info)) {
+            if (key.endsWith('context_length') && typeof value === 'number'
+                && Number.isSafeInteger(value) && value > 0)
+                return value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Read the endpoint's own reasoning levels. `/api/show` reports them as
+ * `thinking: { values: [...], default: '...' }`; a `false` value is the
+ * vendor's spelling of the `off` level, so it maps to the effort id `off`.
+ * @param show - the `/api/show` payload.
+ * @returns the level list and default, or `undefined` when the payload
+ *   carries no usable `thinking` object.
+ */
+function extractThinking(show) {
+    const thinking = recordOf(show['thinking']);
+    if (thinking === undefined)
+        return undefined;
+    const rawValues = thinking['values'];
+    const values = [];
+    if (Array.isArray(rawValues)) {
+        for (const entry of rawValues) {
+            const effort = entry === false ? 'off' : typeof entry === 'string' && entry.length > 0 ? entry : undefined;
+            if (effort !== undefined && !values.includes(effort))
+                values.push(effort);
+        }
+    }
+    const rawDefault = thinking['default'];
+    return {
+        values,
+        ...typeof rawDefault === 'string' && rawDefault.length > 0 ? { default: rawDefault } : {},
+    };
+}
+function discoveredFromShow(id, rawId, show) {
+    const rawCapabilities = show['capabilities'];
+    const capabilities = new Set(Array.isArray(rawCapabilities)
+        ? rawCapabilities.filter((entry) => typeof entry === 'string')
+        : []);
+    const vision = capabilities.has('vision');
+    const thinking = capabilities.has('thinking');
+    const vendor = thinking ? extractThinking(show) : undefined;
+    // The vendor's level list is the truth about the live model; the family
+    // table only answers a model whose thinking capability came without one.
+    const family = thinking && (vendor === undefined || vendor.values.length === 0) ? reasoningFamily(id) : undefined;
+    const efforts = vendor !== undefined && vendor.values.length > 0 ? vendor.values : family?.efforts ?? [];
+    const defaultEffort = vendor?.default ?? family?.defaultEffort;
+    const contextWindow = extractContextWindow(show);
+    return {
+        id,
+        rawId,
+        name: id,
+        thinking,
+        ...contextWindow === undefined ? {} : { contextWindow },
+        inputModalities: vision ? ['text', 'image'] : ['text'],
+        ...efforts.length === 0 ? {} : {
+            reasoning: {
+                efforts: efforts.map(effort => ({ id: ReasoningEffortId(effort), name: effortDisplayName(effort) })),
+                ...defaultEffort === undefined ? {} : { defaultEffort: ReasoningEffortId(defaultEffort) },
+            },
+        },
+    };
+}
+/**
+ * List Cloud models via `/api/tags`, enriching through `/api/show`. A failed
+ * enrichment degrades to an id-only row; a failed listing fails. Listing ids
+ * are normalized to their wire form ({@link normalizeOllamaModelId}) while
+ * `/api/show` still receives the id the endpoint published.
+ */
+export async function fetchOllamaModels(options) {
+    const fetchFn = options.fetchFn ?? hostFetch;
+    const base = options.baseURL.replace(/\/+$/, '');
+    let tagsResponse;
+    let transportError;
+    // The listing gets two attempts; only transport failures retry.
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            tagsResponse = await fetchFn(`${base}/tags`, {
+                headers: discoveryHeaders(options.apiKey),
+                ...options.signal === undefined ? {} : { signal: options.signal },
+            });
+            transportError = undefined;
+            break;
+        }
+        catch (error) {
+            transportError = error;
+        }
+    }
+    if (tagsResponse === undefined)
+        throw transportError;
+    if (!tagsResponse.ok)
+        throw await httpLlmError(tagsResponse, 'ollama models');
+    const tags = recordOf(await readBoundedJson(tagsResponse, 'ollama models', MAX_DISCOVERY_BYTES));
+    const listed = tags?.['models'];
+    if (!Array.isArray(listed))
+        throw new Error('ollama models endpoint returned no models array');
+    const seen = new Set();
+    const entries = [];
+    for (const entry of listed) {
+        const record = recordOf(entry);
+        const raw = record === undefined
+            ? undefined
+            : typeof record['model'] === 'string' ? record['model'] : typeof record['name'] === 'string' ? record['name'] : undefined;
+        if (raw === undefined || raw.length === 0)
+            continue;
+        const wire = normalizeOllamaModelId(raw, options.baseURL);
+        if (seen.has(wire))
+            continue;
+        seen.add(wire);
+        entries.push({ raw, wire });
+    }
+    if (entries.length === 0)
+        throw new LlmError('ollama models endpoint returned an empty catalog', 'DISCOVERY_FAILED');
+    const out = new Array(entries.length);
+    let cursor = 0;
+    const enrich = async () => {
+        for (;;) {
+            const index = cursor;
+            cursor += 1;
+            if (index >= entries.length)
+                return;
+            const { raw, wire } = entries[index];
+            try {
+                const showResponse = await fetchFn(`${base}/show`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json', ...discoveryHeaders(options.apiKey) },
+                    body: JSON.stringify({ model: raw }),
+                    ...options.signal === undefined ? {} : { signal: options.signal },
+                });
+                if (!showResponse.ok)
+                    throw await httpLlmError(showResponse, 'ollama model details');
+                const show = recordOf(await readBoundedJson(showResponse, 'ollama model details', MAX_DISCOVERY_BYTES));
+                out[index] = show === undefined
+                    ? { id: wire, rawId: raw, name: wire, thinking: false }
+                    : discoveredFromShow(wire, raw, show);
+            }
+            catch {
+                // One model's enrichment never sinks the listing.
+                out[index] = { id: wire, rawId: raw, name: wire, thinking: false };
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(SHOW_CONCURRENCY, entries.length) }, enrich));
+    return out;
+}
+export function ollamaChatRequestBody(options, messages, maxTokens) {
+    return {
+        model: options.model,
+        messages,
+        ...options.tools !== undefined && options.tools.length > 0
+            ? { tools: toChatTools(options.tools), tool_choice: 'auto' }
+            : {},
+        // Ollama takes `max_tokens`. The catalog row supplies the default
+        // (32,768, matching upstream); a row without one rides without it.
+        ...maxTokens !== undefined ? { max_tokens: maxTokens } : {},
+        // `off` rides as `none` (upstream parity); any other effort rides
+        // verbatim. Only advertised efforts ever reach this branch.
+        ...options.reasoningEffort !== undefined
+            ? { reasoning_effort: String(options.reasoningEffort) === 'off' ? 'none' : String(options.reasoningEffort) }
+            : {},
+        stream: true,
+        stream_options: { include_usage: true },
+    };
+}
+export class OllamaAdapter extends LlmAdapter {
+    options;
+    catalogCache = new ModelCatalogCache();
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    /** Drop the discovery snapshot so the next picker pass re-reads the endpoint. */
+    invalidateModels() { this.catalogCache.invalidate(); }
+    rows() {
+        return this.options.catalog().map(entry => {
+            const family = reasoningFamily(entry.id);
+            return {
+                id: entry.id,
+                name: entry.name ?? entry.id,
+                contextWindow: entry.contextWindow ?? OLLAMA_DEFAULT_CONTEXT_WINDOW,
+                contextOverride: entry.contextOverride,
+                maxTokens: entry.maxTokens ?? OLLAMA_DEFAULT_MAX_TOKENS,
+                vision: entry.vision === true,
+                efforts: entry.efforts !== undefined && entry.efforts.length > 0
+                    ? [...entry.efforts]
+                    : [...family?.efforts ?? []],
+                // The family default stays out of the stored row: the resolver's
+                // priority keeps it last, so a vendor change is not held back by
+                // the fallback baked in during construction.
+                defaultEffort: entry.defaultEffort,
+            };
+        });
+    }
+    providerInfo(provider) {
+        return { id: provider, name: 'Ollama Cloud' };
+    }
+    async listModels(provider) {
+        const catalog = this.rows();
+        // No stored model means no catalog: the route ships no built-in rows, so
+        // an empty store hides the picker entry instead of advertising models
+        // the user never adopted.
+        if (catalog.length === 0)
+            return [];
+        // No key means logged out: hide the route instead of advertising
+        // models every request would fail for.
+        const apiKey = await this.options.apiKey();
+        if (apiKey === undefined)
+            return [];
+        if (this.options.discovery === false)
+            return this.staticList(provider, catalog);
+        try {
+            const discovered = await withTimeout(signal => this.catalogCache.get(() => fetchOllamaModels({
+                baseURL: this.options.baseURL(),
+                apiKey,
+                fetchFn: this.options.fetchFn,
+                signal,
+            })), DISCOVERY_TIMEOUT_MS);
+            // A timeout resolves undefined: treat it like any other discovery
+            // miss and serve the stored catalog.
+            if (discovered === undefined)
+                return this.staticList(provider, catalog);
+            // Discovery enriches the stored allowlist but never extends it: the
+            // user adopted an exact catalog, so unmatched discoveries stay out of
+            // the picker.
+            return catalog.map(entry => {
+                const match = discoveredFor(entry.id, discovered);
+                if (match === undefined) {
+                    return {
+                        provider,
+                        id: entry.id,
+                        name: entry.name,
+                        inputModalities: entry.vision ? ['text', 'image'] : ['text'],
+                    };
+                }
+                // The picker keeps the stored friendly name: discovered rows carry
+                // listing ids that would read as a rename every refresh. Discovery
+                // enriches capabilities only.
+                return {
+                    provider,
+                    id: entry.id,
+                    name: entry.name,
+                    inputModalities: match.inputModalities ?? (entry.vision ? ['text', 'image'] : ['text']),
+                };
+            });
+        }
+        catch (error) {
+            if (isDiscoveryAborted(error))
+                throw error;
+            // Keys are stateless, so any other failure falls back to the stored
+            // catalog; a 401 instead hides the route like a logout.
+            if (isMissingOrInvalidCredential(error) || isUnauthorized(error))
+                return [];
+            this.options.onWarn?.(`ollama-cloud model discovery failed; using the stored catalog (${errorChain(error)})`);
+            return this.staticList(provider, catalog);
+        }
+    }
+    staticList(provider, catalog) {
+        return catalog.map(entry => ({
+            provider,
+            id: entry.id,
+            name: entry.name,
+            inputModalities: entry.vision ? ['text', 'image'] : ['text'],
+        }));
+    }
+    async resolveModel(provider, model) {
+        const entry = this.rows().find(row => row.id === model);
+        // The pass-through native behavior is deliberately absent: an
+        // uncatalogued id fails here instead of 404ing at the gateway.
+        if (entry === undefined)
+            throw new LlmError(`ollama-cloud has no configured model "${model}"`, 'UNKNOWN_MODEL');
+        // Discovery carries the key when one exists; keyless endpoints still
+        // list, and no secret rides a metadata fetch it cannot use. The fetch
+        // shares the picker bound so a hung listing cannot stall resolution.
+        const discoveryKey = this.options.discovery === false ? undefined : await this.options.apiKey();
+        const discovered = this.options.discovery === false
+            ? undefined
+            : await withTimeout(signal => this.catalogCache.resolve(() => fetchOllamaModels({
+                baseURL: this.options.baseURL(),
+                apiKey: discoveryKey,
+                fetchFn: this.options.fetchFn,
+                signal,
+            })), DISCOVERY_TIMEOUT_MS).then(models => discoveredFor(model, models ?? undefined), () => undefined);
+        const modalities = discovered?.inputModalities ?? (entry.vision ? ['text', 'image'] : ['text']);
+        const configuredDefault = this.options.defaultEffortOf?.(model) ?? entry.defaultEffort;
+        const reasoning = discovered?.reasoning === undefined
+            ? reasoningFor(entry, configuredDefault)
+            : mergeDiscoveredReasoning(entry, discovered.reasoning, configuredDefault);
+        return {
+            provider,
+            id: model,
+            name: entry.name,
+            inputModalities: [...modalities],
+            context: { contextWindow: effectiveContextWindow(entry, discovered?.contextWindow) },
+            defaultMaxTokens: entry.maxTokens,
+            ...reasoning === undefined ? {} : { reasoning },
+        };
+    }
+    async *stream(options) {
+        const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs ?? 300_000);
+        try {
+            const apiKey = await this.options.apiKey();
+            if (apiKey === undefined)
+                throw new LlmError('ollama-cloud API key is not configured', 'MISSING_CREDENTIAL');
+            const entry = this.rows().find(row => row.id === options.model);
+            if (entry === undefined)
+                throw new LlmError(`ollama-cloud has no configured model "${options.model}"`, 'UNKNOWN_MODEL');
+            const requestMessages = entry.vision ? options.messages : withoutImages(options.messages);
+            const resolved = await resolveImages(requestMessages, this.options.resolveAttachments?.(), watchdog.signal);
+            const body = ollamaChatRequestBody(options, toChatMessages(resolved, options.system), options.maxTokens ?? entry.maxTokens);
+            const chatBase = ollamaChatBaseURL(this.options.baseURL());
+            const fetchFn = this.options.fetchFn ?? hostFetch;
+            const response = await fetchFn(`${chatBase}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'authorization': `Bearer ${apiKey}`,
+                    'accept': 'text/event-stream',
+                    'content-type': 'application/json',
+                    ...attributionHeaders(),
+                },
+                body: JSON.stringify(body),
+                signal: watchdog.signal,
+            });
+            if (!response.ok)
+                throw await httpLlmError(response, 'ollama-cloud API');
+            if (response.body === null) {
+                throw new LlmError('ollama-cloud API returned no response body', EMPTY_RESPONSE_CODE);
+            }
+            const pulse = () => { watchdog.pulse(); };
+            yield* streamChatCompletions(response.body, pulse);
+        }
+        catch (error) {
+            throw mapFetchFailure('ollama-cloud API', error, watchdog, options.signal);
+        }
+        finally {
+            watchdog.stop();
+        }
+    }
+}

package/lib/tools/image-generate.js

@@ -21,6 +21,7 @@ import { AccountTokenManager } from '../providers/accounts.js';
 import { ImageAccountPool } from '../providers/image-pool.js';
 import { codexRateLimitReset } from '../providers/codex.js';
 import { grokRateLimitReset } from '../providers/grok.js';
+import { parseProviderJson } from '../providers/common.js';
 import { hostFetch } from '../http.js';
 /** Endpoint the codex generation request is posted to. */
 export const IMAGE_GENERATE_URL = 'https://chatgpt.com/backend-api/codex/images/generations';
@@ -387,7 +388,7 @@ export function createImageGenerateTool(options) {
                 await manager.session(); // logged out: throws the provider's log-in hint
                 throw new Error('image_generate: no image provider is logged in');
             }
-            const images = parseImageGenerateResponse(await response.json());
+            const images = parseImageGenerateResponse(await parseProviderJson(response, 'image generate'));
             const directory = options.imagesDir ?? imagesDirectory();
             await mkdir(directory, { recursive: true });
             const paths = [];