pzero-operator 0.1.6 → 0.1.8

package/dist/core/agent-session.js

@@ -52,9 +52,9 @@ export function parseSkillBlock(text) {
 // Constants
 // ============================================================================
 /** Standard thinking levels */
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
+const THINKING_LEVELS = ["off", "low", "medium", "high"];
 /** Thinking levels including xhigh (for supported models) */
-const THINKING_LEVELS_WITH_XHIGH = ["off", "minimal", "low", "medium", "high", "xhigh"];
+const THINKING_LEVELS_WITH_XHIGH = ["off", "low", "medium", "high", "xhigh"];
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -1887,7 +1887,7 @@ export class AgentSession {
         this._applyExtensionBindings(this._extensionRunner);
         const defaultActiveToolNames = this._baseToolsOverride
             ? Object.keys(this._baseToolsOverride)
-            : ["read", "bash", "edit", "write"];
+            : ["read", "bash", "edit", "write", "web_search"];
         const baseActiveToolNames = options.activeToolNames ?? defaultActiveToolNames;
         this._refreshToolRegistry({
             activeToolNames: baseActiveToolNames,

package/dist/core/keybindings.js

@@ -25,6 +25,7 @@ export const KEYBINDINGS = {
     },
     "app.model.select": { defaultKeys: "ctrl+l", description: "Open model selector" },
     "app.tools.expand": { defaultKeys: "ctrl+o", description: "Toggle tool output" },
+    "app.history.full": { defaultKeys: "ctrl+r", description: "Toggle full conversation view" },
     "app.thinking.toggle": {
         defaultKeys: "ctrl+t",
         description: "Toggle thinking blocks",

package/dist/core/sdk.js

@@ -13,12 +13,12 @@ import { getDefaultSessionDir, SessionManager } from "./session-manager.js";
 import { SettingsManager } from "./settings-manager.js";
 import { isInstallTelemetryEnabled } from "./telemetry.js";
 import { time } from "./timings.js";
-import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue, } from "./tools/index.js";
+import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWebSearchTool, createWriteTool, withFileMutationQueue, } from "./tools/index.js";
 // Re-exports
 export * from "./agent-session-runtime.js";
 export { withFileMutationQueue, 
 // Tool factories (for custom cwd)
-createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
+createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, createWebSearchTool, };
 // Helper Functions
 function getDefaultAgentDir() {
     return getAgentDir();
@@ -135,7 +135,7 @@ export async function createAgentSession(options = {}) {
     if (!model || !model.reasoning) {
         thinkingLevel = "off";
     }
-    const defaultActiveToolNames = ["read", "bash", "edit", "write"];
+    const defaultActiveToolNames = ["read", "bash", "edit", "write", "web_search"];
     const initialActiveToolNames = options.tools ? [...options.tools] : defaultActiveToolNames;
     let agent;
     // Create convertToLlm wrapper that filters images if blockImages is enabled (defense-in-depth)

package/dist/core/system-prompt.js

@@ -45,7 +45,7 @@ export function buildSystemPrompt(options) {
     const examplesPath = getExamplesPath();
     // Build tools list based on selected tools.
     // A tool appears in Available tools only when the caller provides a one-line snippet.
-    const tools = selectedTools || ["read", "bash", "edit", "write"];
+    const tools = selectedTools || ["read", "bash", "edit", "write", "web_search"];
     const visibleTools = tools.filter((name) => !!toolSnippets?.[name]);
     const toolsList = visibleTools.length > 0 ? visibleTools.map((name) => `- ${name}: ${toolSnippets[name]}`).join("\n") : "(none)";
     // Build guidelines based on which tools are actually available
@@ -63,6 +63,7 @@ export function buildSystemPrompt(options) {
     const hasFind = tools.includes("find");
     const hasLs = tools.includes("ls");
     const hasRead = tools.includes("read");
+    const hasWebSearch = tools.includes("web_search");
     // File exploration guidelines
     if (hasBash && !hasGrep && !hasFind && !hasLs) {
         addGuideline("Use bash for file operations like ls, rg, find");
@@ -70,6 +71,9 @@ export function buildSystemPrompt(options) {
     else if (hasBash && (hasGrep || hasFind || hasLs)) {
         addGuideline("Prefer grep/find/ls tools over bash for file exploration (faster, respects .gitignore)");
     }
+    if (hasWebSearch) {
+        addGuideline("Use web_search for current external information, public docs, and recent web content.");
+    }
     for (const guideline of promptGuidelines ?? []) {
         const normalized = guideline.trim();
         if (normalized.length > 0) {

package/dist/core/tools/bash.js

@@ -36,7 +36,7 @@ export function createLocalBashOperations(options) {
             return new Promise((resolve, reject) => {
                 const { shell, args } = getShellConfig(options?.shellPath);
                 if (!existsSync(cwd)) {
-                    reject(new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`));
+                    reject(new Error(`Working directory does not exist: ${cwd}\nCannot execute shell commands.`));
                     return;
                 }
                 const child = spawn(shell, [...args, command], {
@@ -119,6 +119,30 @@ class BashResultRenderComponent extends Container {
 function formatDuration(ms) {
     return `${(ms / 1000).toFixed(1)}s`;
 }
+function getShellPromptText(shellPath) {
+    try {
+        const shellConfig = getShellConfig(shellPath);
+        if (process.platform === "win32") {
+            if (shellConfig.kind === "powershell") {
+                return {
+                    description: `Execute a ${shellConfig.displayName} command in the current working directory. Returns stdout and stderr. Prefer Windows-native commands and PowerShell syntax. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+                    promptSnippet: "Execute PowerShell commands on Windows (Get-ChildItem, Select-String, Test-Path, Remove-Item, etc.)",
+                };
+            }
+            return {
+                description: `Execute a shell command in the current working directory using ${shellConfig.displayName}. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+                promptSnippet: "Execute shell commands on Windows using Bash (ls, grep, find, etc.)",
+            };
+        }
+    }
+    catch {
+        // Fall back to the default Unix-oriented prompt text if shell discovery fails.
+    }
+    return {
+        description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+        promptSnippet: "Execute bash commands (ls, grep, find, etc.)",
+    };
+}
 function formatBashCall(args) {
     const command = str(args?.command);
     const timeout = args?.timeout;
@@ -192,11 +216,12 @@ export function createBashToolDefinition(cwd, options) {
     const ops = options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath });
     const commandPrefix = options?.commandPrefix;
     const spawnHook = options?.spawnHook;
+    const promptText = getShellPromptText(options?.shellPath);
     return {
         name: "bash",
         label: "terminal.exec",
-        description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
-        promptSnippet: "Execute bash commands (ls, grep, find, etc.)",
+        description: promptText.description,
+        promptSnippet: promptText.promptSnippet,
         parameters: bashSchema,
         async execute(_toolCallId, { command, timeout }, signal, onUpdate, _ctx) {
             const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;

package/dist/core/tools/index.js

@@ -6,6 +6,7 @@ export { createGrepTool, createGrepToolDefinition, } from "./grep.js";
 export { createLsTool, createLsToolDefinition, } from "./ls.js";
 export { createReadTool, createReadToolDefinition, } from "./read.js";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
+export { createWebSearchTool, createWebSearchToolDefinition, } from "./web-search.js";
 export { createWriteTool, createWriteToolDefinition, } from "./write.js";
 import { createBashTool, createBashToolDefinition } from "./bash.js";
 import { createEditTool, createEditToolDefinition } from "./edit.js";
@@ -13,8 +14,9 @@ import { createFindTool, createFindToolDefinition } from "./find.js";
 import { createGrepTool, createGrepToolDefinition } from "./grep.js";
 import { createLsTool, createLsToolDefinition } from "./ls.js";
 import { createReadTool, createReadToolDefinition } from "./read.js";
+import { createWebSearchTool, createWebSearchToolDefinition } from "./web-search.js";
 import { createWriteTool, createWriteToolDefinition } from "./write.js";
-export const allToolNames = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
+export const allToolNames = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "web_search"]);
 export function createToolDefinition(toolName, cwd, options) {
     switch (toolName) {
         case "read":
@@ -31,6 +33,8 @@ export function createToolDefinition(toolName, cwd, options) {
             return createFindToolDefinition(cwd, options?.find);
         case "ls":
             return createLsToolDefinition(cwd, options?.ls);
+        case "web_search":
+            return createWebSearchToolDefinition(cwd, options?.web_search);
         default:
             throw new Error(`Unknown tool name: ${toolName}`);
     }
@@ -51,6 +55,8 @@ export function createTool(toolName, cwd, options) {
             return createFindTool(cwd, options?.find);
         case "ls":
             return createLsTool(cwd, options?.ls);
+        case "web_search":
+            return createWebSearchTool(cwd, options?.web_search);
         default:
             throw new Error(`Unknown tool name: ${toolName}`);
     }
@@ -61,6 +67,7 @@ export function createCodingToolDefinitions(cwd, options) {
         createBashToolDefinition(cwd, options?.bash),
         createEditToolDefinition(cwd, options?.edit),
         createWriteToolDefinition(cwd, options?.write),
+        createWebSearchToolDefinition(cwd, options?.web_search),
     ];
 }
 export function createReadOnlyToolDefinitions(cwd, options) {
@@ -80,6 +87,7 @@ export function createAllToolDefinitions(cwd, options) {
         grep: createGrepToolDefinition(cwd, options?.grep),
         find: createFindToolDefinition(cwd, options?.find),
         ls: createLsToolDefinition(cwd, options?.ls),
+        web_search: createWebSearchToolDefinition(cwd, options?.web_search),
     };
 }
 export function createCodingTools(cwd, options) {
@@ -88,6 +96,7 @@ export function createCodingTools(cwd, options) {
         createBashTool(cwd, options?.bash),
         createEditTool(cwd, options?.edit),
         createWriteTool(cwd, options?.write),
+        createWebSearchTool(cwd, options?.web_search),
     ];
 }
 export function createReadOnlyTools(cwd, options) {
@@ -107,6 +116,7 @@ export function createAllTools(cwd, options) {
         grep: createGrepTool(cwd, options?.grep),
         find: createFindTool(cwd, options?.find),
         ls: createLsTool(cwd, options?.ls),
+        web_search: createWebSearchTool(cwd, options?.web_search),
     };
 }
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/core/tools/web-search.js

@@ -0,0 +1,162 @@
+import { Text } from "@operator/tui";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { Type } from "typebox";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { getTextOutput, invalidArgText, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
+const WEB_SEARCH_HELPER = `${process.env.HOME || ""}/.tools/web_search/search.cjs`;
+const webSearchSchema = Type.Object({
+    query: Type.Optional(Type.String({ description: "Search query for full, ddg, instant, or wiki modes" })),
+    url: Type.Optional(Type.String({ description: "Page URL to extract when mode is 'page'" })),
+    mode: Type.Optional(Type.Union([
+        Type.Literal("full"),
+        Type.Literal("ddg"),
+        Type.Literal("instant"),
+        Type.Literal("wiki"),
+        Type.Literal("page"),
+    ], { description: "Search mode (default: full)" })),
+    limit: Type.Optional(Type.Number({ description: "Maximum number of results for ddg/wiki/full (default: 5)" })),
+});
+function formatWebSearchCall(args, theme) {
+    const mode = str(args?.mode) || "full";
+    const query = str(args?.query);
+    const url = str(args?.url);
+    const target = mode === "page" ? url : query;
+    const invalidArg = invalidArgText(theme);
+    return `${theme.fg("toolTitle", theme.bold("web.search"))} ${theme.fg("toolOutput", `[${mode}] `)}${target === null ? invalidArg : theme.fg("accent", target || "...")}`;
+}
+function formatWebSearchResult(result, options, theme, showImages) {
+    const output = getTextOutput(result, showImages).trim();
+    if (!output) {
+        return "";
+    }
+    const lines = output.split("\n");
+    const maxLines = options.expanded ? lines.length : 20;
+    const displayLines = lines.slice(0, maxLines);
+    const remaining = lines.length - maxLines;
+    let text = `\n${displayLines.map((line) => theme.fg("toolOutput", line)).join("\n")}`;
+    if (remaining > 0) {
+        text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")})`;
+    }
+    const truncation = result.details?.truncation;
+    if (truncation?.truncated) {
+        text += `\n${theme.fg("warning", `[Truncated: ${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit]`)}`;
+    }
+    return text;
+}
+export function createWebSearchToolDefinition(_cwd, _options) {
+    return {
+        name: "web_search",
+        label: "web.search",
+        description: `Search the web using DuckDuckGo and Wikipedia, or extract readable text from a web page. Best for current external information, documentation, and quick validation. Output is truncated to ${DEFAULT_MAX_BYTES / 1024}KB if needed.`,
+        promptSnippet: "Search the web for current external information or extract text from a URL",
+        promptGuidelines: [
+            "Use web_search when the user asks for current external information, recent updates, or public web content.",
+        ],
+        parameters: webSearchSchema,
+        async execute(_toolCallId, { query, url, mode, limit }, signal, _onUpdate, _ctx) {
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                if (!existsSync(WEB_SEARCH_HELPER)) {
+                    reject(new Error(`Web search helper not found: ${WEB_SEARCH_HELPER}`));
+                    return;
+                }
+                const effectiveMode = mode || "full";
+                const target = effectiveMode === "page" ? url : query;
+                if (!target) {
+                    reject(new Error(effectiveMode === "page" ? "url is required for page mode" : "query is required for search mode"));
+                    return;
+                }
+                const args = [WEB_SEARCH_HELPER, "--json"];
+                if (effectiveMode === "page") {
+                    args.push("--page", target);
+                }
+                else if (effectiveMode === "ddg") {
+                    args.push("--ddg", target);
+                }
+                else if (effectiveMode === "instant") {
+                    args.push("--instant", target);
+                }
+                else if (effectiveMode === "wiki") {
+                    args.push("--wiki", target);
+                }
+                else {
+                    args.push(target);
+                }
+                if (limit !== undefined && effectiveMode !== "page" && effectiveMode !== "instant") {
+                    args.push("--limit", String(limit));
+                }
+                const child = spawn(process.execPath, args, {
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+                let stdout = "";
+                let stderr = "";
+                let settled = false;
+                const settle = (fn) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    signal?.removeEventListener("abort", onAbort);
+                    fn();
+                };
+                const onAbort = () => {
+                    if (!child.killed) {
+                        child.kill();
+                    }
+                    settle(() => reject(new Error("Operation aborted")));
+                };
+                signal?.addEventListener("abort", onAbort, { once: true });
+                child.stdout?.on("data", (chunk) => {
+                    stdout += chunk.toString();
+                });
+                child.stderr?.on("data", (chunk) => {
+                    stderr += chunk.toString();
+                });
+                child.on("error", (error) => {
+                    settle(() => reject(new Error(`Failed to run web search helper: ${error.message}`)));
+                });
+                child.on("close", (code) => {
+                    if (signal?.aborted) {
+                        settle(() => reject(new Error("Operation aborted")));
+                        return;
+                    }
+                    if (code !== 0) {
+                        settle(() => reject(new Error(stderr.trim() || `web_search exited with code ${code}`)));
+                        return;
+                    }
+                    const output = stdout.trim();
+                    if (!output) {
+                        settle(() => resolve({
+                            content: [{ type: "text", text: "No web search results returned" }],
+                            details: undefined,
+                        }));
+                        return;
+                    }
+                    const truncation = truncateHead(output, { maxLines: Number.MAX_SAFE_INTEGER });
+                    settle(() => resolve({
+                        content: [{ type: "text", text: truncation.content }],
+                        details: truncation.truncated ? { truncation } : undefined,
+                    }));
+                });
+            });
+        },
+        renderCall(args, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatWebSearchCall(args, theme));
+            return text;
+        },
+        renderResult(result, options, theme, context) {
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatWebSearchResult(result, options, theme, context.showImages));
+            return text;
+        },
+    };
+}
+export function createWebSearchTool(cwd, options) {
+    return wrapToolDefinition(createWebSearchToolDefinition(cwd, options));
+}

package/dist/migrations.js

@@ -32,13 +32,14 @@ const DEFAULT_MODELS_CONFIG = {
             authHeader: true,
             compat: {
                 supportsDeveloperRole: true,
-                supportsReasoningEffort: false,
+                supportsReasoningEffort: true,
             },
             models: [
                 {
                     id: "qwen3-6",
                     name: "qwen3.6 27b",
                     reasoning: true,
+                    input: ["text", "image"],
                 },
             ],
         },
@@ -48,13 +49,14 @@ const DEFAULT_MODELS_CONFIG = {
             authHeader: true,
             compat: {
                 supportsDeveloperRole: true,
-                supportsReasoningEffort: false,
+                supportsReasoningEffort: true,
             },
             models: [
                 {
                     id: "gemma4",
                     name: "gemma4",
                     reasoning: true,
+                    input: ["text", "image"],
                 },
             ],
         },
@@ -107,6 +109,13 @@ function migrateAlemBaseUrls() {
                 gptOssProvider.baseUrl = "https://llm.alem.ai";
                 changed = true;
             }
+            if (!gptOssProvider.compat || typeof gptOssProvider.compat !== "object") {
+                gptOssProvider.compat = {};
+            }
+            if (gptOssProvider.compat.supportsReasoningEffort !== true) {
+                gptOssProvider.compat.supportsReasoningEffort = true;
+                changed = true;
+            }
         }
         for (const providerName of ["alem-ai-plus-qwen3-6", "alem-ai-plus-gemma4"]) {
             const provider = parsed.providers[providerName];
@@ -119,6 +128,31 @@ function migrateAlemBaseUrls() {
                 provider.baseUrl = "https://llm.alem.ai/v1";
                 changed = true;
             }
+            if (!provider.compat || typeof provider.compat !== "object") {
+                provider.compat = {};
+            }
+            if (provider.compat.supportsReasoningEffort !== true) {
+                provider.compat.supportsReasoningEffort = true;
+                changed = true;
+            }
+            if (Array.isArray(provider.models)) {
+                for (const model of provider.models) {
+                    if (!model || typeof model !== "object") {
+                        continue;
+                    }
+                    if (!model.compat || typeof model.compat !== "object") {
+                        model.compat = {};
+                    }
+                    if (model.compat.supportsReasoningEffort !== true) {
+                        model.compat.supportsReasoningEffort = true;
+                        changed = true;
+                    }
+                    if (model.reasoning !== true) {
+                        model.reasoning = true;
+                        changed = true;
+                    }
+                }
+            }
         }
         if (changed) {
             writeFileSync(modelsPath, `${JSON.stringify(parsed, null, 2)}\n`, "utf-8");

package/dist/modes/interactive/components/footer.js

@@ -134,7 +134,7 @@ export class FooterComponent {
         if (state.model?.reasoning) {
             const thinkingLevel = state.thinkingLevel || "off";
             rightSideWithoutProvider =
-                thinkingLevel === "off" ? `${modelName} | reasoning off` : `${modelName} | reasoning ${thinkingLevel}`;
+                thinkingLevel === "off" ? `${modelName} | reasoning fast` : `${modelName} | reasoning ${thinkingLevel}`;
         }
         const providerName = state.model?.provider || "none";
         const sessionValue = sessionName || "unnamed";

package/dist/modes/interactive/components/thinking-selector.js

@@ -6,11 +6,10 @@ const THINKING_SELECT_LIST_LAYOUT = {
     maxPrimaryColumnWidth: 32,
 };
 const LEVEL_DESCRIPTIONS = {
-    off: "No analysis pass",
-    minimal: "Tiny analysis pass (~1k tokens)",
-    low: "Light analysis pass (~2k tokens)",
-    medium: "Balanced analysis pass (~8k tokens)",
-    high: "Deep analysis pass (~16k tokens)",
+    off: "Fast mode. Direct output, lowest latency.",
+    low: "Light analysis. Quick check before answering.",
+    medium: "Balanced analysis. Best default for most tasks.",
+    high: "Deep analysis. Slower, but stronger reasoning.",
     xhigh: "Maximum analysis pass (~32k tokens)",
 };
 /**
@@ -22,7 +21,7 @@ export class ThinkingSelectorComponent extends Container {
         super();
         const thinkingLevels = availableLevels.map((level) => ({
             value: level,
-            label: level,
+            label: level === "off" ? "fast" : level,
             description: LEVEL_DESCRIPTIONS[level],
         }));
         // Add top border