mono-pilot 0.2.9 → 0.2.12

package/dist/{tools → src/tools}/subagent.js

@@ -61,6 +61,71 @@ function compact(value, maxLength) {
         return normalized;
     return `${normalized.slice(0, Math.max(0, maxLength - 1))}…`;
 }
+function compactTail(value, maxLength) {
+    const normalized = value.replace(/\r/g, "");
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `…${normalized.slice(Math.max(0, normalized.length - (maxLength - 1)))}`;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function appendTrace(stats, line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return;
+    stats.traceLines.push(trimmed);
+    const TRACE_MAX_LINES = 240;
+    if (stats.traceLines.length > TRACE_MAX_LINES) {
+        stats.traceLines.splice(0, stats.traceLines.length - TRACE_MAX_LINES);
+    }
+}
+function getAssistantTraceLines(message) {
+    if (!message || typeof message !== "object")
+        return [];
+    const record = message;
+    if (record.role !== "assistant")
+        return [];
+    const parts = record.content;
+    if (!Array.isArray(parts))
+        return [];
+    const lines = [];
+    for (const part of parts) {
+        if (!part || typeof part !== "object")
+            continue;
+        const partRecord = part;
+        if (partRecord.type === "thinking" && typeof partRecord.thinking === "string") {
+            lines.push(`[thinking] ${partRecord.thinking}`);
+            continue;
+        }
+        if (partRecord.type === "toolCall") {
+            const name = typeof partRecord.name === "string" ? partRecord.name : "(unknown)";
+            const args = safeStringify(partRecord.arguments ?? {});
+            lines.push(`[tool_call] ${name} ${args}`);
+            continue;
+        }
+        if (partRecord.type === "text" && typeof partRecord.text === "string") {
+            lines.push(`[text] ${partRecord.text}`);
+        }
+    }
+    return lines;
+}
+function getCurrentLine(text) {
+    const lines = text.replace(/\r/g, "").split("\n");
+    const last = lines[lines.length - 1] ?? "";
+    if (last.trim().length > 0)
+        return last;
+    for (let i = lines.length - 2; i >= 0; i--) {
+        if (lines[i].trim().length > 0)
+            return lines[i];
+    }
+    return "";
+}
 function parseBooleanLike(value) {
     if (typeof value === "boolean")
         return value;
@@ -457,10 +522,63 @@ function parseMessageMeta(message) {
         errorMessage: typeof record.errorMessage === "string" ? record.errorMessage : undefined,
     };
 }
+function getToolResultText(result) {
+    if (!result || typeof result !== "object")
+        return undefined;
+    const record = result;
+    const content = record.content;
+    if (!Array.isArray(content))
+        return undefined;
+    const textParts = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object")
+            continue;
+        const partRecord = part;
+        if (partRecord.type === "text" && typeof partRecord.text === "string") {
+            textParts.push(partRecord.text);
+        }
+    }
+    if (textParts.length === 0)
+        return undefined;
+    return textParts.join("\n\n").trim();
+}
 function getProgressPreview(stats) {
-    if (stats.lastAssistantText.length > 0)
-        return compact(stats.lastAssistantText, 220);
-    return "(running...)";
+    if (stats.lastAssistantText.length > 0) {
+        const line = getCurrentLine(stats.lastAssistantText);
+        if (line.length > 0)
+            return compactTail(line, 220);
+        return compactTail(stats.lastAssistantText.replace(/\s+/g, " ").trim(), 220);
+    }
+    if (stats.traceLines.length > 0) {
+        return compactTail(stats.traceLines[stats.traceLines.length - 1], 220);
+    }
+    return "running...";
+}
+function getTraceOutput(stats) {
+    if (stats.traceLines.length === 0)
+        return "";
+    return stats.traceLines.join("\n");
+}
+function getLiveOutput(stats) {
+    const trace = getTraceOutput(stats);
+    if (trace.length > 0) {
+        const MAX_TRACE_CHARS = 12000;
+        if (trace.length <= MAX_TRACE_CHARS)
+            return trace;
+        return `...\n${trace.slice(trace.length - MAX_TRACE_CHARS)}`;
+    }
+    const raw = stats.lastAssistantText.replace(/\r/g, "").trim();
+    if (!raw)
+        return "running...";
+    const MAX_CHARS = 8000;
+    if (raw.length <= MAX_CHARS)
+        return raw;
+    return `...\n${raw.slice(raw.length - MAX_CHARS)}`;
+}
+const RUNNING_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function getRunningSpinner(seed) {
+    const index = Math.abs(Math.floor(seed)) % RUNNING_SPINNER_FRAMES.length;
+    return RUNNING_SPINNER_FRAMES[index] ?? RUNNING_SPINNER_FRAMES[0];
 }
 async function runSubagentForeground(piCliPath, args, cwd, signal, onAssistantUpdate) {
     return new Promise((resolveRun, rejectRun) => {
@@ -481,6 +599,17 @@ async function runSubagentForeground(piCliPath, args, cwd, signal, onAssistantUp
             parsedEvents: 0,
             assistantMessages: 0,
             lastAssistantText: "",
+            traceLines: [],
+        };
+        // Throttle streaming updates to avoid excessive re-renders
+        let lastUpdateTime = 0;
+        const THROTTLE_MS = 150;
+        const throttledUpdate = () => {
+            const now = Date.now();
+            if (now - lastUpdateTime >= THROTTLE_MS) {
+                lastUpdateTime = now;
+                onAssistantUpdate?.({ ...stats });
+            }
         };
         const parseLine = (line) => {
             const trimmed = line.trim();
@@ -494,7 +623,35 @@ async function runSubagentForeground(piCliPath, args, cwd, signal, onAssistantUp
                 return;
             }
             stats.parsedEvents++;
-            if (event.type === "message_end" && event.message) {
+            // Streaming: capture partial assistant text for real-time preview
+            if (event.type === "message_update" && event.message) {
+                const text = getAssistantTextFromMessage(event.message);
+                if (text) {
+                    stats.lastAssistantText = text;
+                    throttledUpdate();
+                }
+            }
+            else if (event.type === "tool_execution_start") {
+                const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
+                stats.lastAssistantText = `[tool:${toolName}] running`;
+                throttledUpdate();
+            }
+            else if (event.type === "tool_execution_update") {
+                const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
+                const partialText = getToolResultText(event.partialResult);
+                stats.lastAssistantText = partialText ? `[tool:${toolName}] ${partialText}` : `[tool:${toolName}] running`;
+                throttledUpdate();
+            }
+            else if (event.type === "tool_execution_end") {
+                const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
+                const resultText = getToolResultText(event.result);
+                stats.lastAssistantText = resultText ? `[tool:${toolName}] ${resultText}` : `[tool:${toolName}] done`;
+                throttledUpdate();
+            }
+            else if (event.type === "message_end" && event.message) {
+                for (const traceLine of getAssistantTraceLines(event.message)) {
+                    appendTrace(stats, traceLine);
+                }
                 const text = getAssistantTextFromMessage(event.message);
                 const meta = parseMessageMeta(event.message);
                 if (meta.stopReason)
@@ -750,7 +907,10 @@ async function executeTask(task, index, options) {
         selected_model: selectedModel?.modelId,
         parsed_events: 0,
         assistant_messages: 0,
-        preview: "(running...)",
+        preview: "running...",
+        live_output: "running...",
+        trace_output: "",
+        spinner_tick: 0,
     };
     options.onProgress?.({ ...detail });
     if (isBackground) {
@@ -788,12 +948,23 @@ async function executeTask(task, index, options) {
         output_path: session.outputPath,
         started_at: new Date().toISOString(),
     });
+    let spinnerTimer = null;
     try {
+        const SPINNER_HEARTBEAT_MS = 80;
+        spinnerTimer = setInterval(() => {
+            if (detail.status !== "running")
+                return;
+            detail.spinner_tick = (detail.spinner_tick ?? 0) + 1;
+            options.onProgress?.({ ...detail });
+        }, SPINNER_HEARTBEAT_MS);
+        spinnerTimer.unref?.();
         const runResult = await runSubagentForeground(options.piCliPath, args, options.ctx.cwd, options.signal, (stats) => {
             detail.status = "running";
             detail.parsed_events = stats.parsedEvents;
             detail.assistant_messages = stats.assistantMessages;
             detail.preview = getProgressPreview(stats);
+            detail.live_output = getLiveOutput(stats);
+            detail.trace_output = getTraceOutput(stats);
             options.onProgress?.({ ...detail });
         });
         const finalOutput = runResult.stats.lastAssistantText.trim() || runResult.stdout.trim();
@@ -802,6 +973,7 @@ async function executeTask(task, index, options) {
         detail.parsed_events = runResult.stats.parsedEvents;
         detail.assistant_messages = runResult.stats.assistantMessages;
         detail.stderr = runResult.stderr.trim() || undefined;
+        detail.trace_output = getTraceOutput(runResult.stats);
         if (isError) {
             const errorText = runResult.stats.errorMessage || runResult.stderr.trim() || finalOutput || "Subagent execution failed.";
             detail.status = "failed";
@@ -822,6 +994,7 @@ async function executeTask(task, index, options) {
         detail.status = "completed";
         detail.final_output = finalOutput || "(no output)";
         detail.preview = compact(detail.final_output, 220);
+        detail.live_output = undefined;
         writeSubagentState(session.statePath, {
             id: session.id,
             status: "completed",
@@ -840,6 +1013,7 @@ async function executeTask(task, index, options) {
         detail.exit_code = 1;
         detail.stderr = message;
         detail.preview = compact(message, 220);
+        detail.live_output = undefined;
         detail.final_output = message;
         writeSubagentState(session.statePath, {
             id: session.id,
@@ -853,6 +1027,11 @@ async function executeTask(task, index, options) {
         });
         return detail;
     }
+    finally {
+        if (spinnerTimer) {
+            clearInterval(spinnerTimer);
+        }
+    }
 }
 export default function (pi) {
     pi.registerTool({
@@ -895,6 +1074,76 @@ export default function (pi) {
             }
             return new Text(text, 0, 0);
         },
+        renderResult(result, { expanded, isPartial }, theme) {
+            const details = result.details;
+            if (!details) {
+                const raw = result.content?.map((c) => c.text ?? "").join("") ?? "";
+                return new Text(raw || "(no output)", 0, 0);
+            }
+            const isParallel = details.mode === "parallel";
+            const hasFailed = details.failed_tasks > 0;
+            // Streaming: collapsed shows one-line preview, expanded shows live multiline output.
+            if (isPartial) {
+                if (expanded) {
+                    const lines = [];
+                    for (const task of details.results) {
+                        if (isParallel) {
+                            const spinner = getRunningSpinner((task.spinner_tick ?? 0) + task.task_index);
+                            lines.push(theme.fg("warning", `${spinner} [${task.task_index + 1}] ${task.description}`));
+                        }
+                        const live = task.trace_output ?? task.live_output ?? task.preview ?? "running...";
+                        lines.push(live);
+                        if (isParallel && task.task_index < details.results.length - 1)
+                            lines.push("");
+                    }
+                    return new Text(lines.join("\n"), 0, 0);
+                }
+                if (isParallel) {
+                    const running = details.results.filter((r) => r.status === "running");
+                    const done = details.completed_tasks;
+                    const label = `${done}/${details.total_tasks}`;
+                    const preview = running.length > 0 ? compact(running[0].preview ?? "", 90) : "...";
+                    const seed = running.length > 0 ? (running[0]?.spinner_tick ?? 0) : 0;
+                    const spinner = getRunningSpinner(seed);
+                    return new Text(theme.fg("warning", `${spinner} ${label} `) + theme.fg("dim", preview), 0, 0);
+                }
+                const task = details.results[0];
+                const preview = task?.preview ?? "running...";
+                const spinner = getRunningSpinner(task?.spinner_tick ?? 0);
+                return new Text(theme.fg("warning", `${spinner} `) + theme.fg("dim", compact(preview, 110)), 0, 0);
+            }
+            // Completed, collapsed: compact summary
+            if (!expanded) {
+                if (isParallel) {
+                    const icon = hasFailed ? theme.fg("error", "✗") : theme.fg("success", "✓");
+                    const summary = `${details.completed_tasks}/${details.total_tasks} completed`;
+                    const failText = hasFailed ? `, ${details.failed_tasks} failed` : "";
+                    return new Text(`${icon} ${summary}${failText}`, 0, 0);
+                }
+                const task = details.results[0];
+                const icon = task?.status === "failed" ? theme.fg("error", "✗") : theme.fg("success", "✓");
+                const preview = compact(task?.final_output ?? task?.preview ?? "(no output)", 110);
+                return new Text(`${icon} ${preview}`, 0, 0);
+            }
+            // Expanded: full output
+            const lines = [];
+            for (const task of details.results) {
+                if (isParallel) {
+                    const icon = task.status === "failed" ? "✗" : "✓";
+                    lines.push(theme.fg(task.status === "failed" ? "error" : "success", `${icon} [${task.task_index + 1}] ${task.description}`));
+                }
+                if (task.trace_output && task.trace_output.trim().length > 0) {
+                    lines.push(task.trace_output);
+                    if (task.final_output && task.final_output.trim().length > 0)
+                        lines.push("");
+                }
+                const output = task.final_output ?? task.preview ?? "(no output)";
+                lines.push(output);
+                if (isParallel && task.task_index < details.results.length - 1)
+                    lines.push("");
+            }
+            return new Text(lines.join("\n"), 0, 0);
+        },
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
             try {
                 const piCliPath = resolvePiCliPath();
@@ -963,7 +1212,7 @@ export default function (pi) {
                     onProgress: (detail) => {
                         lastProgress = detail;
                         onUpdate?.({
-                            content: [{ type: "text", text: detail.preview ?? "(running...)" }],
+                            content: [{ type: "text", text: detail.preview ?? "running..." }],
                             details: buildSubagentDetails("single", [detail]),
                         });
                     },

package/dist/{tools → src/tools}/switch-mode.js

@@ -1,6 +1,8 @@
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { createModeStateData, deriveInitialModeState, modeRuntimeStore, MODE_STATE_ENTRY_TYPE, parseModeStateEntry, } from "../src/extensions/mode-runtime.js";
+import { isAbsolute, resolve } from "node:path";
+import process from "node:process";
+import { createModeStateData, deriveInitialModeState, modeRuntimeStore, MODE_STATE_ENTRY_TYPE, parseModeStateEntry, } from "../extensions/mode-runtime.js";
 const MODE_STATUS_KEY = "mono-pilot-mode";
 const DESCRIPTION = `Switch the interaction mode to better match the current task. Each mode is optimized for a specific type of work.
 
@@ -60,7 +62,20 @@ const switchModeSchema = Type.Object({
     explanation: Type.Optional(Type.String({
         description: "Optional explanation for why the mode switch is requested. This helps the user understand why you're switching modes.",
     })),
+    plan_file: Type.Optional(Type.String({
+        description: "Optional plan file path for Plan mode. If relative, it is resolved against the current workspace.",
+    })),
 });
+function normalizePlanFilePath(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    return isAbsolute(trimmed) ? trimmed : resolve(process.cwd(), trimmed);
+}
 function sanitizeStatusText(text) {
     return text
         .replace(/[\r\n\t]/g, " ")
@@ -261,8 +276,8 @@ function updateModeStatus(ctx) {
 function persistModeState(pi) {
     pi.appendEntry(MODE_STATE_ENTRY_TYPE, createModeStateData(modeRuntimeStore.getSnapshot()));
 }
-function setMode(pi, nextMode, ctx) {
-    const { changed } = modeRuntimeStore.setMode(nextMode);
+function setMode(pi, nextMode, ctx, options) {
+    const { changed } = modeRuntimeStore.setMode(nextMode, options);
     if (changed) {
         persistModeState(pi);
     }
@@ -318,16 +333,32 @@ export default function switchModeExtension(pi) {
         description: DESCRIPTION,
         parameters: switchModeSchema,
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            const { changed } = setMode(pi, "plan", ctx);
+            const before = modeRuntimeStore.getSnapshot();
+            const planFilePath = normalizePlanFilePath(params.plan_file);
+            const { changed } = setMode(pi, "plan", ctx, { planFilePath });
+            const after = modeRuntimeStore.getSnapshot();
             const explanation = params.explanation?.trim();
             const details = {
                 active_mode: "plan",
                 explanation: explanation || undefined,
+                plan_file: after.planFilePath,
             };
             const explanationSuffix = explanation ? ` Reason: ${explanation}` : "";
-            const prefix = changed ? "Switched to Plan mode." : "Plan mode is already active.";
+            const modeChanged = before.activeMode !== after.activeMode;
+            const planFileChanged = before.planFilePath !== after.planFilePath;
+            let prefix;
+            if (modeChanged) {
+                prefix = "Switched to Plan mode.";
+            }
+            else if (planFileChanged) {
+                prefix = "Plan mode is already active. Updated plan file.";
+            }
+            else {
+                prefix = changed ? "Switched to Plan mode." : "Plan mode is already active.";
+            }
+            const planFileSuffix = after.planFilePath ? ` Plan file: ${after.planFilePath}` : "";
             return {
-                content: [{ type: "text", text: `${prefix}${explanationSuffix}` }],
+                content: [{ type: "text", text: `${prefix}${planFileSuffix}${explanationSuffix}` }],
                 details,
             };
         },

package/dist/{tools → src/tools}/web-fetch.js

@@ -1,20 +1,26 @@
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateTail, } from "@mariozechner/pi-coding-agent";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, keyHint, truncateTail, } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 const DESCRIPTION = `Fetch content from a specified URL and return its contents in a readable markdown format. Use this tool when you need to retrieve and analyze web content.
 
 - The URL must be a fully-formed, valid URL.
 - This tool is read-only and will not work for requests intended to have side effects.
 - This fetch tries to return live results but may return previously cached content.
-- This fetch runs from an isolated server - hosts like localhost or private IPs will not work.
+- This fetch runs in the current runtime network context, and blocks localhost/private IP targets for safety.
 - Authentication is not supported, and an error will be returned if the URL requires authentication.
 - If the URL is returning a non-200 status code, e.g. 404, the tool will not return the content and will instead return an error message.
-- The tool prefers markdown content negotiation via \`Accept: text/markdown\` when supported by the target site, and falls back to HTML-to-markdown conversion.
+- The tool prefers readable text output and converts HTML responses into markdown-like text when needed.
 - If present, metadata like \`x-markdown-tokens\` and \`content-signal\` may be returned in tool details.`;
 const REQUEST_TIMEOUT_MS = 20_000;
 const CACHE_TTL_MS = 5 * 60 * 1000;
-const ACCEPT_MARKDOWN_HEADER = "text/markdown, text/html;q=0.9, application/xhtml+xml;q=0.8, application/json;q=0.7, text/plain;q=0.6, */*;q=0.5";
+const DEFAULT_BROWSER_ACCEPT = "text/markdown, text/html;q=0.95, application/xhtml+xml;q=0.9, application/xml;q=0.85, image/avif,image/webp,*/*;q=0.8";
+const DEFAULT_BROWSER_ACCEPT_LANGUAGE = "en-US,en;q=0.9";
+const DEFAULT_BROWSER_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36";
+const WECHAT_MOBILE_ACCEPT = "text/markdown, text/html;q=0.95, application/xhtml+xml;q=0.9, application/xml;q=0.85,*/*;q=0.8";
+const WECHAT_MOBILE_ACCEPT_LANGUAGE = "zh-CN,zh;q=0.9";
+const WECHAT_MOBILE_USER_AGENT = "Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/7.0.20(0x17001422) NetType/WIFI Language/zh_CN";
 const webFetchSchema = Type.Object({
     url: Type.String({
         description: "The URL to fetch. The content will be converted to a readable markdown format.",
@@ -190,12 +196,29 @@ function normalizeFetchedBody(rawText, contentType) {
         body: rawText.trim(),
     };
 }
+function getFetchProfile(url) {
+    if (url.hostname.toLowerCase() === "mp.weixin.qq.com") {
+        return {
+            name: "wechat_mobile",
+            accept: WECHAT_MOBILE_ACCEPT,
+            acceptLanguage: WECHAT_MOBILE_ACCEPT_LANGUAGE,
+            userAgent: WECHAT_MOBILE_USER_AGENT,
+        };
+    }
+    return {
+        name: "browser_default",
+        accept: DEFAULT_BROWSER_ACCEPT,
+        acceptLanguage: DEFAULT_BROWSER_ACCEPT_LANGUAGE,
+        userAgent: DEFAULT_BROWSER_USER_AGENT,
+    };
+}
 function formatFetchedOutput(entry) {
     const lines = [];
     lines.push(`Source URL: ${entry.finalUrl}`);
     if (entry.url !== entry.finalUrl) {
         lines.push(`Requested URL: ${entry.url}`);
     }
+    lines.push(`Request profile: ${entry.requestProfile}`);
     lines.push(`Fetched at: ${entry.fetchedAtIso}`);
     lines.push(`Content-Type: ${entry.contentType || "unknown"}`);
     lines.push(`Markdown negotiated: ${entry.markdownNegotiated ? "yes" : "no"}`);
@@ -209,6 +232,27 @@ function formatFetchedOutput(entry) {
     lines.push(entry.markdownContent.length > 0 ? entry.markdownContent : "(No readable text content found.)");
     return lines.join("\n");
 }
+function isBlockedInterstital(content) {
+    const finalUrlLower = content.finalUrl.toLowerCase();
+    const textLower = content.rawText.toLowerCase();
+    const looksLikeWechatCaptcha = finalUrlLower.includes("wappoc_appmsgcaptcha") ||
+        textLower.includes("wappoc_appmsgcaptcha") ||
+        (content.contentType.includes("text/html") && textLower.includes("环境异常") && textLower.includes("去验证"));
+    if (looksLikeWechatCaptcha) {
+        return {
+            blockedBy: "wechat_risk_control",
+            message: "WebFetch blocked by WeChat risk-control/captcha interstitial. Try local fetch with WeChat mobile UA or provide article text manually.",
+        };
+    }
+    return undefined;
+}
+function isBlockedCachedEntry(entry) {
+    return isBlockedInterstital({
+        finalUrl: entry.finalUrl,
+        contentType: entry.contentType,
+        rawText: entry.markdownContent,
+    }) !== undefined;
+}
 function getCachedEntry(url) {
     const cached = responseCache.get(url);
     if (!cached)
@@ -217,13 +261,18 @@ function getCachedEntry(url) {
         responseCache.delete(url);
         return undefined;
     }
+    if (isBlockedCachedEntry(cached)) {
+        responseCache.delete(url);
+        return undefined;
+    }
     return cached;
 }
-function formatErrorResult(url, error) {
+function formatErrorResult(url, error, extraDetails) {
     return {
         content: [{ type: "text", text: error }],
         details: {
             url,
+            ...extraDetails,
             error,
         },
     };
@@ -235,6 +284,32 @@ export default function webFetchExtension(pi) {
         label: "WebFetch",
         description: DESCRIPTION,
         parameters: webFetchSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const url = typeof input.url === "string" && input.url.trim().length > 0 ? input.url.trim() : "(missing url)";
+            const displayUrl = url.length > 120 ? `${url.slice(0, 119)}…` : url;
+            let text = theme.fg("toolTitle", theme.bold("WebFetch"));
+            text += ` ${theme.fg("toolOutput", displayUrl)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Fetching URL..."), 0, 0);
+            }
+            const textBlock = result.content.find((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!textBlock) {
+                return new Text(theme.fg("error", "No text result returned."), 0, 0);
+            }
+            const fullText = textBlock.text;
+            const lineCount = fullText.split("\n").length;
+            if (!expanded) {
+                const summary = `${lineCount} lines (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
+            let text = fullText.split("\n").map((line) => theme.fg("toolOutput", line)).join("\n");
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
+            return new Text(text, 0, 0);
+        },
         async execute(_toolCallId, params, signal) {
             let parsedUrl;
             try {
@@ -258,6 +333,7 @@ export default function webFetchExtension(pi) {
                     details: {
                         url: normalizedUrl,
                         final_url: cached.finalUrl,
+                        request_profile: cached.requestProfile,
                         status: cached.status,
                         content_type: cached.contentType,
                         markdown_negotiated: cached.markdownNegotiated,
@@ -274,14 +350,16 @@ export default function webFetchExtension(pi) {
             const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
             const onAbort = () => controller.abort();
             signal?.addEventListener("abort", onAbort, { once: true });
+            const fetchProfile = getFetchProfile(parsedUrl);
             try {
                 const response = await fetch(normalizedUrl, {
                     method: "GET",
                     redirect: "follow",
                     signal: controller.signal,
                     headers: {
-                        Accept: ACCEPT_MARKDOWN_HEADER,
-                        "User-Agent": "mono-pilot-web-fetch/0.1",
+                        Accept: fetchProfile.accept,
+                        "Accept-Language": fetchProfile.acceptLanguage,
+                        "User-Agent": fetchProfile.userAgent,
                     },
                 });
                 const finalUrl = response.url || normalizedUrl;
@@ -300,6 +378,24 @@ export default function webFetchExtension(pi) {
                 const markdownTokens = parsePositiveInt(response.headers.get("x-markdown-tokens"));
                 const contentSignal = response.headers.get("content-signal") ?? undefined;
                 const rawText = await response.text();
+                const blocked = isBlockedInterstital({
+                    finalUrl: finalParsed.toString(),
+                    contentType,
+                    rawText,
+                });
+                if (blocked) {
+                    return formatErrorResult(normalizedUrl, blocked.message, {
+                        final_url: finalParsed.toString(),
+                        request_profile: fetchProfile.name,
+                        status: response.status,
+                        content_type: contentType,
+                        markdown_negotiated: markdownNegotiated,
+                        markdown_tokens: markdownTokens,
+                        content_signal: contentSignal,
+                        blocked_by: blocked.blockedBy,
+                        bytes_received: Buffer.byteLength(rawText, "utf-8"),
+                    });
+                }
                 const normalizedBody = normalizeFetchedBody(rawText, contentType);
                 const markdownBody = normalizedBody.title
                     ? `# ${normalizedBody.title}\n\n${normalizedBody.body}`.trim()
@@ -308,6 +404,7 @@ export default function webFetchExtension(pi) {
                 const cacheEntry = {
                     url: normalizedUrl,
                     finalUrl: finalParsed.toString(),
+                    requestProfile: fetchProfile.name,
                     status: response.status,
                     contentType,
                     markdownNegotiated,
@@ -329,6 +426,7 @@ export default function webFetchExtension(pi) {
                     details: {
                         url: normalizedUrl,
                         final_url: cacheEntry.finalUrl,
+                        request_profile: cacheEntry.requestProfile,
                         status: cacheEntry.status,
                         content_type: cacheEntry.contentType,
                         markdown_negotiated: cacheEntry.markdownNegotiated,

package/dist/{tools → src/tools}/web-search.js

@@ -1,4 +1,5 @@
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateTail, } from "@mariozechner/pi-coding-agent";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, keyHint, truncateTail, } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 const DESCRIPTION = "Search web for real-time info on any topic; use for up-to-date facts not in training data, like current events or tech updates. Results include snippets and URLs.";
 const PROVIDER_NAME = "Brave Search API";
@@ -190,6 +191,33 @@ export default function webSearchExtension(pi) {
         label: "WebSearch",
         description: DESCRIPTION,
         parameters: webSearchSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const term = typeof input.search_term === "string" && input.search_term.trim().length > 0 ? input.search_term.trim() : "(missing search_term)";
+            const displayTerm = term.length > 120 ? `${term.slice(0, 119)}…` : term;
+            let text = theme.fg("toolTitle", theme.bold("WebSearch"));
+            text += ` ${theme.fg("toolOutput", displayTerm)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Searching..."), 0, 0);
+            }
+            const textBlock = result.content.find((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!textBlock) {
+                return new Text(theme.fg("error", "No text result returned."), 0, 0);
+            }
+            const fullText = textBlock.text;
+            const details = result.details;
+            const count = details?.result_count ?? 0;
+            if (!expanded) {
+                const summary = `${count} results (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
+            let text = fullText.split("\n").map((line) => theme.fg("toolOutput", line)).join("\n");
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
+            return new Text(text, 0, 0);
+        },
         async execute(_toolCallId, params, signal) {
             const query = normalizeSearchTerm(params.search_term);
             if (query.length === 0) {