pi-web-search 1.3.1 → 1.5.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-web-search
 
-Provider-native web search for [pi](https://github.com/earendil-works/pi-coding-agent), across Google Gemini, OpenAI, and Anthropic, plus Gemini-only URL Context analysis.
+Provider-native web search for [pi](https://pi.dev) with Gemini + URL Context, xAI Grok, OpenAI Responses variants, and Anthropic.
 
 ## Tools
 
@@ -11,11 +11,16 @@ Search the web using your currently selected model. Automatically picks the righ
 | Provider | API |
 |---|---|
 | Google Gemini | Grounding with Google Search |
+| xAI Grok | Responses API `web_search` |
 | OpenAI | Responses API web search |
-| OpenAI Codex | Codex Responses API web search |
+| Azure OpenAI | Responses API web search (`azure-openai-responses`) |
+| 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 |
 
-Supports passing up to 20 additional URLs to analyze alongside the query.
+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`.
+
+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`
 
@@ -33,7 +38,7 @@ pi install npm:pi-web-search
 
 No extra config needed. Select a supported current model in pi and the tools auto-detect the matching provider API.
 
-`web_search` will not scan configured models and pick one automatically when the current model does not support native search. To use a dedicated search model, opt in explicitly with `~/.pi/agent/web-search.json`:
+`web_search` will not scan configured models and pick one automatically when the current model does not support native search. To use a dedicated search model, opt in explicitly with `web-search.json` in pi's agent directory (by default `~/.pi/agent/`; respects `PI_CODING_AGENT_DIR`):
 
 ```json
 {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-web-search",
-  "version": "1.3.1",
-  "description": "Provider-native web search for pi across Google Gemini, OpenAI, and Anthropic, plus Gemini URL Context",
+  "version": "1.5.0",
+  "description": "Provider-native web search for pi: Gemini + URL Context, xAI Grok, OpenAI Responses (Azure/Codex/Copilot), and Anthropic",
   "type": "module",
   "main": "src/index.ts",
   "keywords": [
@@ -11,6 +11,8 @@
     "web-search",
     "gemini",
     "google",
+    "xai",
+    "grok",
     "openai",
     "anthropic",
     "url-context",
@@ -39,6 +41,7 @@
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.80.3",
     "@earendil-works/pi-coding-agent": "^0.80.3",
+    "@earendil-works/pi-tui": "^0.80.3",
     "@types/node": "^25.9.1",
     "typebox": "^1.1.38",
     "typescript": "^6.0.3"
@@ -51,6 +54,7 @@
   "peerDependencies": {
     "@earendil-works/pi-ai": ">=0.80.3",
     "@earendil-works/pi-coding-agent": ">=0.80.3",
+    "@earendil-works/pi-tui": "*",
     "typebox": "*"
   }
 }

package/src/api.ts

@@ -5,7 +5,7 @@ import { TextEncoder, TextDecoder } from "util";
 
 // --- Provider Configuration ---
 
-type ProviderKind = "google" | "openai" | "anthropic" | "unsupported";
+type ProviderKind = "google" | "openai" | "xai" | "anthropic" | "unsupported";
 
 type GoogleRequestBuilder = (model: Model<Api>, body: any) => { url: string; headers: Record<string, string>; body: any };
 
@@ -34,7 +34,12 @@ const GOOGLE_PROVIDERS: Record<string, ProviderConfig> = {
 
 export function getProviderKind(model: Model<Api>): ProviderKind {
     if (GOOGLE_PROVIDERS[model.provider] || GOOGLE_PROVIDERS[model.api]) return "google";
-    if (model.api === "openai-responses" || model.api === "openai-codex-responses") return "openai";
+    if (model.provider === "xai" && model.api === "openai-responses") return "xai";
+    if (
+        model.api === "openai-responses"
+        || model.api === "azure-openai-responses"
+        || model.api === "openai-codex-responses"
+    ) return "openai";
     if (model.api === "anthropic-messages") return "anthropic";
     return "unsupported";
 }
@@ -49,7 +54,7 @@ export function getConfig(model: Model<Api>): ProviderConfig {
 // --- Auth Compatibility Layer ---
 
 type ResolvedAuth = 
-    | { ok: true; apiKey?: string; headers?: Record<string, string>; }
+    | { ok: true; apiKey?: string; headers?: Record<string, string>; baseUrl?: string; }
     | { ok: false; error: string; };
 
 function getEnvAuth(model: Model<Api>): Extract<ResolvedAuth, { ok: true }> | undefined {
@@ -240,8 +245,47 @@ function isOpenAICodexModel(model: Model<Api>): boolean {
     return model.api === "openai-codex-responses";
 }
 
-function resolveOpenAIResponsesUrl(model: Model<Api>): string {
-    const base = trimTrailingSlash(model.baseUrl);
+function resolveGitHubCopilotBaseUrl(
+    model: Model<Api>,
+    auth: Extract<ResolvedAuth, { ok: true }>,
+): string {
+    if (model.provider !== "github-copilot") return model.baseUrl;
+
+    // Modern pi versions expose the credential-specific Copilot endpoint
+    // resolved by the provider. Prefer it so GitHub Enterprise Server and any
+    // future provider-owned routing continue to work without token parsing here.
+    if (typeof auth.baseUrl === "string" && auth.baseUrl.trim()) {
+        return auth.baseUrl;
+    }
+
+    // Compatibility fallback for older pi versions whose extension auth API
+    // returned the Copilot token but not its resolved base URL.
+    if (!auth.apiKey) return model.baseUrl;
+    const proxyEndpoints = auth.apiKey
+        .split(";")
+        .filter((field) => field.startsWith("proxy-ep="))
+        .map((field) => field.slice("proxy-ep=".length));
+    if (proxyEndpoints.length !== 1) return model.baseUrl;
+
+    const proxyHost = proxyEndpoints[0].toLowerCase();
+    const labels = proxyHost.split(".");
+    const isValidLabel = (label: string) =>
+        label.length > 0
+        && label.length <= 63
+        && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(label);
+    const isCopilotProxyHost = proxyHost.length <= 253
+        && labels.length >= 4
+        && labels[0] === "proxy"
+        && labels.at(-2) === "githubcopilot"
+        && labels.at(-1) === "com"
+        && labels.every(isValidLabel);
+    if (!isCopilotProxyHost) return model.baseUrl;
+
+    return `https://api.${labels.slice(1).join(".")}`;
+}
+
+function resolveOpenAIResponsesUrl(model: Model<Api>, baseUrl = model.baseUrl): string {
+    const base = trimTrailingSlash(baseUrl);
     if (!isOpenAICodexModel(model)) return `${base}/responses`;
     if (base.endsWith("/codex/responses")) return base;
     if (base.endsWith("/codex")) return `${base}/responses`;
@@ -421,6 +465,14 @@ async function resolveGoogleGroundingRedirectUrls(searchResults: SearchResultDet
     }
 }
 
+function preserveInlineCitations(text: string, citations: Array<{ endIndex?: number; title: string; url: string }>): { text: string; sources: Source[] } {
+    const sources: Source[] = [];
+    for (const citation of citations) {
+        if (citation.url) pushUniqueSource(sources, { title: citation.title, url: citation.url });
+    }
+    return { text, sources };
+}
+
 function applyIndexCitations(text: string, citations: Array<{ endIndex?: number; title: string; url: string }>): { text: string; sources: Source[] } {
     const sources: Source[] = [];
     const insertions = citations
@@ -639,21 +691,25 @@ async function callOpenAIStream(
     }
     const requestHeaders = Object.fromEntries(headers.entries());
 
+    const isXai = getProviderKind(model) === "xai";
+    const searchProvider: ProviderKind = isXai ? "xai" : "openai";
+    const providerSourceName = isXai ? "xai" : "openai";
     const requestBody: any = {
         model: model.id,
         input: isCodex
             ? [{ role: "user", content: [{ type: "input_text", text: prompt }] }]
-            : prompt,
+            : isXai
+                ? [{ role: "user", content: prompt }]
+                : prompt,
         tools: [{ type: "web_search" }],
-        include: isCodex
-            ? ["web_search_call.action.sources"]
-            : ["web_search_call.action.sources", "web_search_call.results"],
+        ...(isCodex || isXai
+            ? { include: ["web_search_call.action.sources"] }
+            : { include: ["web_search_call.action.sources", "web_search_call.results"] }),
         stream: true,
         store: false,
     };
-    if (model.reasoning) {
-        requestBody.reasoning = { effort: "none" };
-    }
+    // Let the provider choose its supported reasoning default. Some reasoning
+    // models reject "none", and supported effort levels vary between models.
     if (isCodex) {
         requestBody.instructions = "Answer the user's request using web search when needed.";
         requestBody.text = { verbosity: "low" };
@@ -661,7 +717,8 @@ async function callOpenAIStream(
         requestBody.parallel_tool_calls = true;
     }
 
-    const response = await fetch(resolveOpenAIResponsesUrl(model), {
+    const baseUrl = resolveGitHubCopilotBaseUrl(model, auth);
+    const response = await fetch(resolveOpenAIResponsesUrl(model, baseUrl), {
         method: "POST",
         headers: requestHeaders,
         body: JSON.stringify(requestBody),
@@ -669,7 +726,7 @@ async function callOpenAIStream(
     });
 
     if (!response.ok) {
-        throw new Error(`OpenAI API error (${response.status}): ${await response.text()}`);
+        throw new Error(`${isXai ? "xAI" : "OpenAI"} API error (${response.status}): ${await response.text()}`);
     }
 
     let accumulatedText = "";
@@ -691,7 +748,7 @@ async function callOpenAIStream(
         const action = item.action || {};
         const call: NativeSearchCallDetail = {
             id: item.id,
-            provider: "openai",
+            provider: searchProvider,
             status: item.status,
             actionType: action.type,
             raw: item,
@@ -711,7 +768,7 @@ async function callOpenAIStream(
                 pushUniqueSearchResult(searchResults, {
                     title: source.title || source.display_name || source.name || titleFromUrl(source.url),
                     url: source.url,
-                    source: "openai.web_search_call.action.sources",
+                    source: `${providerSourceName}.web_search_call.action.sources`,
                     type: source.type || "url",
                     raw: source,
                 });
@@ -722,7 +779,7 @@ async function callOpenAIStream(
             pushUniqueSearchResult(searchResults, {
                 title: titleFromUrl(action.url),
                 url: action.url,
-                source: `openai.web_search_call.action.${action.type}`,
+                source: `${providerSourceName}.web_search_call.action.${action.type}`,
                 type: action.type,
                 raw: action,
             });
@@ -772,21 +829,23 @@ async function callOpenAIStream(
             pushNativeSearchEvent(nativeSearchEvents, event.type);
             const call = nativeSearchCalls.find((item) => item.id === event.item_id);
             if (call) call.status = event.type.replace("response.web_search_call.", "");
-            else nativeSearchCalls.push({ id: event.item_id, provider: "openai", status: event.type.replace("response.web_search_call.", ""), raw: event });
+            else nativeSearchCalls.push({ id: event.item_id, provider: searchProvider, status: event.type.replace("response.web_search_call.", ""), raw: event });
             if (event.type === "response.web_search_call.searching") {
                 onUpdate?.({
-                    content: [{ type: "text", text: accumulatedText || "Searching the web with OpenAI..." }],
+                    content: [{ type: "text", text: accumulatedText || `Searching the web with ${isXai ? "xAI" : "OpenAI"}...` }],
                     details: { streaming: true, searching: true }
                 });
             }
         }
     });
 
-    const cited = applyIndexCitations(accumulatedText || "No answer available.", citations);
+    const cited = isXai
+        ? preserveInlineCitations(accumulatedText || "No answer available.", citations)
+        : applyIndexCitations(accumulatedText || "No answer available.", citations);
     const citationDetails = citations.map((citation) => ({
         title: citation.title,
         url: citation.url,
-        source: "openai.url_citation",
+        source: `${providerSourceName}.url_citation`,
         type: "citation",
         raw: citation,
     }));
@@ -800,7 +859,7 @@ async function callOpenAIStream(
     return {
         text: cited.text,
         sources: cited.sources.length ? cited.sources.map((source) => ({ ...source, url: normalizeSearchUrl(source.url) })).filter((source) => !isLikelyJunkSearchUrl(source.url)) : derivedSources,
-        providerKind: "openai",
+        providerKind: searchProvider,
         nativeSearchUsed: nativeSearchEvents.length > 0 || nativeSearchCalls.length > 0 || sanitizedSearchResults.length > 0,
         nativeSearchEvents,
         nativeSearchCalls,
@@ -993,7 +1052,7 @@ export async function callApiStream(
         throw new Error("No prompt text found in request body");
     }
 
-    if (kind === "openai") {
+    if (kind === "openai" || kind === "xai") {
         return callOpenAIStream(ctx, model, prompt, onUpdate, signal);
     }
     if (kind === "anthropic") {

package/src/index.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
+import { Text } from "@earendil-works/pi-tui";
 import { getProviderKind } from "./api.ts";
 import { webSearch, WebSearchSchema } from "./web_search.ts";
 import { urlContext, UrlContextSchema } from "./url_context.ts";
@@ -62,9 +63,30 @@ 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, OpenAI, or Anthropic). Optionally include URLs to analyze alongside search results.",
+        description: "Search the web using the current supported provider (Google Gemini, xAI Grok, OpenAI, or Anthropic). Optionally include URLs to analyze alongside search results.",
         parameters: WebSearchSchema,
-        execute: webSearch
+        execute: webSearch,
+        renderCall(args, theme) {
+            const query = args.query || "…";
+            const urlCount = args.urls?.length ?? 0;
+            const urls = urlCount > 0 ? theme.fg("muted", ` + ${urlCount} URL${urlCount === 1 ? "" : "s"}`) : "";
+            return new Text(
+                `${theme.fg("toolTitle", theme.bold("web_search"))} ${theme.fg("accent", query)}${urls}`,
+                0,
+                0,
+            );
+        },
+        renderResult(result, { expanded }, theme) {
+            const output = result.content
+                .filter((part) => part.type === "text")
+                .map((part) => part.text)
+                .join("\n");
+
+            const isError = Boolean(result.details?.error);
+            if (!expanded && !isError) return new Text("", 0, 0);
+
+            return new Text(theme.fg(isError ? "error" : "toolOutput", output), 0, 0);
+        }
     });
 
     pi.registerTool({

package/src/utils.ts

@@ -1,8 +1,7 @@
 import type { ExtensionContext, AgentToolResult } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
-import { truncateHead, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@earendil-works/pi-coding-agent";
+import { truncateHead, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { getProviderKind } from "./api.ts";
 
@@ -18,8 +17,7 @@ export function formatResult(text: string, details: any): AgentToolResult<any> {
 
 // --- Model Selection ---
 
-const SUPPORTED_PROVIDERS = ["google-generative-ai", "openai-responses", "openai-codex-responses", "anthropic-messages"];
-const WEB_SEARCH_CONFIG_PATH = join(homedir(), ".pi", "agent", "web-search.json");
+const SUPPORTED_PROVIDERS = ["google-generative-ai", "xai", "openai-responses", "azure-openai-responses", "openai-codex-responses", "anthropic-messages"];
 
 type WebSearchModelConfig =
     | { status: "missing"; path: string; }
@@ -36,7 +34,7 @@ function describeModel(model: Model<Api>): string {
 }
 
 function getWebSearchConfigPath(): string {
-    return process.env.PI_WEB_SEARCH_CONFIG || WEB_SEARCH_CONFIG_PATH;
+    return process.env.PI_WEB_SEARCH_CONFIG || join(getAgentDir(), "web-search.json");
 }
 
 function readWebSearchModelConfig(): WebSearchModelConfig {

package/src/web_search.ts

@@ -59,7 +59,14 @@ export async function webSearch(
         const cited = applyCitations(result.text, result.groundingMetadata);
         const text = cited.text;
         const sources = result.sources?.length ? result.sources : cited.sources;
-        const extraSearchResults = (result.searchResults || []).filter((item) => item.url && !sources.some((source) => source.url === item.url));
+        const seenAdditionalResults = new Set<string>();
+        const extraSearchResults = (result.searchResults || []).filter((item) => {
+            if (!item.url || sources.some((source) => source.url === item.url)) return false;
+            const key = `${item.title || ""}\t${item.url}`;
+            if (seenAdditionalResults.has(key)) return false;
+            seenAdditionalResults.add(key);
+            return true;
+        });
 
         // Handle URL context metadata
         const urlMeta = result.urlContextMetadata?.urlMetadata 
@@ -90,16 +97,11 @@ export async function webSearch(
         }
 
         if (extraSearchResults.length) {
-            const visibleResults = extraSearchResults.slice(0, 8);
-            summary += `\n\n## Additional Search Results\n${visibleResults.map((r, i) => {
+            summary += `\n\n## Additional Search Results\n${extraSearchResults.map((r, i) => {
                 const label = r.title || r.url || `Result ${i + 1}`;
                 const url = r.url ? ` - ${r.url}` : "";
-                const meta = [r.source, r.type, r.status, r.query ? `query=${r.query}` : undefined].filter(Boolean).join(", ");
-                return `${i + 1}. ${label}${url}${meta ? ` (${meta})` : ""}`;
+                return `${i + 1}. ${label}${url}`;
             }).join("\n")}`;
-            if (extraSearchResults.length > visibleResults.length) {
-                summary += `\n... and ${extraSearchResults.length - visibleResults.length} more results in tool details.`;
-            }
         }
 
         return formatResult(summary, {