pi-web-search 1.0.0

package/README.md

@@ -0,0 +1,24 @@
+# pi-web-search
+
+A pi extension that provides web search and content analysis capabilities powered by Gemini API.
+
+## Features
+
+- **🔍 Web Search** - Google search with citations
+- **📄 URL Analysis** - Analyze web pages, PDFs, and images (up to 20 URLs)
+- **🎥 YouTube** - Video summaries and Q&A
+
+## Installation
+
+```bash
+pi install npm:pi-web-search
+```
+
+## Configuration
+
+No special configuration required. Configure or login to any of the following model providers in pi, and it will be automatically detected and used:
+
+- google-antigravity
+- google-gemini-cli
+- google
+- google-generative-ai

package/dist/advanced_search.d.ts

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

package/dist/advanced_search.js

@@ -0,0 +1,76 @@
+import { Type } from "@sinclair/typebox";
+import { callApiStream, getConfig, applyCitations } from "./api.js";
+import { getModel, missingConfigResult, errorResult, formatResult } from "./utils.js";
+export const AdvancedSearchSchema = Type.Object({
+    query: Type.String({ description: "The search query or question to answer" }),
+    urls: Type.Optional(Type.Array(Type.String(), {
+        description: "Additional URLs to include in context (up to 20)",
+        maxItems: 20
+    })),
+});
+export async function advancedSearch(id, params, signal, onUpdate, ctx) {
+    const model = await getModel(ctx);
+    if (!model)
+        return missingConfigResult(ctx);
+    const hasUrls = params.urls && params.urls.length > 0;
+    const urlCount = hasUrls ? params.urls.length : 0;
+    onUpdate?.({
+        content: [{
+                type: "text",
+                text: hasUrls
+                    ? `Searching and analyzing ${urlCount} URL(s)...`
+                    : `Searching for "${params.query}"...`
+            }],
+        details: {}
+    });
+    try {
+        const config = getConfig(model);
+        // Build prompt: include URLs in the query if provided
+        const prompt = hasUrls
+            ? `${params.query}\n\nAlso analyze these URLs:\n${params.urls.join("\n")}`
+            : params.query;
+        // Enable both tools: google_search + url_context
+        // Gemini will decide when to use each
+        const tools = hasUrls
+            ? [{ [config.searchTool]: {} }, { [config.urlContextTool]: {} }]
+            : [{ [config.searchTool]: {} }];
+        const result = await callApiStream(ctx, model, {
+            contents: [{ role: "user", parts: [{ text: prompt }] }],
+            tools
+        }, onUpdate);
+        const { text, sources } = applyCitations(result.text, result.groundingMetadata);
+        // Handle URL context metadata
+        const urlMeta = result.urlContextMetadata?.urlMetadata
+            || result.urlContextMetadata?.url_metadata || [];
+        const retrieved = urlMeta
+            .filter((m) => (m.urlRetrievalStatus || m.url_retrieval_status) === "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m) => m.retrievedUrl || m.retrieved_url || m.url);
+        const failed = urlMeta
+            .filter((m) => (m.urlRetrievalStatus || m.url_retrieval_status) !== "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m) => ({
+            url: m.retrievedUrl || m.retrieved_url || m.url,
+            status: m.urlRetrievalStatus || m.url_retrieval_status
+        }));
+        let summary = text;
+        // Add URL status if there were failures
+        if (failed.length > 0) {
+            summary += `\n\n## URL Status\n✅ Retrieved: ${retrieved.length}\n❌ Failed: ${failed.length}`;
+            failed.forEach((f) => { summary += `\n- ${f.url}: ${f.status}`; });
+        }
+        // Add sources
+        if (sources.length > 0) {
+            summary += `\n\n## Sources\n${sources.map((s, i) => `${i + 1}. [${s.title}](${s.url})`).join("\n")}`;
+        }
+        return formatResult(summary, {
+            sources,
+            searchQueries: result.groundingMetadata?.webSearchQueries,
+            retrieved: retrieved.length > 0 ? retrieved : undefined,
+            failed: failed.length > 0 ? failed : undefined,
+            model: model.id,
+            grounded: sources.length > 0
+        });
+    }
+    catch (e) {
+        return errorResult(e);
+    }
+}

package/dist/api.d.ts

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,182 @@
+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

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

package/dist/index.js

@@ -0,0 +1,26 @@
+import { webSearch, WebSearchSchema } from "./web_search.js";
+import { urlContext, UrlContextSchema } from "./url_context.js";
+import { youtubeVideo, YoutubeVideoSchema } from "./youtube_video.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 web pages and documents. Extract data, compare documents, synthesize content. Supports text/html, PDF, images, JSON, CSV. Up to 20 URLs.",
+        parameters: UrlContextSchema,
+        execute: urlContext
+    });
+    pi.registerTool({
+        name: "youtube_video",
+        label: "YouTube Video",
+        description: "Analyze YouTube videos. Summarize, answer questions, find timestamps. Supports video clipping (start/end offsets). Preview feature.",
+        parameters: YoutubeVideoSchema,
+        execute: youtubeVideo
+    });
+}

package/dist/url_context.d.ts

@@ -0,0 +1,8 @@
+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>>;

package/dist/url_context.js

@@ -0,0 +1,55 @@
+import { Type } from "@sinclair/typebox";
+import { callApiStream, getConfig, applyCitations } from "./api.js";
+import { getModel, missingConfigResult, errorResult, formatResult } from "./utils.js";
+export const UrlContextSchema = Type.Object({
+    query: Type.String({ description: "Question or task to perform on the URLs" }),
+    urls: Type.Array(Type.String(), {
+        description: "URLs to analyze (up to 20). Supports text/html, PDF, images, JSON, CSV, etc.",
+        minItems: 1,
+        maxItems: 20
+    }),
+});
+export async function urlContext(id, params, signal, onUpdate, ctx) {
+    const model = await getModel(ctx);
+    if (!model)
+        return missingConfigResult(ctx);
+    const count = params.urls.length;
+    onUpdate?.({ content: [{ type: "text", text: `Analyzing ${count} URL${count > 1 ? 's' : ''}...` }], details: {} });
+    try {
+        const config = getConfig(model);
+        const combinedPrompt = `${params.query}\n\nURLs:\n${params.urls.join("\n")}`;
+        const result = await callApiStream(ctx, model, {
+            contents: [{ role: "user", parts: [{ text: combinedPrompt }] }],
+            tools: [{ [config.urlContextTool]: {} }]
+        }, onUpdate);
+        const { text, sources } = applyCitations(result.text, result.groundingMetadata);
+        // Handle both camelCase and snake_case metadata
+        const urlMeta = result.urlContextMetadata?.urlMetadata
+            || result.urlContextMetadata?.url_metadata || [];
+        const retrieved = urlMeta
+            .filter((m) => (m.urlRetrievalStatus || m.url_retrieval_status) === "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m) => m.retrievedUrl || m.retrieved_url || m.url);
+        const failed = urlMeta
+            .filter((m) => (m.urlRetrievalStatus || m.url_retrieval_status) !== "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m) => ({
+            url: m.retrievedUrl || m.retrieved_url || m.url,
+            status: m.urlRetrievalStatus || m.url_retrieval_status
+        }));
+        let summary = text;
+        if (failed.length > 0) {
+            summary += `\n\n## URL Status\n✅ Retrieved: ${retrieved.length}\n❌ Failed: ${failed.length}`;
+            failed.forEach((f) => { summary += `\n- ${f.url}: ${f.status}`; });
+        }
+        if (sources.length > 0 && !summary.includes("## Sources")) {
+            summary += `\n\n## Sources\n${sources.map((s, i) => `${i + 1}. [${s.title}](${s.url})`).join("\n")}`;
+        }
+        return formatResult(summary, {
+            retrieved,
+            failed: failed.length > 0 ? failed : undefined,
+            model: model.id
+        });
+    }
+    catch (e) {
+        return errorResult(e);
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionContext, AgentToolResult } from "@mariozechner/pi-coding-agent";
+import { type Model } from "@mariozechner/pi-ai";
+export declare function formatResult(text: string, details: any): AgentToolResult<any>;
+export declare function getModel(ctx: ExtensionContext): Promise<Model<any> | undefined>;
+export declare function missingConfigResult(ctx: ExtensionContext): AgentToolResult<any>;
+export declare function errorResult(e: Error): AgentToolResult<any>;

package/dist/utils.js

@@ -0,0 +1,63 @@
+import { truncateHead, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@mariozechner/pi-coding-agent";
+// --- Formatting ---
+export function formatResult(text, details) {
+    const { content, truncated } = truncateHead(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+    return {
+        content: [{ type: "text", text: content + (truncated ? "\n\n[Truncated]" : "") }],
+        details
+    };
+}
+// --- Model Selection ---
+export async function getModel(ctx) {
+    // 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 = [
+        /gemini-3.*flash/i,
+        /gemini-2\.5.*flash/i,
+        /gemini-2\.0.*flash/i,
+        /gemini.*flash/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;
+    }
+    // Return first available Google model if any
+    return googleModels[0];
+}
+// --- Error Results ---
+export function missingConfigResult(ctx) {
+    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.";
+    return { content: [{ type: "text", text: `Failed: ${msg}` }], details: { error: "missing_config" } };
+}
+export function errorResult(e) {
+    return { content: [{ type: "text", text: `Error: ${e.message}` }], details: { error: true } };
+}

package/dist/web_search.d.ts

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

package/dist/web_search.js

@@ -0,0 +1,75 @@
+import { Type } from "@sinclair/typebox";
+import { callApiStream, getConfig, applyCitations } from "./api.js";
+import { getModel, missingConfigResult, errorResult, formatResult } from "./utils.js";
+export const WebSearchSchema = Type.Object({
+    query: Type.String({ description: "The search query or question to answer" }),
+    urls: Type.Optional(Type.Array(Type.String(), {
+        description: "Additional URLs to analyze along with search (up to 20)",
+        maxItems: 20
+    })),
+});
+export async function webSearch(id, params, signal, onUpdate, ctx) {
+    const model = await getModel(ctx);
+    if (!model)
+        return missingConfigResult(ctx);
+    const hasUrls = params.urls && params.urls.length > 0;
+    const urlCount = hasUrls ? params.urls.length : 0;
+    onUpdate?.({
+        content: [{
+                type: "text",
+                text: hasUrls
+                    ? `Searching and analyzing ${urlCount} URL(s)...`
+                    : `Searching for "${params.query}"...`
+            }],
+        details: {}
+    });
+    try {
+        const config = getConfig(model);
+        // Build prompt: include URLs if provided
+        const prompt = hasUrls
+            ? `${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]: {} }];
+        const result = await callApiStream(ctx, model, {
+            contents: [{ role: "user", parts: [{ text: prompt }] }],
+            tools
+        }, onUpdate);
+        const { text, sources } = applyCitations(result.text, result.groundingMetadata);
+        // Handle URL context metadata
+        const urlMeta = result.urlContextMetadata?.urlMetadata
+            || result.urlContextMetadata?.url_metadata || [];
+        const retrieved = urlMeta
+            .filter((m) => (m.urlRetrievalStatus || m.url_retrieval_status) === "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m) => m.retrievedUrl || m.retrieved_url || m.url);
+        const failed = urlMeta
+            .filter((m) => (m.urlRetrievalStatus || m.url_retrieval_status) !== "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m) => ({
+            url: m.retrievedUrl || m.retrieved_url || m.url,
+            status: m.urlRetrievalStatus || m.url_retrieval_status
+        }));
+        let summary = text;
+        // Add URL status if there were failures
+        if (failed.length > 0) {
+            summary += `\n\n## URL Status\n✅ Retrieved: ${retrieved.length}\n❌ Failed: ${failed.length}`;
+            failed.forEach((f) => { summary += `\n- ${f.url}: ${f.status}`; });
+        }
+        // Add sources
+        if (sources.length > 0) {
+            summary += `\n\n## Sources\n${sources.map((s, i) => `${i + 1}. [${s.title}](${s.url})`).join("\n")}`;
+        }
+        return formatResult(summary, {
+            sources,
+            searchQueries: result.groundingMetadata?.webSearchQueries,
+            retrieved: retrieved.length > 0 ? retrieved : undefined,
+            failed: failed.length > 0 ? failed : undefined,
+            model: model.id,
+            grounded: sources.length > 0
+        });
+    }
+    catch (e) {
+        return errorResult(e);
+    }
+}

package/dist/youtube_video.d.ts

@@ -0,0 +1,10 @@
+import type { ExtensionContext, AgentToolUpdateCallback } from "@mariozechner/pi-coding-agent";
+import { type Static } from "@sinclair/typebox";
+export declare const YoutubeVideoSchema: import("@sinclair/typebox").TObject<{
+    video_url: import("@sinclair/typebox").TString;
+    query: import("@sinclair/typebox").TString;
+    start_offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    end_offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type YoutubeVideoInput = Static<typeof YoutubeVideoSchema>;
+export declare function youtubeVideo(id: string, params: YoutubeVideoInput, signal: AbortSignal, onUpdate: AgentToolUpdateCallback | undefined, ctx: ExtensionContext): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<any>>;

package/dist/youtube_video.js

@@ -0,0 +1,54 @@
+import { Type } from "@sinclair/typebox";
+import { callApiStream } from "./api.js";
+import { getModel, missingConfigResult, errorResult, formatResult } from "./utils.js";
+import { urlContext } from "./url_context.js";
+export const YoutubeVideoSchema = Type.Object({
+    video_url: Type.String({ description: "YouTube video URL" }),
+    query: Type.String({ description: "Question or task about the video" }),
+    start_offset: Type.Optional(Type.String({ description: "Start time (e.g., '120s' or '2:00')" })),
+    end_offset: Type.Optional(Type.String({ description: "End time (e.g., '300s' or '5:00')" })),
+});
+export async function youtubeVideo(id, params, signal, onUpdate, ctx) {
+    const model = await getModel(ctx);
+    if (!model)
+        return missingConfigResult(ctx);
+    // Only google-generative-ai supports native video; others use URL context
+    if (model.api !== "google-generative-ai") {
+        let query = params.query;
+        if (params.start_offset || params.end_offset) {
+            query += "\n\nFocus on the video section";
+            if (params.start_offset)
+                query += ` from ${params.start_offset}`;
+            if (params.end_offset)
+                query += ` to ${params.end_offset}`;
+            query += ".";
+        }
+        return urlContext(id, { query, urls: [params.video_url] }, signal, onUpdate, ctx);
+    }
+    onUpdate?.({ content: [{ type: "text", text: `Analyzing YouTube video...` }], details: {} });
+    try {
+        const videoPart = {
+            file_data: { file_uri: params.video_url, mime_type: "video/mp4" }
+        };
+        if (params.start_offset || params.end_offset) {
+            videoPart.video_metadata = {};
+            if (params.start_offset)
+                videoPart.video_metadata.start_offset = params.start_offset;
+            if (params.end_offset)
+                videoPart.video_metadata.end_offset = params.end_offset;
+        }
+        const result = await callApiStream(ctx, model, {
+            contents: [{ role: "user", parts: [videoPart, { text: params.query }] }]
+        }, onUpdate);
+        return formatResult(result.text, {
+            videoUrl: params.video_url,
+            clipping: (params.start_offset || params.end_offset)
+                ? { start: params.start_offset, end: params.end_offset }
+                : undefined,
+            model: model.id
+        });
+    }
+    catch (e) {
+        return errorResult(e);
+    }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "pi-web-search",
+  "version": "1.0.0",
+  "description": "Web search and content analysis extension for pi, powered by Gemini API",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "pi",
+    "pi-extension",
+    "web-search",
+    "gemini",
+    "google",
+    "url-analysis",
+    "youtube"
+  ],
+  "author": "ttttmr",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ttttmr/pi-web-search.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ttttmr/pi-web-search/issues"
+  },
+  "homepage": "https://github.com/ttttmr/pi-web-search#readme",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@mariozechner/pi-coding-agent": "^0.51.5",
+    "@sinclair/typebox": "^0.32.15"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "pi": {
+    "extensions": ["./src/index.ts"]
+  }
+}

package/run.sh

@@ -0,0 +1,9 @@
+pi --no-skills --no-extensions -e ./src/index.ts --models "google-antigravity/*" '搜索今天btc价格'
+pi --no-skills --no-extensions -e ./src/index.ts --models "google-gemini-cli/*" '搜索今天btc价格'
+pi --no-skills --no-extensions -e ./src/index.ts --models "google/*" '搜索今天btc价格'
+
+pi --no-skills --no-extensions -e ./src/index.ts --provider google-antigravity --model claude-sonnet-4-5 '搜索今天btc价格'
+# ok
+pi --no-skills --no-extensions -e ./src/index.ts --provider google-gemini-cli --model gemini-3-flash-preview '搜索今天btc价格'
+# ok
+pi --no-skills --no-extensions -e ./src/index.ts --provider google --model gemini-2.5-flash '搜索今天btc价格'

package/src/api.ts

@@ -0,0 +1,225 @@
+import type { ExtensionContext, AgentToolUpdateCallback } from "@mariozechner/pi-coding-agent";
+import { type Model } from "@mariozechner/pi-ai";
+import { TextEncoder, TextDecoder } from "util";
+
+// --- Provider Configuration ---
+
+type ProviderConfig = {
+    searchTool: string;
+    urlContextTool: string;
+    buildRequest: (model: Model<any>, body: any, projectId?: string) => { url: string; headers: Record<string, string>; body: any };
+};
+
+const PROVIDERS: Record<string, ProviderConfig> = {
+    "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: Model<any>): ProviderConfig {
+    return PROVIDERS[model.provider] || PROVIDERS[model.api] || PROVIDERS["google-generative-ai"];
+}
+
+// --- Streaming API Call ---
+
+export interface StreamResult {
+    text: string;
+    groundingMetadata?: any;
+    urlContextMetadata?: any;
+}
+
+export async function callApiStream(
+    ctx: ExtensionContext,
+    model: Model<any>,
+    body: any,
+    onUpdate?: AgentToolUpdateCallback
+): Promise<StreamResult> {
+    const config = getConfig(model);
+    const apiKey = await ctx.modelRegistry.getApiKey(model) || "";
+
+    let projectId: string | undefined;
+    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: any;
+    let urlContextMetadata: any;
+
+    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: any;
+            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: string, groundingMetadata: any): { text: string; sources: { title: string; url: string }[] } {
+    const chunks = groundingMetadata?.groundingChunks || [];
+    const supports = groundingMetadata?.groundingSupports || [];
+
+    const sources = chunks
+        .filter((c: any) => c.web)
+        .map((c: any) => ({ 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: any) => s.segment?.endIndex !== undefined && s.groundingChunkIndices?.length)
+        .map((s: any) => ({
+            index: s.segment.endIndex,
+            marker: s.groundingChunkIndices.map((i: number) => `[${i + 1}]`).join("")
+        }))
+        .sort((a: any, b: any) => b.index - a.index);
+
+    // Byte-safe insertion
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    const bytes = encoder.encode(text);
+
+    const parts: Uint8Array[] = [];
+    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/src/index.ts

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { webSearch, WebSearchSchema } from "./web_search.js";
+import { urlContext, UrlContextSchema } from "./url_context.js";
+import { youtubeVideo, YoutubeVideoSchema } from "./youtube_video.js";
+
+export default function (pi: ExtensionAPI) {
+    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 web pages and documents. Extract data, compare documents, synthesize content. Supports text/html, PDF, images, JSON, CSV. Up to 20 URLs.",
+        parameters: UrlContextSchema,
+        execute: urlContext
+    });
+
+    pi.registerTool({
+        name: "youtube_video",
+        label: "YouTube Video",
+        description: "Analyze YouTube videos. Summarize, answer questions, find timestamps. Supports video clipping (start/end offsets). Preview feature.",
+        parameters: YoutubeVideoSchema,
+        execute: youtubeVideo
+    });
+}

package/src/url_context.ts

@@ -0,0 +1,72 @@
+import type { ExtensionContext, AgentToolUpdateCallback } from "@mariozechner/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";
+
+export const UrlContextSchema = Type.Object({
+    query: Type.String({ description: "Question or task to perform on the URLs" }),
+    urls: Type.Array(Type.String(), { 
+        description: "URLs to analyze (up to 20). Supports text/html, PDF, images, JSON, CSV, etc.",
+        minItems: 1,
+        maxItems: 20
+    }),
+});
+export type UrlContextInput = Static<typeof UrlContextSchema>;
+
+export async function urlContext(
+    id: string, 
+    params: UrlContextInput, 
+    signal: AbortSignal, 
+    onUpdate: AgentToolUpdateCallback | undefined, 
+    ctx: ExtensionContext
+) {
+    const model = await getModel(ctx);
+    if (!model) return missingConfigResult(ctx);
+
+    const count = params.urls.length;
+    onUpdate?.({ content: [{ type: "text", text: `Analyzing ${count} URL${count > 1 ? 's' : ''}...` }], details: {} });
+
+    try {
+        const config = getConfig(model);
+        const combinedPrompt = `${params.query}\n\nURLs:\n${params.urls.join("\n")}`;
+
+        const result = await callApiStream(ctx, model, {
+            contents: [{ role: "user", parts: [{ text: combinedPrompt }] }],
+            tools: [{ [config.urlContextTool]: {} }]
+        }, onUpdate);
+
+        const { text, sources } = applyCitations(result.text, result.groundingMetadata);
+        
+        // Handle both camelCase and snake_case metadata
+        const urlMeta = result.urlContextMetadata?.urlMetadata 
+            || result.urlContextMetadata?.url_metadata || [];
+
+        const retrieved = urlMeta
+            .filter((m: any) => (m.urlRetrievalStatus || m.url_retrieval_status) === "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m: any) => m.retrievedUrl || m.retrieved_url || m.url);
+
+        const failed = urlMeta
+            .filter((m: any) => (m.urlRetrievalStatus || m.url_retrieval_status) !== "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m: any) => ({ 
+                url: m.retrievedUrl || m.retrieved_url || m.url, 
+                status: m.urlRetrievalStatus || m.url_retrieval_status 
+            }));
+
+        let summary = text;
+        if (failed.length > 0) {
+            summary += `\n\n## URL Status\n✅ Retrieved: ${retrieved.length}\n❌ Failed: ${failed.length}`;
+            failed.forEach((f: any) => { summary += `\n- ${f.url}: ${f.status}`; });
+        }
+        if (sources.length > 0 && !summary.includes("## Sources")) {
+            summary += `\n\n## Sources\n${sources.map((s, i) => `${i + 1}. [${s.title}](${s.url})`).join("\n")}`;
+        }
+
+        return formatResult(summary, {
+            retrieved,
+            failed: failed.length > 0 ? failed : undefined,
+            model: model.id
+        });
+    } catch (e: any) {
+        return errorResult(e);
+    }
+}

package/src/utils.ts

@@ -0,0 +1,79 @@
+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";
+
+// --- Formatting ---
+
+export function formatResult(text: string, details: any): AgentToolResult<any> {
+    const { content, truncated } = truncateHead(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+    return {
+        content: [{ type: "text", text: content + (truncated ? "\n\n[Truncated]" : "") }],
+        details
+    };
+}
+
+// --- 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 = [
+        /gemini-3.*flash/i,
+        /gemini-2\.5.*flash/i,
+        /gemini-2\.0.*flash/i,
+        /gemini.*flash/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;
+    }
+    
+    // Return first available Google model if any
+    return googleModels[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.";
+    return { content: [{ type: "text", text: `Failed: ${msg}` }], details: { error: "missing_config" } };
+}
+
+export function errorResult(e: Error): AgentToolResult<any> {
+    return { content: [{ type: "text", text: `Error: ${e.message}` }], details: { error: true } };
+}

package/src/web_search.ts

@@ -0,0 +1,97 @@
+import type { ExtensionContext, AgentToolUpdateCallback } from "@mariozechner/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";
+
+export const WebSearchSchema = Type.Object({
+    query: Type.String({ description: "The search query or question to answer" }),
+    urls: Type.Optional(Type.Array(Type.String(), { 
+        description: "Additional URLs to analyze along with search (up to 20)",
+        maxItems: 20
+    })),
+});
+export type WebSearchInput = Static<typeof WebSearchSchema>;
+
+export async function webSearch(
+    id: string, 
+    params: WebSearchInput, 
+    signal: AbortSignal, 
+    onUpdate: AgentToolUpdateCallback | undefined, 
+    ctx: ExtensionContext
+) {
+    const model = await getModel(ctx);
+    if (!model) return missingConfigResult(ctx);
+
+    const hasUrls = params.urls && params.urls.length > 0;
+    const urlCount = hasUrls ? params.urls!.length : 0;
+    
+    onUpdate?.({ 
+        content: [{ 
+            type: "text", 
+            text: hasUrls 
+                ? `Searching and analyzing ${urlCount} URL(s)...` 
+                : `Searching for "${params.query}"...`
+        }], 
+        details: {} 
+    });
+
+    try {
+        const config = getConfig(model);
+        
+        // Build prompt: include URLs if provided
+        const prompt = hasUrls
+            ? `${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]: {} }];
+
+        const result = await callApiStream(ctx, model, {
+            contents: [{ role: "user", parts: [{ text: prompt }] }],
+            tools
+        }, onUpdate);
+
+        const { text, sources } = applyCitations(result.text, result.groundingMetadata);
+
+        // Handle URL context metadata
+        const urlMeta = result.urlContextMetadata?.urlMetadata 
+            || result.urlContextMetadata?.url_metadata || [];
+
+        const retrieved = urlMeta
+            .filter((m: any) => (m.urlRetrievalStatus || m.url_retrieval_status) === "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m: any) => m.retrievedUrl || m.retrieved_url || m.url);
+
+        const failed = urlMeta
+            .filter((m: any) => (m.urlRetrievalStatus || m.url_retrieval_status) !== "URL_RETRIEVAL_STATUS_SUCCESS")
+            .map((m: any) => ({ 
+                url: m.retrievedUrl || m.retrieved_url || m.url, 
+                status: m.urlRetrievalStatus || m.url_retrieval_status 
+            }));
+
+        let summary = text;
+        
+        // Add URL status if there were failures
+        if (failed.length > 0) {
+            summary += `\n\n## URL Status\n✅ Retrieved: ${retrieved.length}\n❌ Failed: ${failed.length}`;
+            failed.forEach((f: any) => { summary += `\n- ${f.url}: ${f.status}`; });
+        }
+
+        // Add sources
+        if (sources.length > 0) {
+            summary += `\n\n## Sources\n${sources.map((s, i) => `${i + 1}. [${s.title}](${s.url})`).join("\n")}`;
+        }
+
+        return formatResult(summary, {
+            sources,
+            searchQueries: result.groundingMetadata?.webSearchQueries,
+            retrieved: retrieved.length > 0 ? retrieved : undefined,
+            failed: failed.length > 0 ? failed : undefined,
+            model: model.id,
+            grounded: sources.length > 0
+        });
+    } catch (e: any) {
+        return errorResult(e);
+    }
+}

package/src/youtube_video.ts

@@ -0,0 +1,64 @@
+import type { ExtensionContext, AgentToolUpdateCallback } from "@mariozechner/pi-coding-agent";
+import { Type, type Static } from "@sinclair/typebox";
+import { callApiStream } from "./api.js";
+import { getModel, missingConfigResult, errorResult, formatResult } from "./utils.js";
+import { urlContext } from "./url_context.js";
+
+export const YoutubeVideoSchema = Type.Object({
+    video_url: Type.String({ description: "YouTube video URL" }),
+    query: Type.String({ description: "Question or task about the video" }),
+    start_offset: Type.Optional(Type.String({ description: "Start time (e.g., '120s' or '2:00')" })),
+    end_offset: Type.Optional(Type.String({ description: "End time (e.g., '300s' or '5:00')" })),
+});
+export type YoutubeVideoInput = Static<typeof YoutubeVideoSchema>;
+
+export async function youtubeVideo(
+    id: string, 
+    params: YoutubeVideoInput, 
+    signal: AbortSignal, 
+    onUpdate: AgentToolUpdateCallback | undefined, 
+    ctx: ExtensionContext
+) {
+    const model = await getModel(ctx);
+    if (!model) return missingConfigResult(ctx);
+
+    // Only google-generative-ai supports native video; others use URL context
+    if (model.api !== "google-generative-ai") {
+        let query = params.query;
+        if (params.start_offset || params.end_offset) {
+            query += "\n\nFocus on the video section";
+            if (params.start_offset) query += ` from ${params.start_offset}`;
+            if (params.end_offset) query += ` to ${params.end_offset}`;
+            query += ".";
+        }
+        return urlContext(id, { query, urls: [params.video_url] }, signal, onUpdate, ctx);
+    }
+
+    onUpdate?.({ content: [{ type: "text", text: `Analyzing YouTube video...` }], details: {} });
+
+    try {
+        const videoPart: any = {
+            file_data: { file_uri: params.video_url, mime_type: "video/mp4" }
+        };
+
+        if (params.start_offset || params.end_offset) {
+            videoPart.video_metadata = {};
+            if (params.start_offset) videoPart.video_metadata.start_offset = params.start_offset;
+            if (params.end_offset) videoPart.video_metadata.end_offset = params.end_offset;
+        }
+
+        const result = await callApiStream(ctx, model, {
+            contents: [{ role: "user", parts: [videoPart, { text: params.query }] }]
+        }, onUpdate);
+
+        return formatResult(result.text, {
+            videoUrl: params.video_url,
+            clipping: (params.start_offset || params.end_offset) 
+                ? { start: params.start_offset, end: params.end_offset } 
+                : undefined,
+            model: model.id
+        });
+    } catch (e: any) {
+        return errorResult(e);
+    }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"]
+}