pi-web-search 1.6.0 → 1.7.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-web-search
 
-Provider-native web search for [pi](https://pi.dev) with Gemini + URL Context, xAI Grok, OpenAI Responses variants, Anthropic, and OpenCode Zen/Go.
+Provider-native web search for [pi](https://pi.dev) with Gemini + URL Context, xAI Grok, OpenAI Responses variants, Anthropic, DeepSeek, Ollama Cloud, and OpenCode Zen/Go.
 
 ## Tools
 
@@ -17,17 +17,23 @@ Search the web using your currently selected model. Automatically picks the righ
 | OpenAI Codex | Codex Responses API web search (`openai-codex-responses`) |
 | GitHub Copilot | OpenAI Responses API web search via Copilot credentials |
 | Anthropic | Messages API web search |
+| DeepSeek | Anthropic-compatible Messages API `web_search_20260209` |
+| Ollama Cloud | Ollama web search API (`/api/web_search`, standalone REST) |
 | OpenCode Zen / Go | Responses API web search (models that use the `openai-responses` API) |
 
 GitHub Copilot OpenAI Responses models are supported, including Business and Enterprise seats whose API endpoint is resolved from their authenticated Copilot credentials. This includes models such as `gpt-5.6-sol`.
 
-OpenCode Zen and OpenCode Go Responses models (for example `opencode-go/gpt-5.6-luna` or `opencode-go/grok-4.6`) use the same Responses web search. OpenCode routes traffic per conversation, so `web_search` sends the `x-opencode-session` and `x-opencode-client` headers pi uses, keyed to the active session. Only models exposed through that Responses API are supported: OpenCode `chat/completions` models have no provider-native search tool, and the gateway's Anthropic Messages models are unverified.
+OpenCode Zen and OpenCode Go Responses models (for example `opencode-go/gpt-5.6-luna` or `opencode-go/grok-4.6`) use the same Responses web search. OpenCode routes traffic per conversation, so `web_search` sends the `x-opencode-session` and `x-opencode-client` headers pi uses, keyed to the active session. Only models exposed through that Responses API are supported: OpenCode `chat/completions` models have no provider-native search tool, and the gateway's Anthropic Messages models are unverified. Grok ids such as `opencode-go/grok-4.6` get the Grok request shape described below unless `compat.webSearchDialect` is `"openai"`; the session headers are unchanged.
+
+Grok models on OpenAI-compatible Responses gateways use Grok's request shape: no `web_search_call.results` include (Grok rejects it with 400), a message-array input, and inline citations. By default this applies to the native `xai` provider and to any model id starting with `grok-`, `grok.`, or equal to `grok`. Set `"compat": { "webSearchDialect": "grok" }` or `"openai"` in `models.json` to override detection, on the model or on a provider that serves only Grok; model-level `compat` wins over provider-level. Only the request shape changes: auth, error labels, and `providerKind` still follow the provider, and gateway Grok still inherits the session thinking level. Only the native `xai` provider omits `reasoning.effort`.
+
+Ollama Cloud models (provider `ollama-cloud` or any model hosted on `ollama.com`) call Ollama's standalone web search API rather than a model tool. Auth is `OLLAMA_API_KEY` or `/login ollama-cloud`. Any `urls` are fetched through `web_fetch`. A local Ollama daemon is out of scope — the official `@ollama/pi-web-search` package covers its `/api/experimental/*` endpoints.
 
 Supports passing up to 20 additional URLs to analyze alongside the query. Successful `web_search` results are collapsed by default in pi; expand the tool call to inspect the full answer and source details.
 
 ### `url_context`
 
-Gemini-only. Analyze up to 20 public URLs — web pages, documents, images, and YouTube videos. Uses Gemini's native URL Context retrieval with verified metadata.
+Gemini and Ollama Cloud. Analyze up to 20 public URLs — web pages, documents, images, and YouTube videos. Gemini uses native URL Context retrieval with verified metadata; Ollama uses its `web_fetch` endpoint (web pages and documents only).
 
 When using `google-generative-ai`, YouTube URLs are passed as `file_data` for native video understanding.
 
@@ -54,9 +60,37 @@ When this file exists, `web_search` uses the configured provider/model first. If
 
 For OpenAI Responses models (including Azure, Codex, and Copilot), `web_search` inherits the agent's current thinking level on each call. Enabled levels are clamped to the selected search model's supported levels and translated through its `thinkingLevelMap` using pi's model metadata. This also applies when `web-search.json` selects a dedicated search model. Higher effort can increase latency and cost.
 
-When thinking is off or unavailable, or the search model is non-reasoning, the request omits `reasoning` and leaves the choice to the provider. Off does not force reasoning off: some models reject `reasoning.effort: "none"`. Google, Anthropic, and xAI behavior is unchanged.
+When thinking is off or unavailable, or the search model is non-reasoning, the request omits `reasoning` and leaves the choice to the provider. Off does not force reasoning off: some models reject `reasoning.effort: "none"`. Google, Anthropic, xAI, and Ollama behavior is unchanged.
+
+`url_context` is automatically removed from active tools when using a model that supports neither Gemini URL Context nor Ollama web fetch.
+
+### DeepSeek
+
+Select a model from pi's `deepseek` provider and authenticate with `/login` or
+`DEEPSEEK_API_KEY`. Search automatically uses DeepSeek's Anthropic-compatible
+endpoint (`https://api.deepseek.com/anthropic/v1/messages`) with the same model
+and credentials. A configured proxy base URL is preserved and routed through
+its `/anthropic/v1/messages` endpoint; the proxy must support that route.
+
+To use DeepSeek search with another conversation model, set `web-search.json`:
+
+```json
+{
+  "provider": "deepseek",
+  "model": "deepseek-v4-flash"
+}
+```
+
+The selected model must be registered in pi and support DeepSeek's server-side
+search. Unlike the standalone `pi-deepseek-search` extension, this integration
+uses the model selected by this project's configuration; it does not read
+`DEEPSEEK_SEARCH_MODEL` or silently switch models. Do not load both extensions,
+since they both register `web_search`.
+
+DeepSeek requests support cancellation through pi. Additional `urls` are included in
+the prompt; Gemini's verified URL Context retrieval remains Gemini-only.
 
-`url_context` is automatically removed from active tools when using a non-Gemini model.
+This integration was informed by [pi-deepseek-search](https://github.com/bxff/pi-deepseek-search).
 
 ## Test
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-web-search",
-  "version": "1.6.0",
-  "description": "Provider-native web search for pi: Gemini + URL Context, xAI Grok, OpenAI Responses (Azure/Codex/Copilot), Anthropic, and OpenCode Zen/Go",
+  "version": "1.7.0",
+  "description": "Provider-native web search for pi: Gemini + URL Context, xAI Grok, OpenAI Responses (Azure/Codex/Copilot), Anthropic, DeepSeek, and OpenCode Zen/Go",
   "type": "module",
   "main": "src/index.ts",
   "keywords": [
@@ -15,6 +15,7 @@
     "grok",
     "openai",
     "anthropic",
+    "deepseek",
     "opencode",
     "opencode-zen",
     "url-context",

package/src/api.ts

@@ -4,6 +4,7 @@ import { getProviderKind } from "./providers/config.ts";
 import { callGoogleStream, extractPromptFromGeminiBody } from "./providers/google.ts";
 import { callOpenAIStream } from "./providers/openai.ts";
 import { callAnthropicStream } from "./providers/anthropic.ts";
+import { callOllamaSearch } from "./providers/ollama.ts";
 import type { StreamResult } from "./providers/types.ts";
 
 export { getProviderKind, getConfig } from "./providers/config.ts";
@@ -16,7 +17,8 @@ export async function callApiStream(
     body: any,
     onUpdate?: AgentToolUpdateCallback,
     signal?: AbortSignal,
-    thinkingLevel?: ModelThinkingLevel
+    thinkingLevel?: ModelThinkingLevel,
+    urls?: string[]
 ): Promise<StreamResult> {
     const kind = getProviderKind(model);
     if (kind === "google") {
@@ -28,10 +30,16 @@ export async function callApiStream(
         throw new Error("No prompt text found in request body");
     }
 
+    // Ollama search is a standalone REST call, not a model tool — the prompt
+    // carries the embedded URL list only for other providers, so strip it here.
+    if (kind === "ollama") {
+        return callOllamaSearch(ctx, model, prompt, urls, onUpdate, signal);
+    }
+
     if (kind === "openai" || kind === "xai") {
         return callOpenAIStream(ctx, model, prompt, onUpdate, signal, thinkingLevel);
     }
-    if (kind === "anthropic") {
+    if (kind === "anthropic" || kind === "deepseek") {
         return callAnthropicStream(ctx, model, prompt, onUpdate, signal);
     }
 

package/src/index.ts

@@ -9,7 +9,11 @@ const WEB_SEARCH_TOOL = "web_search";
 const URL_CONTEXT_TOOL = "url_context";
 
 function supportsUrlContext(model: Model<Api> | undefined) {
-    return !!model && getProviderKind(model) === "google";
+    if (!model) return false;
+    const kind = getProviderKind(model);
+    // Ollama serves URL retrieval through its web_fetch endpoint instead of
+    // Gemini URL Context; the tool dispatch handles both.
+    return kind === "google" || kind === "ollama";
 }
 
 function setEquals<T>(a: Set<T>, b: Set<T>) {
@@ -63,7 +67,7 @@ export default function (pi: ExtensionAPI) {
     pi.registerTool({
         name: WEB_SEARCH_TOOL,
         label: "Web Search",
-        description: "Search the web using the current supported provider (Google Gemini, xAI Grok, OpenAI, Anthropic, or OpenCode Zen/Go). Optionally include URLs to analyze alongside search results.",
+        description: "Search the web using the current supported provider (Google Gemini, xAI Grok, OpenAI, Anthropic, DeepSeek, Ollama, or OpenCode Zen/Go). Optionally include URLs to analyze alongside search results.",
         parameters: WebSearchSchema,
         execute: (id, params, signal = new AbortController().signal, onUpdate, ctx): Promise<AgentToolResult<any>> =>
             webSearch(id, params, signal, onUpdate, ctx, pi.getThinkingLevel()),
@@ -93,7 +97,7 @@ export default function (pi: ExtensionAPI) {
     pi.registerTool({
         name: URL_CONTEXT_TOOL,
         label: "URL Context",
-        description: "Analyze the content of up to 20 public URLs using Gemini URL Context. Supports web pages, documents, images, and YouTube videos.",
+        description: "Analyze the content of up to 20 public URLs using provider-native URL retrieval (Gemini URL Context or Ollama web fetch). Supports web pages and documents; images and YouTube videos need Gemini.",
         parameters: UrlContextSchema,
         execute: urlContext
     });

package/src/providers/anthropic.ts

@@ -1,6 +1,7 @@
 import type { ExtensionContext, AgentToolUpdateCallback } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { getAuth, getProviderSessionHeaders } from "./auth.ts";
+import { getProviderKind } from "./config.ts";
 import { readSseEvents } from "./sse.ts";
 import {
     applyTextCitations,
@@ -21,6 +22,14 @@ function resolveAnthropicMessagesUrl(baseUrl: string): string {
     return base.endsWith("/v1") ? `${base}/messages` : `${base}/v1/messages`;
 }
 
+// DeepSeek exposes server-side search only on its Anthropic-compatible route.
+// Preserve a configured proxy origin/path instead of sending its credentials elsewhere.
+export function resolveDeepSeekBaseUrl(baseUrl: string): string {
+    const base = baseUrl.replace(/\/+$/, "");
+    if (/\/anthropic(?:\/v1)?$/.test(base)) return base;
+    return `${base.replace(/\/v1$/, "")}/anthropic`;
+}
+
 export async function callAnthropicStream(
     ctx: ExtensionContext,
     model: Model<Api>,
@@ -28,12 +37,15 @@ export async function callAnthropicStream(
     onUpdate?: AgentToolUpdateCallback,
     signal?: AbortSignal
 ): Promise<StreamResult> {
+    const kind = getProviderKind(model) === "deepseek" ? "deepseek" : "anthropic";
+    const isDeepSeek = kind === "deepseek";
+    const providerName = isDeepSeek ? "DeepSeek" : "Anthropic";
     const auth = await getAuth(ctx, model);
     if (!auth.ok) {
         throw new Error(auth.error || "Failed to get API key and headers");
     }
 
-    const isOAuth = !!auth.apiKey && auth.apiKey.includes("sk-ant-oat");
+    const isOAuth = !isDeepSeek && !!auth.apiKey && auth.apiKey.includes("sk-ant-oat");
     const headers: Record<string, string> = {
         "Content-Type": "application/json",
         "Accept": "text/event-stream",
@@ -49,13 +61,19 @@ export async function callAnthropicStream(
             headers["anthropic-beta"] = headers["anthropic-beta"]
                 ? `${headers["anthropic-beta"]},claude-code-20250219,oauth-2025-04-20`
                 : "claude-code-20250219,oauth-2025-04-20";
-            headers["user-agent"] = headers["user-agent"] || "claude-cli/2.1.75";
+            // Anthropic rejects OAuth requests from anything older than 2.1.251.
+            headers["user-agent"] = headers["user-agent"] || "claude-cli/2.1.251";
             headers["x-app"] = headers["x-app"] || "cli";
         } else if (!headers["x-api-key"] && !headers["X-Api-Key"]) {
             headers["x-api-key"] = auth.apiKey;
         }
     }
 
+    if (isDeepSeek && !Object.entries(headers).some(([name, value]) =>
+        value && ["authorization", "x-api-key"].includes(name.toLowerCase()))) {
+        throw new Error("No DeepSeek API key found. Run /login in pi and select DeepSeek, or set DEEPSEEK_API_KEY.");
+    }
+
     const maxTokens = Math.min(Math.max(1024, Math.floor(model.maxTokens / 3) || 4096), 8192);
     const requestBody = {
         model: model.id,
@@ -64,11 +82,17 @@ export async function callAnthropicStream(
         // system prompt, reporting it as an opaque 429 rate_limit_error.
         ...(isOAuth ? { system: [{ type: "text", text: CLAUDE_CODE_SYSTEM_PROMPT }] } : {}),
         messages: [{ role: "user", content: prompt }],
-        tools: [{ type: "web_search_20250305", name: "web_search", max_uses: 10 }],
+        tools: [{
+            type: "web_search_20260209",
+            name: "web_search",
+            max_uses: 10,
+            // Keep direct search compatible with models without programmatic tool calling.
+            allowed_callers: ["direct"],
+        }],
         stream: true,
     };
 
-    const response = await fetch(resolveAnthropicMessagesUrl(model.baseUrl), {
+    const response = await fetch(resolveAnthropicMessagesUrl(isDeepSeek ? resolveDeepSeekBaseUrl(auth.baseUrl || model.baseUrl) : model.baseUrl), {
         method: "POST",
         headers,
         body: JSON.stringify(requestBody),
@@ -76,7 +100,7 @@ export async function callAnthropicStream(
     });
 
     if (!response.ok) {
-        throw new Error(`Anthropic API error (${response.status}): ${await response.text()}`);
+        throw new Error(`${providerName} API error (${response.status}): ${await response.text()}`);
     }
 
     let accumulatedText = "";
@@ -93,7 +117,7 @@ export async function callAnthropicStream(
             title,
             url: source.url,
             pageAge: source.page_age ?? source.pageAge,
-            source: "anthropic.web_search_tool_result",
+            source: `${kind}.web_search_tool_result`,
             type: source.type || "web_search_result",
             raw: { toolUseId, ...source },
         });
@@ -106,30 +130,31 @@ export async function callAnthropicStream(
                 accumulatedText += block.text;
                 onUpdate?.({ content: [{ type: "text", text: accumulatedText }], details: { streaming: true } });
             } else if (block?.type === "server_tool_use" && block.name === "web_search") {
-                pushNativeSearchEvent(nativeSearchEvents, "anthropic.content_block_start.server_tool_use.web_search");
+                pushNativeSearchEvent(nativeSearchEvents, `${kind}.content_block_start.server_tool_use.web_search`);
                 nativeSearchCalls.push({
                     id: block.id,
-                    provider: "anthropic",
+                    provider: kind,
                     status: "in_progress",
                     actionType: block.name,
                     queries: typeof block.input?.query === "string" ? [block.input.query] : undefined,
                     raw: block,
                 });
                 onUpdate?.({
-                    content: [{ type: "text", text: accumulatedText || "Searching the web with Anthropic..." }],
+                    content: [{ type: "text", text: accumulatedText || `Searching the web with ${providerName}...` }],
                     details: { streaming: true, searching: true }
                 });
             } else if (block?.type === "web_search_tool_result") {
-                pushNativeSearchEvent(nativeSearchEvents, "anthropic.content_block_start.web_search_tool_result");
+                pushNativeSearchEvent(nativeSearchEvents, `${kind}.content_block_start.web_search_tool_result`);
                 const call = nativeSearchCalls.find((item) => item.id === block.tool_use_id);
                 if (call) call.status = "completed";
-                else nativeSearchCalls.push({ id: block.tool_use_id, provider: "anthropic", status: "completed", actionType: "web_search", raw: block });
+                else nativeSearchCalls.push({ id: block.tool_use_id, provider: kind, status: "completed", actionType: "web_search", raw: block });
                 if (Array.isArray(block.content)) {
                     for (const result of block.content) collectSource(result, block.tool_use_id);
                 } else if (block.content?.type === "web_search_tool_result_error") {
+                    if (isDeepSeek) throw new Error(`DeepSeek web search failed: ${block.content.error_code || "unknown error"}`);
                     pushUniqueSearchResult(searchResults, {
                         status: block.content.error_code,
-                        source: "anthropic.web_search_tool_result_error",
+                        source: `${kind}.web_search_tool_result_error`,
                         type: block.content.type,
                         raw: block,
                     });
@@ -150,7 +175,7 @@ export async function callAnthropicStream(
                         citedText: citation.cited_text,
                         title: citation.title || titleFromUrl(citation.url),
                         url: citation.url,
-                        source: "anthropic.citations_delta",
+                        source: `${kind}.citations_delta`,
                         type: citation.type,
                         raw: citation,
                     };
@@ -168,7 +193,7 @@ export async function callAnthropicStream(
         title: citation.title || titleFromUrl(citation.url),
         url: citation.url,
         citedText: citation.citedText,
-        source: "anthropic.citation",
+        source: `${kind}.citation`,
         type: "citation",
         raw: citation,
     }));
@@ -181,7 +206,7 @@ export async function callAnthropicStream(
     return {
         text: cited.text,
         sources: cited.sources.length ? normalizeCitedSources(cited.sources) : derivedSources,
-        providerKind: "anthropic",
+        providerKind: kind,
         nativeSearchUsed: nativeSearchEvents.length > 0 || nativeSearchCalls.length > 0 || sanitizedSearchResults.length > 0,
         nativeSearchEvents,
         nativeSearchCalls,

package/src/providers/config.ts

@@ -1,7 +1,8 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ProviderKind } from "./types.ts";
+import type { ResolvedAuth } from "./auth.ts";
 
-export type GoogleRequestBuilder = (model: Model<Api>, body: any) => { url: string; headers: Record<string, string>; body: any };
+export type GoogleRequestBuilder = (model: Model<Api>, body: any, auth?: ResolvedAuth) => { url: string; headers: Record<string, string>; body: any };
 
 export type ProviderConfig = {
     kind: ProviderKind;
@@ -10,6 +11,13 @@ export type ProviderConfig = {
     buildRequest?: GoogleRequestBuilder;
 };
 
+const ANTIGRAVITY_MODEL_MAP: Record<string, string> = {
+    "gemini-3.7-flash": "gemini-3.7-flash-medium",
+    "gemini-3.7-flash-medium": "gemini-3.7-flash-medium",
+    "gemini-3.6-flash": "gemini-3.6-flash-low",
+    "gemini-3.5-flash": "gemini-3.5-flash-extra-low",
+};
+
 const GOOGLE_PROVIDERS: Record<string, ProviderConfig> = {
     "google-generative-ai": {
         kind: "google",
@@ -23,11 +31,63 @@ const GOOGLE_PROVIDERS: Record<string, ProviderConfig> = {
             },
             body
         })
+    },
+    "antigravity": {
+        kind: "google",
+        searchTool: "google_search",
+        urlContextTool: "url_context",
+        buildRequest: (model, body, auth) => {
+            let token = "";
+            let projectId = "aicode-consumers";
+            if (auth?.ok && auth.apiKey) {
+                try {
+                    const parsed = JSON.parse(auth.apiKey);
+                    token = parsed.token || auth.apiKey;
+                    projectId = parsed.projectId || projectId;
+                } catch {
+                    token = auth.apiKey;
+                }
+            }
+            const runtimeModel = ANTIGRAVITY_MODEL_MAP[model.id] || model.id;
+            const platform = process.platform === "darwin" ? "MACOS" : process.platform === "win32" ? "WINDOWS" : "LINUX";
+            const osType = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : "linux";
+            const arch = process.arch === "arm64" ? "arm64" : "x64";
+            return {
+                url: "https://daily-cloudcode-pa.googleapis.com/v1internal:streamGenerateContent?alt=sse",
+                headers: {
+                    "Authorization": `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                    "Accept": "text/event-stream",
+                    "User-Agent": `antigravity/hub/2.8.0 ${osType}/${arch}`,
+                    "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+                    "Client-Metadata": JSON.stringify({ ideType: "ANTIGRAVITY", platform, pluginType: "GEMINI" })
+                },
+                body: {
+                    project: projectId,
+                    model: runtimeModel,
+                    request: { contents: body.contents, ...(body.tools ? { tools: body.tools } : {}) },
+                    requestType: "AGENT",
+                    userAgent: "antigravity"
+                }
+            };
+        }
     }
 };
 
+function isOllamaModel(model: Model<Api>): boolean {
+    if (model.provider === "ollama-cloud") return true;
+    try {
+        return new URL(model.baseUrl).hostname === "ollama.com";
+    } catch {
+        return false;
+    }
+}
+
 export function getProviderKind(model: Model<Api>): ProviderKind {
+    if (model.provider === "deepseek") return "deepseek";
+    if (model.provider === "antigravity" || model.api === "antigravity") return "google";
     if (GOOGLE_PROVIDERS[model.provider] || GOOGLE_PROVIDERS[model.api]) return "google";
+    if (isOllamaModel(model)) return "ollama";
     if (model.provider === "xai" && model.api === "openai-responses") return "xai";
     if (
         model.api === "openai-responses"
@@ -38,6 +98,29 @@ export function getProviderKind(model: Model<Api>): ProviderKind {
     return "unsupported";
 }
 
+export type SearchDialect = "grok" | "openai";
+
+// Optional models.json override: compat.webSearchDialect. Not part of pi-ai's
+// compat types, so read it through a local cast and ignore unknown values.
+function dialectOverride(model: Model<Api>): SearchDialect | undefined {
+    const value = (model.compat as { webSearchDialect?: unknown } | undefined)?.webSearchDialect;
+    return value === "grok" || value === "openai" ? value : undefined;
+}
+
+// Wire shape only (include, input, citation parsing). Grok is also served through
+// third-party OpenAI-compatible Responses gateways whose provider kind is "openai";
+// those reject web_search_call.results with 400 and return inline citations.
+// Provider identity (auth, labels, reasoning semantics) stays with getProviderKind.
+export function getSearchDialect(model: Model<Api>): SearchDialect {
+    const override = dialectOverride(model);
+    if (override) return override;
+    if (getProviderKind(model) === "xai") return "grok";
+    // Default only, matching official ids (grok-4.6, grok-4-fast, grok-code-fast-1).
+    // Prefixed or renamed ids opt in with compat.webSearchDialect.
+    if (/^grok([.-]|$)/i.test(model.id)) return "grok";
+    return "openai";
+}
+
 export function getConfig(model: Model<Api>): ProviderConfig {
     const googleConfig = GOOGLE_PROVIDERS[model.provider] || GOOGLE_PROVIDERS[model.api];
     if (googleConfig) return googleConfig;

package/src/providers/google.ts

@@ -103,14 +103,14 @@ export async function callGoogleStream(
         throw new Error(auth.error || "Failed to get API key and headers");
     }
 
-    const req = config.buildRequest(model, body);
+    const req = config.buildRequest(model, body, auth);
 
     // Handle auth
     Object.assign(req.headers, getProviderSessionHeaders(model, ctx) || {});
     if (auth.headers) {
         Object.assign(req.headers, auth.headers);
     }
-    if (auth.apiKey) {
+    if (auth.apiKey && model.provider !== "antigravity" && model.api !== "antigravity") {
         req.headers["x-goog-api-key"] = auth.apiKey;
     }
 

package/src/providers/ollama.ts

@@ -0,0 +1,239 @@
+import type { ExtensionContext, AgentToolUpdateCallback } from "@earendil-works/pi-coding-agent";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { getAuth, type ResolvedAuth } from "./auth.ts";
+import { titleFromUrl } from "./results.ts";
+import type { SearchResultDetail, Source, StreamResult } from "./types.ts";
+
+/**
+ * Ollama Cloud exposes search/fetch as standalone REST endpoints rather than
+ * model tools, so this module talks to the API directly:
+ *   POST {root}/api/web_search and POST {root}/api/web_fetch
+ * Both require an Ollama API key (OLLAMA_API_KEY or /login ollama-cloud).
+ * A local Ollama daemon is out of scope — it proxies these endpoints through
+ * its own `ollama signin` session under /api/experimental/*, which the
+ * official @ollama/pi-web-search package already covers.
+ */
+
+const MAX_RESULTS = 10;
+const FETCH_CONTENT_LIMIT = 8000;
+
+interface OllamaSearchResult {
+    title?: string;
+    url?: string;
+    content?: string;
+}
+
+interface OllamaFetchResult {
+    title?: string;
+    content?: string;
+    links?: string[];
+}
+
+/** Strip the OpenAI-compatible suffix so `/api/*` endpoints resolve. */
+export function resolveOllamaApiRoot(model: Model<Api>, auth?: ResolvedAuth): string {
+    const base = ((auth?.ok && auth.baseUrl) || model.baseUrl || "").replace(/\/+$/, "");
+    return base.replace(/\/v\d+$/i, "");
+}
+
+async function ollamaPost<T>(
+    root: string,
+    path: string,
+    body: unknown,
+    apiKey: string,
+    signal?: AbortSignal,
+): Promise<T> {
+    const response = await fetch(`${root}${path}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(body),
+        signal,
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        if (response.status === 401) {
+            throw new Error("Ollama API key missing or invalid — set OLLAMA_API_KEY or run /login ollama-cloud.");
+        }
+        throw new Error(`Ollama API error (${response.status}): ${text || response.statusText}`);
+    }
+    return (await response.json()) as T;
+}
+
+function truncateContent(text: string | undefined, limit = FETCH_CONTENT_LIMIT): string {
+    if (!text) return "";
+    return text.length > limit ? `${text.slice(0, limit)}…` : text;
+}
+
+interface FetchedPage {
+    url: string;
+    title?: string;
+    content?: string;
+    ok: boolean;
+    status?: string;
+}
+
+async function fetchPages(
+    root: string,
+    urls: string[],
+    apiKey: string,
+    signal?: AbortSignal,
+): Promise<FetchedPage[]> {
+    return Promise.all(
+        urls.map(async (url): Promise<FetchedPage> => {
+            try {
+                const data = await ollamaPost<OllamaFetchResult>(root, "/api/web_fetch", { url }, apiKey, signal);
+                return { url, title: data.title, content: data.content, ok: true };
+            } catch (error) {
+                return {
+                    url,
+                    ok: false,
+                    status: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }),
+    );
+}
+
+/** URL metadata in the same shape Gemini's url_context produces downstream. */
+function toUrlContextMetadata(pages: FetchedPage[]) {
+    return {
+        urlMetadata: pages.map((page) => ({
+            retrievedUrl: page.url,
+            urlRetrievalStatus: page.ok ? "URL_RETRIEVAL_STATUS_SUCCESS" : "URL_RETRIEVAL_STATUS_ERROR",
+        })),
+    };
+}
+
+async function resolveOllamaTarget(
+    ctx: ExtensionContext,
+    model: Model<Api>,
+): Promise<{ root: string; apiKey: string }> {
+    const auth = await getAuth(ctx, model);
+    if (!auth.ok) throw new Error(auth.error || "Failed to resolve Ollama credentials");
+    const apiKey = auth.apiKey || process.env.OLLAMA_API_KEY;
+    if (!apiKey) {
+        throw new Error(
+            "Ollama web search needs an API key — set OLLAMA_API_KEY or run /login ollama-cloud.",
+        );
+    }
+    return { root: resolveOllamaApiRoot(model, auth), apiKey };
+}
+
+export async function callOllamaSearch(
+    ctx: ExtensionContext,
+    model: Model<Api>,
+    query: string,
+    urls?: string[],
+    onUpdate?: AgentToolUpdateCallback,
+    signal?: AbortSignal,
+): Promise<StreamResult> {
+    const { root, apiKey } = await resolveOllamaTarget(ctx, model);
+
+    onUpdate?.({
+        content: [{ type: "text", text: `Searching the web with Ollama...` }],
+        details: { streaming: true, searching: true },
+    });
+
+    const data = await ollamaPost<{ results?: OllamaSearchResult[] }>(
+        root,
+        "/api/web_search",
+        { query, max_results: MAX_RESULTS },
+        apiKey,
+        signal,
+    );
+    const hits = (data.results ?? []).filter((r) => r && typeof r.url === "string");
+
+    const searchResults: SearchResultDetail[] = hits.map((hit) => ({
+        title: hit.title || titleFromUrl(hit.url!),
+        url: hit.url,
+        citedText: hit.content,
+        source: "ollama.web_search",
+        type: "search_result",
+        query,
+        raw: hit,
+    }));
+    const sources: Source[] = hits.map((hit) => ({
+        title: hit.title || titleFromUrl(hit.url!),
+        url: hit.url!,
+    }));
+
+    const lines = [`Search results for "${query}" via Ollama:`];
+    if (hits.length === 0) lines.push("No results found.");
+    hits.forEach((hit, i) => {
+        lines.push(`\n${i + 1}. ${hit.title || hit.url}\n   ${hit.url}${hit.content ? `\n   ${hit.content}` : ""}`);
+    });
+
+    // Optional URL analysis through web_fetch (the fetch half of the API pair).
+    let urlContextMetadata;
+    if (urls?.length) {
+        onUpdate?.({
+            content: [{ type: "text", text: `Fetching ${urls.length} URL(s) with Ollama...` }],
+            details: { streaming: true },
+        });
+        const pages = await fetchPages(root, urls, apiKey, signal);
+        urlContextMetadata = toUrlContextMetadata(pages);
+        for (const page of pages) {
+            if (!page.ok) continue;
+            lines.push(
+                `\n## Fetched: ${page.title || page.url}\n${page.url}\n\n${truncateContent(page.content)}`,
+            );
+            if (!sources.some((s) => s.url === page.url)) {
+                sources.push({ title: page.title || titleFromUrl(page.url), url: page.url });
+            }
+        }
+    }
+
+    return {
+        text: lines.join("\n"),
+        sources,
+        providerKind: "ollama",
+        nativeSearchUsed: true,
+        searchQueries: [query],
+        searchResults,
+        urlContextMetadata,
+    };
+}
+
+/** url_context for Ollama: fetch each URL through web_fetch, no model involved. */
+export async function callOllamaUrlContext(
+    ctx: ExtensionContext,
+    model: Model<Api>,
+    query: string,
+    urls: string[],
+    signal?: AbortSignal,
+): Promise<StreamResult> {
+    const { root, apiKey } = await resolveOllamaTarget(ctx, model);
+    const pages = await fetchPages(root, urls, apiKey, signal);
+
+    const lines = [`URL contents for: ${query}`];
+    const sources: Source[] = [];
+    const searchResults: SearchResultDetail[] = [];
+    for (const page of pages) {
+        if (!page.ok) {
+            lines.push(`\n## Failed: ${page.url}\n${page.status}`);
+            continue;
+        }
+        lines.push(`\n## ${page.title || page.url}\n${page.url}\n\n${truncateContent(page.content)}`);
+        sources.push({ title: page.title || titleFromUrl(page.url), url: page.url });
+        searchResults.push({
+            title: page.title,
+            url: page.url,
+            citedText: truncateContent(page.content),
+            source: "ollama.web_fetch",
+            type: "fetched_page",
+            raw: page,
+        });
+    }
+
+    return {
+        text: lines.join("\n"),
+        sources,
+        providerKind: "ollama",
+        nativeSearchUsed: false,
+        searchResults,
+        urlContextMetadata: toUrlContextMetadata(pages),
+    };
+}

package/src/providers/openai.ts

@@ -1,7 +1,7 @@
 import type { ExtensionContext, AgentToolUpdateCallback } from "@earendil-works/pi-coding-agent";
 import { clampThinkingLevel, type Api, type Model, type ModelThinkingLevel } from "@earendil-works/pi-ai";
 import { TextDecoder } from "util";
-import { getProviderKind } from "./config.ts";
+import { getProviderKind, getSearchDialect } from "./config.ts";
 import { getAuth, getProviderSessionHeaders, type ResolvedAuth } from "./auth.ts";
 import { readSseEvents } from "./sse.ts";
 import {
@@ -138,17 +138,20 @@ export async function callOpenAIStream(
     const requestHeaders = Object.fromEntries(headers.entries());
 
     const isXai = getProviderKind(model) === "xai";
+    // Dialect shapes the wire format only (input, include, citations); labels,
+    // providerKind, and reasoning stay keyed to provider identity.
+    const isGrok = getSearchDialect(model) === "grok";
     const searchProvider: "xai" | "openai" = isXai ? "xai" : "openai";
     const providerSourceName = isXai ? "xai" : "openai";
     const requestBody: any = {
         model: model.id,
         input: isCodex
             ? [{ role: "user", content: [{ type: "input_text", text: prompt }] }]
-            : isXai
+            : isGrok
                 ? [{ role: "user", content: prompt }]
-                : prompt,
+                : [{ role: "user", content: [{ type: "input_text", text: prompt }] }],
         tools: [{ type: "web_search" }],
-        ...(isCodex || isXai
+        ...(isCodex || isGrok
             ? { include: ["web_search_call.action.sources"] }
             : { include: ["web_search_call.action.sources", "web_search_call.results"] }),
         stream: true,
@@ -158,6 +161,7 @@ export async function callOpenAIStream(
     // model (which can differ from the conversation model). Keep provider defaults
     // when thinking is off/unavailable; do not reintroduce an implicit "none".
     // xAI shares this transport but does not share OpenAI's effort semantics.
+    // Keyed to provider identity, not dialect: gateway-hosted Grok keeps effort.
     if (!isXai && model.reasoning && thinkingLevel && thinkingLevel !== "off") {
         const level = clampThinkingLevel(model, thinkingLevel);
         const effort = model.thinkingLevelMap?.[level] ?? level;
@@ -292,7 +296,7 @@ export async function callOpenAIStream(
         }
     });
 
-    const cited = isXai
+    const cited = isGrok
         ? preserveInlineCitations(accumulatedText || "No answer available.", citations)
         : applyIndexCitations(accumulatedText || "No answer available.", citations);
     const citationDetails = citations.map((citation) => ({

package/src/providers/types.ts

@@ -1,4 +1,4 @@
-export type ProviderKind = "google" | "openai" | "xai" | "anthropic" | "unsupported";
+export type ProviderKind = "google" | "openai" | "xai" | "anthropic" | "deepseek" | "ollama" | "unsupported";
 
 export interface Source {
     title: string;

package/src/url_context.ts

@@ -1,6 +1,7 @@
 import type { ExtensionContext, AgentToolUpdateCallback } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 import { callApiStream, getConfig } from "./api.ts";
+import { callOllamaUrlContext } from "./providers/ollama.ts";
 import { formatResult, formatUrlContextResult } from "./format.ts";
 import { getModel, missingConfigResult, errorResult } from "./utils.ts";
 
@@ -31,6 +32,10 @@ export async function urlContext(
 
     try {
         const config = getConfig(model);
+        if (config.kind === "ollama") {
+            const result = await callOllamaUrlContext(ctx, model, params.query, params.urls, signal);
+            return formatUrlContextResult(result, { modelId: model.id });
+        }
         if (config.kind !== "google") {
             return formatResult(
                 `url_context currently requires a Google Gemini-compatible model. Current model: ${model.id} (${model.provider}/${model.api}).\n\nUse web_search for cross-provider web search, or switch to Gemini for provider-native URL context retrieval.`,

package/src/utils.ts

@@ -7,7 +7,7 @@ import { getProviderKind } from "./api.ts";
 
 // --- Model Selection ---
 
-const SUPPORTED_PROVIDERS = ["google-generative-ai", "xai", "openai-responses", "azure-openai-responses", "openai-codex-responses", "anthropic-messages"];
+const SUPPORTED_PROVIDERS = ["deepseek", "google-generative-ai", "antigravity", "xai", "openai-responses", "azure-openai-responses", "openai-codex-responses", "anthropic-messages", "ollama"];
 
 type WebSearchModelConfig =
     | { status: "missing"; path: string; }

package/src/web_search.ts

@@ -40,9 +40,11 @@ export async function webSearch(
 
     try {
         const config = getConfig(model);
-        
-        // Build prompt: include URLs if provided
-        const prompt = hasUrls
+
+        // Build prompt: include URLs if provided. Ollama receives the URL list as
+        // a separate argument (its search is a REST endpoint, not a model tool),
+        // so the prompt stays a clean query.
+        const prompt = hasUrls && config.kind !== "ollama"
             ? `${params.query}\n\nAlso analyze these URLs:\n${params.urls!.join("\n")}`
             : params.query;
 
@@ -57,7 +59,7 @@ export async function webSearch(
         const result = await callApiStream(ctx, model, {
             contents: [{ role: "user", parts: [{ text: prompt }] }],
             ...(tools ? { tools } : {})
-        }, onUpdate, signal, thinkingLevel);
+        }, onUpdate, signal, thinkingLevel, params.urls);
 
         return formatWebSearchResult(result, { modelId: model.id });
     } catch (e: any) {