pi-ollama-cloud 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.9.0] - 2026-08-11
+
+- Add `/ollama-cloud-usage` command to show Ollama Cloud session (5h) and weekly (7d) usage limits, per-model request counts, and the 4-week activity cost, fetched from the undocumented `/api/usage` endpoint with the already-resolved API key.
+- Add a footer usage status bar (`5h ▕███░░░░░░░▏ 34% 7d ▕████░░░░░░▏ 45%`) while an `ollama-cloud` model is active, refreshing every 5 minutes and after each agent turn (throttled so it never exceeds one /api/usage call per 5 minutes). Segments are colored by usage level (green <60%, yellow 60-79%, red 80%+). The quota-bar concept is inspired by `@entelligentsia/pi-ollama-cloud-usage-tracker`. Off by default; enable with `/ollama-usage-status on` or `"usageStatus": true` in `ollama-cloud.json`.
+- Add `/ollama-usage-status [on|off|enable|disable]` to toggle the footer usage status bar at runtime (toggles without an argument).
+- Document the exported usage API (`fetchUsage`, `formatUsageStatusColored`, `getCloudApiKey`, validators) so custom status bars can reuse it.
+
 ## [0.8.0] - 2026-08-09
 
 - **Breaking:** Migrate model refresh to pi's native `refreshModels` mechanism. Remove the `/ollama-cloud-refresh` command and the manual `~/.pi/agent/cache/ollama-cloud-models.json` cache. The catalog now refreshes automatically on startup, on `/model` open, and via `pi update --models`, persisted through pi's own `FileModelsStore`. Users should delete the orphaned cache file after upgrade: `rm ~/.pi/agent/cache/ollama-cloud-models.json`.

package/README.md

@@ -97,12 +97,14 @@ Extension settings can be set via JSON config files. Project-local settings over
 | Setting | Type | Default | Description |
 |---|---|---|---|
 | `webTools` | boolean | `true` | Set to `false` to prevent `ollama_web_search` and `ollama_web_fetch` from being registered |
+| `usageStatus` | boolean | `false` | Set to `true` to show the footer usage status bar (opt-in; enable at runtime with `/ollama-usage-status`) |
 
 Example `ollama-cloud.json`:
 
 ```json
 {
-  "webTools": false
+  "webTools": false,
+  "usageStatus": true
 }
 ```
 
@@ -164,6 +166,58 @@ Both tools use the same Ollama Cloud API key configured for the provider. No loc
 | 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 session (5h) and weekly (7d) usage limits, per-model request counts, and the 4-week activity cost. |
+| `/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 (`5h ▕███░░░░░░░▏ 34% 7d ▕████░░░░░░▏ 45%`) that refreshes
+every 5 minutes and after each agent turn (but no more often than every 5 minutes). Each segment 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.
+
+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
+bar never appears after enabling, run `/ollama-cloud-usage` to see the
+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.
+
+## Usage API for custom status bars
+
+The usage data plane is exported so you can plug it into your own footer or
+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 { 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. |
+| `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). |
+| `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. |
+
+Example custom status bar:
+
+```ts
+const apiKey = await getCloudApiKey(ctx);
+const data = await fetchUsage(apiKey);
+ctx.ui.setStatus("my-usage", formatUsageStatusColored(ctx.ui.theme, data));
+```
+
+Note that the package ships raw TypeScript sources (no build step), so submodule
+imports use the `.ts` extension, matching how the extension imports internally.
 
 ## Development
 
@@ -192,7 +246,7 @@ Live smoke against the real API (needs an `OLLAMA_API_KEY` or an `ollama-cloud`
 ```bash
 # Run pi with the local extension, no install required. The --no-* flags isolate
 # the run from other installed extensions, skills, prompt templates, themes,
-# context files, and session storage so only the local checkout is exercised.
+# context files, and session storage so only the local checkout is exercised
 pi --no-extensions --no-skills --no-prompt-templates --no-themes --no-context-files --no-session \
   -e ./index.ts --model "ollama-cloud/gemma4:31b" --no-tools -p "Say hi in one word"
 

package/config.ts

@@ -25,12 +25,15 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 export interface OllamaCloudConfig {
   /** When false, ollama_web_search and ollama_web_fetch tools are not registered. Default: true. */
   webTools?: boolean;
+  /** When true, the footer usage status bar is shown. Default: false (opt-in; enable with /ollama-usage-status). */
+  usageStatus?: boolean;
 }
 
 // --- Defaults ---
 
 const DEFAULT_CONFIG: OllamaCloudConfig = {
   webTools: true,
+  usageStatus: false,
 };
 
 // --- Validation ---
@@ -38,6 +41,7 @@ const DEFAULT_CONFIG: OllamaCloudConfig = {
 /** Allowed config keys and their expected types for runtime validation. */
 const CONFIG_SCHEMA: Record<keyof OllamaCloudConfig, "boolean"> = {
   webTools: "boolean",
+  usageStatus: "boolean",
 };
 
 /**

package/index.ts

@@ -24,12 +24,29 @@
  * Only models with "tools" capability are registered.
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 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 { 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.
+ */
+export function resolveUsageStatusToggle(arg: string, current: boolean): { enabled: boolean; error?: string } {
+  const a = arg.trim().toLowerCase();
+  if (a === "on" || a === "enable") return { enabled: true };
+  if (a === "off" || a === "disable") return { enabled: false };
+  if (a === "") return { enabled: !current };
+  return {
+    enabled: current,
+    error: `Unknown argument "${arg.trim()}". Usage: /ollama-usage-status [on|off|enable|disable]`,
+  };
+}
+
 // --- Main ---
 
 export default async function (pi: ExtensionAPI) {
@@ -82,21 +99,25 @@ export default async function (pi: ExtensionAPI) {
     }
   }
 
-  // Module-level tracking across session restarts within the same extension
-  // instance. The config file is read once, on the first session_start;
-  // later sessions reuse webToolsEnabled (including any /ollama-webtools
-  // override). Restart pi or /reload to pick up config file changes.
-  let webToolsConfigured = false;
+  // Config is read once per extension factory invocation (on the first
+  // session_start). The factory is re-invoked on /new, /fork, /resume, and
+  // /reload, so runtime toggles (e.g. /ollama-webtools, /ollama-usage-status)
+  // reset to the config default on each session restart. Restart pi or /reload
+  // to pick up config file changes.
+  let configLoaded = false;
   let webToolsEnabled = false;
+  let usageStatusEnabled = false;
 
   pi.on("session_start", async (_event, ctx) => {
-    if (!webToolsConfigured) {
-      webToolsConfigured = true;
+    if (!configLoaded) {
+      configLoaded = true;
       const config = loadConfig(ctx.cwd);
       if (config.webTools !== false) {
         webToolsEnabled = true;
         ensureWebToolsRegistered();
       }
+      // The status bar is opt-in: enabled only when the config explicitly sets it true.
+      usageStatusEnabled = config.usageStatus === true;
     }
     // On every session start (including resume/fork/new), re-apply the
     // runtime state. Tools may have been unregistered during teardown.
@@ -104,6 +125,126 @@ export default async function (pi: ExtensionAPI) {
       ensureWebToolsRegistered();
       setWebToolsActive(true);
     }
+    // Start the usage status bar when ollama-cloud is the active provider.
+    if (usageStatusEnabled && isOllamaCloud(ctx)) {
+      startUsageStatus(ctx);
+    }
+  });
+
+  // --- Usage Command ---
+
+  pi.registerCommand("ollama-cloud-usage", {
+    description: "Show Ollama Cloud session and weekly usage limits.",
+    handler: async (_args, ctx) => {
+      const apiKey = await getCloudApiKey(ctx);
+      if (!apiKey) {
+        ctx.ui.notify("No Ollama Cloud API key configured. Set OLLAMA_API_KEY or add to auth.json.", "error");
+        return;
+      }
+      try {
+        const data = await fetchUsage(apiKey);
+        ctx.ui.notify(formatUsage(data), "info");
+      } catch (err) {
+        ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
+      }
+    },
+  });
+
+  // --- Usage Status Bar ---
+
+  // Footer status showing live session/weekly usage 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
+  // @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;
+  // 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);
+    }
+  }
+
+  function startUsageStatus(ctx: ExtensionContext) {
+    if (usageActive) return;
+    // The status bar is TUI-only; skip the fetch and timer in print/json/rpc.
+    if (ctx.mode !== "tui") return;
+    usageActive = true;
+    refreshUsageStatus(ctx);
+    usageTimer = setInterval(() => refreshUsageStatus(ctx), USAGE_REFRESH_MS);
+  }
+
+  function stopUsageStatus(ctx: ExtensionContext) {
+    usageActive = false;
+    if (usageTimer) {
+      clearInterval(usageTimer);
+      usageTimer = null;
+    }
+    ctx.ui.setStatus(USAGE_STATUS_KEY, undefined);
+  }
+
+  function isOllamaCloud(ctx: ExtensionContext): boolean {
+    return ctx.model?.provider === "ollama-cloud";
+  }
+
+  pi.on("model_select", async (_event, ctx) => {
+    if (usageStatusEnabled && isOllamaCloud(ctx)) {
+      startUsageStatus(ctx);
+    } else {
+      stopUsageStatus(ctx);
+    }
+  });
+
+  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.
+    if (usageActive && isOllamaCloud(ctx) && Date.now() - lastRefreshAt >= USAGE_REFRESH_MS) {
+      await refreshUsageStatus(ctx);
+    }
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    stopUsageStatus(ctx);
+  });
+
+  pi.registerCommand("ollama-usage-status", {
+    description:
+      "Enable or disable the Ollama Cloud usage status bar. " +
+      "Accepts optional argument: on/off/enable/disable. Without argument, toggles.",
+    handler: async (args, ctx) => {
+      const { enabled, error } = resolveUsageStatusToggle(args, usageStatusEnabled);
+      if (error) {
+        ctx.ui.notify(error, "error");
+        return;
+      }
+      usageStatusEnabled = enabled;
+
+      if (usageStatusEnabled && isOllamaCloud(ctx)) {
+        startUsageStatus(ctx);
+      } else {
+        stopUsageStatus(ctx);
+      }
+
+      ctx.ui.notify(`Ollama Cloud usage status: ${usageStatusEnabled ? "enabled" : "disabled"}`, "info");
+    },
   });
 
   // Only register the runtime toggle command when the env var doesn't force tools off.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ollama-cloud",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -12,6 +12,7 @@
     "models.generated.ts",
     "pricing.generated.ts",
     "thinking-levels.ts",
+    "usage.ts",
     "utils.ts",
     "web-tools.ts",
     "CHANGELOG.md",

package/usage.ts

@@ -0,0 +1,170 @@
+/**
+ * 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.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { OLLAMA_BASE } from "./models.ts";
+import { fetchJsonWithTimeout, httpError } from "./utils.ts";
+
+// --- Types ---
+
+export interface UsageModel {
+  name: string;
+  request_count: 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 UsageActivity {
+  cost?: string;
+  period?: {
+    type?: string;
+    starting_at?: string;
+    ending_at?: string;
+  };
+}
+
+export interface UsageData {
+  limits: {
+    session: UsageLimit;
+    weekly: UsageLimit;
+  };
+  activity?: UsageActivity;
+}
+
+// --- Constants ---
+
+const USAGE_TIMEOUT_MS = 10000;
+
+// --- Validation ---
+
+/** 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",
+    )
+  );
+}
+
+/** Validate a parsed /api/usage response: must have session and weekly limits. */
+export function isUsageResponse(data: unknown): data is UsageData {
+  if (data == null || typeof data !== "object") return false;
+  const d = data as UsageData;
+  return (
+    d.limits != null && typeof d.limits === "object" && isUsageLimit(d.limits.session) && isUsageLimit(d.limits.weekly)
+  );
+}
+
+// --- Fetch ---
+
+/**
+ * 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}` },
+    },
+    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 === 404) {
+      throw new Error(
+        "Ollama Cloud usage failed: the /api/usage endpoint is unavailable (status 404). " +
+          "It is undocumented and may have changed.",
+      );
+    }
+    httpError("usage", res.status, res.error);
+  }
+  if (!isUsageResponse(res.data)) {
+    throw new Error("Ollama Cloud usage failed: unexpected response shape from the API.");
+  }
+  return res.data;
+}
+
+// --- Formatting ---
+
+/** 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);
+}
+
+/** Format usage for the /ollama-cloud-usage command output. */
+export function formatUsage(data: UsageData): string {
+  const lines: string[] = ["Ollama Cloud usage:"];
+
+  const sessionPct = usagePercent(data.limits.session.usage);
+  lines.push(`  Session (5h): ${sessionPct}%`);
+  for (const m of data.limits.session.models) {
+    lines.push(`    - ${m.name}: ${m.request_count} request${m.request_count === 1 ? "" : "s"}`);
+  }
+
+  const weeklyPct = usagePercent(data.limits.weekly.usage);
+  lines.push(`  Weekly (7d): ${weeklyPct}%`);
+  for (const m of data.limits.weekly.models) {
+    lines.push(`    - ${m.name}: ${m.request_count} request${m.request_count === 1 ? "" : "s"}`);
+  }
+
+  if (typeof data.activity?.cost === "string") {
+    lines.push(`  Activity (4wk): $${data.activity.cost}`);
+  }
+
+  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.
+ * The endpoint exposes reset periods (5h/7d) but not exact timestamps, so the
+ * color reflects the usage fraction rather than pace.
+ */
+export function formatUsageStatusColored(theme: Theme, data: UsageData): string {
+  const session = usagePercent(data.limits.session.usage);
+  const weekly = usagePercent(data.limits.weekly.usage);
+  return `${colorSegment(theme, "5h", session)} ${colorSegment(theme, "7d", weekly)}`;
+}

package/utils.ts

@@ -1,3 +1,5 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
 export async function fetchJsonWithTimeout<T>(
   url: string,
   init: RequestInit,
@@ -75,3 +77,37 @@ export function getContextLength(modelInfo: Record<string, unknown>): number {
   }
   return 128000;
 }
+
+/**
+ * Resolve the Ollama Cloud API key for a tool execution or command.
+ *
+ * Prefers the canonical provider auth chain (ctx.modelRegistry.getApiKeyForProvider),
+ * which honors runtime/CLI key overrides, the registered
+ * apiKey: "$OLLAMA_API_KEY" config, and stored auth.json credentials. Falls back
+ * to the OLLAMA_API_KEY env var for the case where the provider is not yet
+ * registered at call time.
+ */
+export async function getCloudApiKey(ctx: Pick<ExtensionContext, "modelRegistry">): Promise<string | undefined> {
+  return (await ctx.modelRegistry.getApiKeyForProvider("ollama-cloud")) ?? process.env.OLLAMA_API_KEY;
+}
+
+/**
+ * Throw a user-facing error for a non-ok Ollama Cloud HTTP response, mapping
+ * distinct status codes. Shared by the web tools and the usage command.
+ */
+export function httpError(op: string, status: number, error?: string): never {
+  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.`,
+    );
+  }
+  if (status === 429) {
+    throw new Error(`Ollama Cloud ${op} failed: rate limited. Try again shortly.`);
+  }
+  if (status >= 500) {
+    throw new Error(`Ollama Cloud ${op} failed: server error (status ${status}). Try again shortly.`);
+  }
+  throw new Error(
+    `Ollama Cloud ${op} failed: unexpected response (status ${status}${error ? `: ${error}` : ""}). Try again shortly.`,
+  );
+}

package/web-tools.ts

@@ -19,7 +19,6 @@
 import {
   type AgentToolResult,
   type ExtensionAPI,
-  type ExtensionContext,
   keyHint,
   type Theme,
   type ToolRenderResultOptions,
@@ -28,7 +27,7 @@ import {
 import { type Component, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { OLLAMA_BASE } from "./models.ts";
-import { fetchJsonWithTimeout } from "./utils.ts";
+import { fetchJsonWithTimeout, getCloudApiKey, httpError } from "./utils.ts";
 
 // --- Types ---
 
@@ -50,62 +49,11 @@ interface FetchResponse {
 
 const WEB_TOOLS_TIMEOUT_MS = 15000;
 
-/**
- * Resolve the Ollama Cloud API key for a tool execution.
- *
- * Prefers the canonical provider auth chain (ctx.modelRegistry.getApiKeyForProvider),
- * which honors runtime/CLI key overrides, the registered
- * apiKey: "$OLLAMA_API_KEY" config, and stored auth.json credentials. Falls back
- * to the OLLAMA_API_KEY env var for the case where the provider is not yet
- * registered at tool-call time.
- *
- * Exported for unit testing.
- */
-export async function getCloudApiKey(ctx: Pick<ExtensionContext, "modelRegistry">): Promise<string | undefined> {
-  return (await ctx.modelRegistry.getApiKeyForProvider("ollama-cloud")) ?? process.env.OLLAMA_API_KEY;
-}
-
 /** Throw a no-API-key error. */
 function noApiKeyError(): never {
   throw new Error("No Ollama Cloud API key configured. Set OLLAMA_API_KEY or add to auth.json.");
 }
 
-/** Throw a search error for a non-ok result, mapping distinct status codes. */
-function searchError(status: number, error?: string): never {
-  if (status === 401 || status === 403) {
-    throw new Error(
-      "Ollama Cloud search failed: authentication error. " + "Check your API key in OLLAMA_API_KEY or auth.json.",
-    );
-  }
-  if (status === 429) {
-    throw new Error("Ollama Cloud search failed: rate limited. Try again shortly.");
-  }
-  if (status >= 500) {
-    throw new Error(`Ollama Cloud search failed: server error (status ${status}). Try again shortly.`);
-  }
-  throw new Error(
-    `Ollama Cloud search failed: unexpected response (status ${status}${error ? `: ${error}` : ""}). Try again shortly.`,
-  );
-}
-
-/** Throw a fetch error for a non-ok result, mapping distinct status codes. */
-function fetchError(status: number, error?: string): never {
-  if (status === 401 || status === 403) {
-    throw new Error(
-      "Ollama Cloud fetch failed: authentication error. " + "Check your API key in OLLAMA_API_KEY or auth.json.",
-    );
-  }
-  if (status === 429) {
-    throw new Error("Ollama Cloud fetch failed: rate limited. Try again shortly.");
-  }
-  if (status >= 500) {
-    throw new Error(`Ollama Cloud fetch failed: server error (status ${status}). Try again shortly.`);
-  }
-  throw new Error(
-    `Ollama Cloud fetch failed: unexpected response (status ${status}${error ? `: ${error}` : ""}). Try again shortly.`,
-  );
-}
-
 const PREVIEW_LINES = 8;
 
 /**
@@ -232,7 +180,7 @@ export function registerWebSearchTool(pi: ExtensionAPI) {
       );
 
       if (!res.ok) {
-        searchError(res.status, res.error);
+        httpError("search", res.status, res.error);
       }
       if (!isSearchResponse(res.data)) {
         throw new Error("Web search failed: unexpected response shape from the API.");
@@ -287,7 +235,7 @@ export function registerWebFetchTool(pi: ExtensionAPI) {
       );
 
       if (!res.ok) {
-        fetchError(res.status, res.error);
+        httpError("fetch", res.status, res.error);
       }
       if (!isFetchResponse(res.data)) {
         throw new Error("Web fetch failed: unexpected response shape from the API.");