dsh-subscriptions 0.1.4 → 0.2.0

package/README.md

@@ -13,6 +13,24 @@ reported quota in **Settings → Subscriptions**.
 - **Six subscription model sources:** Connect ChatGPT/Codex, Claude, Grok,
   GitHub Copilot, Google Antigravity, or Cursor and choose their models in
   DSH's picker. These routes use account sign-in, without provider API keys.
+- **Ollama Cloud key route:** Add the `ollama-cloud` route with an
+  `OLLAMA_API_KEY` credential. The route ships no model catalog:
+  configure it on the Settings → Subscriptions card, which fetches the
+  cloud list, ticks the models to keep, and edits each one's display
+  name, order, default reasoning effort, and local context window.
+  The picker shows exactly the ticked list, so an unconfigured route
+  offers no model. The card also edits the base URL, the credential
+  reference, and the web search/fetch switch, and persists them under
+  the DSH home directory. No OAuth sign-in. A hand-written `llm-pi-ai`
+  route with the same id collides with this one: delete the manual
+  block when enabling the plugin route. Stop sequences are unsupported
+  on this route, consistent with the other adapters. Web search/fetch
+  stay off until the card's switch is on (or a profile sets
+  `ollama.web`), so untouched installs keep their existing web
+  provider; a profile still pins them to `ollama-cloud`. Not ported
+  from the standalone plugin: its transient-error reclassification,
+  per-image request quotas, and per-model usage counts. See the
+  [key-route note](.agents/notes/implemented/provider/2026-10-10-ollama-cloud-key-route.md).
 - **Account and model control:** Refresh catalogs and choose visible models.
   For Codex, Claude, Grok, Copilot, and Antigravity, manage multiple accounts
   and same-provider pools. Pools can use available quota to select an account
@@ -20,8 +38,9 @@ reported quota in **Settings → Subscriptions**.
 - **Quota while you work:** See reported usage windows and reset times on
   provider cards and in an optional session-footer pill. The same view reads
   OpenCode Go and Kimi Code usage through keys already configured in
-  **Settings → Models**. Their model routes remain built into DSH. GitHub
-  Copilot has no usage endpoint.
+  **Settings → Models** (their model routes remain built into DSH), and
+  Ollama Cloud usage through its `OLLAMA_API_KEY` credential (its route
+  ships in this plugin). GitHub Copilot has no usage endpoint.
 - **Provider tools:** Use Codex web search, Grok X search, ChatGPT or Grok
   image generation and editing, and Grok video generation when the matching
   provider is enabled.
@@ -60,7 +79,9 @@ in the composer's tool row: Standard or Fast, per session.
 
 **Settings → Subscriptions → provider → Manage** edits account aliases,
 pool participation, model allowlists, and the per-model effort, context,
-and tool settings.
+and tool settings. A context value only lowers the window a session plans
+against, never above what the provider advertises; Codex and Claude support
+it, and it does not enlarge the API's capacity.
 
 ![Model settings](docs/images/model-settings.png)
 
@@ -175,8 +196,8 @@ allowBuilds:
 Restart `dsh web` after installation. Open **Settings → Subscriptions** to
 connect providers, manage accounts and model lists, and inspect available
 quota. The session footer quota pill can be shown or hidden there for the
-current browser. OpenCode Go and Kimi Code cards show usage when their API
-keys are configured in **Settings → Models**.
+current browser. OpenCode Go, Kimi Code, and Ollama Cloud cards show
+usage when their API keys are configured.
 
 To update an installation, run the same `dsh plugin --profile web add` command again and restart `dsh web`.
 
@@ -209,6 +230,11 @@ that a provider still accepts live sign-in or model requests. See
 - **OpenCode Go and Kimi Code:** Live usage responses were verified. Their API
   keys stay on the DSH host; the browser receives configured status and quota
   windows, not the keys.
+- **Ollama Cloud:** Unit and fixture coverage only (chat wire, discovery
+  mapping and wire-id normalization, the settings store and its RPC
+  endpoints, usage parsing, web providers, host E2E fixtures). The card's
+  rendering has no browser test. Live chat, listing, usage, and web calls
+  against `ollama.com` remain to be verified with a real key.
 
 Cursor uses one connected account and a live model catalog. Its model
 visibility selection persists under the DSH home directory, and automatic

package/lib/auth/device-flow.js

@@ -8,6 +8,7 @@
  * engines uniformly.
  */
 import { hostFetch } from '../http.js';
+import { parseProviderJson } from '../providers/common.js';
 /** Default poll interval when the device-code response omits one. */
 const DEFAULT_INTERVAL_SEC = 5;
 /** Default device-code lifetime when the response omits one (GitHub: 15 minutes). */
@@ -77,7 +78,7 @@ export class DeviceFlowManager {
         if (!response.ok) {
             throw new Error(`${provider} device-code request failed (HTTP ${String(response.status)})`);
         }
-        const wire = await response.json();
+        const wire = await parseProviderJson(response, 'device code request');
         if (typeof wire.device_code !== 'string' || wire.device_code.length === 0
             || typeof wire.user_code !== 'string' || wire.user_code.length === 0
             || typeof wire.verification_uri !== 'string' || wire.verification_uri.length === 0) {
@@ -133,7 +134,7 @@ export class DeviceFlowManager {
                     }).toString(),
                     signal: controller.signal,
                 });
-                const result = await pollResponse.json();
+                const result = await parseProviderJson(pollResponse, 'device token poll');
                 if (typeof result.access_token === 'string' && result.access_token.length > 0) {
                     settle(undefined, result.access_token);
                     return;
@@ -152,7 +153,9 @@ export class DeviceFlowManager {
                         settle(new Error('the device code expired before authorization completed'));
                         return;
                     default:
-                        settle(new Error(`${provider} device-flow polling failed: ${result.error_description ?? result.error ?? `HTTP ${String(pollResponse.status)}`}`));
+                        // Safe means this failure path carries no provider-controlled free text,
+                        // not that no secret can exist elsewhere in the system.
+                        settle(new Error(`${provider} device-flow polling failed (HTTP ${String(pollResponse.status)}): [provider response body omitted]`));
                         return;
                 }
             }

package/lib/auth/oauth-flow.js

@@ -12,6 +12,38 @@ export const DEFAULT_FLOW_TIMEOUT_MS = 180_000;
 const SUCCESS_PAGE = '<!doctype html><html><head><meta charset="utf-8"><title>Login successful</title></head>'
     + '<body style="font-family:sans-serif"><h1>Login successful</h1>'
     + '<p>You can close this tab and return to DeepSeek Harness.</p></body></html>';
+function authorizationFailure(error) {
+    // Safe means this failure path carries no provider-controlled free text,
+    // not that no secret can exist elsewhere in the system.
+    // RFC 6749 §4.1.2.1 categories select local literals, never provider prose.
+    let category;
+    switch (error) {
+        case 'invalid_request':
+            category = 'invalid_request';
+            break;
+        case 'unauthorized_client':
+            category = 'unauthorized_client';
+            break;
+        case 'access_denied':
+            category = 'access_denied';
+            break;
+        case 'unsupported_response_type':
+            category = 'unsupported_response_type';
+            break;
+        case 'invalid_scope':
+            category = 'invalid_scope';
+            break;
+        case 'server_error':
+            category = 'server_error';
+            break;
+        case 'temporarily_unavailable':
+            category = 'temporarily_unavailable';
+            break;
+    }
+    return 'authorization failed'
+        + (category === undefined ? '' : ` (${category})`)
+        + ': [provider message omitted]';
+}
 function failurePage(detail) {
     return '<!doctype html><html><head><meta charset="utf-8"><title>Login failed</title></head>'
         + `<body style="font-family:sans-serif"><h1>Login failed</h1><p>${detail.replace(/[<>&]/g, '')}</p></body></html>`;
@@ -138,19 +170,20 @@ export class OAuthFlowManager {
                 response.end('not found');
                 return;
             }
-            const errorDescription = url.searchParams.get('error_description') ?? url.searchParams.get('error');
-            if (errorDescription !== null) {
-                response.writeHead(200, { 'content-type': 'text/html' });
-                response.end(failurePage(errorDescription));
-                settle(new Error(`authorization failed: ${errorDescription}`));
-                return;
-            }
             if (url.searchParams.get('state') !== input.state) {
-                // A stray or replayed redirect must not kill the real attempt.
+                // A stray or replayed redirect must not kill the real attempt, even on error.
+                // RFC 6749 §4.1.2.1 requires errors to echo the state sent in the request.
                 response.writeHead(400, { 'content-type': 'text/plain' });
                 response.end('state mismatch');
                 return;
             }
+            if (url.searchParams.has('error_description') || url.searchParams.has('error')) {
+                const detail = authorizationFailure(url.searchParams.get('error'));
+                response.writeHead(200, { 'content-type': 'text/html' });
+                response.end(failurePage(detail));
+                settle(new Error(detail));
+                return;
+            }
             const code = url.searchParams.get('code');
             if (code === null || code.length === 0) {
                 response.writeHead(400, { 'content-type': 'text/plain' });

package/lib/auth/rpc.d.ts

@@ -23,7 +23,7 @@ export declare const SUBSCRIPTIONS_AUTH_PREFIX = "subscriptions-auth.";
  * Every endpoint {@link dispatch} answers; each gets one exact Fetch route.
  * Kept in one place so the route table and the switch cannot drift apart.
  */
-export declare const SUBSCRIPTIONS_AUTH_ENDPOINTS: readonly ["providerSettings", "setProviderSettings", "status", "login", "manual", "cancel", "logout", "setDefault", "usage", "externalStatus", "externalUsage", "cursorStatus", "cursorLogin", "cursorCancel", "cursorLogout", "cursorUsage", "cursorModels", "cursorSettings", "cursorSetSettings", "image", "video", "prepareReset", "consumeReset", "speed", "setSpeed", "modelDefaults", "setModelDefault"];
+export declare const SUBSCRIPTIONS_AUTH_ENDPOINTS: readonly ["providerSettings", "setProviderSettings", "status", "login", "manual", "cancel", "logout", "setDefault", "usage", "externalStatus", "externalUsage", "cursorStatus", "cursorLogin", "cursorCancel", "cursorLogout", "cursorUsage", "cursorModels", "cursorSettings", "cursorSetSettings", "ollamaSettings", "ollamaSetSettings", "ollamaModels", "image", "video", "prepareReset", "consumeReset", "speed", "setSpeed", "modelDefaults", "setModelDefault"];
 /** Decoded image bytes returned by the `image` endpoint. */
 export interface ImageBytesResult {
     mediaType: string;
@@ -201,11 +201,82 @@ export interface CursorRpcController {
     settings(force: boolean, signal: AbortSignal): Promise<unknown>;
     setSettings(input: unknown): Promise<void>;
 }
+/** One model in the Ollama Cloud picker catalog, with its capability flags. */
+export interface OllamaModelView {
+    id: string;
+    name: string;
+    /** The endpoint advertised the `vision` capability. */
+    vision: boolean;
+    /** The endpoint advertised the `thinking` capability. */
+    thinking: boolean;
+    contextWindow?: number;
+    /** Advertised reasoning levels, when the model reasons. */
+    efforts?: {
+        id: string;
+        name: string;
+    }[];
+    /** The level preselected for the model, when one is known. */
+    defaultEffort?: string;
+}
+/** One candidate returned by the cloud listing; adopting it stores `id`. */
+export interface OllamaCloudCandidate {
+    /** Normalized wire id, e.g. `glm-5.3:cloud`. */
+    id: string;
+    /** The id exactly as the listing published it, e.g. `glm-5.3`. */
+    rawId: string;
+    /** Display basename for the checkbox row. */
+    name: string;
+    vision: boolean;
+    thinking: boolean;
+    contextWindow?: number;
+    efforts: string[];
+    defaultEffort?: string;
+}
+/**
+ * What the Ollama card renders: the stored overrides, the effective values
+ * after config/default fallback, and the catalog the picker serves.
+ */
+export interface OllamaSettingsView {
+    provider: 'ollama-cloud';
+    /** The stored document; absent fields mean "no override". */
+    settings: unknown;
+    effective: {
+        baseURL: string;
+        apiKeyRef: string;
+        web: boolean;
+    };
+    /** The effective catalog, in picker order (empty hides the picker entry). */
+    models: OllamaModelView[];
+    /** A non-empty `config.ollama.models` wins over the store, so card edits are inert. */
+    configOverridesModels: boolean;
+}
+/** Ollama Cloud catalog and connection settings; the API key stays in DSH credentials. */
+export interface OllamaRpcController {
+    settings(): Promise<OllamaSettingsView>;
+    /** Validate and persist the store document, then re-announce the route. */
+    setSettings(input: unknown): Promise<void>;
+    /**
+     * List the endpoint's Cloud models for the adoption checklist.
+     * @param input - an optional one-time API key and base URL override; the
+     *   key is used for this listing only and never persisted.
+     * @param signal - caller cancellation from the RPC transport.
+     */
+    models(input: {
+        apiKey?: string;
+        baseURL?: string;
+    }, signal: AbortSignal): Promise<{
+        models: OllamaCloudCandidate[];
+    }>;
+}
 /**
  * Register the `/subscriptions-auth` RPC channel when a host connection exists.
  * @param ctx - the plugin context (headless profiles have no `connection`).
  * @param controller - the auth operations backing the endpoints.
  * @param speed - the per-session speed-tier state backing the Speed toggle.
  * @param modelDefaults - optional per-model default-effort state backing `modelDefaults`/`setModelDefault`.
+ * @param providerSettings - optional OAuth provider/account preferences.
+ * @param externalUsage - optional credential-backed quota readers.
+ * @param cursor - optional Cursor account and model-visibility actions.
+ * @param ollama - optional Ollama Cloud catalog and connection settings.
  */
-export declare function registerAuthRpc(ctx: Context, controller: AuthController, speed: SpeedController, modelDefaults?: ModelDefaultsController | undefined, providerSettings?: ProviderSettingsController | undefined, externalUsage?: ExternalUsageRpcController | undefined, cursor?: CursorRpcController | undefined): void;
+export declare function registerAuthRpc(ctx: Context, controller: AuthController, speed: SpeedController, modelDefaults?: ModelDefaultsController | undefined, providerSettings?: ProviderSettingsController | undefined, externalUsage?: ExternalUsageRpcController | undefined, cursor?: CursorRpcController | undefined, ollama?: OllamaRpcController | undefined): void;

package/lib/auth/rpc.js

@@ -9,6 +9,7 @@
 import { AttachmentId } from '@deepseek-ai/dsh-attachment';
 import { PROVIDER_IDS } from './store.js';
 import { EXTERNAL_USAGE_SOURCES } from '../providers/external-usage-controller.js';
+import { validateOllamaBaseURL } from '../providers/ollama-settings.js';
 /**
  * Endpoint-name prefix under the shared `/api` channel: endpoint `status`
  * is served at `/api/subscriptions-auth.status`. The browser half calls
@@ -25,6 +26,7 @@ export const SUBSCRIPTIONS_AUTH_ENDPOINTS = [
     'externalStatus', 'externalUsage',
     'cursorStatus', 'cursorLogin', 'cursorCancel', 'cursorLogout', 'cursorUsage', 'cursorModels',
     'cursorSettings', 'cursorSetSettings',
+    'ollamaSettings', 'ollamaSetSettings', 'ollamaModels',
     'image', 'video', 'prepareReset', 'consumeReset',
     'speed', 'setSpeed',
     'modelDefaults', 'setModelDefault',
@@ -121,6 +123,18 @@ function readString(payload, field) {
     }
     return value;
 }
+/** Read a field that may be omitted, rejecting an empty or non-string value. */
+function readOptionalString(payload, field) {
+    if (typeof payload !== 'object' || payload === null)
+        throw new BadRequest('payload must be an object');
+    const value = payload[field];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new BadRequest(`payload.${field} must be a non-empty string when present`);
+    }
+    return value;
+}
 /** Validate the `setModelDefault` endpoint's payload. */
 function readModelDefaultInput(payload) {
     const provider = readProvider(payload);
@@ -222,7 +236,7 @@ function readSessionId(payload) {
         throw new BadRequest('payload must be an object');
     return readString(payload, 'sessionId');
 }
-async function dispatch(controller, speed, modelDefaults, endpoint, payload, signal, providerSettings, externalUsage, cursor) {
+async function dispatch(controller, speed, modelDefaults, endpoint, payload, signal, providerSettings, externalUsage, cursor, ollama) {
     switch (endpoint) {
         case 'providerSettings':
             if (!providerSettings)
@@ -322,6 +336,38 @@ async function dispatch(controller, speed, modelDefaults, endpoint, payload, sig
                 throw new BadRequest('payload must be an object');
             await cursor.setSettings(payload.settings);
             return ok({ ok: true });
+        case 'ollamaSettings':
+            if (!ollama)
+                throw new BadRequest('Ollama settings are unavailable');
+            return ok(await ollama.settings());
+        case 'ollamaSetSettings':
+            if (!ollama)
+                throw new BadRequest('Ollama settings are unavailable');
+            if (payload === null || typeof payload !== 'object')
+                throw new BadRequest('payload must be an object');
+            await ollama.setSettings(payload.settings);
+            return ok({ ok: true });
+        case 'ollamaModels': {
+            if (!ollama)
+                throw new BadRequest('Ollama settings are unavailable');
+            const apiKey = readOptionalString(payload, 'apiKey');
+            const rawBaseURL = readOptionalString(payload, 'baseURL');
+            let baseURL;
+            if (rawBaseURL !== undefined) {
+                // The listing may run against a not-yet-saved draft address, so it
+                // passes the same URL check the store applies.
+                try {
+                    baseURL = validateOllamaBaseURL(rawBaseURL);
+                }
+                catch (error) {
+                    throw new BadRequest(error instanceof Error ? error.message : String(error));
+                }
+            }
+            return ok(await ollama.models({
+                ...apiKey === undefined ? {} : { apiKey },
+                ...baseURL === undefined ? {} : { baseURL },
+            }, signal));
+        }
         case 'prepareReset':
             if (!controller.prepareReset)
                 throw new BadRequest('Reset redemption unavailable');
@@ -363,8 +409,12 @@ async function dispatch(controller, speed, modelDefaults, endpoint, payload, sig
  * @param controller - the auth operations backing the endpoints.
  * @param speed - the per-session speed-tier state backing the Speed toggle.
  * @param modelDefaults - optional per-model default-effort state backing `modelDefaults`/`setModelDefault`.
+ * @param providerSettings - optional OAuth provider/account preferences.
+ * @param externalUsage - optional credential-backed quota readers.
+ * @param cursor - optional Cursor account and model-visibility actions.
+ * @param ollama - optional Ollama Cloud catalog and connection settings.
  */
-export function registerAuthRpc(ctx, controller, speed, modelDefaults = undefined, providerSettings = undefined, externalUsage = undefined, cursor = undefined) {
+export function registerAuthRpc(ctx, controller, speed, modelDefaults = undefined, providerSettings = undefined, externalUsage = undefined, cursor = undefined, ollama = undefined) {
     // `connection` is not in this plugin's inject list (headless compositions
     // lack it), so its startup order is unconstrained: defer registration until
     // the service exists instead of probing once at apply time.
@@ -381,7 +431,7 @@ export function registerAuthRpc(ctx, controller, speed, modelDefaults = undefine
         const connection = ctx.get('connection');
         const handler = async (endpoint, payload, signal) => {
             try {
-                return await dispatch(controller, speed, modelDefaults, endpoint, payload, signal, providerSettings, externalUsage, cursor);
+                return await dispatch(controller, speed, modelDefaults, endpoint, payload, signal, providerSettings, externalUsage, cursor, ollama);
             }
             catch (error) {
                 return failure(error);

package/lib/client/ExternalUsageCards.js

@@ -77,7 +77,7 @@ export function ExternalUsageCards({ rpc, t }) {
             const snapshot = usage[id];
             return _jsxs("div", { style: styles.card, children: [_jsxs("div", { style: styles.header, children: [_jsx("span", { style: { ...styles.dot, background: configured
                                         ? 'var(--dsw-alias-state-success-primary)' : 'var(--dsw-alias-label-dimmed)' } }), _jsx("span", { style: styles.name, children: name })] }), !(status === undefined && statusError !== undefined) && _jsx("p", { style: styles.status, children: status === undefined ? t('checking')
-                            : configured ? t('externalUsageConnected') : t('externalUsageNotConfigured') }), statusError !== undefined && _jsx("p", { style: styles.error, children: t('externalUsageUnavailable', { message: statusError }) }), status !== undefined && !configured && _jsx("p", { style: styles.status, children: t('externalUsageConfigure', { ref }) }), configured && _jsxs("div", { style: styles.account, children: [_jsxs("div", { style: styles.accountHeader, children: [_jsx("span", { style: styles.defaultStar, title: t('defaultBadge'), children: "\u2605" }), _jsx("span", { style: styles.accountName, children: t('externalUsageApiKey') })] }), _jsxs("div", { style: styles.usage, children: [_jsxs("div", { style: styles.usageHeader, children: [_jsx("span", { style: styles.usageTitle, children: t('usageTitle') }), snapshot?.plan !== undefined && _jsx("span", { style: styles.usagePlan, children: t('usagePlan', { plan: snapshot.plan }) }), _jsx("button", { type: "button", style: styles.usageRefresh, disabled: loading[id] === true, onClick: () => { void refresh(id); }, children: t('usageRefresh') })] }), loading[id] === true && snapshot === undefined && _jsx("p", { style: styles.status, children: t('usageLoading') }), errors[id] !== undefined && _jsx("p", { style: styles.error, children: t('usageError', { message: errors[id] }) }), snapshot?.windows?.length === 0 && _jsx("p", { style: styles.status, children: t('usageEmpty') }), snapshot?.windows?.map((window, index) => {
+                            : configured ? t('externalUsageConnected') : t('externalUsageNotConfigured') }), statusError !== undefined && _jsx("p", { style: styles.error, children: t('externalUsageUnavailable', { message: statusError }) }), status !== undefined && !configured && _jsx("p", { style: styles.status, children: t('externalUsageConfigure', { ref }) }), configured && _jsxs("div", { style: styles.account, children: [_jsxs("div", { style: styles.accountHeader, children: [_jsx("span", { style: styles.defaultStar, title: t('defaultBadge'), children: "\u2605" }), _jsx("span", { style: styles.accountName, children: t('externalUsageApiKey') })] }), _jsxs("div", { style: styles.usage, children: [_jsxs("div", { style: styles.usageHeader, children: [_jsx("span", { style: styles.usageTitle, children: t('usageTitle') }), snapshot?.plan !== undefined && _jsx("span", { style: styles.usagePlan, children: t('usagePlan', { plan: snapshot.plan }) }), _jsx("button", { type: "button", style: styles.usageRefresh, disabled: loading[id] === true, onClick: () => { void refresh(id); }, children: t('usageRefresh') })] }), loading[id] === true && snapshot === undefined && _jsx("p", { style: styles.status, children: t('usageLoading') }), errors[id] !== undefined && _jsx("p", { style: styles.error, children: t('usageError', { message: errors[id] }) }), snapshot !== undefined && snapshot.supported === false && _jsx("p", { style: styles.status, children: t('usageUnsupported') }), snapshot?.windows?.length === 0 && _jsx("p", { style: styles.status, children: t('usageEmpty') }), snapshot?.windows?.map((window, index) => {
                                         const percent = displayUsedPercent(window.usedPercent);
                                         const label = externalUsageWindowLabel(t, window);
                                         return _jsxs("div", { style: styles.usageRow, children: [_jsxs("div", { style: styles.usageMeta, children: [_jsx("span", { children: label }), _jsxs("span", { children: [percent === undefined ? t('usageMeterInvalid') : `${percent}%`, window.resetsAt === undefined ? ''

package/lib/client/OllamaCard.d.ts

@@ -0,0 +1,13 @@
+import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
+import type { SubscriptionsSectionInjected } from './SubscriptionsSection.js';
+type Translate = SubscriptionsSectionInjected['t'];
+/**
+ * Ollama Cloud route card: the catalog the model picker shows, the web
+ * capability toggle, and the API-key usage row. The settings dialog owns
+ * every write; the card only reads, so a save is reflected by re-reading.
+ */
+export declare function OllamaCard({ rpc, t }: {
+    rpc: ConnectionHandle['rpc'];
+    t: Translate;
+}): import("react").JSX.Element;
+export {};

package/lib/client/OllamaCard.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from 'react';
+import { callSubscriptionsAuth } from './subscriptions-rpc.js';
+import { externalUsageWindowLabel } from './ExternalUsageCards.js';
+import { OllamaSettingsManager } from './OllamaSettingsManager.js';
+import { USAGE_BADGE_REFRESH_EVENT } from './usage-badge-preferences.js';
+import { subscriptionCardStyles as styles } from './subscription-card-styles.js';
+import { UsageMeter } from './UsageMeter.js';
+import { displayUsedPercent } from './usage-pace.js';
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Ollama Cloud route card: the catalog the model picker shows, the web
+ * capability toggle, and the API-key usage row. The settings dialog owns
+ * every write; the card only reads, so a save is reflected by re-reading.
+ */
+export function OllamaCard({ rpc, t }) {
+    const [view, setView] = useState();
+    const [configured, setConfigured] = useState();
+    const [usage, setUsage] = useState();
+    const [observedAt, setObservedAt] = useState();
+    const [usageStale, setUsageStale] = useState(false);
+    const [loading, setLoading] = useState(false);
+    // Two failure surfaces: the card's own load and the usage lookup. They
+    // render in different places so a stale usage reading cannot masquerade as
+    // a settings failure.
+    const [statusError, setStatusError] = useState();
+    const [usageError, setUsageError] = useState();
+    const [manage, setManage] = useState(false);
+    const refreshUsage = useCallback(async () => {
+        setLoading(true);
+        try {
+            const value = await callSubscriptionsAuth(rpc, 'externalUsage', { source: 'ollama-cloud' });
+            setUsage(value);
+            // Prefer the server's observation time; a cached reading must not look fresh.
+            setObservedAt(value.observedAt ?? Date.now());
+            setUsageStale(value.stale === true);
+            setUsageError(undefined);
+            window.dispatchEvent(new Event(USAGE_BADGE_REFRESH_EVENT));
+        }
+        catch (failure) {
+            setUsageError(message(failure));
+            setUsageStale(true);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [rpc]);
+    const refreshStatus = useCallback(async () => {
+        try {
+            const [settings, status] = await Promise.all([
+                callSubscriptionsAuth(rpc, 'ollamaSettings', {}),
+                callSubscriptionsAuth(rpc, 'externalStatus', {}),
+            ]);
+            setView(settings);
+            setStatusError(undefined);
+            const isConfigured = status['ollama-cloud']?.configured === true;
+            setConfigured(isConfigured);
+            if (isConfigured)
+                void refreshUsage();
+        }
+        catch (failure) {
+            setStatusError(message(failure));
+        }
+    }, [rpc, refreshUsage]);
+    useEffect(() => { void refreshStatus(); }, [refreshStatus]);
+    return _jsxs("div", { style: styles.card, children: [_jsxs("div", { style: styles.header, children: [_jsx("span", { style: { ...styles.dot, background: configured === true
+                                ? 'var(--dsw-alias-state-success-primary)' : 'var(--dsw-alias-label-dimmed)' } }), _jsx("span", { style: styles.name, children: t('ollamaTitle') })] }), _jsx("p", { style: styles.status, children: view === undefined ? t('checking')
+                    : view.models.length > 0 ? t('ollamaStatus', { count: view.models.length }) : t('ollamaStatusNone') }), view !== undefined && _jsx("p", { style: styles.status, children: view.effective.web ? t('ollamaWebOn') : t('ollamaWebOff') }), statusError !== undefined && _jsx("p", { style: styles.error, children: t('ollamaModelsLoadFailed', { message: statusError }) }), view !== undefined && configured === false && _jsx("p", { style: styles.status, children: t('ollamaConfigureHint', { ref: view.effective.apiKeyRef }) }), configured === true && _jsxs("div", { style: styles.account, children: [_jsxs("div", { style: styles.accountHeader, children: [_jsx("span", { style: styles.defaultStar, title: t('defaultBadge'), children: "\u2605" }), _jsx("span", { style: styles.accountName, children: t('externalUsageApiKey') })] }), _jsxs("div", { style: styles.usage, children: [_jsxs("div", { style: styles.usageHeader, children: [_jsx("span", { style: styles.usageTitle, children: t('usageTitle') }), usage?.plan !== undefined && _jsx("span", { style: styles.usagePlan, children: t('usagePlan', { plan: usage.plan }) }), _jsx("button", { type: "button", style: styles.usageRefresh, disabled: loading, onClick: () => { void refreshUsage(); }, children: t('usageRefresh') })] }), loading && usage === undefined && _jsx("p", { style: styles.status, children: t('usageLoading') }), usageError !== undefined && _jsx("p", { style: styles.error, children: t('usageError', { message: usageError }) }), usage !== undefined && usage.supported === false && _jsx("p", { style: styles.status, children: t('usageUnsupported') }), usage?.windows?.length === 0 && _jsx("p", { style: styles.status, children: t('usageEmpty') }), usage?.windows?.map((window, index) => {
+                                const percent = displayUsedPercent(window.usedPercent);
+                                const label = externalUsageWindowLabel(t, window);
+                                return _jsxs("div", { style: styles.usageRow, children: [_jsxs("div", { style: styles.usageMeta, children: [_jsx("span", { children: label }), _jsxs("span", { children: [percent === undefined ? t('usageMeterInvalid') : `${percent}%`, window.resetsAt === undefined ? ''
+                                                            : ` · ${t('usageResets', { date: new Date(window.resetsAt).toLocaleString() })}`] })] }), _jsx(UsageMeter, { window: window, t: t, observedAt: observedAt, stale: usageStale })] }, index);
+                            })] })] }), view?.configOverridesModels === true && _jsx("p", { style: styles.status, children: t('ollamaCatalogOverride') }), _jsxs("div", { style: styles.actions, children: [_jsx("button", { type: "button", style: styles.button, "aria-haspopup": "dialog", onClick: () => setManage(true), children: t('accountsManage') }), configured !== true && _jsx("button", { type: "button", style: styles.button, onClick: () => { void refreshStatus(); }, children: t('usageRefresh') })] }), manage && _jsx(OllamaSettingsManager, { rpc: rpc, t: t, onClose: () => setManage(false), onSaved: () => { void refreshStatus(); } })] });
+}

package/lib/client/OllamaSettingsManager.d.ts

@@ -0,0 +1,24 @@
+import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
+import type { SubscriptionsSectionInjected } from './SubscriptionsSection.js';
+type Translate = SubscriptionsSectionInjected['t'];
+interface Props {
+    rpc: ConnectionHandle['rpc'];
+    t: Translate;
+    onClose: () => void;
+    /** Called after a successful save or reset, so the card re-reads its status. */
+    onSaved: () => void;
+}
+/**
+ * Ollama Cloud settings dialog. It owns one draft (model list, web toggle,
+ * base URL and credential reference) that Save writes in a single
+ * `ollamaSetSettings` call, so a failure keeps every edit. Fetching the cloud
+ * catalog is a read-only side trip, and a key typed for the fetch never
+ * leaves this component. The model list follows the shared model editor: a
+ * filter, select all/none over the filtered rows, and one checkbox per
+ * model, where ticking edits the draft and enables Save. Ollama adds what the
+ * shared editor lacks: a display name, ordering, and a local context window.
+ * Unticking keeps the row's full settings in a dialog-local stash, so ticking
+ * it again restores them even when the cloud listing no longer returns it.
+ */
+export declare function OllamaSettingsManager({ rpc, t, onClose, onSaved }: Props): import("react").JSX.Element;
+export {};