dsh-subscriptions 0.1.5 → 0.2.0

package/lib/provider-settings.d.ts

@@ -32,7 +32,8 @@ export declare class ProviderSettingsStore {
     constructor(path?: string);
     get(provider: ProviderId): ProviderPreferences;
     visible(provider: ProviderId, model: string): boolean;
-    contextWindow(model: string): number | undefined;
+    /** The user's local context-window override for one model; absent follows the provider. */
+    contextWindow(model: string, provider?: ProviderId): number | undefined;
     /** Creation-time policy survives restarts and never changes an existing session. */
     toolEnabled(provider: ProviderId, tool: SubscriptionTool, createdAt?: number): boolean;
     set(provider: ProviderId, input: unknown): Promise<void>;

package/lib/provider-settings.js

@@ -51,8 +51,9 @@ export function validatePreferences(provider, input) {
         result.visibleModels = [...new Set(raw.visibleModels)];
     }
     if (raw.contextWindows !== undefined) {
-        if (provider !== 'codex')
-            throw new Error('context window overrides are currently supported only for Codex');
+        if (provider !== 'codex' && provider !== 'claude') {
+            throw new Error('context window overrides are supported only for Codex and Claude');
+        }
         if (!raw.contextWindows || typeof raw.contextWindows !== 'object' || Array.isArray(raw.contextWindows)) {
             throw new Error('contextWindows must be a model-to-token map');
         }
@@ -110,8 +111,9 @@ export class ProviderSettingsStore {
     visible(provider, model) {
         return this.current.providers[provider]?.visibleModels?.includes(model) ?? true;
     }
-    contextWindow(model) {
-        const windows = this.current.providers.codex?.contextWindows;
+    /** The user's local context-window override for one model; absent follows the provider. */
+    contextWindow(model, provider = 'codex') {
+        const windows = this.current.providers[provider]?.contextWindows;
         return windows && Object.hasOwn(windows, model) ? windows[model] : undefined;
     }
     /** Creation-time policy survives restarts and never changes an existing session. */

package/lib/providers/claude.d.ts

@@ -127,6 +127,12 @@ export interface ClaudeAdapterOptions {
      * the provider's own default.
      */
     defaultEffortOf?: (model: string) => string | undefined;
+    /**
+     * The user's local context-window override for one model (the Settings
+     * editor). Returns undefined to follow the advertised window. The result
+     * is capped at that window: Anthropic advertises no separate maximum.
+     */
+    contextWindowOf?: (model: string) => number | undefined;
     /** Resolves the Claude Code version to present (npm-backed); absent means the local floor. */
     resolveCliVersion?: () => Promise<string>;
     /** Cache breakpoint lifetime; absent means the API's five-minute default. */
@@ -183,7 +189,14 @@ export declare class ClaudeAdapter extends LlmAdapter {
     listOwnModels(provider: string, account?: string, signal?: AbortSignal): Promise<readonly LlmModelInfo[]>;
     resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
     /** Capability resolution of the provider's own models (the pool resolves members here). */
-    resolveOwnModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    resolveOwnModel(provider: string, model: string, account?: string): Promise<LlmResolvedModelInfo>;
+    /** The advertised window is both the default and the ceiling for a local override. */
+    private contextLimitsFor;
+    /** Account-specific bounds the Settings editor shows next to a model's override input. */
+    contextLimits(model: string, account?: string): Promise<{
+        default: number;
+        max: number;
+    }>;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
     /** Pool seam: stream through one specific account instead of the default. */
     streamAccount(options: GenerateOptions, account: string): AsyncIterable<StreamChunk>;

package/lib/providers/claude.js

@@ -600,10 +600,14 @@ export class ClaudeAdapter extends LlmAdapter {
         }
         return cache;
     }
-    async discovered(model) {
+    async discovered(model, account) {
         if (!this.options.discovery)
             return undefined;
-        const accounts = (await this.options.tokens.list()).map(entry => entry.key);
+        // A named account is looked up alone: its window must not be borrowed
+        // from another account's catalog.
+        const accounts = account === undefined
+            ? (await this.options.tokens.list()).map(entry => entry.key)
+            : [account];
         return discoverAcrossAccounts(accounts, async (account) => {
             const catalog = await this.catalogFor(account);
             const models = await catalog.resolve(() => this.fetchCatalog(account));
@@ -674,22 +678,30 @@ export class ClaudeAdapter extends LlmAdapter {
         return this.resolveOwnModel(provider, model);
     }
     /** Capability resolution of the provider's own models (the pool resolves members here). */
-    async resolveOwnModel(provider, model) {
-        const disc = await this.discovered(model);
+    async resolveOwnModel(provider, model, account) {
+        const disc = await this.discovered(model, account);
         const configured = this.options.models.find(entry => entry.id === model);
+        const limits = this.contextLimitsFor(disc, configured);
         const reasoning = mergeReasoning(this.options.defaultEffortOf?.(model), disc?.reasoning);
         return {
             provider,
             id: model,
             name: disc?.name ?? configured?.name ?? model,
             inputModalities: configured?.inputModalities ?? CLAUDE_MODALITIES,
-            context: {
-                contextWindow: disc?.contextWindow ?? configured?.contextWindow ?? CLAUDE_CONTEXT_WINDOW,
-            },
+            context: { contextWindow: Math.min(this.options.contextWindowOf?.(model) ?? limits.default, limits.max) },
             defaultMaxTokens: claudeMaxTokens(configured, disc),
             ...(reasoning === undefined ? {} : { reasoning }),
         };
     }
+    /** The advertised window is both the default and the ceiling for a local override. */
+    contextLimitsFor(disc, configured) {
+        const advertised = disc?.contextWindow ?? configured?.contextWindow ?? CLAUDE_CONTEXT_WINDOW;
+        return { default: advertised, max: advertised };
+    }
+    /** Account-specific bounds the Settings editor shows next to a model's override input. */
+    async contextLimits(model, account) {
+        return this.contextLimitsFor(await this.discovered(model, account), this.options.models.find(entry => entry.id === model));
+    }
     async *stream(options) {
         const pool = this.options.pool?.();
         if (pool !== undefined && await pool.owns(options.provider, options.model)) {

package/lib/providers/common.d.ts

@@ -46,6 +46,13 @@ export declare function validateModels(models: readonly ModelEntry[], label: str
  * @throws SyntaxError with the local origin and a fixed omission marker.
  */
 export declare function parseProviderJson<T = unknown>(input: Response | string, origin: string): Promise<T>;
+/**
+ * Read a bounded JSON body; oversized or malformed payloads fail loudly.
+ * Bytes accumulate per chunk and the stream is cancelled past the cap, so
+ * the bound limits memory even when the body has no end; a declared
+ * over-cap `content-length` fails before the first read.
+ */
+export declare function readBoundedJson(response: Response, label: string, maxBytes: number): Promise<unknown>;
 /** Optional per-call hooks {@link httpLlmError} uses to read a rate-limit window. */
 export interface HttpLlmErrorOptions {
     /**
@@ -212,6 +219,13 @@ export interface UsageWindow {
     windowDurationMs?: number;
     /** Provider-verified fixed interval; permits deriving start from end and duration. */
     fixedWindow?: boolean;
+    /**
+     * Display-only start the reader assumed (kind or label based, clamped
+     * to now). The time marker may ride it; pace and color must never —
+     * it is not evidence of when the window opened. Mutually exclusive
+     * with `startsAt`.
+     */
+    displayStartsAt?: number;
 }
 /** One banked reset credit (Codex), or one grant containing resets (Claude). */
 export interface ResetCredit {

package/lib/providers/common.js

@@ -83,6 +83,54 @@ export async function parseProviderJson(input, origin) {
         throw new SyntaxError(providerDiagnostic(`${origin}: invalid JSON`, true));
     }
 }
+/**
+ * Read a bounded JSON body; oversized or malformed payloads fail loudly.
+ * Bytes accumulate per chunk and the stream is cancelled past the cap, so
+ * the bound limits memory even when the body has no end; a declared
+ * over-cap `content-length` fails before the first read.
+ */
+export async function readBoundedJson(response, label, maxBytes) {
+    const declared = Number(response.headers.get('content-length'));
+    if (Number.isFinite(declared) && declared > maxBytes) {
+        // Stop the socket too: the headers arrived, but the body must never flow.
+        await response.body?.cancel().catch(() => undefined);
+        throw new Error(`${label} response exceeds ${String(maxBytes)} bytes`);
+    }
+    if (response.body === null)
+        throw new Error(`${label} response has no body`);
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let bytes = 0;
+    let text = '';
+    try {
+        for (;;) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            bytes += chunk.value.byteLength;
+            if (bytes > maxBytes) {
+                // Cancel before throwing so the live stream does not linger behind
+                // a rejection the caller already stopped listening to.
+                await reader.cancel().catch(() => undefined);
+                throw new Error(`${label} response exceeds ${String(maxBytes)} bytes`);
+            }
+            text += decoder.decode(chunk.value, { stream: true });
+        }
+        text += decoder.decode();
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch { /* best effort */ }
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`${label} response is not JSON`);
+    }
+}
 /**
  * Build an LlmError from a non-2xx provider response, mapping the status to a
  * stable code and, for a rate-limited request, the disclosed reset instant to

package/lib/providers/external-usage-controller.d.ts

@@ -1,6 +1,6 @@
 import type { ProviderUsage } from './common.js';
 /** Usage-only sources whose model routes are supplied by the DSH base install. */
-export type ExternalUsageSource = 'opencode-go' | 'kimi-code' | 'minimax' | 'minimax-cn';
+export type ExternalUsageSource = 'opencode-go' | 'kimi-code' | 'minimax' | 'minimax-cn' | 'ollama-cloud';
 export declare const EXTERNAL_USAGE_SOURCES: readonly ExternalUsageSource[];
 export interface ExternalUsageStatus {
     configured: boolean;
@@ -8,11 +8,18 @@ export interface ExternalUsageStatus {
 type ResolveCredential = (name: string) => Promise<{
     value: string;
 } | undefined>;
+/**
+ * A setting the controller reads per call. The function form keeps the Ollama
+ * reference and base URL live: the Settings card can change them after the
+ * controller was constructed.
+ */
+type LiveValue = string | (() => string);
 export declare class ExternalUsageController {
     private readonly resolveCredential;
     private readonly http;
     private readonly refs;
-    constructor(resolveCredential: ResolveCredential, http?: typeof fetch, refs?: Partial<Record<ExternalUsageSource, string>>);
+    private readonly ollamaBaseURL;
+    constructor(resolveCredential: ResolveCredential, http?: typeof fetch, refs?: Partial<Record<ExternalUsageSource, LiveValue>>, ollamaBaseURL?: LiveValue);
     status(): Promise<Record<ExternalUsageSource, ExternalUsageStatus>>;
     usage(source: ExternalUsageSource, signal?: AbortSignal): Promise<ProviderUsage>;
 }

package/lib/providers/external-usage-controller.js

@@ -1,35 +1,49 @@
 import { fetchMiniMaxUsage } from './minimax-usage.js';
-import { fetchKimiCodeUsage, fetchOpenCodeGoUsage } from './external-usage.js';
-export const EXTERNAL_USAGE_SOURCES = ['opencode-go', 'kimi-code', 'minimax', 'minimax-cn'];
+import { fetchKimiCodeUsage, fetchOllamaUsage, fetchOpenCodeGoUsage } from './external-usage.js';
+import { DEFAULT_OLLAMA_API_KEY_REF, DEFAULT_OLLAMA_BASE_URL } from './ollama.js';
+export const EXTERNAL_USAGE_SOURCES = ['opencode-go', 'kimi-code', 'minimax', 'minimax-cn', 'ollama-cloud'];
+function valueOf(value) {
+    return typeof value === 'function' ? value() : value;
+}
 const DEFAULT_REFS = {
     'opencode-go': 'OPENCODE_GO_API_KEY',
     'kimi-code': 'KIMI_CODING_API_KEY',
     'minimax': 'MINIMAX_API_KEY',
     'minimax-cn': 'MINIMAX_CN_API_KEY',
+    'ollama-cloud': DEFAULT_OLLAMA_API_KEY_REF,
 };
 export class ExternalUsageController {
     resolveCredential;
     http;
     refs;
-    constructor(resolveCredential, http = fetch, refs = {}) {
+    ollamaBaseURL;
+    constructor(resolveCredential, http = fetch, refs = {}, ollamaBaseURL = DEFAULT_OLLAMA_BASE_URL) {
         this.resolveCredential = resolveCredential;
         this.http = http;
         this.refs = { ...DEFAULT_REFS, ...refs };
+        this.ollamaBaseURL = ollamaBaseURL;
     }
     async status() {
         const values = await Promise.all(EXTERNAL_USAGE_SOURCES.map(async (source) => {
-            const value = await this.resolveCredential(this.refs[source]);
+            const value = await this.resolveCredential(valueOf(this.refs[source]));
             return typeof value?.value === 'string' && value.value.length > 0;
         }));
         return Object.fromEntries(EXTERNAL_USAGE_SOURCES.map((source, i) => [source, { configured: values[i] ?? false }]));
     }
     async usage(source, signal) {
-        const credential = await this.resolveCredential(this.refs[source]);
+        // Snapshot the endpoint facts before the first await: a save that
+        // switches the ref or host mid-flight must not send the old
+        // reference's key to the new host.
+        const ref = valueOf(this.refs[source]);
+        const ollamaBase = valueOf(this.ollamaBaseURL);
+        const credential = await this.resolveCredential(ref);
         if (credential?.value === undefined || credential.value.length === 0) {
             throw new Error(`${source} API key is not configured`);
         }
         if (source === 'minimax' || source === 'minimax-cn')
             return fetchMiniMaxUsage(credential.value, source === 'minimax-cn' ? 'cn' : 'global', this.http, signal);
+        if (source === 'ollama-cloud')
+            return fetchOllamaUsage(credential.value, ollamaBase, this.http, signal);
         return source === 'opencode-go'
             ? fetchOpenCodeGoUsage(credential.value, this.http, signal)
             : fetchKimiCodeUsage(credential.value, this.http, signal);

package/lib/providers/external-usage.d.ts

@@ -5,4 +5,12 @@ type HttpFetch = typeof fetch;
 export declare function fetchOpenCodeGoUsage(apiKey: string, http?: HttpFetch, signal?: AbortSignal): Promise<ProviderUsage>;
 /** Read official CLI count windows and retain compatibility with older ratio pools. */
 export declare function fetchKimiCodeUsage(apiKey: string, http?: HttpFetch, signal?: AbortSignal): Promise<ProviderUsage>;
+/**
+ * Read Ollama Cloud quota from `GET {base}/balance`. The Cloud has no
+ * `limits` object: quota is the included allowance against its remaining
+ * balance (`included.allowance_usd`, `included.balance_usd`) over the
+ * reported period. A 404 means a self-hosted endpoint without the
+ * surface: not an error, the card renders an unsupported note instead.
+ */
+export declare function fetchOllamaUsage(apiKey: string, baseURL: string, http?: HttpFetch, signal?: AbortSignal): Promise<ProviderUsage>;
 export {};

package/lib/providers/external-usage.js

@@ -1,5 +1,6 @@
 /** Usage readers for subscriptions whose model adapters are built into DSH. */
-import { parseProviderJson } from './common.js';
+import { attributionHeaders } from '@deepseek-ai/dsh-llm';
+import { parseProviderJson, readBoundedJson } from './common.js';
 function numeric(value) {
     const n = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
     return typeof n === 'number' && Number.isFinite(n) ? n : undefined;
@@ -59,6 +60,12 @@ export async function fetchOpenCodeGoUsage(apiKey, http = fetch, signal) {
         if (usedPercent === undefined)
             continue;
         const resetsAt = resetTime(value?.resetsAt);
+        // Monthly has no interval fields. Both key providers' monthly pools
+        // read the same display assumption: a 30-day span back from the
+        // reset, clamped to now. Only the marker may ride it — pace never.
+        const monthlyDisplay = field === 'monthly' && resetsAt !== undefined
+            ? { displayStartsAt: Math.min(resetsAt - 30 * 86_400_000, Date.now()) }
+            : {};
         windows.push({
             kind,
             ...(scope === undefined ? {} : { scope }),
@@ -67,6 +74,7 @@ export async function fetchOpenCodeGoUsage(apiKey, http = fetch, signal) {
             ...(field === 'rolling' ? { fixedWindow: true, windowDurationMs: 18_000_000 }
                 : field === 'weekly' ? { fixedWindow: true, windowDurationMs: 604_800_000 } : {}),
             ...(resetsAt === undefined ? {} : { resetsAt }),
+            ...monthlyDisplay,
         });
     }
     if (windows.length === 0)
@@ -79,11 +87,13 @@ export async function fetchKimiCodeUsage(apiKey, http = fetch, signal) {
     if (body === undefined)
         throw new Error('Kimi Code usage response is not an object');
     const modern = [];
+    // Only the top-level `usage` object is the summary the official CLI labels
+    // "Weekly limit"; an anonymous `limits[]` entry is "Limit #n" there.
     const rows = [
-        ...(record(body.usage) ? [{ detail: body.usage }] : []),
-        ...(Array.isArray(body.limits) ? body.limits : []),
+        ...(record(body.usage) ? [{ raw: { detail: body.usage }, summary: true }] : []),
+        ...(Array.isArray(body.limits) ? body.limits.map(raw => ({ raw, summary: false })) : []),
     ];
-    for (const raw of rows) {
+    for (const { raw, summary } of rows) {
         const item = record(raw);
         if (!item)
             continue;
@@ -103,16 +113,34 @@ export async function fetchKimiCodeUsage(apiKey, http = fetch, signal) {
             : unit.includes('DAY') ? 86_400_000 : unit.includes('SECOND') ? 1000 : undefined;
         const durationMs = duration === undefined || duration <= 0 || multiplier === undefined
             ? undefined : duration * multiplier;
-        const kind = durationMs === 18_000_000 ? 'session' : durationMs === 604_800_000 ? 'weekly' : 'other';
+        const kind = durationMs === 18_000_000 ? 'session'
+            : durationMs === 604_800_000 ? 'weekly'
+                // No period fields at all: the official CLI labels the top-level
+                // summary the weekly limit, so use that kind rather than 'other'.
+                : durationMs === undefined && unit === '' ? 'weekly' : 'other';
         const resetsAt = kimiReset(detail);
         const scope = detail.name ?? detail.title ?? item.name ?? item.title;
+        // A vendor-declared span anchors the display marker at
+        // min(reset − span, now); pace stays unverified (rolling semantics
+        // are not established), so the assumed instant rides displayStartsAt.
+        // The top-level summary without a usable period (absent, zero, or no
+        // unit) is read as the weekly limit (above), so its marker assumes seven
+        // days. The official CLI
+        // gives only the label, not a span; the span rests on a live account
+        // whose summary reset matched `usages.limit_7d` to within a second.
+        // An anonymous `limits[]` entry gets no such assumption. Display only.
+        const markerSpan = durationMs ?? (summary && kind === 'weekly' ? 604_800_000 : undefined);
+        const displayStart = resetsAt !== undefined && markerSpan !== undefined
+            ? { displayStartsAt: Math.min(resetsAt - markerSpan, Date.now()) }
+            : {};
         modern.push({ kind, usedPercent,
             ...(typeof scope === 'string' ? { scope } : {}),
             ...(resetsAt === undefined ? {} : { resetsAt }),
             ...(durationMs === undefined ? {} : { windowDurationMs: durationMs }),
-            // Legacy weekly plans reset as whole seven-day buckets; five-hour semantics
-            // are documented as rolling, so no fixed-window assertion is made there.
-            ...(kind === 'weekly' ? { fixedWindow: true } : {}),
+            // A whole seven-day bucket reset, not a rolling span, only where the
+            // endpoint actually said 7 DAY.
+            ...(durationMs === 604_800_000 ? { fixedWindow: true } : {}),
+            ...displayStart,
         });
     }
     if (modern.length)
@@ -131,13 +159,69 @@ export async function fetchKimiCodeUsage(apiKey, http = fetch, signal) {
         if (typeof ratio !== 'number' || !Number.isFinite(ratio) || ratio < 0 || ratio > 1)
             continue;
         const resetsAt = resetTime(value?.reset_time ?? value?.resetAt);
+        // The monthly total resets on the subscription's cycle, not the
+        // calendar month; the display marker assumes ~30 days back. It only
+        // moves the marker — pace never rides it.
+        const monthlyDisplay = field === 'limit_month_total' && resetsAt !== undefined
+            ? { displayStartsAt: Math.min(resetsAt - 30 * 86_400_000, Date.now()) }
+            : {};
         windows.push({
             kind,
             ...(scope === undefined ? {} : { scope }),
             usedPercent: ratio * 100,
             ...(field === 'limit_7d' ? { fixedWindow: true, windowDurationMs: 604_800_000 } : {}),
             ...(resetsAt === undefined ? {} : { resetsAt }),
+            ...monthlyDisplay,
         });
     }
     return { supported: true, windows, plan: 'Kimi Code' };
 }
+/**
+ * Read Ollama Cloud quota from `GET {base}/balance`. The Cloud has no
+ * `limits` object: quota is the included allowance against its remaining
+ * balance (`included.allowance_usd`, `included.balance_usd`) over the
+ * reported period. A 404 means a self-hosted endpoint without the
+ * surface: not an error, the card renders an unsupported note instead.
+ */
+export async function fetchOllamaUsage(apiKey, baseURL, http = fetch, signal) {
+    const combined = signal === undefined
+        ? AbortSignal.timeout(15_000)
+        : AbortSignal.any([AbortSignal.timeout(15_000), signal]);
+    const response = await http(`${baseURL.replace(/\/+$/, '')}/balance`, {
+        headers: {
+            accept: 'application/json',
+            authorization: `Bearer ${apiKey}`,
+            ...attributionHeaders(),
+        },
+        redirect: 'error',
+        signal: combined,
+    });
+    if (signal?.aborted)
+        throw signal.reason;
+    if (response.status === 404)
+        return { supported: false };
+    if (!response.ok)
+        throw new Error(`Usage endpoint returned HTTP ${response.status}`);
+    const body = record(await readBoundedJson(response, 'usage', 1 * 1024 * 1024));
+    const included = record(body?.included);
+    const allowance = numeric(included?.allowance_usd);
+    const balance = numeric(included?.balance_usd);
+    if (included === undefined || allowance === undefined || allowance <= 0 || balance === undefined) {
+        throw new Error('Ollama balance response has no usable included allowance');
+    }
+    const period = record(included.period);
+    const resetsAt = period === undefined ? undefined : resetTime(period.until);
+    const startsAt = period === undefined ? undefined : resetTime(period.from);
+    return {
+        supported: true,
+        windows: [{
+                kind: 'other',
+                scope: 'Credits',
+                // An overdrawn balance stays visible instead of dropping the window.
+                usedPercent: (allowance - balance) / allowance * 100,
+                ...(resetsAt === undefined ? {} : { resetsAt }),
+                ...(startsAt === undefined ? {} : { startsAt }),
+            }],
+        plan: 'Ollama Cloud',
+    };
+}

package/lib/providers/ollama-settings.d.ts

@@ -0,0 +1,90 @@
+/**
+ * One model the Ollama Cloud route serves. The route ships no catalog of its
+ * own: this list is the catalog, in the order the picker shows it. Adoption
+ * fills the capability fields from the endpoint's `/api/tags` + `/api/show`
+ * reply; every field except `id` is optional so a hand-written row still
+ * works.
+ */
+export interface OllamaModelSetting {
+    /** Wire model id; must be non-empty and unique within the list. */
+    id: string;
+    /** Selector label; defaults to the id. */
+    name?: string;
+    /** Known combined request/response context capacity in tokens. */
+    contextWindow?: number;
+    /**
+     * The user's local context-window choice. Unlike `contextWindow`, which
+     * snapshots what the endpoint advertised, this records only an explicit
+     * edit: absent follows the endpoint. The runtime caps it at the advertised
+     * window and it never widens the API's real capacity.
+     */
+    contextOverride?: number;
+    /** Per-request output cap; defaults to the route's fallback. */
+    maxTokens?: number;
+    /** The endpoint advertised the `vision` capability. */
+    vision?: boolean;
+    /** The endpoint advertised the `thinking` capability. */
+    thinking?: boolean;
+    /** Advertised reasoning efforts, in picker order; empty means non-reasoning. */
+    efforts?: string[];
+    /** Effort preselected when the session picks none; must be one of `efforts`. */
+    defaultEffort?: string;
+}
+/**
+ * Durable, non-secret Ollama Cloud configuration. Every field is optional and
+ * its absence means "no override": the effective value then falls back to the
+ * plugin config and, last, to the built-in default. The API key itself never
+ * appears here; `apiKeyRef` only names a DSH credential.
+ */
+export interface OllamaSettings {
+    /** The route's catalog, in picker order. `[]` hides every model. */
+    models?: OllamaModelSetting[];
+    /** Register the web search/fetch providers; the config value is the default. */
+    web?: boolean;
+    /** Native base URL; the config value is the default. */
+    baseURL?: string;
+    /** Credential reference naming the API key; the config value is the default. */
+    apiKeyRef?: string;
+}
+/**
+ * Accept only an absolute http(s) base URL with no credentials, query, or
+ * fragment, and return its trimmed form. The route appends `/tags`, `/show`,
+ * and `/v1/chat/completions` to this value, so anything else would build a URL
+ * that cannot work — and a non-official host receives the referenced
+ * credential, which the dialog tells the user.
+ * @param value - the candidate URL.
+ * @returns the trimmed URL to store.
+ * @throws when the value is not a usable absolute http(s) URL.
+ */
+export declare function validateOllamaBaseURL(value: unknown): string;
+/**
+ * Validate one settings document, dropping unknown keys and duplicate model
+ * ids (first wins, matching the Cursor store's visible-model handling).
+ * @param input - the parsed store document or an RPC payload.
+ * @throws when a known field has the wrong type or an unusable value.
+ */
+export declare function validateOllamaSettings(input: unknown): OllamaSettings;
+/**
+ * Durable Ollama Cloud configuration under the DSH home directory. Writes are
+ * serialized and atomic (temp file with mode 0600, then rename), so a crash
+ * never leaves a half-written document and a concurrent writer cannot lose an
+ * earlier save.
+ */
+export declare class OllamaSettingsStore {
+    readonly path: string;
+    private readonly onCorrupt?;
+    private current;
+    private writes;
+    /** Set when the stored file existed but was unreadable or invalid. */
+    private corrupt;
+    constructor(path?: string, onCorrupt?: ((message: string) => void) | undefined);
+    /** Why the stored file is ignored, when it is. */
+    corruption(): string | undefined;
+    get(): OllamaSettings;
+    /** The stored catalog, or `undefined` when the store carries no override. */
+    models(): readonly OllamaModelSetting[] | undefined;
+    web(): boolean | undefined;
+    baseURL(): string | undefined;
+    apiKeyRef(): string | undefined;
+    set(input: unknown): Promise<void>;
+}