pi-ollama-cloud 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fabio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,191 @@
+# pi-ollama-cloud
+
+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.
+
+## 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.
+- **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).
+- **`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.
+
+## Prerequisites
+
+- An [Ollama Cloud API key](https://ollama.com)
+
+## Installation
+
+### Option 1: from npm (recommended)
+
+```bash
+pi install npm:pi-ollama-cloud
+```
+
+This installs the latest published version from npm. Run `pi update` to get new versions.
+
+### Option 2: from git
+
+```bash
+pi install git:github.com/fgrehm/pi-ollama-cloud
+```
+
+This clones the repo to `~/.pi/agent/git/` and adds it to your settings.
+
+For project-local install (stored in `.pi/git/`):
+
+```bash
+pi install git:github.com/fgrehm/pi-ollama-cloud --local
+```
+
+### Option 3: `-e` flag (try without installing)
+
+```bash
+pi -e npm:pi-ollama-cloud
+```
+
+### Option 4: Clone manually (if you want to make changes and "try it live")
+
+Pi auto-discovers subdirectories under `~/.pi/agent/extensions/`:
+
+```bash
+git clone git@github.com:fgrehm/pi-ollama-cloud.git ~/.pi/agent/extensions/pi-ollama-cloud
+```
+
+## Setup
+
+### 1. Get an API key
+
+Sign up at [ollama.com](https://ollama.com) and generate an API key.
+
+### 2. Configure the API key
+
+Either set the `OLLAMA_API_KEY` environment variable:
+
+```bash
+export OLLAMA_API_KEY="your-key"
+```
+
+Or add it to `~/.pi/agent/auth.json`:
+
+```json
+{
+  "ollama-cloud": {
+    "type": "api_key",
+    "key": "your-key"
+  }
+}
+```
+
+### 3. Fetch models
+
+On first launch the plugin will use a small set of fallback models. Run:
+
+```
+/ollama-cloud-refresh
+```
+
+This fetches the full model list from the Ollama Cloud API and caches it locally.
+
+### 4. Select a model
+
+Use `/model` or `Ctrl+L` to switch to an Ollama Cloud model. Models appear under the `ollama-cloud` provider.
+
+## How it works
+
+The plugin uses two Ollama Cloud API endpoints to build the model list:
+
+1. **`GET https://ollama.com/v1/models`** - Returns a list of all available model IDs.
+2. **`POST https://ollama.com/api/show`** - For each model, fetches details including capabilities (`tools`, `thinking`, `vision`) and context length.
+
+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.
+
+Model metadata is derived from the cached data:
+
+| Field | Source |
+|---|---|
+| `reasoning` | `capabilities` includes `"thinking"` |
+| `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)) |
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `ollama_web_search` | Search the web via Ollama Cloud's `/api/web_search` |
+| `ollama_web_fetch` | Fetch a web page via Ollama Cloud's `/api/web_fetch` |
+
+Both tools use the same Ollama Cloud API key configured for the provider. No local Ollama server is needed.
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `/ollama-cloud-refresh` | Fetch models from the Ollama Cloud API, update cache, and re-register the provider |
+
+## Development
+
+```bash
+npm install          # install devDependencies (biome)
+npm run check        # lint + format with auto-fix
+npm run lint        # lint only (no fixes)
+npm run format      # format only
+```
+
+The project uses [Biome](https://biomejs.dev/) for linting and formatting (2-space indent, line width 120).
+
+## How is this different from `ollama launch pi`?
+
+[`ollama launch pi`](https://docs.ollama.com/integrations/pi) is Ollama's built-in one-command setup that configures Pi to talk to your **local Ollama server**. Both local and cloud models work - cloud models (e.g. `qwen3.5:cloud`) are proxied through your local server to `ollama.com`. This extension takes a different approach: it connects Pi **directly** to Ollama's hosted API at `ollama.com`, bypassing the local server entirely.
+
+| | `ollama launch pi` | `pi-ollama-cloud` |
+|---|---|---|
+| **Provider name** | `ollama` | `ollama-cloud` |
+| **Endpoint** | Local Ollama server (`http://localhost:11434/v1`) | Ollama Cloud (`https://ollama.com/v1`) |
+| **Local models** | ✅ Run on your machine | ❌ Not available |
+| **Cloud models** | ✅ Proxied through local server (e.g. `qwen3.5:cloud`) | ✅ Connected directly |
+| **Local Ollama required?** | Yes - must be installed and running | No - works without any local server |
+| **Authentication** | Handled by the local server (sign-in flow via `ollama`) | Ollama Cloud API key (set via `OLLAMA_API_KEY` or `auth.json`) |
+| **Model discovery** | Interactive picker with curated recommendations + pulled models | Dynamic - fetches all available cloud models with tool support from the API |
+| **Web tools** | Auto-installed (`@ollama/pi-web-search`) when cloud is enabled | ✅ Built-in: `ollama_web_search` and `ollama_web_fetch` use the [Ollama Cloud web search API](https://docs.ollama.com/capabilities/web-search) directly (same API key, no local server needed) |
+| **Setup effort** | One command: `ollama launch pi` | Install extension + API key + `/ollama-cloud-refresh` |
+| **Use when** | You're already running Ollama locally and want the default experience | You don't want to run a local server, or want a standalone cloud-only provider alongside your local setup |
+
+**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.
+
+## Releasing
+
+Publishing a new version to npm is a two-command process:
+
+```bash
+# 1. 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
+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 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:
+   - **Workflow filename**: `publish.yml`
+3. Save
+
+Each publish also gets automatic [provenance attestation](https://docs.npmjs.com/generating-provenance-statements).
+
+## 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 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

@@ -0,0 +1,471 @@
+/**
+ * Ollama Cloud Provider Extension
+ *
+ * Registers Ollama Cloud as a model provider with dynamically fetched models.
+ *
+ * Setup:
+ *   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)
+ *   4. Use /model or ctrl+l to select an Ollama Cloud model
+ *
+ * Two endpoints are used to build the model list:
+ *   - GET  https://ollama.com/v1/models  → list of model IDs
+ *   - POST https://ollama.com/api/show   → per-model details (capabilities, context length)
+ *
+ * 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.
+ *
+ * Only models with "tools" capability are registered.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+  type ProviderModelConfig,
+  getAgentDir,
+  keyHint,
+  truncateToVisualLines,
+} from "@mariozechner/pi-coding-agent";
+import { Text, truncateToWidth } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+
+const CACHE_DIR = join(getAgentDir(), "cache");
+const CACHE_FILE = join(CACHE_DIR, "ollama-cloud-models.json");
+const FETCH_TIMEOUT_MS = 10000;
+
+/**
+ * Base URL for the Ollama Cloud API.
+ * Defaults to "https://ollama.com"; override with OLLAMA_API_BASE to point at a proxy or self-hosted instance.
+ */
+const OLLAMA_BASE = process.env.OLLAMA_API_BASE || "https://ollama.com";
+
+// --- 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>;
+  capabilities: string[];
+  modified_at: string;
+}
+
+/** On-disk cache: raw /api/show responses keyed by model ID */
+interface CachedData {
+  timestamp: number;
+  models: Record<string, 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;
+}
+
+function assembleModels(raw: Record<string, OllamaShowResponse>): ProviderModelConfig[] {
+  return Object.entries(raw)
+    .filter(([, data]) => data.capabilities?.includes("tools"))
+    .map(([id, data]) => ({
+      id,
+      name: id,
+      reasoning: data.capabilities?.includes("thinking") ?? false,
+      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,
+    }));
+}
+
+// --- Fallback models (cold cache) ---
+
+const FALLBACK_MODELS: ProviderModelConfig[] = [
+  {
+    id: "glm-5.1:cloud",
+    name: "GLM 5.1 Cloud",
+    reasoning: true,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 202752,
+    maxTokens: 32768,
+  },
+  {
+    id: "gemma4:cloud",
+    name: "Gemma 4 Cloud",
+    reasoning: true,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 262144,
+    maxTokens: 32768,
+  },
+];
+
+// --- Cache I/O ---
+
+function readCache(): Record<string, OllamaShowResponse> | null {
+  try {
+    if (!existsSync(CACHE_FILE)) return null;
+    const data: CachedData = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    if (!data.models || Object.keys(data.models).length === 0) return null;
+    return data.models;
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(models: Record<string, OllamaShowResponse>): void {
+  try {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(CACHE_FILE, JSON.stringify({ timestamp: Date.now(), models } satisfies CachedData, null, 2));
+  } catch {
+    // Ignore cache write errors
+  }
+}
+
+// --- API fetch ---
+
+async function fetchModels(ctx: ExtensionCommandContext): Promise<Record<string, OllamaShowResponse>> {
+  const apiKey = await ctx.modelRegistry.getApiKeyForProvider("ollama-cloud");
+  if (!apiKey) {
+    ctx.ui.notify("No Ollama Cloud API key configured (auth.json or OLLAMA_API_KEY env var)", "error");
+    return {};
+  }
+
+  // 1. Fetch model list from /v1/models
+  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 {};
+    }
+    const data = (await res.json()) as { data: { id: string }[] };
+    const modelIds = data.data.map((m) => m.id);
+    ctx.ui.notify(`Found ${modelIds.length} models, fetching details...`);
+    clearTimeout(listTimeout);
+
+    // 2. Fetch /api/show for each model in parallel
+    const results: Record<string, OllamaShowResponse> = {};
+    const settled = 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) return;
+          const showData = (await res.json()) as OllamaShowResponse;
+          results[id] = showData;
+        } finally {
+          clearTimeout(showTimeout);
+        }
+      }),
+    );
+
+    const succeeded = settled.filter((r) => r.status === "fulfilled").length;
+    const failed = settled.length - succeeded;
+    ctx.ui.notify(`Fetched ${Object.keys(results).length} model details${failed ? ` (${failed} failed)` : ""}`, "info");
+
+    return results;
+  } catch {
+    ctx.ui.notify("Failed to fetch Ollama Cloud models", "error");
+    return {};
+  }
+}
+
+// --- Web search/fetch types ---
+
+interface SearchResponse {
+  results: Array<{
+    title: string;
+    url: string;
+    content: string;
+  }>;
+}
+
+interface FetchResponse {
+  title: string;
+  content: string;
+  links: string[];
+}
+
+async function getCloudApiKey(ctx: ExtensionContext): Promise<string | undefined> {
+  return ctx.modelRegistry.getApiKeyForProvider("ollama-cloud");
+}
+
+// --- Tool rendering helpers ---
+
+const PREVIEW_LINES = 8;
+
+/**
+ * Build a renderResult handler that shows a truncated preview when collapsed
+ * and the full output when expanded. Follows the bash tool pattern.
+ */
+function createRenderResult() {
+  return (
+    result: { content: Array<{ type: string; text: string }>; isError?: boolean },
+    options: { expanded: boolean; isPartial: boolean },
+    theme: import("@mariozechner/pi-coding-agent").Theme,
+    context: {
+      invalidate: () => void;
+      lastComponent: import("@mariozechner/pi-tui").Component | undefined;
+      state: { cachedWidth?: number; cachedLines?: string[]; cachedSkipped?: number };
+    },
+  ) => {
+    const state = context.state;
+    const output = result.content
+      .map((c) => c.text)
+      .join("")
+      .trim();
+    const styledOutput = output
+      .split("\n")
+      .map((line: string) => theme.fg("toolOutput", line))
+      .join("\n");
+
+    if (options.expanded || result.isError) {
+      const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+      text.setText(result.isError ? styledOutput : `\n${styledOutput}`);
+      return text;
+    }
+
+    return {
+      render: (width: number) => {
+        if (state.cachedWidth !== width) {
+          const preview = truncateToVisualLines(styledOutput, PREVIEW_LINES, width);
+          state.cachedLines = preview.visualLines;
+          state.cachedSkipped = preview.skippedCount;
+          state.cachedWidth = width;
+        }
+        if (state.cachedSkipped && state.cachedSkipped > 0) {
+          const hint =
+            theme.fg("muted", `... (${state.cachedSkipped} earlier lines,`) +
+            ` ${keyHint("app.tools.expand", "to expand")})`;
+          return ["", truncateToWidth(hint, width, "..."), ...(state.cachedLines ?? [])];
+        }
+        return ["", ...(state.cachedLines ?? [])];
+      },
+      invalidate: () => {
+        state.cachedWidth = undefined;
+        state.cachedLines = undefined;
+        state.cachedSkipped = undefined;
+      },
+    };
+  };
+}
+
+// --- Main ---
+
+export default async function (pi: ExtensionAPI) {
+  // Boot: assemble from cache or fall back
+  const cached = readCache();
+  const models = cached ? assembleModels(cached) : FALLBACK_MODELS;
+
+  pi.registerProvider("ollama-cloud", {
+    baseUrl: `${OLLAMA_BASE}/v1`,
+    apiKey: "OLLAMA_API_KEY",
+    api: "openai-completions",
+    models,
+  });
+
+  // Slash command to refresh model list
+  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...");
+
+      const raw = await fetchModels(ctx);
+      if (Object.keys(raw).length === 0) {
+        ctx.ui.notify("No models fetched — keeping existing models", "warning");
+        ctx.ui.setWorkingMessage();
+        return;
+      }
+
+      writeCache(raw);
+      const newModels = assembleModels(raw);
+
+      // 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 }
+      pi.registerProvider("ollama-cloud", {
+        baseUrl: `${OLLAMA_BASE}/v1`,
+        apiKey: "OLLAMA_API_KEY",
+        api: "openai-completions",
+        models: newModels,
+      });
+
+      ctx.ui.notify(`Registered ${newModels.length} Ollama Cloud models`, "info");
+      ctx.ui.setWorkingMessage();
+    },
+  });
+
+  // Web search tool — uses Ollama Cloud API (no local server needed)
+  pi.registerTool({
+    name: "ollama_web_search",
+    label: "Ollama Web Search",
+    description:
+      "Search the web for real-time information using Ollama Cloud's web search API. " +
+      "Returns relevant results with titles, URLs, and content snippets. " +
+      "Requires an Ollama Cloud API key.",
+    parameters: Type.Object({
+      query: Type.String({ description: "The search query to execute" }),
+      max_results: Type.Optional(
+        Type.Number({ description: "Maximum number of search results to return (default: 5, max: 10)", default: 5 }),
+      ),
+    }),
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const apiKey = await getCloudApiKey(ctx);
+      if (!apiKey) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: No Ollama Cloud API key configured. Set OLLAMA_API_KEY or add to auth.json.",
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      try {
+        const res = await fetch(`${OLLAMA_BASE}/api/web_search`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            query: params.query,
+            max_results: params.max_results ?? 5,
+          }),
+          signal,
+        });
+
+        if (!res.ok) {
+          const errorText = await res.text().catch(() => "");
+          return {
+            content: [
+              { type: "text", text: `Search API error (status ${res.status}): ${errorText || res.statusText}` },
+            ],
+            isError: true,
+          };
+        }
+
+        const data = (await res.json()) as SearchResponse;
+        const formatted = data.results
+          .map((r, i) => `${i + 1}. ${r.title}\n   URL: ${r.url}\n   ${r.content}`)
+          .join("\n\n");
+
+        return {
+          content: [{ type: "text", text: formatted || "No results found." }],
+          details: { results: data.results },
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Web search failed: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true,
+        };
+      }
+    },
+    renderResult: createRenderResult(),
+  });
+
+  // Web fetch tool — uses Ollama Cloud API (no local server needed)
+  pi.registerTool({
+    name: "ollama_web_fetch",
+    label: "Ollama Web Fetch",
+    description:
+      "Fetch and extract text content from a web page URL using Ollama Cloud's web fetch API. " +
+      "Returns the page title, main content, and links found on the page. " +
+      "Requires an Ollama Cloud API key.",
+    parameters: Type.Object({
+      url: Type.String({ description: "URL to fetch and extract content from" }),
+    }),
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const apiKey = await getCloudApiKey(ctx);
+      if (!apiKey) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: No Ollama Cloud API key configured. Set OLLAMA_API_KEY or add to auth.json.",
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      try {
+        const res = await fetch(`${OLLAMA_BASE}/api/web_fetch`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ url: params.url }),
+          signal,
+        });
+
+        if (!res.ok) {
+          const errorText = await res.text().catch(() => "");
+          return {
+            content: [{ type: "text", text: `Fetch API error (status ${res.status}): ${errorText || res.statusText}` }],
+            isError: true,
+          };
+        }
+
+        const data = (await res.json()) as FetchResponse;
+        const formatted = [
+          `Title: ${data.title}`,
+          "",
+          "Content:",
+          data.content,
+          "",
+          `Links found: ${data.links?.length ?? 0}`,
+          ...(data.links?.slice(0, 10).map((l) => `  - ${l}`) ?? []),
+        ].join("\n");
+
+        return {
+          content: [{ type: "text", text: formatted }],
+          details: { title: data.title, content: data.content, links: data.links },
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Web fetch failed: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true,
+        };
+      }
+    },
+    renderResult: createRenderResult(),
+  });
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "pi-ollama-cloud",
+  "version": "0.1.0",
+  "type": "module",
+  "keywords": ["pi-package"],
+  "files": ["index.ts", "README.md", "LICENSE"],
+  "scripts": {
+    "check": "biome check --write .",
+    "lint": "biome check .",
+    "format": "biome format --write ."
+  },
+  "pi": {
+    "extensions": ["./index.ts"]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2"
+  }
+}