pi-web-search 1.0.2 → 1.2.0

package/src/index.ts

@@ -1,21 +1,83 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { webSearch, WebSearchSchema } from "./web_search.js";
-import { urlContext, UrlContextSchema } from "./url_context.js";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type Model } from "@earendil-works/pi-ai";
+import { getProviderKind } from "./api.ts";
+import { webSearch, WebSearchSchema } from "./web_search.ts";
+import { urlContext, UrlContextSchema } from "./url_context.ts";
+
+const WEB_SEARCH_TOOL = "web_search";
+const URL_CONTEXT_TOOL = "url_context";
+
+function supportsUrlContext(model: Model<any> | undefined) {
+    return !!model && getProviderKind(model) === "google";
+}
+
+function setEquals<T>(a: Set<T>, b: Set<T>) {
+    if (a.size !== b.size) return false;
+    for (const value of a) {
+        if (!b.has(value)) return false;
+    }
+    return true;
+}
+
+export function createModelScopedToolManager(pi: Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">) {
+    let preferredActiveTools: Set<string> | undefined;
+    let lastAppliedActiveTools: Set<string> | undefined;
+    let suppressedTools = new Set<string>();
+
+    const sync = (model: Model<any> | undefined) => {
+        const currentActiveTools = new Set(pi.getActiveTools());
+
+        if (!preferredActiveTools) {
+            preferredActiveTools = new Set(currentActiveTools);
+        } else if (lastAppliedActiveTools) {
+            for (const tool of currentActiveTools) {
+                if (!lastAppliedActiveTools.has(tool)) preferredActiveTools.add(tool);
+            }
+            for (const tool of lastAppliedActiveTools) {
+                if (!currentActiveTools.has(tool) && !suppressedTools.has(tool)) {
+                    preferredActiveTools.delete(tool);
+                }
+            }
+        }
+
+        const desiredActiveTools = new Set(preferredActiveTools);
+        suppressedTools = new Set<string>();
+        if (!supportsUrlContext(model)) {
+            desiredActiveTools.delete(URL_CONTEXT_TOOL);
+            if (preferredActiveTools.has(URL_CONTEXT_TOOL)) {
+                suppressedTools.add(URL_CONTEXT_TOOL);
+            }
+        }
+
+        if (!setEquals(currentActiveTools, desiredActiveTools)) {
+            pi.setActiveTools(Array.from(desiredActiveTools));
+        }
+        lastAppliedActiveTools = new Set(desiredActiveTools);
+    };
+
+    return { sync };
+}
 
 export default function (pi: ExtensionAPI) {
     pi.registerTool({
-        name: "web_search",
+        name: WEB_SEARCH_TOOL,
         label: "Web Search",
-        description: "Search the web using Google Gemini's grounding. Optionally include URLs to analyze alongside search results.",
+        description: "Search the web using the current supported provider (Google Gemini, OpenAI, or Anthropic). Optionally include URLs to analyze alongside search results.",
         parameters: WebSearchSchema,
         execute: webSearch
     });
 
     pi.registerTool({
-        name: "url_context",
+        name: URL_CONTEXT_TOOL,
         label: "URL Context",
-        description: "Analyze the content of up to 20 public URLs. Supports web pages, documents, images, and YouTube videos.",
+        description: "Analyze the content of up to 20 public URLs using Gemini URL Context. Supports web pages, documents, images, and YouTube videos.",
         parameters: UrlContextSchema,
         execute: urlContext
     });
+
+    const toolManager = createModelScopedToolManager(pi);
+    pi.on("session_start", (_event, ctx) => toolManager.sync(ctx.model));
+    pi.on("session_switch", (_event, ctx) => toolManager.sync(ctx.model));
+    pi.on("session_tree", (_event, ctx) => toolManager.sync(ctx.model));
+    pi.on("model_select", (event) => toolManager.sync(event.model));
 }

package/src/url_context.ts

@@ -1,7 +1,7 @@
-import type { ExtensionContext, AgentToolUpdateCallback } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext, AgentToolUpdateCallback } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "@sinclair/typebox";
-import { callApiStream, getConfig, applyCitations } from "./api.js";
-import { getModel, missingConfigResult, errorResult, formatResult } from "./utils.js";
+import { callApiStream, getConfig, applyCitations } from "./api.ts";
+import { getModel, missingConfigResult, errorResult, formatResult } from "./utils.ts";
 
 export const UrlContextSchema = Type.Object({
     query: Type.String({ description: "Question or task to perform on the URLs" }),
@@ -30,9 +30,21 @@ export async function urlContext(
 
     try {
         const config = getConfig(model);
+        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.`,
+                {
+                    error: "unsupported_provider",
+                    providerKind: config.kind,
+                    model: model.id,
+                    supportedProviders: ["google", "google-generative-ai"],
+                    grounded: false,
+                }
+            );
+        }
         
         let contents: any[] = [];
-        let tools: any[] | undefined = [{ [config.urlContextTool]: {} }];
+        let tools: any[] | undefined = [{ [config.urlContextTool!]: {} }];
 
         // Special handling for YouTube videos on Gemini
         if (model.api === "google-generative-ai") {
@@ -83,10 +95,13 @@ export async function urlContext(
 
         const result = await callApiStream(ctx, model, {
             contents,
-            tools
-        }, onUpdate);
+            ...(tools ? { tools } : {})
+        }, onUpdate, signal);
 
-        const { text, sources } = applyCitations(result.text, result.groundingMetadata);
+        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));
         
         // Handle both camelCase and snake_case metadata
         const urlMeta = result.urlContextMetadata?.urlMetadata 
@@ -108,14 +123,40 @@ export async function urlContext(
             summary += `\n\n## URL Status\n✅ Retrieved: ${retrieved.length}\n❌ Failed: ${failed.length}`;
             failed.forEach((f: any) => { summary += `\n- ${f.url}: ${f.status}`; });
         }
+        const hasUrlContextMetadata = urlMeta.length > 0 || retrieved.length > 0 || sources.length > 0 || extraSearchResults.length > 0;
+        if (!hasUrlContextMetadata) {
+            summary += `\n\n## URL Context Verification\n⚠️ No verified URL context metadata was returned by provider ${result.providerKind || "unknown"}. Treat the answer as ungrounded unless sources, retrieved URLs, or searchResults are present in tool details.`;
+        }
         if (sources.length > 0 && !summary.includes("## Sources")) {
             summary += `\n\n## Sources\n${sources.map((s, i) => `${i + 1}. [${s.title}](${s.url})`).join("\n")}`;
         }
+        if (extraSearchResults.length) {
+            const visibleResults = extraSearchResults.slice(0, 8);
+            summary += `\n\n## Additional Search Results\n${visibleResults.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})` : ""}`;
+            }).join("\n")}`;
+            if (extraSearchResults.length > visibleResults.length) {
+                summary += `\n... and ${extraSearchResults.length - visibleResults.length} more results in tool details.`;
+            }
+        }
 
         return formatResult(summary, {
+            sources,
+            providerKind: result.providerKind,
+            nativeSearchUsed: result.nativeSearchUsed,
+            nativeSearchEvents: result.nativeSearchEvents,
+            nativeSearchCalls: result.nativeSearchCalls,
+            searchQueries: result.searchQueries,
+            searchResults: result.searchResults,
+            citations: result.citations,
             retrieved,
             failed: failed.length > 0 ? failed : undefined,
-            model: model.id
+            model: model.id,
+            grounded: sources.length > 0 || (result.searchResults?.length || 0) > 0,
+            resultCount: result.searchResults?.length || sources.length
         });
     } catch (e: any) {
         return errorResult(e);

package/src/utils.ts

@@ -1,6 +1,7 @@
-import type { ExtensionContext, AgentToolResult } from "@mariozechner/pi-coding-agent";
-import { type Model } from "@mariozechner/pi-ai";
-import { truncateHead, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext, AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { type Model } from "@earendil-works/pi-ai";
+import { truncateHead, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@earendil-works/pi-coding-agent";
+import { getProviderKind } from "./api.ts";
 
 // --- Formatting ---
 
@@ -14,63 +15,62 @@ export function formatResult(text: string, details: any): AgentToolResult<any> {
 
 // --- Model Selection ---
 
-export async function getModel(ctx: ExtensionContext): Promise<Model<any> | undefined> {
-    // flash first, big first: 3-flash -> 2.5-flash -> 2.0-flash
-    // provider priority: google-gemini-cli -> google-antigravity -> google -> google-generative-ai
-    const models = ctx.modelRegistry.getAvailable();
-    
-    const flashModels = [
+function isSupportedSearchModel(model: Model<any> | undefined): model is Model<any> {
+    if (!model) return false;
+    return getProviderKind(model) !== "unsupported";
+}
+
+function providerPriority(model: Model<any>): number {
+    const priorities = [
+        "google",
+        "google-generative-ai",
+        "openai",
+        "anthropic",
+    ];
+    const providerIndex = priorities.indexOf(model.provider);
+    if (providerIndex >= 0) return providerIndex;
+    return priorities.length;
+}
+
+function modelPriority(model: Model<any>): number {
+    const id = model.id;
+    const patterns = [
         /gemini-3.*flash/i,
         /gemini-2\.5.*flash/i,
         /gemini-2\.0.*flash/i,
         /gemini.*flash/i,
+        /gpt-5\..*mini/i,
+        /gpt-4\.1.*mini/i,
+        /gpt-4o-mini/i,
+        /claude.*haiku/i,
+        /claude.*sonnet/i,
     ];
-    
-    const providers = [
-        "google-gemini-cli",
-        "google-antigravity", 
-        "google",
-        "google-generative-ai",
-    ];
-    
-    // Filter to only Google-compatible models (those with supported api/provider)
-    const googleModels = models.filter(m => 
-        providers.includes(m.provider) ||
-        m.api === "google-generative-ai" || 
-        m.api === "google-gemini-cli"
-    );
-    
-    // Try each flash pattern in priority order
-    for (const pattern of flashModels) {
-        const matching = googleModels.filter(m => pattern.test(m.id));
-        if (matching.length === 0) continue;
-        
-        // Among matches, pick by provider priority
-        for (const provider of providers) {
-            const model = matching.find(m => m.provider === provider);
-            if (model) return model;
-        }
-        
-        // Fall back to first match if no priority provider found
-        return matching[0];
-    }
-    
-    // No flash model found, try any Google model by provider priority
-    for (const provider of providers) {
-        const model = googleModels.find(m => m.provider === provider);
-        if (model) return model;
+    const patternIndex = patterns.findIndex((pattern) => pattern.test(id));
+    return patternIndex >= 0 ? patternIndex : patterns.length;
+}
+
+export async function getModel(ctx: ExtensionContext): Promise<Model<any> | undefined> {
+    // Use the current model first so the tool follows the user's selected provider.
+    // This lets pi --provider openai/anthropic/google automatically pick the matching API.
+    if (isSupportedSearchModel(ctx.model)) {
+        return ctx.model;
     }
-    
-    // Return first available Google model if any
-    return googleModels[0];
+
+    const models = ctx.modelRegistry.getAvailable().filter(isSupportedSearchModel);
+    if (models.length === 0) return undefined;
+
+    return models.sort((a, b) => {
+        const byProvider = providerPriority(a) - providerPriority(b);
+        if (byProvider !== 0) return byProvider;
+        return modelPriority(a) - modelPriority(b);
+    })[0];
 }
 
 // --- Error Results ---
 
 export function missingConfigResult(ctx: ExtensionContext): AgentToolResult<any> {
-    const msg = ctx.model && ["google-gemini-cli", "google-antigravity"].includes(ctx.model.provider)
-        ? `Provider ${ctx.model.provider} requires valid OAuth credentials.`
-        : "No Google Gemini configuration found. Please configure GEMINI_API_KEY.";
+    const current = ctx.model ? `${ctx.model.provider} (${ctx.model.api})` : "none";
+    const msg = `No supported web-search model configuration found. Current model: ${current}. Configure or select a supported provider: google-generative-ai, openai, or anthropic.`;
     return { content: [{ type: "text", text: `Failed: ${msg}` }], details: { error: "missing_config" } };
 }
 

package/src/web_search.ts

@@ -1,7 +1,7 @@
-import type { ExtensionContext, AgentToolUpdateCallback } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext, AgentToolUpdateCallback } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "@sinclair/typebox";
-import { callApiStream, getConfig, applyCitations } from "./api.js";
-import { getModel, missingConfigResult, errorResult, formatResult } from "./utils.js";
+import { callApiStream, getConfig, applyCitations } from "./api.ts";
+import { getModel, missingConfigResult, errorResult, formatResult } from "./utils.ts";
 
 export const WebSearchSchema = Type.Object({
     query: Type.String({ description: "The search query or question to answer" }),
@@ -43,17 +43,23 @@ export async function webSearch(
             ? `${params.query}\n\nAlso analyze these URLs:\n${params.urls!.join("\n")}`
             : params.query;
 
-        // Enable google_search, add url_context if URLs provided
-        const tools = hasUrls
-            ? [{ [config.searchTool]: {} }, { [config.urlContextTool]: {} }]
-            : [{ [config.searchTool]: {} }];
+        // Enable provider-native search tools. Google needs explicit Gemini tool names;
+        // OpenAI/Anthropic are handled inside callApiStream based on the current model.
+        const tools = config.kind === "google"
+            ? (hasUrls
+                ? [{ [config.searchTool!]: {} }, { [config.urlContextTool!]: {} }]
+                : [{ [config.searchTool!]: {} }])
+            : undefined;
 
         const result = await callApiStream(ctx, model, {
             contents: [{ role: "user", parts: [{ text: prompt }] }],
-            tools
-        }, onUpdate);
+            ...(tools ? { tools } : {})
+        }, onUpdate, signal);
 
-        const { text, sources } = applyCitations(result.text, result.groundingMetadata);
+        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));
 
         // Handle URL context metadata
         const urlMeta = result.urlContextMetadata?.urlMetadata 
@@ -78,18 +84,42 @@ export async function webSearch(
             failed.forEach((f: any) => { summary += `\n- ${f.url}: ${f.status}`; });
         }
 
+        if (result.nativeSearchUsed === false) {
+            summary += `\n\n## Search Verification\n⚠️ No verified native search metadata was returned by provider ${result.providerKind || "unknown"}. Treat the answer as ungrounded unless sources/searchResults are present in tool details.`;
+        }
+
         // Add sources
         if (sources.length > 0) {
             summary += `\n\n## Sources\n${sources.map((s, i) => `${i + 1}. [${s.title}](${s.url})`).join("\n")}`;
         }
 
+        if (extraSearchResults.length) {
+            const visibleResults = extraSearchResults.slice(0, 8);
+            summary += `\n\n## Additional Search Results\n${visibleResults.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})` : ""}`;
+            }).join("\n")}`;
+            if (extraSearchResults.length > visibleResults.length) {
+                summary += `\n... and ${extraSearchResults.length - visibleResults.length} more results in tool details.`;
+            }
+        }
+
         return formatResult(summary, {
             sources,
-            searchQueries: result.groundingMetadata?.webSearchQueries,
+            providerKind: result.providerKind,
+            nativeSearchUsed: result.nativeSearchUsed,
+            nativeSearchEvents: result.nativeSearchEvents,
+            nativeSearchCalls: result.nativeSearchCalls,
+            searchQueries: result.searchQueries || result.groundingMetadata?.webSearchQueries,
+            searchResults: result.searchResults,
+            citations: result.citations,
             retrieved: retrieved.length > 0 ? retrieved : undefined,
             failed: failed.length > 0 ? failed : undefined,
             model: model.id,
-            grounded: sources.length > 0
+            grounded: sources.length > 0 || (result.searchResults?.length || 0) > 0,
+            resultCount: result.searchResults?.length || sources.length
         });
     } catch (e: any) {
         return errorResult(e);

package/dist/api.d.ts

@@ -1,26 +0,0 @@
-import type { ExtensionContext, AgentToolUpdateCallback } from "@mariozechner/pi-coding-agent";
-import { type Model } from "@mariozechner/pi-ai";
-type ProviderConfig = {
-    searchTool: string;
-    urlContextTool: string;
-    buildRequest: (model: Model<any>, body: any, projectId?: string) => {
-        url: string;
-        headers: Record<string, string>;
-        body: any;
-    };
-};
-export declare function getConfig(model: Model<any>): ProviderConfig;
-export interface StreamResult {
-    text: string;
-    groundingMetadata?: any;
-    urlContextMetadata?: any;
-}
-export declare function callApiStream(ctx: ExtensionContext, model: Model<any>, body: any, onUpdate?: AgentToolUpdateCallback): Promise<StreamResult>;
-export declare function applyCitations(text: string, groundingMetadata: any): {
-    text: string;
-    sources: {
-        title: string;
-        url: string;
-    }[];
-};
-export {};

package/dist/api.js

@@ -1,182 +0,0 @@
-import { TextEncoder, TextDecoder } from "util";
-const PROVIDERS = {
-    "google-generative-ai": {
-        searchTool: "google_search",
-        urlContextTool: "url_context",
-        buildRequest: (model, body) => ({
-            url: `${model.baseUrl}/models/${model.id}:streamGenerateContent?alt=sse`,
-            headers: {
-                "Content-Type": "application/json",
-                "Accept": "text/event-stream",
-            },
-            body
-        })
-    },
-    "google-gemini-cli": {
-        searchTool: "googleSearch",
-        urlContextTool: "urlContext",
-        buildRequest: (model, body, projectId) => ({
-            url: `${model.baseUrl}/v1internal:streamGenerateContent?alt=sse`,
-            headers: {
-                "Content-Type": "application/json",
-                "Accept": "text/event-stream",
-                "User-Agent": "google-cloud-sdk vscode_cloudshelleditor/0.1",
-                "X-Goog-Api-Client": "gl-node/22.17.0",
-                "Client-Metadata": JSON.stringify({ ideType: "IDE_UNSPECIFIED", platform: "PLATFORM_UNSPECIFIED", pluginType: "GEMINI" }),
-            },
-            body: { project: projectId, model: model.id, request: body }
-        })
-    },
-    "google-antigravity": {
-        searchTool: "googleSearch",
-        urlContextTool: "urlContext",
-        buildRequest: (model, body, projectId) => ({
-            url: `${model.baseUrl}/v1internal:streamGenerateContent?alt=sse`,
-            headers: {
-                "Content-Type": "application/json",
-                "Accept": "text/event-stream",
-                "User-Agent": "antigravity/1.15.8 darwin/arm64",
-                "X-Goog-Api-Client": "gl-node/22.17.0",
-                "Client-Metadata": JSON.stringify({ ideType: "IDE_UNSPECIFIED", platform: "PLATFORM_UNSPECIFIED", pluginType: "GEMINI" }),
-            },
-            body: {
-                project: projectId,
-                model: model.id,
-                request: body,
-                requestType: "agent",
-                userAgent: "antigravity",
-                requestId: `agent-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
-            }
-        })
-    }
-};
-export function getConfig(model) {
-    return PROVIDERS[model.provider] || PROVIDERS[model.api] || PROVIDERS["google-generative-ai"];
-}
-export async function callApiStream(ctx, model, body, onUpdate) {
-    const config = getConfig(model);
-    const apiKey = await ctx.modelRegistry.getApiKey(model) || "";
-    let projectId;
-    if (model.api !== "google-generative-ai") {
-        const parsed = JSON.parse(apiKey);
-        projectId = parsed.projectId;
-    }
-    const req = config.buildRequest(model, body, projectId);
-    // Handle auth
-    if (model.api === "google-generative-ai") {
-        req.headers["x-goog-api-key"] = apiKey;
-    }
-    else {
-        const parsed = JSON.parse(apiKey);
-        req.headers["Authorization"] = `Bearer ${parsed.token}`;
-    }
-    const response = await fetch(req.url, {
-        method: "POST",
-        headers: req.headers,
-        body: JSON.stringify(req.body)
-    });
-    if (!response.ok) {
-        throw new Error(`API error (${response.status}): ${await response.text()}`);
-    }
-    if (!response.body) {
-        throw new Error("No response body");
-    }
-    // Parse SSE stream
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let accumulatedText = "";
-    let groundingMetadata;
-    let urlContextMetadata;
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-            if (!line.startsWith("data:"))
-                continue;
-            const jsonStr = line.slice(5).trim();
-            if (!jsonStr)
-                continue;
-            let chunk;
-            try {
-                chunk = JSON.parse(jsonStr);
-            }
-            catch {
-                continue;
-            }
-            // Unwrap response for internal APIs
-            const data = chunk.response || chunk;
-            const candidate = data.candidates?.[0];
-            if (candidate?.content?.parts) {
-                for (const part of candidate.content.parts) {
-                    if (part.text) {
-                        accumulatedText += part.text;
-                        // Stream update
-                        onUpdate?.({
-                            content: [{ type: "text", text: accumulatedText }],
-                            details: { streaming: true }
-                        });
-                    }
-                }
-            }
-            // Capture metadata from final chunk
-            if (candidate?.groundingMetadata) {
-                groundingMetadata = candidate.groundingMetadata;
-            }
-            // Handle both camelCase and snake_case
-            if (candidate?.urlContextMetadata || candidate?.url_context_metadata) {
-                urlContextMetadata = candidate.urlContextMetadata || candidate.url_context_metadata;
-            }
-        }
-    }
-    return {
-        text: accumulatedText || "No answer available.",
-        groundingMetadata,
-        urlContextMetadata
-    };
-}
-// --- Citation Processing (byte-safe) ---
-export function applyCitations(text, groundingMetadata) {
-    const chunks = groundingMetadata?.groundingChunks || [];
-    const supports = groundingMetadata?.groundingSupports || [];
-    const sources = chunks
-        .filter((c) => c.web)
-        .map((c) => ({ title: c.web.title || "Unknown", url: c.web.uri || "" }));
-    if (!supports.length || !sources.length)
-        return { text, sources };
-    // Collect insertions, sort descending
-    const insertions = supports
-        .filter((s) => s.segment?.endIndex !== undefined && s.groundingChunkIndices?.length)
-        .map((s) => ({
-        index: s.segment.endIndex,
-        marker: s.groundingChunkIndices.map((i) => `[${i + 1}]`).join("")
-    }))
-        .sort((a, b) => b.index - a.index);
-    // Byte-safe insertion
-    const encoder = new TextEncoder();
-    const decoder = new TextDecoder();
-    const bytes = encoder.encode(text);
-    const parts = [];
-    let lastIndex = bytes.length;
-    for (const ins of insertions) {
-        const pos = Math.min(ins.index, lastIndex);
-        if (pos < lastIndex)
-            parts.unshift(bytes.subarray(pos, lastIndex));
-        parts.unshift(encoder.encode(ins.marker));
-        lastIndex = pos;
-    }
-    if (lastIndex > 0)
-        parts.unshift(bytes.subarray(0, lastIndex));
-    const total = parts.reduce((acc, p) => acc + p.length, 0);
-    const final = new Uint8Array(total);
-    let offset = 0;
-    for (const part of parts) {
-        final.set(part, offset);
-        offset += part.length;
-    }
-    return { text: decoder.decode(final), sources };
-}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-export default function (pi: ExtensionAPI): void;

package/dist/index.js

@@ -1,18 +0,0 @@
-import { webSearch, WebSearchSchema } from "./web_search.js";
-import { urlContext, UrlContextSchema } from "./url_context.js";
-export default function (pi) {
-    pi.registerTool({
-        name: "web_search",
-        label: "Web Search",
-        description: "Search the web using Google Gemini's grounding. Optionally include URLs to analyze alongside search results.",
-        parameters: WebSearchSchema,
-        execute: webSearch
-    });
-    pi.registerTool({
-        name: "url_context",
-        label: "URL Context",
-        description: "Analyze the content of up to 20 public URLs. Supports web pages, documents, images, and YouTube videos.",
-        parameters: UrlContextSchema,
-        execute: urlContext
-    });
-}

package/dist/url_context.d.ts

@@ -1,8 +0,0 @@
-import type { ExtensionContext, AgentToolUpdateCallback } from "@mariozechner/pi-coding-agent";
-import { type Static } from "@sinclair/typebox";
-export declare const UrlContextSchema: import("@sinclair/typebox").TObject<{
-    query: import("@sinclair/typebox").TString;
-    urls: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-}>;
-export type UrlContextInput = Static<typeof UrlContextSchema>;
-export declare function urlContext(id: string, params: UrlContextInput, signal: AbortSignal, onUpdate: AgentToolUpdateCallback | undefined, ctx: ExtensionContext): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<any>>;