dsh-subscriptions 0.1.5 → 0.2.2

package/lib/providers/ollama.js

@@ -0,0 +1,608 @@
+/**
+ * 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/providers/pool-family.js

@@ -30,14 +30,22 @@ export function buildAccountPools(sources) {
                     entry = { members: [], info: model };
                     byModel.set(model.id, entry);
                 }
-                entry.members.push({ provider, account: catalog.account, model: model.id });
+                entry.members.push({
+                    provider,
+                    account: catalog.account,
+                    model: model.id,
+                });
             }
         }
         for (const [id, { members, info }] of byModel) {
             pools.set(poolKey(provider, id), {
                 members,
-                ...info.name === undefined || info.name === id ? {} : { name: info.name },
-                ...info.description === undefined ? {} : { description: info.description },
+                ...(info.name === undefined || info.name === id
+                    ? {}
+                    : { name: info.name }),
+                ...(info.description === undefined
+                    ? {}
+                    : { description: info.description }),
             });
         }
     }