pi-ollama-cloud 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.4.0] - 2026-05-06
+
+- Fix `/api/chat` requests not disabling thinking when Pi's thinking level is set to `off`. Maps Pi `off` to `reasoning_effort: "none"` on models where the API respects it, hides the `off` level on models where it doesn't (gpt-oss, kimi-k2-thinking, minimax, qwen3-vl). (#6)
+- Add `thinking-levels.ts` with curated per-model thinking level maps (DEFAULT, GPT_OSS, QWEN3, NO_OFF), validated against all 24 thinking-capable models via automated experiment (see docs/think-experiment.md).
+- Fix system prompt (AGENTS.md content) not being read by GLM models by setting `supportsDeveloperRole: false` on all registered models.
+- Rename smoke test to test, add lint step.
+- Treat stale local model caches as usable for immediate startup while triggering the same visible refresh flow as `/ollama-cloud-refresh` on `session_start`; use fallback models only when the cache is missing or invalid.
+- Add a single-line `/ollama-cloud-refresh` progress widget showing the current stage, count, percentage, failures, and progress bar.
+- Add thinking on/off assertions to the CI test workflow.
+
 ## [0.3.1] - 2026-05-05
 
 - Fix `OLLAMA_API_KEY` env var not being respected by `fetchModels` and web tools. pi-ai does not know about the `ollama-cloud` provider ID, so `AuthStorage.getApiKey()` alone misses the env var. Added explicit `process.env.OLLAMA_API_KEY` fallback.

package/README.md

@@ -2,14 +2,15 @@
 
 Ollama Cloud provider plugin for [Pi](https://github.com/badlogic/pi-mono) coding agent.
 
-Registers Ollama Cloud as a model provider with dynamically fetched models, and provides `ollama_web_search` and `ollama_web_fetch` tools that use the [Ollama Cloud web search API](https://docs.ollama.com/capabilities/web-search) — no local Ollama server required.
+Registers Ollama Cloud as a model provider with dynamically fetched models, and provides `ollama_web_search` and `ollama_web_fetch` tools that use the [Ollama Cloud web search API](https://docs.ollama.com/capabilities/web-search) - no local Ollama server required.
 
 ## Features
 
 - **Dynamic model discovery** - Fetches the full model list from `ollama.com/v1/models`, then fetches per-model details via `/api/show` to determine capabilities, context length, and tool support.
+- **Curated thinking levels** - Maps Pi's thinking levels to Ollama Cloud's OpenAI-compatible `reasoning_effort` values via `thinking-levels.ts`, with per-model exceptions based on API testing.
 - **Persistent cache** - Raw API responses are cached at `~/.pi/agent/cache/ollama-cloud-models.json` so models are available immediately on startup without hitting the network.
-- **Cold cache fallback** - When no cache exists, a small set of hardcoded models is used until `/ollama-cloud-refresh` is run.
-- **`/ollama-cloud-refresh` command** - Re-fetches the model list from the API and updates the cache and provider registration live (no restart needed).
+- **Startup refresh** - When the local cache is stale, the plugin uses it immediately and then runs the same visible refresh flow as `/ollama-cloud-refresh` once the Pi session UI is available. Missing/invalid caches use a small fallback list until refresh completes.
+- **`/ollama-cloud-refresh` command** - Re-fetches the model list and updates the cache and provider registration live (no restart needed).
 - **`ollama_web_search` tool** - Search the web for real-time information using Ollama Cloud's `/api/web_search` endpoint. Returns titles, URLs, and content snippets.
 - **`ollama_web_fetch` tool** - Fetch and extract text content from a web page URL using Ollama Cloud's `/api/web_fetch` endpoint. Returns page title, content, and links.
 - **Zero cost tracking** - All models are registered with zero costs since Ollama Cloud uses a flat subscription model (Free, Pro, Max) rather than per-token billing. Per-request costs don't apply, so Pi's cost tracker always shows zero. See [ollama.com/pricing](https://ollama.com/pricing) for plan details.
@@ -93,13 +94,13 @@ Accepted disabling values are `0`, `false`, `no`, `off`, or an empty string. Whe
 
 ### 4. Fetch models
 
-On first launch the plugin will use a small set of fallback models. Run:
+On first launch the plugin registers a small hardcoded fallback list, then refreshes model metadata automatically with the same progress widget used by the manual command. If an existing cache is merely stale, that cached model list remains active while refresh runs. You can also run:
 
 ```
 /ollama-cloud-refresh
 ```
 
-This fetches the full model list from the Ollama Cloud API and caches it locally.
+This fetches the full model list from the Ollama Cloud API and overwrites the local cache.
 
 ### 5. Select a model
 
@@ -114,18 +115,40 @@ The plugin uses two Ollama Cloud API endpoints to build the model list:
 
 Only models with the `tools` capability are registered - these are the ones Pi can use for tool-calling.
 
-The raw `/api/show` responses are cached at `~/.pi/agent/cache/ollama-cloud-models.json`. This cache **never expires** - run `/ollama-cloud-refresh` to update it.
+The raw `/api/show` responses are cached at `~/.pi/agent/cache/ollama-cloud-models.json` with a top-level `timestamp` value. If that local cache is older than 30 days, the plugin keeps using it immediately and triggers the visible refresh flow on `session_start`. If the cache is missing or invalid, the plugin registers a small hardcoded model list until refresh succeeds. If no key is available or refresh fails, the current registered list remains active until `/ollama-cloud-refresh` succeeds.
 
 Model metadata is derived from the cached data:
 
 | Field | Source |
 |---|---|
 | `reasoning` | `capabilities` includes `"thinking"` |
+| `thinkingLevelMap` | [`thinking-levels.ts`](thinking-levels.ts) with 4 maps (DEFAULT, GPT_OSS, QWEN3, NO_OFF) based on API testing |
 | `input` | `["text", "image"]` if `capabilities` includes `"vision"`, else `["text"]` |
 | `contextWindow` | `model_info.*.context_length` (falls back to 128000) |
 | `maxTokens` | Fixed at 32768 |
 | `cost` | All zeros (Ollama Cloud uses subscription plans, not per-token billing - see [pricing](https://ollama.com/pricing)) |
 
+### Thinking level mapping
+
+Pi's thinking levels are mapped to Ollama Cloud's OpenAI-compatible `reasoning_effort` parameter in [`thinking-levels.ts`](thinking-levels.ts). The API accepts `none`, `low`, `medium`, `high`, and `max`. Effects of `max` over `high` vary by model and prompt difficulty - see [`docs/think-experiment.md`](docs/think-experiment.md) for details.
+
+| Map | Models | Levels exposed | Notes |
+|---|---|---|---|
+| `DEFAULT` | Most thinking models | off, low, medium, high, xhigh | `minimal` hidden (duplicate of low) |
+| `GPT_OSS` | `gpt-oss*` | low, medium, high | Can't disable thinking, no off or xhigh |
+| `QWEN3` | `qwen3*` (except `qwen3-vl*`) | off, medium | Binary-only (think/nothink), no gradation |
+| `NO_OFF` | `qwen3-vl*`, `kimi-k2-thinking`, `minimax*` | low, medium, high, xhigh | "none" doesn't disable thinking on these models |
+
+See [docs/think-experiment.md](docs/think-experiment.md) for the testing methodology and results.
+
+Refresh from inside Pi:
+
+```text
+/ollama-cloud-refresh
+```
+
+That command updates `~/.pi/agent/cache/ollama-cloud-models.json` with a new `timestamp` and re-registers the provider live, so no restart is required.
+
 ## Tools
 
 | Tool | Description |
@@ -171,7 +194,7 @@ The project uses [Biome](https://biomejs.dev/) for linting and formatting (2-spa
 
 **You can use both at the same time.** The providers live under different names (`ollama` vs `ollama-cloud`), so you can switch between them with `/model` or `Ctrl+L`. For example, use your local `ollama` provider for low-latency work on smaller models, and `ollama-cloud` for direct access to the full catalog of cloud models without needing a local server.
 
-> **Note:** The [`@ollama/pi-web-search`](https://www.npmjs.com/package/@ollama/pi-web-search) package (installed automatically by `ollama launch pi`) calls the **local** Ollama server's `/api/experimental/web_search` and `/api/experimental/web_fetch` endpoints and authenticates via `ollama signin`. This extension's `ollama_web_search` and `ollama_web_fetch` tools use the **cloud** API at `ollama.com/api/web_search` and `ollama.com/api/web_fetch` instead — same API key, no local server required. Both can coexist: the local tools register as `web_search`/`web_fetch` and these register as `ollama_web_search`/`ollama_web_fetch` to avoid name conflicts.
+> **Note:** The [`@ollama/pi-web-search`](https://www.npmjs.com/package/@ollama/pi-web-search) package (installed automatically by `ollama launch pi`) calls the **local** Ollama server's `/api/experimental/web_search` and `/api/experimental/web_fetch` endpoints and authenticates via `ollama signin`. This extension's `ollama_web_search` and `ollama_web_fetch` tools use the **cloud** API at `ollama.com/api/web_search` and `ollama.com/api/web_fetch` instead - same API key, no local server required. Both can coexist: the local tools register as `web_search`/`web_fetch` and these register as `ollama_web_search`/`ollama_web_fetch` to avoid name conflicts.
 
 ## Releasing
 
@@ -184,9 +207,9 @@ npm version minor   # or patch, or major
 git push --tags
 ```
 
-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.
+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.
 
-The workflow uses npm's [trusted publishing](https://docs.npmjs.com/trusted-publishers/) (OIDC) — no tokens stored as secrets. To set it up:
+The workflow uses npm's [trusted publishing](https://docs.npmjs.com/trusted-publishers/) (OIDC) - no tokens stored as secrets. To set it up:
 
 1. Go to [npmjs.com](https://www.npmjs.com) → your avatar → **Packages** → `pi-ollama-cloud` → **Settings** → **Trusted publishing**
 2. Click **GitHub Actions** and enter:
@@ -197,5 +220,5 @@ Each publish also gets automatic [provenance attestation](https://docs.npmjs.com
 
 ## Notes
 
-- Some Ollama Cloud models may reject the `developer` message role, causing a `400` error. If you encounter this, the model may need `compat: { supportsDeveloperRole: false }`. You can edit `index.ts` to add this for specific models, or open an issue to track it.
+- The extension sets `supportsDeveloperRole: false` on all models so the system prompt always uses `role: "system"`. Without this, pi sends the prompt as `role: "developer"` for thinking-capable models, which some models (e.g. GLM-5.1) ignore entirely - the prompt simply isn't read.
 - The fetch timeout is 10 seconds per request. On slow connections, some model detail fetches may time out - the plugin reports how many succeeded vs failed.

package/index.ts

@@ -7,7 +7,7 @@
  *   1. Get an API key from https://ollama.com
  *   2. Add to auth.json in the agent config dir (~/.pi/agent/auth.json, or set PI_CODING_AGENT_DIR):
  *      { "ollama-cloud": { "type": "api_key", "key": "your-key" } }
- *   3. Run /ollama-cloud-refresh to fetch models (uses cache or fallback on boot)
+ *   3. Run /ollama-cloud-refresh to fetch model metadata
  *   4. Use /model or ctrl+l to select an Ollama Cloud model
  *
  * Two endpoints are used to build the model list:
@@ -17,14 +17,22 @@
  * Raw /api/show responses are cached at <agentDir>/cache/ollama-cloud-models.json
  * so the provider assembly can be debugged and re-derived without re-fetching.
  *
- * Cache never expires -- run /ollama-cloud-refresh to update.
- * Cold cache falls back to a small set of hardcoded models.
+ * Local cache entries include timestamp. Stale local caches are used immediately while a visible startup
+ * refresh runs; missing/invalid caches use a small hardcoded model list until refresh completes.
  *
  * Only models with "tools" capability are registered.
  */
 
 import type { ExtensionAPI, ExtensionCommandContext, ProviderModelConfig } from "@mariozechner/pi-coding-agent";
-import { assembleModels, FALLBACK_MODELS, fetchModels, OLLAMA_BASE, readCache, writeCache } from "./models.ts";
+import {
+  assembleModels,
+  FALLBACK_MODELS,
+  fetchModels,
+  OLLAMA_BASE,
+  type RefreshProgress,
+  readCacheState,
+  writeCache,
+} from "./models.ts";
 import { registerWebFetchTool, registerWebSearchTool } from "./web-tools.ts";
 
 /**
@@ -48,30 +56,66 @@ function registerProvider(pi: ExtensionAPI, models: ProviderModelConfig[]) {
   });
 }
 
-function registerRefreshCommand(pi: ExtensionAPI) {
-  pi.registerCommand("ollama-cloud-refresh", {
-    description: "Refresh Ollama Cloud models from the API",
-    handler: async (_args: string, ctx: ExtensionCommandContext) => {
-      ctx.ui.setWorkingMessage("Refreshing Ollama Cloud models...");
+function renderProgressBar(current: number, total: number, width = 15): string {
+  if (total <= 0) return `[${"░".repeat(width)}]`;
+  const ratio = Math.max(0, Math.min(1, current / total));
+  const filled = Math.round(ratio * width);
+  return `[${"█".repeat(filled)}${"░".repeat(width - filled)}]`;
+}
 
-      const raw = await fetchModels(ctx);
-      if (!raw) {
-        ctx.ui.setWorkingMessage();
-        return;
-      }
+function createRefreshProgressUi(ctx: Pick<ExtensionCommandContext, "ui">) {
+  const key = "ollama-cloud-refresh";
+  return {
+    update(progress: RefreshProgress) {
+      const current = progress.current ?? 0;
+      const total = progress.total ?? 0;
+      const percent = total > 0 ? Math.round((current / total) * 100) : 0;
+      const failed = progress.failed ? `, ${progress.failed} failed` : "";
+      const stage =
+        progress.stage === "list"
+          ? "Discovering models"
+          : progress.stage === "details"
+            ? "Fetching model details"
+            : "Done";
+      const summary = total > 0 ? `${current}/${total} (${percent}%${failed})` : progress.message;
+      const line = `☁ Ollama Cloud - ${stage} — ${summary} ${renderProgressBar(current, total)}`;
 
-      writeCache(raw);
-      const newModels = assembleModels(raw);
+      ctx.ui.setWorkingMessage(`Refreshing Ollama Cloud models - ${stage.toLowerCase()}`);
+      ctx.ui.setWidget(key, [line], { placement: "belowEditor" });
+    },
+    clear() {
+      ctx.ui.setWidget(key, undefined);
+      ctx.ui.setStatus(key, undefined);
+      ctx.ui.setWorkingMessage();
+    },
+  };
+}
 
-      // NOTE: Some models may trigger errors like:
-      //   Error: 400 "developer is not one of ['system', 'assistant', 'user', 'tool', 'function']"
-      // If that comes up, consider setting `supportsDeveloperRole: false` in the compat field
-      // for the provider or specific models, e.g.:
-      //   compat: { supportsDeveloperRole: false }
-      registerProvider(pi, newModels);
+async function runRefresh(pi: ExtensionAPI, ctx: Pick<ExtensionCommandContext, "ui">) {
+  const progressUi = createRefreshProgressUi(ctx);
+  try {
+    progressUi.update({ stage: "list", message: "Starting refresh..." });
 
-      ctx.ui.notify(`Registered ${newModels.length} Ollama Cloud models`, "info");
-      ctx.ui.setWorkingMessage();
+    const raw = await fetchModels(ctx, (progress) => progressUi.update(progress));
+    if (!raw) return false;
+
+    writeCache(raw);
+    const newModels = assembleModels(raw);
+
+    registerProvider(pi, newModels);
+
+    ctx.ui.notify(`Registered ${newModels.length} Ollama Cloud models`, "info");
+    return true;
+  } finally {
+    progressUi.clear();
+  }
+}
+
+function registerRefreshCommand(pi: ExtensionAPI) {
+  pi.registerCommand("ollama-cloud-refresh", {
+    description: "Refresh Ollama Cloud models from the API",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      await runRefresh(pi, ctx);
     },
   });
 }
@@ -79,12 +123,22 @@ function registerRefreshCommand(pi: ExtensionAPI) {
 // --- Main ---
 
 export default async function (pi: ExtensionAPI) {
-  const cached = readCache();
-  const models = cached ? assembleModels(cached) : FALLBACK_MODELS;
+  const cacheState = readCacheState();
+  const needsStartupRefresh = cacheState.status !== "fresh";
+  const models = cacheState.status === "missing" ? FALLBACK_MODELS : assembleModels(cacheState.models);
 
   registerProvider(pi, models);
   registerRefreshCommand(pi);
 
+  if (needsStartupRefresh) {
+    let started = false;
+    pi.on("session_start", async (_event, ctx) => {
+      if (started) return;
+      started = true;
+      await runRefresh(pi, ctx);
+    });
+  }
+
   if (!WEB_TOOLS_DISABLED) {
     registerWebSearchTool(pi);
     registerWebFetchTool(pi);

package/models.ts

@@ -1,19 +1,20 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { getModels, getProviders } from "@mariozechner/pi-ai";
 import {
   AuthStorage,
   type ExtensionCommandContext,
   getAgentDir,
   type ProviderModelConfig,
 } from "@mariozechner/pi-coding-agent";
+import { resolve as resolveThinkingLevelMap } from "./thinking-levels.ts";
+import { concurrentMap, fetchJsonWithTimeout, getContextLength } from "./utils.ts";
 
 // --- Constants ---
 const CACHE_DIR = join(getAgentDir(), "cache");
 const CACHE_FILE = join(CACHE_DIR, "ollama-cloud-models.json");
+const CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
 const FETCH_TIMEOUT_MS = 10000;
 
-// --- API fetch ---
 export const OLLAMA_BASE = (process.env.OLLAMA_API_BASE || "https://ollama.com").replace(/\/+$/, "");
 
 // Initialize AuthStorage
@@ -21,7 +22,7 @@ const authStorage = AuthStorage.create();
 
 // --- Raw API types ---
 /** Response from POST /api/show */
-export interface OllamaShowResponse {
+interface OllamaShowResponse {
   details: {
     parent_model: string;
     format: string;
@@ -35,82 +36,39 @@ export interface OllamaShowResponse {
   modified_at: string;
 }
 
-/** On-disk cache: raw /api/show responses keyed by model ID */
-interface CachedData {
-  timestamp: number;
-  models: Record<string, OllamaShowResponse>;
-}
+type CachedOllamaModel = OllamaShowResponse;
 
-// --- Assembly: raw API data -> ProviderModelConfig[] ---
-function getContextLength(modelInfo: Record<string, unknown>): number {
-  for (const [key, value] of Object.entries(modelInfo)) {
-    if (key.endsWith(".context_length") && typeof value === "number") {
-      return value;
-    }
-  }
-  return 128000;
+/** On-disk cache: raw /api/show responses keyed by model ID. */
+interface CachedData {
+  /** Unix epoch milliseconds used to decide when the generated metadata is stale. */
+  timestamp?: number;
+  models: Record<string, CachedOllamaModel>;
 }
 
-// --- Built-in model knowledge index ---
-// Build a lookup of model ID -> thinkingLevelMap from pi's built-in models.
-// This avoids hardcoding model-family mappings: when pi-mono updates its
-// model definitions (e.g. DeepSeek V4's thinking levels), the extension
-// picks up the changes automatically.
-const BUILTIN_THINKING_MAP: Record<string, ProviderModelConfig["thinkingLevelMap"]> = {};
-// Fallback: family stem -> [stem, thinkingLevelMap] pairs for models whose Ollama Cloud
-// ID doesn't match exactly.  The stem is derived by stripping provider prefixes and
-// non-alphanumeric characters (e.g. "gemma-4-31b-it" -> "gemma431bit").
-// When looking up an Ollama model by its details.family field, we search for a pi stem
-// that starts with the family stem (e.g. family "gemma4" -> pi "gemma431bit").
-// Entries are sorted longest-first so the most specific match wins.
-const BUILTIN_FAMILY_ENTRIES: [string, NonNullable<ProviderModelConfig["thinkingLevelMap"]>][] = [];
-for (const provider of getProviders()) {
-  for (const model of getModels(provider as any)) {
-    if (model.thinkingLevelMap) {
-      BUILTIN_THINKING_MAP[model.id] = model.thinkingLevelMap;
-      const stem = model.id
-        .replace(/^[a-z0-9-]+\//, "") // strip provider prefix (e.g. "zai/", "deepseek/")
-        .replace(/[^a-zA-Z0-9]/g, "") // strip non-alphanumeric
-        .toLowerCase();
-      BUILTIN_FAMILY_ENTRIES.push([stem, model.thinkingLevelMap]);
-    }
-  }
-}
-// Longest stems first so a more specific match (e.g. "gemma431bit") wins over a generic one (e.g. "gemma4").
-BUILTIN_FAMILY_ENTRIES.sort((a, b) => b[0].length - a[0].length);
-
-function resolveThinkingLevelMap(modelId: string, data: OllamaShowResponse): ProviderModelConfig["thinkingLevelMap"] {
-  // 1. Exact ID match (e.g. "deepseek-v4-pro")
-  const exact = BUILTIN_THINKING_MAP[modelId];
-  if (exact) return exact;
-
-  // 2. Family-based fallback: match Ollama's details.family against pi model stems
-  if (data.capabilities?.includes("thinking")) {
-    const familyStem = data.details?.family?.replace(/[^a-zA-Z0-9]/g, "").toLowerCase() ?? "";
-    if (familyStem) {
-      for (const [stem, tlm] of BUILTIN_FAMILY_ENTRIES) {
-        if (stem.startsWith(familyStem)) {
-          return tlm;
-        }
-      }
-    }
-  }
+type RefreshProgressStage = "list" | "details" | "done";
 
-  return undefined;
+export interface RefreshProgress {
+  stage: RefreshProgressStage;
+  current?: number;
+  total?: number;
+  failed?: number;
+  message: string;
 }
 
-export function assembleModels(raw: Record<string, OllamaShowResponse>): ProviderModelConfig[] {
+// --- Assembly: raw API data -> ProviderModelConfig[] ---
+export function assembleModels(raw: Record<string, CachedOllamaModel>): ProviderModelConfig[] {
   return Object.entries(raw)
     .filter(([, data]) => data.capabilities?.includes("tools"))
     .map(([id, data]) => ({
       id,
       name: id,
       reasoning: data.capabilities?.includes("thinking") ?? false,
-      thinkingLevelMap: resolveThinkingLevelMap(id, data),
+      thinkingLevelMap: resolveThinkingLevelMap(id, data.capabilities ?? []),
       input: (data.capabilities?.includes("vision") ? ["text", "image"] : ["text"]) as ("text" | "image")[],
       cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
       contextWindow: getContextLength(data.model_info ?? {}),
       maxTokens: 32768,
+      compat: { supportsDeveloperRole: false },
     }));
 }
 
@@ -124,6 +82,7 @@ export const FALLBACK_MODELS: ProviderModelConfig[] = [
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
     contextWindow: 202752,
     maxTokens: 32768,
+    compat: { supportsDeveloperRole: false },
   },
   {
     id: "gemma4:31b",
@@ -133,102 +92,216 @@ export const FALLBACK_MODELS: ProviderModelConfig[] = [
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
     contextWindow: 262144,
     maxTokens: 32768,
+    compat: { supportsDeveloperRole: false },
+  },
+  {
+    id: "deepseek-v4-pro",
+    name: "DeepSeek V4 Pro",
+    reasoning: true,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 1000000,
+    maxTokens: 32768,
+    compat: { supportsDeveloperRole: false },
+  },
+  {
+    id: "qwen3.5",
+    name: "Qwen 3.5",
+    reasoning: true,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 131072,
+    maxTokens: 32768,
+    compat: { supportsDeveloperRole: false },
+  },
+  {
+    id: "kimi-k2.6",
+    name: "Kimi K2.6",
+    reasoning: true,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 131072,
+    maxTokens: 32768,
+    compat: { supportsDeveloperRole: false },
   },
 ];
 
 // --- Cache I/O ---
-export function readCache(): Record<string, OllamaShowResponse> | null {
+type CacheState =
+  | { status: "fresh"; models: Record<string, CachedOllamaModel> }
+  | { status: "stale"; models: Record<string, CachedOllamaModel> }
+  | { status: "missing" };
+
+function createCacheData(models: Record<string, CachedOllamaModel>, now = new Date()): CachedData {
+  return { timestamp: now.getTime(), models };
+}
+
+function readCacheData(path: string): CachedData | null {
   try {
-    if (!existsSync(CACHE_FILE)) return null;
-    const data: CachedData = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    const data: CachedData = JSON.parse(readFileSync(path, "utf-8"));
     if (!data.models || Object.keys(data.models).length === 0) return null;
-    return data.models;
+    return data;
   } catch {
     return null;
   }
 }
 
-export function writeCache(models: Record<string, OllamaShowResponse>): void {
+function isFreshGeneratedCache(data: CachedData): boolean {
+  if (typeof data.timestamp !== "number" || !Number.isFinite(data.timestamp)) return false;
+  return Date.now() - data.timestamp <= CACHE_MAX_AGE_MS;
+}
+
+export function readCacheState(): CacheState {
+  if (!existsSync(CACHE_FILE)) return { status: "missing" };
+
+  const data = readCacheData(CACHE_FILE);
+  if (!data) {
+    try {
+      rmSync(CACHE_FILE, { force: true });
+    } catch {
+      // Ignore cache delete errors.
+    }
+    return { status: "missing" };
+  }
+
+  return isFreshGeneratedCache(data)
+    ? { status: "fresh", models: data.models }
+    : { status: "stale", models: data.models };
+}
+
+export function writeCache(models: Record<string, CachedOllamaModel>): void {
   try {
     mkdirSync(CACHE_DIR, { recursive: true });
-    writeFileSync(CACHE_FILE, JSON.stringify({ timestamp: Date.now(), models } satisfies CachedData, null, 2));
+    writeFileSync(CACHE_FILE, JSON.stringify(createCacheData(models), null, 2));
   } catch {
     // Ignore cache write errors
   }
 }
 
 // --- Fetch Models ---
-export async function fetchModels(ctx: ExtensionCommandContext): Promise<Record<string, OllamaShowResponse> | null> {
-  const apiKey = (await authStorage.getApiKey("ollama-cloud")) ?? process.env.OLLAMA_API_KEY;
-
-  if (!apiKey) {
-    ctx.ui.notify(
-      "No Ollama Cloud API key found. \n" +
-        "Please ensure your API key is set in: \n" +
-        "- auth.json file (at ~/.pi/agent/auth.json) under 'ollama-cloud' key,\n" +
-        "- or via the CLI --api-key flag.\n" +
-        "Example auth.json entry: \n" +
-        '{ "ollama-cloud": { "type": "api_key", "key": "YOUR_API_KEY" } }',
-      "error",
-    );
-    return null;
-  }
+async function fetchModelIds(apiKey: string, timeoutMs = FETCH_TIMEOUT_MS): Promise<string[]> {
+  const res = await fetchJsonWithTimeout<{ data: { id: string }[] }>(
+    `${OLLAMA_BASE}/v1/models`,
+    { headers: { Authorization: `Bearer ${apiKey}` } },
+    timeoutMs,
+  );
+  if (!res.ok || !res.data)
+    throw new Error(`Failed to fetch model list: ${res.status}${res.error ? ` - ${res.error}` : ""}`);
+  return res.data.data.map((m) => m.id);
+}
 
-  // 1. Fetch model list from /v1/models
-  let modelIds: string[];
-  const listController = new AbortController();
-  const listTimeout = setTimeout(() => listController.abort(), FETCH_TIMEOUT_MS);
-  try {
-    const res = await fetch(`${OLLAMA_BASE}/v1/models`, {
-      headers: { Authorization: `Bearer ${apiKey}` },
-      signal: listController.signal,
-    });
-    if (!res.ok) {
-      ctx.ui.notify(`Failed to fetch model list: ${res.status}`, "error");
-      return null;
+async function fetchModelDetails(apiKey: string, id: string, timeoutMs = FETCH_TIMEOUT_MS): Promise<CachedOllamaModel> {
+  const res = await fetchJsonWithTimeout<OllamaShowResponse>(
+    `${OLLAMA_BASE}/api/show`,
+    {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ model: id }),
+    },
+    timeoutMs,
+  );
+  if (!res.ok || !res.data)
+    throw new Error(`Failed to fetch /api/show for ${id}: ${res.status}${res.error ? ` - ${res.error}` : ""}`);
+  return res.data;
+}
+
+async function refreshOllamaCloudModels(params: {
+  apiKey: string;
+  notify?: (message: string, level?: "info" | "error") => void;
+  onProgress?: (progress: RefreshProgress) => void;
+  workers?: number;
+}): Promise<Record<string, CachedOllamaModel>> {
+  const notify = params.notify ?? (() => undefined);
+  const onProgress = params.onProgress ?? (() => undefined);
+  onProgress({ stage: "list", message: "Fetching model list..." });
+  const modelIds = await fetchModelIds(params.apiKey);
+  notify(`Found ${modelIds.length} models, fetching details...`);
+  onProgress({ stage: "details", current: 0, total: modelIds.length, failed: 0, message: "Fetching model details" });
+
+  let detailsDone = 0;
+  let detailsFailed = 0;
+  const detailResults = await concurrentMap(modelIds, params.workers ?? 8, async (id) => {
+    try {
+      return [id, await fetchModelDetails(params.apiKey, id)] as const;
+    } catch (error) {
+      detailsFailed++;
+      throw error;
+    } finally {
+      detailsDone++;
+      onProgress({
+        stage: "details",
+        current: detailsDone,
+        total: modelIds.length,
+        failed: detailsFailed,
+        message: "Fetching model details",
+      });
+    }
+  });
+  const models: Record<string, CachedOllamaModel> = {};
+  for (const result of detailResults) {
+    if (result.status === "fulfilled") {
+      const [id, data] = result.value;
+      models[id] = data;
     }
-    const data = (await res.json()) as { data: { id: string }[] };
-    modelIds = data.data.map((m) => m.id);
-    ctx.ui.notify(`Found ${modelIds.length} models, fetching details...`);
-  } catch {
-    ctx.ui.notify("Failed to fetch Ollama Cloud models", "error");
-    return null;
-  } finally {
-    clearTimeout(listTimeout);
   }
+  const succeeded = Object.keys(models).length;
+  if (succeeded === 0)
+    throw new Error(`Failed to fetch model details${detailsFailed ? ` (${detailsFailed} failed)` : ""}`);
+  notify(`Fetched ${succeeded} model details${detailsFailed ? ` (${detailsFailed} failed)` : ""}`, "info");
 
-  // 2. Fetch /api/show for each model in parallel
-  const results: Record<string, OllamaShowResponse> = {};
-  await Promise.allSettled(
-    modelIds.map(async (id) => {
-      const showController = new AbortController();
-      const showTimeout = setTimeout(() => showController.abort(), FETCH_TIMEOUT_MS);
-      try {
-        const res = await fetch(`${OLLAMA_BASE}/api/show`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({ model: id }),
-          signal: showController.signal,
-        });
-        if (!res.ok) throw new Error(`status ${res.status}`);
-        const showData = (await res.json()) as OllamaShowResponse;
-        results[id] = showData;
-      } finally {
-        clearTimeout(showTimeout);
-      }
-    }),
-  );
+  onProgress({
+    stage: "done",
+    current: Object.keys(models).length,
+    total: Object.keys(models).length,
+    message: "Done",
+  });
+  return models;
+}
+
+async function getOllamaCloudApiKey(): Promise<string | undefined> {
+  return (await authStorage.getApiKey("ollama-cloud")) ?? process.env.OLLAMA_API_KEY;
+}
 
-  const succeeded = Object.keys(results).length;
-  const failed = modelIds.length - succeeded;
-  if (succeeded === 0) {
-    ctx.ui.notify(`Failed to fetch model details${failed ? ` (${failed} failed)` : ""}`, "error");
+async function refreshModelsFromAuth(
+  params: {
+    notify?: (message: string, level?: "info" | "error") => void;
+    onProgress?: (progress: RefreshProgress) => void;
+  } = {},
+): Promise<Record<string, CachedOllamaModel> | null> {
+  const apiKey = await getOllamaCloudApiKey();
+  if (!apiKey) return null;
+
+  return refreshOllamaCloudModels({
+    apiKey,
+    notify: params.notify,
+    onProgress: params.onProgress,
+  });
+}
+
+export async function fetchModels(
+  ctx: Pick<ExtensionCommandContext, "ui">,
+  onProgress?: (progress: RefreshProgress) => void,
+): Promise<Record<string, CachedOllamaModel> | null> {
+  try {
+    const result = await refreshModelsFromAuth({
+      notify: (message, level) => ctx.ui.notify(message, level),
+      onProgress,
+    });
+    if (!result) {
+      ctx.ui.notify(
+        "No Ollama Cloud API key found. \n" +
+          "Please ensure your API key is set in either: \n" +
+          "- OLLAMA_API_KEY environment variable,\n" +
+          "- auth.json file (at ~/.pi/agent/auth.json) under 'ollama-cloud' key,\n" +
+          "- or via the CLI --api-key flag.\n" +
+          "Example auth.json entry: \n" +
+          '{ "ollama-cloud": { "type": "api_key", "key": "YOUR_API_KEY" } }',
+        "error",
+      );
+    }
+    return result;
+  } catch (error) {
+    ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
     return null;
   }
-  ctx.ui.notify(`Fetched ${succeeded} model details${failed ? ` (${failed} failed)` : ""}`, "info");
-
-  return results;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ollama-cloud",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -8,6 +8,8 @@
   "files": [
     "index.ts",
     "models.ts",
+    "thinking-levels.ts",
+    "utils.ts",
     "web-tools.ts",
     "CHANGELOG.md",
     "README.md",

package/thinking-levels.ts

@@ -0,0 +1,84 @@
+/**
+ * Thinking level mapping for Ollama Cloud models.
+ *
+ * Maps Pi's thinking levels to Ollama Cloud's OpenAI-compatible
+ * `reasoning_effort` values. The API accepts "none", "low", "medium",
+ * "high", and "max". On simple prompts, "max" can be a no-op over
+ * "high", but on harder prompts it can increase thinking substantially
+ * (e.g. deepseek-v4-pro: ~32k tokens on high vs ~55k on max).
+ *
+ * A `null` value means the level is hidden in Pi's UI.
+ *
+ * Model-specific behavior discovered through testing (see docs/think-experiment.md):
+ *   - Most models: all levels work, "none" disables thinking
+ *   - GPT-OSS: no off mode, only low/medium/high
+ *   - Qwen 3.x (non-VL): binary-only (think/nothink) - off works
+ *   - Qwen 3 VL: "none" doesn't disable thinking - off is hidden
+ *   - Kimi K2 Thinking: "none" doesn't disable thinking - off is hidden
+ *   - MiniMax M2.x: "none" doesn't disable thinking - off is hidden
+ *
+ * Reference: https://docs.ollama.com/api/openai-compatibility
+ */
+
+import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
+
+export type ThinkingLevelMap = NonNullable<ProviderModelConfig["thinkingLevelMap"]>;
+
+/** Default: off/low/medium/high/xhigh with minimal hidden. */
+export const DEFAULT: ThinkingLevelMap = {
+  off: "none",
+  minimal: null,
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "max",
+};
+
+/** GPT-OSS: can't disable thinking, only low/medium/high.
+ *  https://ollama.com/library/gpt-oss */
+export const GPT_OSS: ThinkingLevelMap = {
+  off: null,
+  minimal: null,
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: null,
+};
+
+/** Qwen 3.x: binary-only (think/nothink), no gradation.
+ *  https://docs.ollama.com/capabilities/thinking */
+export const QWEN3: ThinkingLevelMap = {
+  off: "none",
+  minimal: null,
+  low: null,
+  medium: "medium",
+  high: null,
+  xhigh: null,
+};
+
+/** "none" doesn't disable thinking - off is hidden.
+ *  Used by kimi and minimax families. */
+export const NO_OFF: ThinkingLevelMap = {
+  off: null,
+  minimal: null,
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "max",
+};
+
+/**
+ * Resolve the thinking level map for a model.
+ * Matches by model ID prefix (case-sensitive, checks first chars).
+ */
+export function resolve(id: string, capabilities: string[]): ThinkingLevelMap | undefined {
+  if (!capabilities.includes("thinking")) return undefined;
+
+  if (id.startsWith("gpt-oss")) return GPT_OSS;
+  if (id.startsWith("qwen3-vl")) return NO_OFF;
+  if (id.startsWith("qwen3")) return QWEN3;
+  if (id === "kimi-k2-thinking") return NO_OFF;
+  if (id.startsWith("minimax")) return NO_OFF;
+
+  return DEFAULT;
+}

package/utils.ts

@@ -0,0 +1,60 @@
+export async function fetchJsonWithTimeout<T>(
+  url: string,
+  init: RequestInit,
+  timeoutMs: number,
+): Promise<{ ok: boolean; status: number; data: T | null; error?: string }> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { ...init, signal: controller.signal });
+    const text = await res.text();
+    let data: T | null = null;
+    try {
+      data = text ? (JSON.parse(text) as T) : null;
+    } catch {
+      // Keep data null and report text below.
+    }
+    const error =
+      data && typeof data === "object" && "error" in data
+        ? typeof (data as { error: unknown }).error === "object"
+          ? JSON.stringify((data as { error: unknown }).error)
+          : String((data as { error: unknown }).error)
+        : text;
+    return { ok: res.ok, status: res.status, data, error: res.ok ? undefined : error };
+  } catch (error) {
+    return { ok: false, status: 0, data: null, error: error instanceof Error ? error.message : String(error) };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function concurrentMap<T, R>(
+  items: T[],
+  workers: number,
+  fn: (item: T) => Promise<R>,
+): Promise<PromiseSettledResult<R>[]> {
+  const results: PromiseSettledResult<R>[] = new Array(items.length);
+  let next = 0;
+  await Promise.all(
+    Array.from({ length: Math.max(1, workers) }, async () => {
+      while (next < items.length) {
+        const index = next++;
+        try {
+          results[index] = { status: "fulfilled", value: await fn(items[index]) };
+        } catch (reason) {
+          results[index] = { status: "rejected", reason };
+        }
+      }
+    }),
+  );
+  return results;
+}
+
+export function getContextLength(modelInfo: Record<string, unknown>): number {
+  for (const [key, value] of Object.entries(modelInfo)) {
+    if (key.endsWith(".context_length") && typeof value === "number") {
+      return value;
+    }
+  }
+  return 128000;
+}