pi-ollama-cloud 0.12.2 → 0.13.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.13.0] - 2026-10-07
+
+- Fix the usage command and status bar after Ollama moved quota data to `/api/balance`, supporting both legacy remaining-percentage windows and the included-balance allowance shape. Show allowance renewal dates and purchased credits when returned, and optionally display request totals from the documented `/api/usage` histogram endpoint.
+
+## [0.12.3] - 2026-10-06
+
+- Keep the usage indicator accurate when turning it off or switching providers, and show clearer errors for connection problems and invalid responses.
+- Hide unsupported reasoning controls on affected gpt-oss models and limit disk space used by web-tool caching.
+- Keep Ollama Cloud models compatible with Pi 1.0.
+- Allow model-limit updates to use the API key configured in Pi, with `OLLAMA_API_KEY` as a fallback.
+- Run the test suite successfully before publishing a release.
+
 ## [0.12.2] - 2026-09-27
 
 - Refresh the model catalog for the September 25, 2026 retirements (`deepseek-v4-flash:0731`, `glm-5.1`, `qwen3.5:397b`): dropped from the generated catalog and pricing, 20 -> 17 models. Recommended replacements per Ollama: `deepseek-v4.1-flash`, `glm-5.3`, and `glm-5.3-flash` / `deepseek-v4.1-flash`.

package/README.md

@@ -134,11 +134,11 @@ Model metadata is derived from the `/api/show` response:
 | `reasoning` | `capabilities` includes `"thinking"` |
 | `thinkingLevelMap` | [`thinking-levels.ts`](thinking-levels.ts) + [`reasoning.generated.ts`](reasoning.generated.ts) (models.dev reasoning options), with an `off` override table for models that ignore `none` |
 | `input` | `["text", "image"]` if `capabilities` includes `"vision"`, else `["text"]` |
-| `contextWindow` | `model_info.*.context_length` (falls back to 128000) |
-| `maxTokens` | Probed per-model limits from [`limits.generated.ts`](limits.generated.ts), generated by `scripts/generate-limits.ts` (requires `OLLAMA_API_KEY`). Models without a probed limit fall back to 32768. |
+| `contextWindow` | Positive integer `model_info.*.context_length` (falls back to 128000 when missing or invalid) |
+| `maxTokens` | Probed per-model limits from [`limits.generated.ts`](limits.generated.ts), generated by `scripts/generate-limits.ts` (reads the Ollama Cloud API key from Pi's `auth.json` or `OLLAMA_API_KEY`). Models without a probed limit fall back to 32768. |
 | `cost` | Official per-1M-token prices from the [ollama.com/pricing](https://ollama.com/pricing) model table, generated by `scripts/generate-pricing.ts` into `pricing.generated.ts`. Ollama Cloud is subscription-billed, so these are equivalent pay-as-you-go rates, not actual charges. Catalog IDs with no matching pricing row default to zero. Prices are pinned to the installed package version and only update on a new release, so newly added models register with zero cost until then. |
 
-The per-model max output token table (`limits.generated.ts`) is probed against the live API by `scripts/generate-limits.ts`, since `/api/show` does not expose the limit. It needs an API key: `OLLAMA_API_KEY=<key> npm run generate-limits`. Limits ship with the package, so regenerated values take effect on the next release.
+The per-model max output token table (`limits.generated.ts`) is probed against the live API by `scripts/generate-limits.ts`, since `/api/show` does not expose the limit. The script uses the `ollama-cloud` API key in Pi's `auth.json`, falling back to `OLLAMA_API_KEY`; run `npm run generate-limits` (optionally followed by a model ID to probe only that model). Limits ship with the package, so regenerated values take effect on the next release.
 
 The API itself returns no cost data: completion responses report only token counts (`prompt_tokens`/`completion_tokens`/`total_tokens`, including the final usage chunk when streaming), and `/api/show` exposes no pricing fields. The prices above come from the static `/pricing` page table and are only as fresh as the last regeneration.
 
@@ -167,7 +167,7 @@ Both tools cache results on disk (under the pi agent home, `~/.pi/agent/cache/pi
 
 - Successful searches and pages: cached for 24h
 - Failed page fetches: negative-cached for 15 min, so retrying a dead page does not re-call the API. Auth (401/403), rate-limit (429), transport (timeouts, aborts, network errors), and server (5xx) failures are not cached — fixing the key, waiting out the limit, or a transient blip lets a retry through immediately
-- Expired entries are pruned on write and the cache is capped at 500 entries per kind (searches/pages), evicting the oldest first. This bounds entry count, not file size: full page and search content can still make `cache.json` large, and loading it parses the whole file
+- Expired entries are pruned on write; the cache is capped at 500 entries per kind (searches/pages), 256 KiB per serialized entry (including its key), and 8 MiB for the complete serialized file. Oldest entries are evicted first to meet the limits. Oversized content remains available for the current call but is not persisted, so a later paging/expand request may fetch it again
 - The cache file is written with `0600` permissions. It stores full page content and raw URLs, which can embed credentials in query strings — avoid fetching URLs that carry secrets in the query string, or set a custom `PI_OLLAMA_SEARCH_CACHE_PATH`
 - Concurrent pi processes share the cache file on a last-writer-wins basis (no cross-process locking): one process's save can drop another's fresh entries, at the cost of a redundant API call
 - `refresh=true` on either tool bypasses the cache (including a cached failure) and re-calls the API; the fresh result replaces the cache entry
@@ -206,18 +206,20 @@ A failed fetch throws a diagnostic message (likely cause + next steps) instead o
 | Command | Description |
 |---|---|
 | `/ollama-webtools [on\|off\|enable\|disable]` | Enable or disable the `ollama_web_search` and `ollama_web_fetch` tools. Toggles if no argument given. |
-| `/ollama-cloud-usage` | Show Ollama Cloud usage limits (one section per limit bucket the API reports), per-model request counts, and the 4-week activity cost. |
+| `/ollama-cloud-usage` | Show included quota or balance, billing-period renewal date when available, purchased credits, and request totals when the histogram endpoint is available. |
 | `/ollama-usage-status [on\|off\|enable\|disable]` | Enable or disable the footer usage status bar. Toggles if no argument given. |
 
 ## Usage status bar
 
 While an `ollama-cloud` model is the active provider, the footer shows a compact
-live usage readout with one segment per limit bucket the API reports
-(`5h ▕███░░░░░░░▏ 34% 7d ▕█░░░░░░░░░▏ 7%`, or a single `30d` segment) that
-refreshes every 5 minutes and after each agent turn (but no more often than every 5 minutes). It is colored by how close
-it is to the cap: green below 60%, yellow at 60-79%, red at 80%+. It reads the
-same undocumented `/api/usage` endpoint as `/ollama-cloud-usage` and clears
-itself on transient errors or when you switch to a non-Ollama-Cloud provider.
+live quota readout. It displays one segment per legacy quota window when those
+are returned, or a `plan` segment derived from the included balance and
+allowance. For example, `$55.50` remaining of a `$60.00` allowance displays as
+`plan ▕░░░░░░░░░░▏ 7%`. The bar refreshes every 5 minutes and after an agent turn (no more
+often than every 5 minutes). It is colored by usage: green below 60%, yellow
+at 60-79%, and red at 80% or above. Quota comes from the documented
+[`/api/balance` endpoint](https://docs.ollama.com/api/balance); transient errors
+or switching providers clear the status.
 
 It is off by default. Enable it at runtime with `/ollama-usage-status on`, or
 enable it by default with `"usageStatus": true` in `ollama-cloud.json`. If the
@@ -226,8 +228,8 @@ underlying error (e.g. a misconfigured API key).
 
 The quota-bar concept is inspired by
 [`@entelligentsia/pi-ollama-cloud-usage-tracker`](https://github.com/Entelligentsia/pi-ollama-cloud-usage-tracker),
-but this extension fetches usage from the `/api/usage` endpoint with the API key
-it already resolves, rather than scraping the settings page with Chrome cookies.
+but this extension fetches quota from `/api/balance` with the API key it already
+resolves, rather than scraping the settings page with Chrome cookies.
 
 ## Usage API for custom status bars
 
@@ -236,18 +238,19 @@ status bar instead of (or alongside) the built-in one. The relevant modules ship
 with the package and are importable directly:
 
 ```ts
-import { fetchUsage, formatUsage, formatUsageStatusColored } from "pi-ollama-cloud/usage.ts";
+import { fetchUsage, fetchUsageStats, formatUsage, formatUsageStatusColored } from "pi-ollama-cloud/usage.ts";
 import { getCloudApiKey } from "pi-ollama-cloud/utils.ts";
 import type { UsageData } from "pi-ollama-cloud/usage.ts";
 ```
 
 | Export | Description |
 |---|---|
-| `fetchUsage(apiKey, signal?)` | Fetch the raw `/api/usage` data, returning a typed `UsageData`. Throws a status-mapped error on 401/403/429/404/5xx. |
+| `fetchUsage(apiKey, signal?)` | Fetch quota from the documented [`/api/balance` endpoint](https://docs.ollama.com/api/balance), including legacy windows or the allowance-based billing-period shape. `UsageData.included.period.until` contains the renewal boundary when provided. |
 | `formatUsageStatusColored(theme, data)` | One-line status string with quota bars, colored by usage level. Takes a `Theme` (e.g. `ctx.ui.theme`). |
-| `formatUsage(data)` | Multi-line human-readable output (percentages, per-model request counts, activity cost). |
+| `fetchUsageStats(apiKey, range?, signal?)` | Fetch request histogram data from the documented [`/api/usage` endpoint](https://docs.ollama.com/api/cloud-usage), limited to 10 requests per minute per user. |
+| `formatUsage(data, stats?)` | Multi-line quota and billing-period output, with request totals when stats are provided. |
 | `getCloudApiKey(ctx)` | Resolve the Ollama Cloud API key the same way the extension does. |
-| `isUsageResponse(data)` / `isUsageLimit(data)` | Validators for parsing the raw response yourself. |
+| `isUsageResponse(data)` / `isUsageStats(data)` | Validators for parsing the raw responses yourself. |
 
 Example custom status bar:
 
@@ -268,7 +271,7 @@ npm run check        # lint + format + type-check (auto-fix)
 npm run lint         # lint only (no fixes)
 npm run typecheck    # type-check only (tsgo --noEmit)
 npm run format       # format only
-OLLAMA_API_KEY=<key> npm run generate-limits   # probe max output tokens (writes limits.generated.ts)
+npm run generate-limits                         # probe max output tokens using auth.json or OLLAMA_API_KEY (writes limits.generated.ts)
 ```
 
 The project uses [Biome](https://biomejs.dev/) for linting and formatting (2-space indent, line width 120) and [tsgo](https://github.com/microsoft/typescript-go) for type-checking.
@@ -325,20 +328,24 @@ The `-e`/`--extension` flag loads the extension from the local checkout without
 
 ## Releasing
 
-Publishing a new version to npm is a two-command process:
+Publishing a new version to npm is a three-step process:
 
 ```bash
-# 1. Bump version and create a git tag in one step
+# 1. Commit and push main, then wait for the Test workflow to go green
+#    (gh run watch, or the Actions tab). CI must be green before tagging.
+# 2. Bump version and create a git tag in one step
 npm version minor   # or patch, or major
-# 2. Push the tag to trigger the GitHub Actions publish workflow
+# 3. Push the tag to trigger the GitHub Actions publish workflow
 git push --tags
 ```
 
+The publish workflow gates on CI: its `await-tests` job polls the check runs on the tagged commit and only proceeds if the Test workflow completed successfully on that exact commit (it fails closed after a timeout if the commit was never tested, e.g. a tag on a commit that is not on `main`).
+
 Because the model catalog refreshes automatically at runtime, a release is **not** needed to ship new models. Publish only when:
 
 - A model is retired and still listed by the API: add it to `RETIRED_MODEL_IDS` in `scripts/generate-models.ts` (check https://docs.ollama.com/cloud#retirements, then regenerate `models.generated.ts`).
 - Pricing changes: Ollama updates the model pricing table, or a new model needs a pricing row (regenerate `pricing.generated.ts`).
-- Max output token limits changed: run `OLLAMA_API_KEY=<key> npm run generate-limits` locally and commit.
+- Max output token limits changed: run `npm run generate-limits` locally (uses Pi's `auth.json` or `OLLAMA_API_KEY`) and commit.
 
 The tag version must match the version in `package.json` - `npm version` handles this automatically. The workflow at `.github/workflows/publish.yml` verifies the match before publishing to npm.
 

package/cache.ts

@@ -10,6 +10,10 @@ export const CACHE_TTL_MS = envInt("PI_OLLAMA_SEARCH_TTL_HOURS", 24) * 60 * 60 *
 export const FAIL_TTL_MS = envInt("PI_OLLAMA_SEARCH_FAIL_TTL_MINUTES", 15) * 60 * 1000;
 /** Max entries per map (searches/pages); oldest-ts entries are evicted beyond this. */
 export const MAX_ENTRIES = envInt("PI_OLLAMA_SEARCH_MAX_ENTRIES", 500);
+/** Maximum serialized UTF-8 size for one persisted entry, including its key. */
+export const MAX_PERSISTED_ENTRY_BYTES = 256 * 1024;
+/** Maximum serialized UTF-8 size of the complete persisted cache file. */
+export const MAX_CACHE_BYTES = 8 * 1024 * 1024;
 
 export interface SearchResult {
   title: string;
@@ -43,6 +47,8 @@ interface CacheOptions {
   ttlMs: number;
   failTtlMs: number;
   maxEntries: number;
+  maxPersistedEntryBytes: number;
+  maxCacheBytes: number;
 }
 
 function isRecord(v: unknown): v is Record<string, unknown> {
@@ -69,6 +75,14 @@ function isSearchEntry(v: unknown): v is SearchCacheEntry {
   );
 }
 
+function normalizeSearchEntry(entry: SearchCacheEntry): SearchCacheEntry {
+  return {
+    ts: entry.ts,
+    q: entry.q,
+    results: entry.results.map(({ title, url, content }) => ({ title, url, content })),
+  };
+}
+
 function isPageEntry(v: unknown): v is PageCacheEntry {
   if (!isRecord(v) || typeof v.ts !== "number") return false;
   const fieldsValid =
@@ -89,6 +103,17 @@ function isPageEntry(v: unknown): v is PageCacheEntry {
   );
 }
 
+function normalizePageEntry(entry: PageCacheEntry): PageCacheEntry {
+  const normalized: PageCacheEntry = { ts: entry.ts };
+  if (entry.status !== undefined) normalized.status = entry.status;
+  if (entry.title !== undefined) normalized.title = entry.title;
+  if (entry.content !== undefined) normalized.content = entry.content;
+  if (entry.links !== undefined) normalized.links = entry.links;
+  if (entry.error !== undefined) normalized.error = entry.error;
+  if (entry.errorType !== undefined) normalized.errorType = entry.errorType;
+  return normalized;
+}
+
 export interface CacheStore {
   loadCache(): CacheData;
   saveCache(): void;
@@ -100,6 +125,8 @@ export function createCache(options: Partial<CacheOptions> = {}): CacheStore {
   const ttlMs = options.ttlMs ?? CACHE_TTL_MS;
   const failTtlMs = options.failTtlMs ?? FAIL_TTL_MS;
   const maxEntries = options.maxEntries ?? MAX_ENTRIES;
+  const maxPersistedEntryBytes = options.maxPersistedEntryBytes ?? MAX_PERSISTED_ENTRY_BYTES;
+  const maxCacheBytes = options.maxCacheBytes ?? MAX_CACHE_BYTES;
   let cacheData: CacheData | null = null;
 
   function loadCache(): CacheData {
@@ -111,10 +138,10 @@ export function createCache(options: Partial<CacheOptions> = {}): CacheStore {
         // file degrades to "those entries are gone" instead of crashing calls.
         cacheData = { searches: {}, pages: {} };
         for (const [key, entry] of Object.entries(raw.searches)) {
-          if (isSafeKey(key) && isSearchEntry(entry)) cacheData.searches[key] = entry;
+          if (isSafeKey(key) && isSearchEntry(entry)) cacheData.searches[key] = normalizeSearchEntry(entry);
         }
         for (const [key, entry] of Object.entries(raw.pages)) {
-          if (isSafeKey(key) && isPageEntry(entry)) cacheData.pages[key] = entry;
+          if (isSafeKey(key) && isPageEntry(entry)) cacheData.pages[key] = normalizePageEntry(entry);
         }
         return cacheData;
       }
@@ -139,14 +166,66 @@ export function createCache(options: Partial<CacheOptions> = {}): CacheStore {
     for (const key of overflow) delete map[key];
   }
 
+  function serializedEntrySize(
+    key: string,
+    entry: SearchCacheEntry | PageCacheEntry,
+  ): {
+    entryBytes: number;
+    propertyBytes: number;
+  } {
+    // The one-property object includes the JSON-escaped cache key and braces.
+    // Removing only those two braces yields the exact property size in a map.
+    const onePropertyObject = JSON.stringify({ [key]: entry });
+    const entryBytes = Buffer.byteLength(onePropertyObject);
+    return { entryBytes, propertyBytes: entryBytes - 2 };
+  }
+
   function saveCache(): void {
     const data = loadCache();
     for (const [key, entry] of Object.entries(data.searches)) if (!isFresh(entry)) delete data.searches[key];
     for (const [key, entry] of Object.entries(data.pages)) if (!isFresh(entry)) delete data.pages[key];
-    // TTL bounds entry age; the cap bounds entry count so an aggressive session
-    // cannot grow the file without limit.
+    // Prune stale and over-count entries before applying serialized-byte limits.
     evictOldest(data.searches);
     evictOldest(data.pages);
+
+    const persistedData: CacheData = { searches: { ...data.searches }, pages: { ...data.pages } };
+    const searches = Object.entries(persistedData.searches).map(([key, entry]) => ({
+      ...serializedEntrySize(key, entry),
+      key,
+      entry,
+      map: persistedData.searches,
+    }));
+    const pages = Object.entries(persistedData.pages).map(([key, entry]) => ({
+      ...serializedEntrySize(key, entry),
+      key,
+      entry,
+      map: persistedData.pages,
+    }));
+    const entries = [...searches, ...pages];
+    for (const item of entries) {
+      if (item.entryBytes > maxPersistedEntryBytes) delete item.map[item.key];
+    }
+
+    function serializedCacheSize(): number {
+      let bytes = Buffer.byteLength('{"searches":{},"pages":{}}');
+      for (const mapEntries of [searches, pages]) {
+        const persistedEntries = mapEntries.filter((item) => item.map[item.key] !== undefined);
+        if (persistedEntries.length === 0) continue;
+        // The empty-map braces are already included in the base size.
+        bytes += persistedEntries.reduce((total, item) => total + item.propertyBytes, 0);
+        bytes += persistedEntries.length - 1;
+      }
+      return bytes;
+    }
+
+    let persistedBytes = serializedCacheSize();
+    const oldestFirst = entries.sort((a, b) => a.entry.ts - b.entry.ts);
+    for (const item of oldestFirst) {
+      if (persistedBytes <= maxCacheBytes) break;
+      if (item.map[item.key] === undefined) continue;
+      delete item.map[item.key];
+      persistedBytes = serializedCacheSize();
+    }
     try {
       mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
       // Use a unique temporary path so concurrent processes cannot overwrite
@@ -155,7 +234,7 @@ export function createCache(options: Partial<CacheOptions> = {}): CacheStore {
       try {
         // 0o600: the cache stores full page content and URLs, which can embed
         // credentials in query strings; it should not be world-readable.
-        writeFileSync(tmp, JSON.stringify(data), { mode: 0o600 });
+        writeFileSync(tmp, JSON.stringify(persistedData), { mode: 0o600 });
         renameSync(tmp, path);
         // Fix perms of a file written by a pre-0600 version.
         chmodSync(path, 0o600);

package/index.ts

@@ -28,14 +28,40 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { loadConfig, resolveWebToolsEnv } from "./config.ts";
 import { GENERATED_MODELS } from "./models.generated.ts";
 import { OLLAMA_BASE, refreshOllamaCatalog } from "./models.ts";
-import { fetchUsage, formatUsage, formatUsageStatusColored } from "./usage.ts";
+import { fetchUsage, fetchUsageStats, formatUsage, formatUsageStatusColored, type UsageStats } from "./usage.ts";
 import { getCloudApiKey } from "./utils.ts";
 import { registerWebFetchTool, registerWebSearchTool } from "./web-tools.ts";
 
-/**
- * Resolve the new enabled state for /ollama-usage-status from its argument.
- * Exported for unit testing.
- */
+/** Guard usage-status refreshes against stale generations and duplicate triggers. */
+export function createUsageStatusRefreshGuard() {
+  let generation = 0;
+  let inFlightGeneration: number | undefined;
+
+  return {
+    invalidate() {
+      generation += 1;
+    },
+    async run(
+      isCurrent: () => boolean,
+      refresh: (stillCurrent: () => boolean) => Promise<string | undefined>,
+      setStatus: (text: string | undefined) => void,
+    ): Promise<void> {
+      if (inFlightGeneration === generation || !isCurrent()) return;
+      const requestGeneration = generation;
+      inFlightGeneration = requestGeneration;
+      try {
+        const text = await refresh(() => generation === requestGeneration && isCurrent());
+        if (generation === requestGeneration && isCurrent()) setStatus(text);
+      } catch {
+        if (generation === requestGeneration && isCurrent()) setStatus(undefined);
+      } finally {
+        if (inFlightGeneration === requestGeneration) inFlightGeneration = undefined;
+      }
+    },
+  };
+}
+
+/** Resolve the new enabled state for /ollama-usage-status from its argument. */
 export function resolveUsageStatusToggle(arg: string, current: boolean): { enabled: boolean; error?: string } {
   const a = arg.trim().toLowerCase();
   if (a === "on" || a === "enable") return { enabled: true };
@@ -143,7 +169,17 @@ export default async function (pi: ExtensionAPI) {
       }
       try {
         const data = await fetchUsage(apiKey);
-        ctx.ui.notify(formatUsage(data), "info");
+        let stats: UsageStats | undefined;
+        let statsError: string | undefined;
+        try {
+          stats = await fetchUsageStats(apiKey);
+        } catch (err) {
+          statsError = err instanceof Error ? err.message : String(err);
+        }
+        ctx.ui.notify(formatUsage(data, stats), "info");
+        if (statsError) {
+          ctx.ui.notify(`Ollama Cloud request statistics unavailable: ${statsError}`, "warning");
+        }
       } catch (err) {
         ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
       }
@@ -152,35 +188,33 @@ export default async function (pi: ExtensionAPI) {
 
   // --- Usage Status Bar ---
 
-  // Footer status showing live usage while ollama-cloud is the
+  // Footer status showing live quota while ollama-cloud is the
   // active provider. Refreshes on a 5-minute timer; agent_end also triggers a
-  // refresh but is throttled to the same cooldown so a turn never hammers the
-  // undocumented /api/usage endpoint. The quota-bar concept is inspired by
+  // refresh but is throttled to the same cooldown. Quota comes from the
+  // /api/balance endpoint. The quota-bar concept is inspired by
   // @entelligentsia/pi-ollama-cloud-usage-tracker.
   const USAGE_STATUS_KEY = "ollama-usage";
   const USAGE_REFRESH_MS = 5 * 60_000;
   let usageTimer: ReturnType<typeof setInterval> | null = null;
   let usageActive = false;
+  const usageRefreshGuard = createUsageStatusRefreshGuard();
   // Timestamp (ms) of the most recent refresh attempt; gates the agent_end
   // refresh so it fires at most once per cooldown. Set when a fetch starts, so
   // a failing endpoint is also throttled, not just a successful one.
   let lastRefreshAt = 0;
 
   async function refreshUsageStatus(ctx: ExtensionContext) {
-    try {
-      const apiKey = await getCloudApiKey(ctx);
-      if (!apiKey) {
-        ctx.ui.setStatus(USAGE_STATUS_KEY, undefined);
-        return;
-      }
-      lastRefreshAt = Date.now();
-      const data = await fetchUsage(apiKey);
-      ctx.ui.setStatus(USAGE_STATUS_KEY, formatUsageStatusColored(ctx.ui.theme, data));
-    } catch {
-      // Transient errors (undocumented endpoint, network) should not spam the
-      // footer; clear the status and retry on the next refresh.
-      ctx.ui.setStatus(USAGE_STATUS_KEY, undefined);
-    }
+    await usageRefreshGuard.run(
+      () => usageActive && isOllamaCloud(ctx),
+      async (stillCurrent) => {
+        const apiKey = await getCloudApiKey(ctx);
+        if (!stillCurrent() || !apiKey) return undefined;
+        lastRefreshAt = Date.now();
+        const data = await fetchUsage(apiKey);
+        return formatUsageStatusColored(ctx.ui.theme, data);
+      },
+      (text) => ctx.ui.setStatus(USAGE_STATUS_KEY, text),
+    );
   }
 
   function startUsageStatus(ctx: ExtensionContext) {
@@ -193,6 +227,7 @@ export default async function (pi: ExtensionAPI) {
   }
 
   function stopUsageStatus(ctx: ExtensionContext) {
+    usageRefreshGuard.invalidate();
     usageActive = false;
     if (usageTimer) {
       clearInterval(usageTimer);
@@ -215,7 +250,7 @@ export default async function (pi: ExtensionAPI) {
 
   pi.on("agent_end", async (_event, ctx) => {
     // Throttle the after-turn refresh to the same cooldown as the timer so a
-    // burst of turns never exceeds one /api/usage call per 5 minutes.
+    // burst of turns never exceeds one /api/balance call per 5 minutes.
     if (usageActive && isOllamaCloud(ctx) && Date.now() - lastRefreshAt >= USAGE_REFRESH_MS) {
       await refreshUsageStatus(ctx);
     }

package/limits.generated.ts

@@ -1,13 +1,11 @@
 // Auto-generated by scripts/generate-limits.ts
 // Do not edit manually.
-// Entries: 20
+// Entries: 17
 
 export const MODEL_MAX_OUTPUT_TOKENS: Record<string, number> = {
-  "deepseek-v4-flash:0731": 65536,
   "deepseek-v4-pro:0813": 65536,
   "deepseek-v4.1-flash": 393216,
   "gemma4:31b": 262144,
-  "glm-5.1": 131072,
   "glm-5.2": 131072,
   "glm-5.3": 524288,
   "glm-5.3-flash": 524288,
@@ -22,5 +20,4 @@ export const MODEL_MAX_OUTPUT_TOKENS: Record<string, number> = {
   "nemotron-3-nano:30b": 131072,
   "nemotron-3-super": 65536,
   "nemotron-3-ultra": 65536,
-  "qwen3.5:397b": 65536,
 };

package/models.generated.ts

@@ -3,9 +3,9 @@
 // Generated: 2026-09-27T00:52:07.773Z
 // Model count: 17
 
-import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import type { ChatModelConfig } from "./models.ts";
 
-export const GENERATED_MODELS: ProviderModelConfig[] = [
+export const GENERATED_MODELS: ChatModelConfig[] = [
   {
     id: "deepseek-v4-pro:0813",
     name: "deepseek-v4-pro:0813",

package/models.ts

@@ -6,6 +6,11 @@ import { MODEL_PRICING, type ModelPrice } from "./pricing.generated.ts";
 import { resolve as resolveThinkingLevelMap } from "./thinking-levels.ts";
 import { concurrentMap, fetchJsonWithTimeout, getContextLength } from "./utils.ts";
 
+export type ChatModelConfig =
+  Extract<ProviderModelConfig, { type?: "chat" }> extends never
+    ? ProviderModelConfig
+    : Extract<ProviderModelConfig, { type?: "chat" }>;
+
 // --- Pricing ---
 // Per-1M-token prices are generated from the ollama.com/pricing model table by
 // scripts/generate-pricing.ts (see pricing.generated.ts, do not edit by hand).
@@ -66,17 +71,21 @@ export const OLLAMA_BASE = CLOUD_BASE_URL.replace(/\/+$/, "");
 // --- Raw API types ---
 /** Response from POST /api/show */
 interface OllamaShowResponse {
-  details: {
-    parent_model: string;
-    format: string;
-    family: string;
-    families: string[] | null;
-    parameter_size: string;
-    quantization_level: string;
-  };
-  model_info: Record<string, unknown>;
+  model_info?: Record<string, unknown> | null;
   capabilities: string[];
-  modified_at: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isOllamaShowResponse(value: unknown): value is OllamaShowResponse {
+  return (
+    isRecord(value) &&
+    (value.model_info === undefined || value.model_info === null || isRecord(value.model_info)) &&
+    Array.isArray(value.capabilities) &&
+    value.capabilities.every((capability) => typeof capability === "string")
+  );
 }
 
 // --- Assembly: raw API data -> ProviderModelConfig[] ---
@@ -89,7 +98,7 @@ interface OllamaShowResponse {
  * pi type definition: https://github.com/earendil-works/pi/blob/b94482762321ed0b9f8f245be57c84d786a7105d/packages/ai/src/types.ts#L361-L400
  * pi compat resolution:  https://docs.ollama.com/api/openai-compatibility https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/types.ts#L365-L425
  */
-function buildCompat(): ProviderModelConfig["compat"] {
+function buildCompat(): ChatModelConfig["compat"] {
   return {
     // Ollama uses "system" role, not "developer" (ollama: docs.ollama.com/api/openai-compatibility, pi: types.ts#supportsDeveloperRole).
     supportsDeveloperRole: false,
@@ -138,15 +147,21 @@ function buildCompat(): ProviderModelConfig["compat"] {
   };
 }
 
-export function assembleModels(raw: Record<string, OllamaShowResponse>): ProviderModelConfig[] {
+export function assembleModels(raw: Record<string, unknown>): ChatModelConfig[] {
   return Object.entries(raw)
-    .filter(([, data]) => data.capabilities?.includes("tools"))
+    .map(([id, data]) => {
+      if (!isOllamaShowResponse(data)) {
+        throw new Error(`Invalid /api/show response for ${id}: expected string capabilities and model_info object.`);
+      }
+      return [id, data] as const;
+    })
+    .filter(([, data]) => data.capabilities.includes("tools"))
     .map(([id, data]) => ({
       id,
       name: id,
-      reasoning: data.capabilities?.includes("thinking") ?? false,
-      thinkingLevelMap: resolveThinkingLevelMap(id, data.capabilities ?? []),
-      input: (data.capabilities?.includes("vision") ? ["text", "image"] : ["text"]) as ("text" | "image")[],
+      reasoning: data.capabilities.includes("thinking"),
+      thinkingLevelMap: resolveThinkingLevelMap(id, data.capabilities),
+      input: (data.capabilities.includes("vision") ? ["text", "image"] : ["text"]) as ("text" | "image")[],
       cost: resolvePrice(id),
       contextWindow: getContextLength(data.model_info ?? {}),
       maxTokens: resolveMaxTokens(id),
@@ -162,21 +177,30 @@ export async function fetchModelIds(signal?: AbortSignal, timeoutMs = FETCH_TIME
     headers.Authorization = `Bearer ${apiKey}`;
   }
 
-  const res = await fetchJsonWithTimeout<{ data: { id: string }[] }>(
-    `${OLLAMA_BASE}/v1/models`,
-    { headers },
-    timeoutMs,
-    signal,
-  );
+  const res = await fetchJsonWithTimeout<unknown>(`${OLLAMA_BASE}/v1/models`, { headers }, timeoutMs, signal);
 
   if (res.status === 429) {
     throw new Error("Ollama Cloud model list fetch rate limited. Try again shortly.");
   }
-  if (!res.ok || !res.data) {
+  if (!res.ok) {
+    if (res.status === 0) {
+      throw new Error(
+        `Ollama Cloud model list fetch failed: transport error (${res.error ?? "unknown"}). Try again shortly.`,
+      );
+    }
     throw new Error(`Failed to fetch model list: ${res.status}${res.error ? ` - ${res.error}` : ""}`);
   }
-
-  return res.data.data.map((m) => m.id);
+  if (!isRecord(res.data) || !Array.isArray(res.data.data)) {
+    throw new Error("Failed to fetch model list: unexpected response shape (expected a data array).");
+  }
+  const ids: string[] = [];
+  for (const [index, model] of res.data.data.entries()) {
+    if (!isRecord(model) || typeof model.id !== "string" || model.id.trim() !== model.id || model.id === "") {
+      throw new Error(`Failed to fetch model list: invalid model ID at data[${index}].`);
+    }
+    ids.push(model.id);
+  }
+  return ids;
 }
 
 export async function fetchModelDetails(
@@ -190,7 +214,7 @@ export async function fetchModelDetails(
     headers.Authorization = `Bearer ${apiKey}`;
   }
 
-  const res = await fetchJsonWithTimeout<OllamaShowResponse>(
+  const res = await fetchJsonWithTimeout<unknown>(
     `${OLLAMA_BASE}/api/show`,
     {
       method: "POST",
@@ -204,10 +228,19 @@ export async function fetchModelDetails(
   if (res.status === 429) {
     throw new Error("Ollama Cloud /api/show rate limited. Try again shortly.");
   }
-  if (!res.ok || !res.data) {
+  if (!res.ok) {
+    if (res.status === 0) {
+      throw new Error(
+        `Ollama Cloud /api/show for ${id} failed: transport error (${res.error ?? "unknown"}). Try again shortly.`,
+      );
+    }
     throw new Error(`Failed to fetch /api/show for ${id}: ${res.status}${res.error ? ` - ${res.error}` : ""}`);
   }
-
+  if (!isOllamaShowResponse(res.data)) {
+    throw new Error(
+      `Failed to fetch /api/show for ${id}: unexpected response shape (expected string capabilities and model_info object).`,
+    );
+  }
   return res.data;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ollama-cloud",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "type": "module",
   "keywords": [
     "pi-package"

package/thinking-levels.ts

@@ -33,7 +33,12 @@
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import { MODEL_REASONING_OPTIONS, type ModelsDevReasoningOption } from "./reasoning.generated.ts";
 
-export type ThinkingLevelMap = NonNullable<ProviderModelConfig["thinkingLevelMap"]>;
+type ChatModelConfig =
+  Extract<ProviderModelConfig, { type?: "chat" }> extends never
+    ? ProviderModelConfig
+    : Extract<ProviderModelConfig, { type?: "chat" }>;
+
+export type ThinkingLevelMap = NonNullable<ChatModelConfig["thinkingLevelMap"]>;
 
 /** Default: off/low/medium/high/xhigh with minimal hidden. */
 export const DEFAULT: ThinkingLevelMap = {
@@ -70,6 +75,10 @@ function hidesOff(id: string): boolean {
   return OFF_NULL_EXACT.has(id) || OFF_NULL_FAMILIES.some((prefix) => id.startsWith(prefix));
 }
 
+function applyOffRestriction(id: string, map: ThinkingLevelMap): ThinkingLevelMap {
+  return hidesOff(id) ? { ...map, off: null } : map;
+}
+
 /**
  * Map a models.dev `effort` value onto the Pi level key and the reasoning_effort
  * string to send for it. Ollama's top effort value is "max"; Pi exposes it via
@@ -140,6 +149,6 @@ export function resolve(id: string, capabilities: string[]): ThinkingLevelMap |
   // An empty array (e.g. minimax-m2.5) carries no verified options; fall back
   // to DEFAULT rather than a degenerate map whose only selectable level can
   // be a leaking off.
-  if (options === undefined || options.length === 0) return DEFAULT;
+  if (options === undefined || options.length === 0) return applyOffRestriction(id, DEFAULT);
   return buildMap(options, matchedKey);
 }

package/usage.ts

@@ -1,197 +1,209 @@
-/**
- * Ollama Cloud usage data plane: fetch and format /api/usage.
- *
- * Self-contained module. Depends on:
- *   - models.ts - only for OLLAMA_BASE URL constant
- *   - utils.ts  - fetchJsonWithTimeout
- * Does NOT depend on provider registration, model fetching, or API key
- * resolution (the caller resolves the key and passes it in).
- *
- * The /api/usage endpoint is undocumented and could change or disappear. The
- * fetch degrades gracefully: distinct HTTP statuses map to distinct
- * user-facing errors, and a malformed body raises a clear error rather than
- * crashing.
- *
- * The response shape has flipped twice: through 2026-09-02 it carried
- * limits.session and limits.weekly, on 2026-09-03 it switched to a single
- * limits.monthly bucket (0.10.0 adapted to that), and by 2026-09-07 it
- * returned session and weekly again. All three buckets are therefore optional
- * and whichever are present are displayed.
- */
-
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { OLLAMA_BASE } from "./models.ts";
 import { fetchJsonWithTimeout, httpError } from "./utils.ts";
 
-// --- Types ---
+export interface BalanceWindow {
+  remaining_percent: number;
+  resets_at?: string;
+}
 
-export interface UsageModel {
-  name: string;
-  request_count: number;
+export interface UsageData {
+  included?: {
+    session?: BalanceWindow;
+    weekly?: BalanceWindow;
+    monthly?: BalanceWindow;
+    balance_usd?: number;
+    allowance_usd?: number;
+    period?: { from?: string; until?: string };
+  };
+  purchased?: { balance_usd?: number };
 }
 
-export interface UsageLimit {
-  /** Fraction of the plan's cap, 0-1 (not tokens). */
-  usage: number;
-  /** Per-model request counts (not token counts). */
-  models: UsageModel[];
+export interface UsageBucket {
+  from?: string;
+  until?: string;
+  request_count: number;
+  partial?: boolean;
+  usage_usd?: number;
+  input_tokens?: number;
+  cached_input_tokens?: number;
+  output_tokens?: number;
 }
 
-export interface UsageActivity {
-  cost?: string;
-  period?: {
-    type?: string;
-    starting_at?: string;
-    ending_at?: string;
+export interface UsageStats {
+  range?: "24h" | "7d" | "30d";
+  totals: {
+    request_count: number;
+    usage_usd?: number;
+    input_tokens?: number;
+    cached_input_tokens?: number;
+    output_tokens?: number;
   };
-  models?: UsageModel[];
+  buckets?: UsageBucket[];
 }
 
-export interface UsageData {
-  limits: {
-    /** Monthly (30d) bucket, served by the API between 2026-09-03 and 2026-09-07. */
-    monthly?: UsageLimit;
-    /** Session (5h) bucket, served before 2026-09-03 and again as of 2026-09-07. */
-    session?: UsageLimit;
-    /** Weekly (7d) bucket, served before 2026-09-03 and again as of 2026-09-07. */
-    weekly?: UsageLimit;
-  };
-  activity?: UsageActivity;
+const USAGE_TIMEOUT_MS = 10000;
+
+function isObject(data: unknown): data is Record<string, unknown> {
+  return data !== null && typeof data === "object" && !Array.isArray(data);
 }
 
-// --- Constants ---
+export function isBalanceWindow(data: unknown): data is BalanceWindow {
+  if (!isObject(data) || typeof data.remaining_percent !== "number" || !Number.isFinite(data.remaining_percent)) {
+    return false;
+  }
+  return data.resets_at === undefined || typeof data.resets_at === "string";
+}
 
-const USAGE_TIMEOUT_MS = 10000;
+function isPurchased(data: unknown): boolean {
+  return isObject(data) && typeof data.balance_usd === "number" && Number.isFinite(data.balance_usd);
+}
 
-// --- Validation ---
+function isIncluded(data: unknown): data is NonNullable<UsageData["included"]> {
+  if (!isObject(data)) return false;
+  const windows = [data.session, data.weekly, data.monthly];
+  if (windows.some((window) => window !== undefined && !isBalanceWindow(window))) return false;
+
+  const balance = data.balance_usd;
+  const allowance = data.allowance_usd;
+  if (balance !== undefined && (typeof balance !== "number" || !Number.isFinite(balance))) return false;
+  if (allowance !== undefined && (typeof allowance !== "number" || !Number.isFinite(allowance))) return false;
+  if ((balance === undefined) !== (allowance === undefined)) return false;
+
+  if (data.period !== undefined) {
+    if (!isObject(data.period)) return false;
+    if (data.period.from !== undefined && typeof data.period.from !== "string") return false;
+    if (data.period.until !== undefined && typeof data.period.until !== "string") return false;
+  }
 
-/** Validate a single usage limit: a 0-1 fraction plus per-model request counts. */
-export function isUsageLimit(data: unknown): data is UsageLimit {
-  if (data == null || typeof data !== "object") return false;
-  const d = data as UsageLimit;
-  return (
-    typeof d.usage === "number" &&
-    Array.isArray(d.models) &&
-    d.models.every(
-      (m) =>
-        m != null &&
-        typeof m === "object" &&
-        typeof (m as UsageModel).name === "string" &&
-        typeof (m as UsageModel).request_count === "number",
-    )
-  );
+  return true;
 }
 
-/**
- * Validate a parsed /api/usage response: needs at least one valid limit bucket.
- * The endpoint is undocumented and flips shape unpredictably (monthly-only,
- * session+weekly, possibly other combinations), so any bucket present alone or
- * in any combination is accepted and rendered.
- */
 export function isUsageResponse(data: unknown): data is UsageData {
-  if (data == null || typeof data !== "object") return false;
-  const d = data as UsageData;
-  if (d.limits == null || typeof d.limits !== "object" || Array.isArray(d.limits)) return false;
-  const buckets = [d.limits.monthly, d.limits.session, d.limits.weekly];
-  return buckets.some(isUsageLimit) && buckets.every((bucket) => bucket === undefined || isUsageLimit(bucket));
+  if (!isObject(data)) return false;
+  const included = data.included;
+  const hasPurchased = isPurchased(data.purchased);
+  if (data.purchased !== undefined && !hasPurchased) return false;
+  if (included === undefined) return hasPurchased;
+  if (!isIncluded(included)) return false;
+
+  const hasWindow = [included.session, included.weekly, included.monthly].some(isBalanceWindow);
+  const hasAllowance = typeof included.balance_usd === "number" && typeof included.allowance_usd === "number";
+  return hasWindow || hasAllowance || hasPurchased;
 }
 
-// --- Fetch ---
+export function isUsageStats(data: unknown): data is UsageStats {
+  if (!isObject(data) || !isObject(data.totals) || typeof data.totals.request_count !== "number") return false;
+  if (data.buckets === undefined) return true;
+  return (
+    Array.isArray(data.buckets) &&
+    data.buckets.every((bucket) => isObject(bucket) && typeof bucket.request_count === "number")
+  );
+}
 
-/**
- * Fetch Ollama Cloud usage from the undocumented /api/usage endpoint.
- * The caller resolves the API key and passes it in.
- */
 export async function fetchUsage(apiKey: string, externalSignal?: AbortSignal): Promise<UsageData> {
   const res = await fetchJsonWithTimeout<UsageData>(
-    `${OLLAMA_BASE}/api/usage`,
-    {
-      method: "GET",
-      headers: { Authorization: `Bearer ${apiKey}` },
-    },
+    `${OLLAMA_BASE}/api/balance`,
+    { method: "GET", headers: { Authorization: `Bearer ${apiKey}` } },
     USAGE_TIMEOUT_MS,
     externalSignal,
   );
-
   if (!res.ok) {
-    // The 404 case is specific to this undocumented endpoint: it may have
-    // changed or disappeared, so surface that distinctly before the shared
-    // status mapping.
+    if (res.status === 0) {
+      throw new Error(`Ollama Cloud balance failed: transport error (${res.error ?? "unknown"}). Try again shortly.`);
+    }
     if (res.status === 404) {
-      throw new Error(
-        "Ollama Cloud usage failed: the /api/usage endpoint is unavailable (status 404). " +
-          "It is undocumented and may have changed.",
-      );
+      throw new Error("Ollama Cloud balance failed: the /api/balance endpoint is unavailable (status 404).");
     }
-    httpError("usage", res.status, res.error);
-  }
-  if (!isUsageResponse(res.data)) {
-    throw new Error("Ollama Cloud usage failed: unexpected response shape from the API.");
+    httpError("balance", res.status, res.error);
   }
+  if (!isUsageResponse(res.data))
+    throw new Error("Ollama Cloud balance failed: unexpected response shape from the API.");
   return res.data;
 }
 
-// --- Formatting ---
+export async function fetchUsageStats(
+  apiKey: string,
+  range: "24h" | "7d" | "30d" = "7d",
+  externalSignal?: AbortSignal,
+): Promise<UsageStats> {
+  const res = await fetchJsonWithTimeout<UsageStats>(
+    `${OLLAMA_BASE}/api/usage?range=${range}`,
+    { method: "GET", headers: { Authorization: `Bearer ${apiKey}` } },
+    USAGE_TIMEOUT_MS,
+    externalSignal,
+  );
+  if (!res.ok) httpError("usage stats", res.status, res.error);
+  if (!isUsageStats(res.data))
+    throw new Error("Ollama Cloud usage stats failed: unexpected response shape from the API.");
+  return res.data;
+}
 
-/** Clamp a 0-1 usage fraction to a 0-100 percentage for display. */
-function usagePercent(usage: number): number {
-  if (!Number.isFinite(usage)) return 0;
-  return Math.min(Math.max(Math.round(usage * 100), 0), 100);
+function usedPercent(remaining: number): number {
+  if (!Number.isFinite(remaining)) return 100;
+  return Math.min(Math.max(Math.round(100 - remaining), 0), 100);
 }
 
-/** The limit buckets present in a response, in display order. */
-function limitSegments(data: UsageData): Array<{ label: string; short: string; limit: UsageLimit }> {
-  const segs: Array<{ label: string; short: string; limit: UsageLimit }> = [];
-  if (isUsageLimit(data.limits.session)) {
-    segs.push({ label: "Session (5h)", short: "5h", limit: data.limits.session });
-  }
-  if (isUsageLimit(data.limits.weekly)) {
-    segs.push({ label: "Weekly (7d)", short: "7d", limit: data.limits.weekly });
+function limitSegments(data: UsageData): Array<{ short: string; used: number }> {
+  const included = data.included;
+  if (!included) return [];
+  const segments: Array<{ short: string; used: number }> = [];
+  for (const [key, short] of [
+    ["session", "5h"],
+    ["weekly", "7d"],
+    ["monthly", "30d"],
+  ] as const) {
+    const window = included[key];
+    if (window && isBalanceWindow(window)) segments.push({ short, used: usedPercent(window.remaining_percent) });
   }
-  if (isUsageLimit(data.limits.monthly)) {
-    segs.push({ label: "Monthly (30d)", short: "30d", limit: data.limits.monthly });
+  if (
+    segments.length === 0 &&
+    typeof included.balance_usd === "number" &&
+    typeof included.allowance_usd === "number" &&
+    included.allowance_usd > 0
+  ) {
+    const used = (1 - included.balance_usd / included.allowance_usd) * 100;
+    segments.push({ short: "plan", used: Math.min(Math.max(Math.round(used), 0), 100) });
   }
-  return segs;
+  return segments;
 }
 
-/** Format usage for the /ollama-cloud-usage command output. */
-export function formatUsage(data: UsageData): string {
-  const lines: string[] = ["Ollama Cloud usage:"];
-
-  for (const seg of limitSegments(data)) {
-    lines.push(`  ${seg.label}: ${usagePercent(seg.limit.usage)}%`);
-    for (const m of seg.limit.models) {
-      lines.push(`    - ${m.name}: ${m.request_count} request${m.request_count === 1 ? "" : "s"}`);
+export function formatUsage(data: UsageData, stats?: UsageStats): string {
+  const lines = ["Ollama Cloud usage:"];
+  for (const segment of limitSegments(data)) lines.push(`  ${segment.short}: ${segment.used}% used`);
+  const included = data.included;
+  if (included && typeof included.balance_usd === "number" && typeof included.allowance_usd === "number") {
+    lines.push(
+      `  Included balance: $${included.balance_usd.toFixed(2)} / $${included.allowance_usd.toFixed(2)} remaining`,
+    );
+    if (included.period?.from || included.period?.until) {
+      lines.push(`  Included allowance period: ${included.period.from ?? "?"} to ${included.period.until ?? "?"}`);
+      if (included.period.until) lines.push(`  Included allowance renews: ${included.period.until}`);
     }
   }
-
-  if (typeof data.activity?.cost === "string") {
-    lines.push(`  Activity (4wk): $${data.activity.cost}`);
+  if (data.purchased?.balance_usd && data.purchased.balance_usd > 0) {
+    lines.push(`  Purchased credits: $${data.purchased.balance_usd.toFixed(2)}`);
+  }
+  if (stats) {
+    lines.push(`  Requests (${stats.range ?? "7d"}): ${stats.totals.request_count.toLocaleString()}`);
+    const current = stats.buckets?.at(-1);
+    if (current?.partial) lines.push(`    - current period: ${current.request_count.toLocaleString()}`);
   }
-
   return lines.join("\n");
 }
 
-/** Render a 10-character quota bar for a 0-100 percentage. */
 function quotaBar(pct: number): string {
   const filled = Math.min(Math.max(Math.floor(pct / 10), 0), 10);
   return `▕${"█".repeat(filled)}${"░".repeat(10 - filled)}▏`;
 }
 
-/** Color a single usage segment by how close it is to the cap. */
 function colorSegment(theme: Theme, label: string, pct: number): string {
   const color = pct >= 80 ? "error" : pct >= 60 ? "warning" : "success";
   return theme.fg(color, `${label} ${quotaBar(pct)} ${pct}%`);
 }
 
-/**
- * Compact one-line usage for the footer status bar, colored by usage level,
- * with one segment per limit bucket present in the response (5h and 7d, or
- * 30d when the API serves the monthly shape). The color reflects the usage
- * fraction rather than pace because the bucket periods differ per shape.
- */
 export function formatUsageStatusColored(theme: Theme, data: UsageData): string {
   return limitSegments(data)
-    .map((seg) => colorSegment(theme, seg.short, usagePercent(seg.limit.usage)))
+    .map((segment) => colorSegment(theme, segment.short, segment.used))
     .join(" ");
 }

package/utils.ts

@@ -71,7 +71,7 @@ export async function concurrentMap<T, R>(
 
 export function getContextLength(modelInfo: Record<string, unknown>): number {
   for (const [key, value] of Object.entries(modelInfo)) {
-    if (key.endsWith(".context_length") && typeof value === "number") {
+    if (key.endsWith(".context_length") && typeof value === "number" && Number.isInteger(value) && value > 0) {
       return value;
     }
   }
@@ -96,6 +96,9 @@ export async function getCloudApiKey(ctx: Pick<ExtensionContext, "modelRegistry"
  * distinct status codes. Shared by the web tools and the usage command.
  */
 export function httpError(op: string, status: number, error?: string): never {
+  if (status === 0) {
+    throw new Error(`Ollama Cloud ${op} failed: transport error (${error ?? "unknown"}). Try again shortly.`);
+  }
   if (status === 401 || status === 403) {
     throw new Error(
       `Ollama Cloud ${op} failed: authentication error. Check your API key in OLLAMA_API_KEY or auth.json.`,

package/web-tools.ts

@@ -137,7 +137,15 @@ export function isSearchResponse(data: unknown): data is SearchResponse {
   const results = (data as SearchResponse).results;
   return (
     Array.isArray(results) &&
-    results.every((r) => typeof r.title === "string" && typeof r.url === "string" && typeof r.content === "string")
+    results.every(
+      (result) =>
+        typeof result === "object" &&
+        result !== null &&
+        !Array.isArray(result) &&
+        typeof result.title === "string" &&
+        typeof result.url === "string" &&
+        typeof result.content === "string",
+    )
   );
 }
 
@@ -176,6 +184,11 @@ function fetchFailureMessage(
     );
   } else if (entry.status === 429) {
     lines.push("Likely cause: rate limited.", "Suggestion: try again shortly (rate-limit failures are not cached).");
+  } else if (entry.status === 0) {
+    lines.push(
+      "Likely cause: a transport error (timeout, cancellation, or network failure).",
+      "Suggestion: try again shortly; transport failures are not cached.",
+    );
   } else if (entry.errorType === "response-shape") {
     lines.push(
       "Likely cause: Ollama Cloud returned an unexpected response shape.",
@@ -403,7 +416,14 @@ export function registerWebFetchTool(pi: ExtensionAPI, cacheStore: CacheStore =
         );
 
         if (!res.ok) {
-          entry = { ts: Date.now(), status: res.status, error: `HTTP ${res.status}: ${res.error ?? "unknown error"}` };
+          entry = {
+            ts: Date.now(),
+            status: res.status,
+            error:
+              res.status === 0
+                ? `Transport error: ${res.error ?? "unknown error"}`
+                : `HTTP ${res.status}: ${res.error ?? "unknown error"}`,
+          };
           // Auth, rate-limit, transport (status 0: timeout, abort, DNS/connection
           // errors), and server (5xx) failures are not negative-cached: a fixed
           // key, an expired rate-limit window, or a transient server/network