wave-agent-sdk 1.2.0 → 1.3.0

package/dist/tools/bashTool.js

@@ -11,6 +11,7 @@ import { processToolResult } from "../utils/toolResultStorage.js";
 import { BASH_MAX_OUTPUT_CHARS } from "../constants/toolLimits.js";
 import { BASH_TOOL_NAME, GLOB_TOOL_NAME, GREP_TOOL_NAME, READ_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, } from "../constants/tools.js";
 const BASH_DEFAULT_TIMEOUT_MS = 120000;
+const BASH_MAX_TIMEOUT_MS = 600000;
 // After the shell exits, its last stdout/stderr chunks may still be in flight:
 // Node emits the child's 'exit' event as soon as the process terminates, then
 // delivers the remaining pipe data on a later event-loop turn and finally
@@ -64,7 +65,7 @@ export const bashTool = {
                     },
                     timeout: {
                         type: "number",
-                        description: "Optional timeout in milliseconds (max 600000)",
+                        description: `Optional timeout in milliseconds (max ${BASH_MAX_TIMEOUT_MS})`,
                     },
                     description: {
                         type: "string",
@@ -102,7 +103,7 @@ Before executing the command, please follow these steps:
 
 Usage notes:
   - The command argument is required.
-  - You can specify an optional timeout in milliseconds (up to ${BASH_DEFAULT_TIMEOUT_MS}ms / ${BASH_DEFAULT_TIMEOUT_MS / 60000} minutes). If not specified, commands will timeout after ${BASH_DEFAULT_TIMEOUT_MS}ms (${BASH_DEFAULT_TIMEOUT_MS / 60000} minutes).
+  - You may specify an optional timeout in milliseconds (up to ${BASH_MAX_TIMEOUT_MS}ms / ${BASH_MAX_TIMEOUT_MS / 60000} minutes). By default, your command will timeout after ${BASH_DEFAULT_TIMEOUT_MS}ms (${BASH_DEFAULT_TIMEOUT_MS / 60000} minutes).
   - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
   - If the output exceeds ${BASH_MAX_OUTPUT_CHARS.toLocaleString()} characters, output will be truncated and the full output will be persisted to a file you can read with the Read tool.
   - You can use the \`run_in_background\` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the ${READ_TOOL_NAME} tool as it becomes available. You do not need to use '&' at the end of the command when using this parameter.
@@ -179,13 +180,14 @@ The working directory persists between commands. Try to maintain your current wo
                     : "No suitable shell found. Please ensure bash or zsh is installed, or set WAVE_SHELL environment variable.",
             };
         }
-        // Validate timeout
-        if (timeout !== undefined &&
-            (typeof timeout !== "number" || timeout < 0 || timeout > 600000)) {
+        // Validate the timeout's type only. An upper bound is deliberately not
+        // enforced (matching Claude Code, which leaves the type check to its zod
+        // schema and applies whatever value the model sends).
+        if (timeout !== undefined && (typeof timeout !== "number" || timeout < 0)) {
             return {
                 success: false,
                 content: "",
-                error: "Timeout must be a number between 0 and 600000 milliseconds",
+                error: "Timeout must be a non-negative number of milliseconds",
             };
         }
         // Permission check after validation but before real operation

package/dist/tools/editTool.js

@@ -1,6 +1,7 @@
-import { readFile, writeFile, stat } from "fs/promises";
+import { readFile, stat } from "fs/promises";
 import { createHash } from "crypto";
 import { logger } from "../utils/globalLogger.js";
+import { atomicWriteFile } from "../utils/atomicWrite.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
 import { escapeRegExp, analyzeEditMismatch } from "../utils/editUtils.js";
 import { EDIT_TOOL_NAME, READ_TOOL_NAME } from "../constants/tools.js";
@@ -221,9 +222,10 @@ Usage:
             if (context.reversionManager && context.messageId) {
                 snapshotId = await context.reversionManager.recordSnapshot(context.messageId, resolvedPath, "modify");
             }
-            // Write file
+            // Write file (atomic: temp file + rename, so concurrent readers never
+            // observe a truncated file). Staleness/OCC was checked above.
             try {
-                await writeFile(resolvedPath, newContent, "utf-8");
+                await atomicWriteFile(resolvedPath, newContent);
                 // Commit snapshot on success
                 if (context.reversionManager && snapshotId) {
                     await context.reversionManager.commitSnapshot(snapshotId);
@@ -244,6 +246,7 @@ Usage:
                     mtime: newStats.mtime.getTime(),
                     hash,
                     source: "edit",
+                    content: newContent,
                     offset: undefined,
                     limit: undefined,
                 });

package/dist/tools/execTool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolPlugin } from "./types.js";
+export declare const execTool: ToolPlugin;

package/dist/tools/execTool.js

@@ -0,0 +1,165 @@
+import { EXEC_TOOL_NAME } from "../constants/tools.js";
+import { EXEC_RESERVED_NAMESPACE } from "../exec/constants.js";
+import { buildExecPool } from "../exec/catalog.js";
+import { runExecScript } from "../exec/execRuntime.js";
+/**
+ * The `search` bullet of the sandbox API blurb. It names the entry point and stops
+ * there: the call form is taught by the catalog announcement, and only while the
+ * catalog is actually truncated. Printing it here would advertise a search on every
+ * turn, complete catalog or not — the tool has no idea how many tools exist.
+ *
+ * The path is derived from the reserved namespace, the same constant the sandbox
+ * builds its `tools` object from, so the two cannot drift.
+ */
+const SEARCH_ENTRY = `- \`tools[${JSON.stringify(EXEC_RESERVED_NAMESPACE)}].search(...)\` — ` +
+    "search the whole pool from inside the script.";
+/**
+ * Model-visible API description.
+ *
+ * Static on purpose, and not merely "no tunable limits in it": it must be identical
+ * for any tool pool. `tools[]` sits in the cached prefix, so a description that
+ * mentioned the MCP servers (or their tools) would rewrite that prefix every time a
+ * server connected or dropped. The catalog is a tail announcement instead — see
+ * `exec/catalogAnnouncement.ts`.
+ */
+const EXEC_DESCRIPTION = `Run a JavaScript script in a sandbox where every MCP tool of this session is exposed as a function, so a whole sequence of MCP calls can be composed in a single turn instead of one model round-trip per call.
+
+Sandbox API:
+- \`await tools.<name>(args)\` — call an MCP tool, passing that tool's own arguments object directly. Resolves to the tool's output: its \`structuredContent\` object when it returned one, otherwise its text, otherwise \`null\`. The catalog gives each tool's return type.
+${SEARCH_ENTRY}
+- \`console.log(...)\` — collected and returned alongside the result. Use it to inspect intermediate values.
+- \`return <value>\` — the returned value is JSON-serialized and given back to you.
+
+It is very helpful if you write a clear, concise description of what this script does in 5-10 words.
+
+Which MCP tools are reachable is announced in the conversation as the catalog changes. The script has no filesystem, no network, no \`import\`, and no \`eval\`/\`new Function\`. It stops when it exceeds its time or tool-call budget. Every nested MCP call goes through the normal permission check, so it can still be denied — a denied call rejects with the reason.`;
+/**
+ * How many of the most recent nested calls the result summary lists, mirroring
+ * how the `Agent` tool lists the subagent tools it just ran.
+ */
+const RECENT_CALLS_SHOWN = 2;
+/**
+ * The collapsed result row: the call count, then the most recent calls by name.
+ *
+ * Names only — MCP tools have no compact-params summary of their own, and a
+ * flat MCP call's collapsed row shows just the name. No "Exec" prefix either:
+ * the row this text sits in already prints the tool name.
+ *
+ * Derived from the calls the sandbox actually issued, so it can be rendered
+ * mid-run as well as at the end.
+ */
+function formatSummary(calls) {
+    const count = calls.length;
+    const lines = [
+        `${count > RECENT_CALLS_SHOWN ? "... " : ""}${count} tool call${count === 1 ? "" : "s"}`,
+    ];
+    for (const name of calls.slice(-RECENT_CALLS_SHOWN)) {
+        lines.push(name);
+    }
+    return lines.join("\n");
+}
+function formatRun(result, calls) {
+    const lines = [];
+    if (result.logs.length > 0) {
+        lines.push(result.logs.join("\n"));
+    }
+    if (result.ok) {
+        if (result.value !== undefined && result.value !== "undefined") {
+            lines.push(result.value);
+        }
+        else if (lines.length === 0) {
+            lines.push("Exec finished without a return value or console output.");
+        }
+    }
+    else {
+        lines.push(result.error ?? "Exec script failed");
+    }
+    const content = lines.join("\n");
+    return {
+        success: result.ok,
+        content,
+        ...(result.ok ? {} : { error: result.error }),
+        shortResult: result.ok ? formatSummary(calls) : "failed",
+        ...(result.images.length > 0 ? { images: result.images } : {}),
+    };
+}
+export const execTool = {
+    name: EXEC_TOOL_NAME,
+    // Nested calls reach arbitrary MCP tools, which are conservatively non-safe.
+    isConcurrencySafe: false,
+    config: {
+        type: "function",
+        function: {
+            name: EXEC_TOOL_NAME,
+            description: EXEC_DESCRIPTION,
+            parameters: {
+                type: "object",
+                properties: {
+                    code: {
+                        type: "string",
+                        description: "JavaScript to run in the sandbox. It may `await` tool calls and `return` a value.",
+                    },
+                    description: {
+                        type: "string",
+                        description: "Clear, concise description of what this script does in 5-10 words.",
+                    },
+                },
+                required: ["code"],
+            },
+        },
+    },
+    prompt: () => EXEC_DESCRIPTION,
+    /**
+     * The parameter slot of the collapsed row, shared by the TUI and the desktop
+     * UI: the model's own one-line summary of the script, taken verbatim — no
+     * prefix (the row already prints `Exec`), no rewrite, no truncation.
+     *
+     * `Bash` can fall back to the command string; a script has no equivalent, and
+     * the first line of a multi-line blob usually says nothing, so an absent or
+     * empty description leaves the slot blank rather than inventing text. What the
+     * script actually did is the result slot's job (`formatSummary`).
+     *
+     * Deliberately reads nothing but the argument: no code scan, no pool, no
+     * catalog, so the preview cannot claim a call the script never makes.
+     */
+    formatCompactParams: (params) => {
+        const description = params.description;
+        return typeof description === "string" ? description : "";
+    },
+    execute: async (args, context) => {
+        const code = typeof args.code === "string" ? args.code : "";
+        if (code.trim().length === 0) {
+            return {
+                success: false,
+                content: "",
+                error: `${EXEC_TOOL_NAME}: missing required parameter "code"`,
+            };
+        }
+        const mcpManager = context.mcpManager;
+        if (!mcpManager) {
+            return {
+                success: false,
+                content: "",
+                error: `${EXEC_TOOL_NAME}: MCP manager is not available in this session`,
+            };
+        }
+        // Recomputed here rather than reused from the declaration-time catalog: a
+        // server may have connected or dropped since. Both are derived from the same
+        // `buildExecPool`, so the sandbox can never reach a tool the agent could not
+        // already call directly.
+        const pool = buildExecPool(mcpManager, context.permissionManager);
+        const calls = [];
+        const result = await runExecScript({
+            code,
+            pool,
+            context,
+            // Report each call as it is issued, so the collapsed row shows what the
+            // script is doing while it runs — the same live update the Agent tool does.
+            onToolCall: (name) => {
+                calls.push(name);
+                context.onShortResultUpdate?.(formatSummary(calls));
+            },
+        });
+        return formatRun(result, calls);
+    },
+};

package/dist/tools/grepTool.js

@@ -1,5 +1,6 @@
 import { spawn } from "child_process";
-import { rgPath } from "../utils/ripgrep.js";
+import { getRgPath } from "../utils/ripgrep.js";
+import { ensureRuntimeDeps } from "../utils/runtimeDeps.js";
 import { getDisplayPath } from "../utils/path.js";
 import { logger } from "../utils/globalLogger.js";
 import { GREP_TOOL_NAME, BASH_TOOL_NAME, AGENT_TOOL_NAME, } from "../constants/tools.js";
@@ -122,7 +123,12 @@ export const grepTool = {
                 error: "pattern parameter is required and must be a string",
             };
         }
+        // Resolved per call, not at import time: the CLI installs this dependency
+        // itself, possibly after the module graph has been evaluated.
+        const rgPath = getRgPath();
         if (!rgPath) {
+            // Cover the entry points that do not await the installer at startup.
+            void ensureRuntimeDeps();
             return {
                 success: false,
                 content: "",

package/dist/tools/readTool.js

@@ -7,6 +7,8 @@ import { formatLineNumberPrefix } from "../utils/stringUtils.js";
 import { estimateTokens } from "../utils/tokenEstimate.js";
 import { isBinaryDocument, getBinaryDocumentError, } from "../utils/fileFormat.js";
 import { convertImageToBase64 } from "../utils/messageOperations.js";
+import { isPathInside } from "../utils/pathSafety.js";
+import { memoryFreshnessNote } from "../utils/memoryAge.js";
 import { READ_TOOL_NAME } from "../constants/tools.js";
 /**
  * Supported image file extensions
@@ -88,6 +90,15 @@ async function processImageFile(filePath, context) {
         }
         // Convert image to base64
         const imageDataUrl = convertImageToBase64(actualFilePath);
+        if (!imageDataUrl) {
+            // Unreadable, empty or unknown-format file: fail instead of handing the
+            // model an empty image payload.
+            return {
+                success: false,
+                content: "",
+                error: `Failed to process image: ${getDisplayPath(filePath, context.workdir)} is empty or not a readable image file`,
+            };
+        }
         const mimeType = getImageMimeType(actualFilePath);
         // Extract base64 data from data URL (remove data:image/type;base64, prefix)
         const base64Data = imageDataUrl.split(",")[1] || "";
@@ -254,8 +265,17 @@ Usage:
                     source: "read",
                     offset, // undefined for full reads
                     limit, // undefined for full reads
+                    // Retain the raw content only for full reads: it is the diff baseline
+                    // for the external-change notification, and partial entries are
+                    // excluded from that comparison anyway.
+                    ...(offset === undefined && limit === undefined
+                        ? { content: fileContent }
+                        : {}),
                 });
             }
+            // A successful read may pull in the memory files of its ancestor
+            // directories (see `collectNestedMemoryFiles`); only Read triggers this.
+            context.messageManager?.triggerNestedMemory(actualFilePath);
             // Check if file is empty
             if (fileContent.length === 0) {
                 logger.warn(`File ${filePath} exists but has empty contents`);
@@ -315,8 +335,16 @@ Usage:
                     },
                 };
             }
-            // Add file information header
-            let content = `File: ${filePath}\n`;
+            // Add file information header. A file inside the auto-memory directory
+            // gets a staleness note in front of it: memory is a point-in-time
+            // observation, and a stale `file:line` citation reads as authoritative.
+            // `autoMemoryDir` is unset when auto-memory is off, so the note can never
+            // fire for a disabled feature.
+            const memoryNote = context.autoMemoryDir &&
+                isPathInside(actualFilePath, context.autoMemoryDir)
+                ? memoryFreshnessNote(stats.mtime.getTime())
+                : "";
+            let content = `${memoryNote}File: ${filePath}\n`;
             if (startLine > 1 || endLine < totalLines) {
                 content += `Lines ${startLine}-${endLine} of ${totalLines}\n`;
             }

package/dist/tools/types.d.ts

@@ -5,6 +5,32 @@ import { ChatCompletionFunctionTool } from "openai/resources.js";
 import type { PermissionMode, PermissionCallback } from "../types/permissions.js";
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
 import type { SkillMetadata } from "../types/skills.js";
+/**
+ * Read state recorded for a file by the Read/Write/Edit tools. Used for
+ * read-before-write enforcement, staleness detection, Read dedup, and the
+ * external-change notification (diffing `content` against the disk).
+ */
+export interface ReadFileStateEntry {
+    /** File mtime (ms) observed when this entry was recorded. */
+    mtime: number;
+    /** sha256 of the content observed when this entry was recorded. */
+    hash: string;
+    /**
+     * Which tool recorded the entry. Read dedups only entries from Read;
+     * "changed" is recorded when an external change was observed and reported.
+     */
+    source: "read" | "edit" | "write" | "changed";
+    /**
+     * Content observed when this entry was recorded (full reads and writes
+     * only). Serves as the diff baseline for the external-change notification.
+     */
+    content?: string;
+    /** Line offset the entry was recorded at; undefined = full read. */
+    offset?: number;
+    limit?: number;
+}
+/** Per-session read state keyed by resolved absolute path. */
+export type ReadFileState = Map<string, ReadFileStateEntry>;
 export interface ToolPlugin {
     name: string;
     config: ChatCompletionFunctionTool;
@@ -46,7 +72,7 @@ export interface ToolContext {
     abortSignal?: AbortSignal;
     backgroundTaskManager?: import("../managers/backgroundTaskManager.js").BackgroundTaskManager;
     workdir: string;
-    /** Tool manager instance for tool discovery (used by ToolSearchTool) */
+    /** Tool manager instance, for tools that need to change session tool state */
     toolManager?: import("../managers/toolManager.js").ToolManager;
     /** Permission mode for this tool execution */
     permissionMode?: PermissionMode;
@@ -92,13 +118,7 @@ export interface ToolContext {
         maxTokens: number;
     };
     /** State of files read in the current session for deduplication */
-    readFileState?: Map<string, {
-        mtime: number;
-        hash: string;
-        source: "read" | "edit" | "write";
-        offset?: number;
-        limit?: number;
-    }>;
+    readFileState?: ReadFileState;
     /** Hook manager instance for executing hooks */
     hookManager?: import("../managers/hookManager.js").HookManager;
     /** Callback to notify when the current working directory changes */
@@ -114,4 +134,10 @@ export interface ToolContext {
      * the subprocess without polluting other sessions in one stdio process.
      */
     sessionEnv?: Record<string, string>;
+    /**
+     * Auto-memory directory for this session, or undefined when auto-memory is
+     * off. Read uses it to prepend a staleness note to files inside it — leaving
+     * it unset is what keeps that note off when the feature is disabled.
+     */
+    autoMemoryDir?: string;
 }

package/dist/tools/webFetchTool.js

@@ -1,19 +1,16 @@
-import TurndownService from "turndown";
 import { LRUCache } from "lru-cache";
 import { WEB_FETCH_TOOL_NAME } from "../constants/tools.js";
 import { logger } from "../utils/globalLogger.js";
 import { isArtifactEnabled } from "../services/artifactAvailability.js";
-import { authService, createAuthAwareFetch } from "../services/authService.js";
 import { recordVersion } from "../services/artifactSession.js";
-import { buildPersistedOutputMessage, generatePreview, persistToolResult, } from "../utils/toolResultStorage.js";
+import { extractArtifactSlug, htmlToMarkdown, readArtifactContent, summarizeArtifactAsReader, } from "../services/artifactContent.js";
+import { formatSize, processContentWithAI, } from "../services/contentSummarizer.js";
 // --- Security Limits ---
 const MAX_HTTP_CONTENT_LENGTH = 10 * 1024 * 1024; // 10MB
 const FETCH_TIMEOUT_MS = 60000; // 60s
 const MAX_REDIRECTS = 10;
 const MAX_MARKDOWN_LENGTH = 100000;
 const USER_AGENT = "Wave-User (+https://github.com/netease-lcap/wave-agent)";
-/** Artifact HTML beyond this size is persisted to a temp file (path + head preview). */
-const ARTIFACT_PREVIEW_BYTES = 2 * 1024; // ~2KB
 // --- Cache (LRU with 15min TTL, 50MB max) ---
 const CACHE_TTL = 15 * 60 * 1000; // 15 minutes
 const CACHE_MAX_BYTES = 50 * 1024 * 1024; // 50MB
@@ -22,14 +19,6 @@ const cache = new LRUCache({
     maxSize: CACHE_MAX_BYTES,
     sizeCalculation: (entry) => entry.bytes,
 });
-// --- Helpers ---
-function formatSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
 function validateURL(url) {
     if (url.length > 2000) {
         return {
@@ -79,124 +68,6 @@ function isPermittedRedirect(originalUrl, redirectUrl) {
         return false;
     }
 }
-// --- Artifact read channel ---
-/** Extract the artifact slug from a `{host}/code/artifact/{slug}` URL. */
-function extractArtifactSlug(url) {
-    try {
-        const parsed = new URL(url);
-        const match = parsed.pathname.match(/^\/code\/artifact\/([^/]+)\/?$/);
-        return match ? decodeURIComponent(match[1]) : null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Fetch artifact metadata (`via=model_read`) then the HTML content (Bearer).
- * Returns markdown (HTML converted via turndown) on success.
- */
-async function readArtifact(url, slug, abortSignal) {
-    const serverUrl = authService.getServerUrl();
-    const authFetch = createAuthAwareFetch(globalThis.fetch);
-    const signal = abortSignal
-        ? AbortSignal.any([abortSignal, AbortSignal.timeout(FETCH_TIMEOUT_MS)])
-        : AbortSignal.timeout(FETCH_TIMEOUT_MS);
-    let meta;
-    try {
-        const metaRes = await authFetch(`${serverUrl}/api/frame/${encodeURIComponent(slug)}?via=model_read`, { method: "GET", signal });
-        if (metaRes.status === 404) {
-            return {
-                kind: "error",
-                error: `Artifact not found: ${url} (it may have been deleted)`,
-            };
-        }
-        if (!metaRes.ok) {
-            return {
-                kind: "error",
-                error: `Failed to fetch artifact metadata: ${metaRes.status} ${metaRes.statusText}`,
-            };
-        }
-        meta = (await metaRes.json());
-    }
-    catch (error) {
-        logger?.warn("Artifact read metadata failed", {
-            slug,
-            error: String(error),
-        });
-        return {
-            kind: "error",
-            error: `Failed to fetch artifact metadata: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    const contentUrl = typeof meta.contentUrl === "string" ? meta.contentUrl : "";
-    const version = typeof meta.version === "string" ? meta.version : "";
-    if (!contentUrl) {
-        return {
-            kind: "error",
-            error: "Artifact metadata did not include a contentUrl",
-        };
-    }
-    let html;
-    try {
-        const contentRes = await authFetch(new URL(contentUrl, serverUrl).toString(), { method: "GET", signal });
-        if (!contentRes.ok) {
-            return {
-                kind: "error",
-                error: `Failed to fetch artifact content: ${contentRes.status} ${contentRes.statusText}`,
-            };
-        }
-        html = await contentRes.text();
-    }
-    catch (error) {
-        logger?.warn("Artifact read content failed", {
-            slug,
-            error: String(error),
-        });
-        return {
-            kind: "error",
-            error: `Failed to fetch artifact content: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    const turndownService = new TurndownService();
-    const markdown = turndownService.turndown(html);
-    return {
-        kind: "ok",
-        slug,
-        version,
-        markdown,
-        bytes: new TextEncoder().encode(markdown).length,
-    };
-}
-/**
- * Process an artifact read result: persist content >~2KB to a temp file
- * (return file path + head preview), run the prompt, attach artifactRead metadata.
- */
-async function processArtifactRead(url, prompt, markdown, slug, version, context) {
-    const bytes = new TextEncoder().encode(markdown).length;
-    let aiInput = markdown;
-    let persistedMessage = "";
-    if (bytes > ARTIFACT_PREVIEW_BYTES) {
-        const filePath = persistToolResult(markdown, "artifact");
-        if (filePath) {
-            persistedMessage = buildPersistedOutputMessage(markdown.length, filePath, generatePreview(markdown));
-            aiInput = persistedMessage;
-        }
-        else {
-            aiInput =
-                markdown.substring(0, MAX_MARKDOWN_LENGTH) +
-                    "\n\n... (content truncated, failed to persist full output)";
-        }
-    }
-    const result = await processWithAI(url, prompt, aiInput, 200, "OK", context, bytes);
-    result.metadata = { artifactRead: { slug, ver: version } };
-    if (persistedMessage) {
-        // Append the persisted-output message so the model can Read the full content.
-        result.content = result.content
-            ? result.content + "\n\n" + persistedMessage
-            : persistedMessage;
-    }
-    return result;
-}
 // --- Tool ---
 export const webFetchTool = {
     name: WEB_FETCH_TOOL_NAME,
@@ -271,22 +142,28 @@ Usage notes:
         if (isArtifactEnabled(context.workdir)) {
             const artifactSlug = extractArtifactSlug(url);
             if (artifactSlug) {
-                const readResult = await readArtifact(url, artifactSlug, context.abortSignal);
+                const readResult = await readArtifactContent(artifactSlug, {
+                    url,
+                    abortSignal: context.abortSignal,
+                });
                 if (readResult.kind === "error") {
                     return { success: false, content: "", error: readResult.error };
                 }
-                if (context.sessionId && readResult.version) {
+                const { slug, version, html } = readResult.artifact;
+                if (context.sessionId && version) {
                     // Keep the stale-version guard in sync with what the model has seen.
-                    recordVersion(context.sessionId, artifactSlug, readResult.version);
+                    recordVersion(context.sessionId, slug, version);
                 }
-                return processArtifactRead(url, prompt, readResult.markdown, artifactSlug, readResult.version, context);
+                const result = await summarizeArtifactAsReader(url, prompt, html, context);
+                result.metadata = { artifactRead: { slug, ver: version } };
+                return result;
             }
         }
         try {
             const cached = cache.get(url);
             if (cached) {
                 const markdown = cached.content;
-                return processWithAI(url, prompt, markdown, cached.code, cached.codeText, context);
+                return processContentWithAI(url, prompt, markdown, cached.code, cached.codeText, context);
             }
             // Fetch with redirect following
             const result = await fetchWithRedirects(url, context.abortSignal);
@@ -323,8 +200,7 @@ Usage notes:
                 };
             }
             const html = await response.text();
-            const turndownService = new TurndownService();
-            let markdown = turndownService.turndown(html);
+            let markdown = htmlToMarkdown(html);
             const markdownBytes = new TextEncoder().encode(markdown).length;
             // Truncate if too large
             if (markdown.length > MAX_MARKDOWN_LENGTH) {
@@ -340,7 +216,7 @@ Usage notes:
                 content: markdown,
                 contentType: response.headers.get("content-type") || "",
             });
-            return processWithAI(finalUrl, prompt, markdown, response.status, response.statusText, context, markdownBytes);
+            return processContentWithAI(finalUrl, prompt, markdown, response.status, response.statusText, context, markdownBytes);
         }
         catch (error) {
             logger.error(`WebFetch failed for ${url}:`, error);
@@ -398,30 +274,3 @@ async function fetchWithRedirects(initialUrl, abortSignal, redirectCount = 0) {
     }
     return { kind: "response", response, finalUrl: initialUrl };
 }
-// --- AI Processing ---
-async function processWithAI(url, prompt, markdown, statusCode, statusText, context, contentSize) {
-    if (!context.aiManager || !context.aiService) {
-        return {
-            success: false,
-            content: markdown,
-            error: "AI Manager or AI Service not available for processing content",
-        };
-    }
-    const modelConfig = context.aiManager.getModelConfig();
-    const fastModel = modelConfig.fastModel;
-    const aiResponse = await context.aiService.processWebContent({
-        gatewayConfig: context.aiManager.getGatewayConfig(),
-        modelConfig: modelConfig,
-        content: markdown,
-        prompt: prompt,
-        model: fastModel,
-        abortSignal: context.abortSignal,
-    });
-    const sizeStr = contentSize !== undefined ? formatSize(contentSize) : "unknown size";
-    const statusStr = `${statusCode} ${statusText}`.trim();
-    return {
-        success: true,
-        content: aiResponse.content || "",
-        shortResult: `Received ${sizeStr} (${statusStr}) from ${url}`,
-    };
-}