npm - wave-agent-sdk - Versions diffs - 1.0.7 → 1.0.8 - Mend

wave-agent-sdk 1.0.7 → 1.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/builtin/skills/settings/ENV.md +1 -0
package/builtin/skills/settings/MODELS.md +3 -0
package/builtin/subagents/vision.md +18 -0
package/dist/constants/tools.d.ts +1 -0
package/dist/constants/tools.js +1 -0
package/dist/managers/aiManager.js +46 -4
package/dist/managers/messageManager.js +8 -2
package/dist/managers/permissionManager.d.ts +5 -0
package/dist/managers/permissionManager.js +18 -2
package/dist/managers/pluginManager.d.ts +9 -0
package/dist/managers/pluginManager.js +20 -0
package/dist/managers/subagentManager.d.ts +12 -0
package/dist/managers/subagentManager.js +32 -2
package/dist/managers/toolManager.js +7 -0
package/dist/services/aiService.d.ts +1 -1
package/dist/services/aiService.js +3 -2
package/dist/services/artifactAvailability.d.ts +7 -0
package/dist/services/artifactAvailability.js +26 -0
package/dist/services/artifactSession.d.ts +27 -0
package/dist/services/artifactSession.js +52 -0
package/dist/services/configurationService.d.ts +2 -1
package/dist/services/configurationService.js +16 -1
package/dist/services/initializationService.js +5 -0
package/dist/tools/agentTool.js +2 -1
package/dist/tools/artifactTool.d.ts +2 -0
package/dist/tools/artifactTool.js +357 -0
package/dist/tools/bashTool.js +11 -11
package/dist/tools/types.d.ts +3 -1
package/dist/tools/webFetchTool.js +141 -0
package/dist/types/agent.d.ts +2 -0
package/dist/types/config.d.ts +2 -0
package/dist/types/configuration.d.ts +2 -0
package/dist/types/messaging.d.ts +3 -1
package/dist/types/permissions.d.ts +3 -1
package/dist/types/permissions.js +2 -1
package/dist/utils/bashParser.d.ts +14 -0
package/dist/utils/bashParser.js +45 -1
package/dist/utils/convertMessagesForAPI.js +51 -4
package/dist/utils/messageOperations.d.ts +4 -2
package/dist/utils/messageOperations.js +23 -7
package/dist/utils/subagentParser.d.ts +5 -2
package/dist/utils/subagentParser.js +14 -4
package/package.json +2 -1

package/dist/tools/artifactTool.js ADDED Viewed

@@ -0,0 +1,357 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { marked } from "marked";
+import { ARTIFACT_TOOL_NAME } from "../constants/tools.js";
+import { authService, createAuthAwareFetch } from "../services/authService.js";
+import { logger } from "../utils/globalLogger.js";
+import { recordArtifact, getArtifactByFilePath, getRecordedVersion, recordVersion, } from "../services/artifactSession.js";
+// --- Limits ---
+const DEPLOY_TIMEOUT_MS = 30000;
+const PROBE_TIMEOUT_MS = 15000;
+/** Server-side content limit — POSTs above this get a 413. */
+const ARTIFACT_MAX_CONTENT_BYTES = 16 * 1024 * 1024; // 16MB
+const LABEL_MAX_LENGTH = 60;
+const DEFAULT_FAVICON = "📄";
+function isValidFavicon(favicon) {
+    if (!favicon || favicon.trim().length === 0)
+        return false;
+    // Count code points excluding variation selectors (👨‍👩‍👧 counts as 3 and is
+    // rejected — only simple 1-2 emoji are accepted per the server contract).
+    const codePoints = [...favicon].filter((cp) => cp !== "\uFE0F");
+    if (codePoints.length < 1 || codePoints.length > 2)
+        return false;
+    return codePoints.every((cp) => {
+        // \p{Emoji} also matches ASCII digits/letters — plain text is not an emoji.
+        if (/[A-Za-z0-9]/.test(cp))
+            return false;
+        return /\p{Emoji}/u.test(cp);
+    });
+}
+/** Extract the artifact slug from a `{host}/code/artifact/{slug}` URL. */
+function extractSlugFromUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const match = parsed.pathname.match(/^\/code\/artifact\/([^/]+)\/?$/);
+        return match ? decodeURIComponent(match[1]) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function escapeHtml(s) {
+    return s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+}
+/** Render Markdown to a complete HTML document (client-side md→HTML). */
+function renderMarkdown(md, title) {
+    const body = marked.parse(md, { async: false });
+    const titleTag = title ? `<title>${escapeHtml(title)}</title>` : "";
+    return `<!DOCTYPE html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">${titleTag}</head><body>${body}</body></html>`;
+}
+/** Probe an artifact's current metadata (`via=model_read` marks model access). */
+async function probeFrame(slug, signal) {
+    const serverUrl = authService.getServerUrl();
+    const authFetch = createAuthAwareFetch(globalThis.fetch);
+    try {
+        const res = await authFetch(`${serverUrl}/api/frame/${encodeURIComponent(slug)}?via=model_read`, { method: "GET", signal });
+        if (res.status === 404)
+            return null;
+        if (!res.ok) {
+            logger?.warn("Artifact probe failed", {
+                slug,
+                status: res.status,
+                statusText: res.statusText,
+            });
+            return null;
+        }
+        return (await res.json());
+    }
+    catch (err) {
+        logger?.warn("Artifact probe error", { slug, error: String(err) });
+        return null;
+    }
+}
+export const artifactTool = {
+    name: ARTIFACT_TOOL_NAME,
+    isConcurrencySafe: false,
+    config: {
+        type: "function",
+        function: {
+            name: ARTIFACT_TOOL_NAME,
+            description: "Publish local HTML or Markdown files as shareable web pages (artifacts). " +
+                "Each publish returns a private URL you can share; the page is only accessible to you " +
+                "unless you change its sharing. Only .html and .md files are supported — inline content " +
+                "is not accepted. Markdown files are rendered to HTML automatically. " +
+                "Pass `url` (an existing artifact URL) to redeploy that artifact, " +
+                "or omit it to republish a file already published in this session. " +
+                "Use `force` to overwrite an artifact that has been updated by someone else.",
+            parameters: {
+                type: "object",
+                properties: {
+                    file_path: {
+                        type: "string",
+                        description: "Path to the .html or .md file to publish (relative to the working directory). The file must exist.",
+                    },
+                    favicon: {
+                        type: "string",
+                        description: "1-2 emoji characters shown as the page favicon (no text, URLs, or HTML). Defaults to 📄.",
+                    },
+                    label: {
+                        type: "string",
+                        description: `Optional short label for the artifact (max ${LABEL_MAX_LENGTH} characters).`,
+                    },
+                    url: {
+                        type: "string",
+                        description: "Existing artifact URL to redeploy, e.g. https://host/code/artifact/abc123. Omit when republishing a file already published earlier in this session.",
+                    },
+                    force: {
+                        type: "boolean",
+                        description: "Set true to overwrite an artifact that was updated since this session last saw it (stale version or conflict).",
+                    },
+                },
+                required: ["file_path"],
+            },
+        },
+    },
+    formatCompactParams: (params) => {
+        const filePath = typeof params.file_path === "string" ? params.file_path : "";
+        const url = typeof params.url === "string" ? params.url : "";
+        return `${ARTIFACT_TOOL_NAME}(${filePath}${url ? ` → ${url}` : ""})`;
+    },
+    execute: async (args, context) => {
+        const filePath = typeof args.file_path === "string" ? args.file_path.trim() : "";
+        if (!filePath) {
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: missing required parameter "file_path"`,
+            };
+        }
+        const faviconRaw = typeof args.favicon === "string" ? args.favicon.trim() : "";
+        const favicon = faviconRaw || DEFAULT_FAVICON;
+        if (!isValidFavicon(favicon)) {
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: favicon must be 1-2 emoji characters (e.g. "📄" or "🔖"), no text, URLs, or HTML markup`,
+            };
+        }
+        const labelRaw = typeof args.label === "string" ? args.label.trim() : "";
+        const label = labelRaw || undefined;
+        if (label !== undefined && label.length > LABEL_MAX_LENGTH) {
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: label must be at most ${LABEL_MAX_LENGTH} characters (got ${label.length})`,
+            };
+        }
+        const force = args.force === true;
+        const urlRaw = typeof args.url === "string" ? args.url.trim() : "";
+        const url = urlRaw || undefined;
+        let slug;
+        if (url) {
+            slug = extractSlugFromUrl(url);
+            if (!slug) {
+                return {
+                    success: false,
+                    content: "",
+                    error: `${ARTIFACT_TOOL_NAME}: url must point to an artifact page ({host}/code/artifact/{slug})`,
+                };
+            }
+        }
+        // Resolve and read the file (relative to the workdir).
+        const absolutePath = path.resolve(context.workdir, filePath);
+        const ext = path.extname(absolutePath).toLowerCase();
+        if (ext !== ".html" && ext !== ".md") {
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: only .html and .md files can be published as artifacts (got "${ext || "no extension"}")`,
+            };
+        }
+        let fileContent;
+        try {
+            fileContent = readFileSync(absolutePath, "utf-8");
+        }
+        catch {
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: file not found or unreadable: ${filePath}`,
+            };
+        }
+        const content = ext === ".md" ? renderMarkdown(fileContent, label) : fileContent;
+        const contentBytes = Buffer.byteLength(content, "utf-8");
+        if (contentBytes > ARTIFACT_MAX_CONTENT_BYTES) {
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: content exceeds the ${Math.floor(ARTIFACT_MAX_CONTENT_BYTES / 1024 / 1024)}MB server limit (${(contentBytes / 1024 / 1024).toFixed(1)}MB). Reduce the file or split it up.`,
+            };
+        }
+        if (!authService.getSSOToken()) {
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: not authenticated. Run /login to connect your account before publishing artifacts.`,
+            };
+        }
+        const sessionId = context.sessionId || "";
+        const signal = context.abortSignal
+            ? AbortSignal.any([
+                context.abortSignal,
+                AbortSignal.timeout(DEPLOY_TIMEOUT_MS),
+            ])
+            : AbortSignal.timeout(DEPLOY_TIMEOUT_MS);
+        // Redeploy: probe current metadata for baseVersion, shared-live detection,
+        // and the stale-version guard.
+        let serverVersion;
+        let sharedLive = false;
+        if (url && slug) {
+            const meta = await probeFrame(slug, AbortSignal.timeout(PROBE_TIMEOUT_MS));
+            if (!meta) {
+                return {
+                    success: false,
+                    content: "",
+                    error: `${ARTIFACT_TOOL_NAME}: artifact not found at ${url}. It may have been deleted or the URL is invalid.`,
+                };
+            }
+            serverVersion = meta.version;
+            sharedLive = !!(meta.perm && meta.perm.mode !== "owner" && !meta.shared);
+            const recorded = getRecordedVersion(sessionId, slug);
+            if (recorded !== undefined && recorded !== meta.version && !force) {
+                return {
+                    success: false,
+                    content: "",
+                    error: `${ARTIFACT_TOOL_NAME}: stale version — this artifact has been updated to version ${meta.version} since this session last saw version ${recorded}. Pass "force": true to overwrite it anyway.`,
+                };
+            }
+        }
+        // Permission check: first publish and shared-live redeploys require
+        // confirmation; republishing a file/artifact this session already
+        // confirmed once auto-allows (matching Claude Code's behavior).
+        const publishedThisSession = !!getArtifactByFilePath(sessionId, filePath) ||
+            (slug ? getRecordedVersion(sessionId, slug) !== undefined : false);
+        const needsConfirm = !publishedThisSession || sharedLive;
+        if (context.permissionManager && needsConfirm) {
+            const permissionContext = context.permissionManager.createContext(ARTIFACT_TOOL_NAME, context.permissionMode || "default", context.canUseToolCallback, {
+                file_path: filePath,
+                ...(favicon !== DEFAULT_FAVICON ? { favicon } : {}),
+                ...(label !== undefined ? { label } : {}),
+                ...(url !== undefined ? { url } : {}),
+                ...(force ? { force: true } : {}),
+            }, context.toolCallId);
+            if (sharedLive) {
+                permissionContext.warning =
+                    "此 artifact 处于 shared-live 状态（共享且实时更新），重新部署后所有访问者都会立即看到新内容。";
+                permissionContext.hidePersistentOption = true;
+            }
+            const permissionResult = await context.permissionManager.checkPermission(permissionContext);
+            if (permissionResult.behavior === "deny") {
+                return {
+                    success: false,
+                    content: "",
+                    error: `${ARTIFACT_TOOL_NAME} operation denied by user, reason: ${permissionResult.message || "No reason provided"}`,
+                };
+            }
+        }
+        // Deploy.
+        const serverUrl = authService.getServerUrl();
+        const authFetch = createAuthAwareFetch(globalThis.fetch);
+        const body = {
+            content,
+            favicon,
+            ...(label !== undefined ? { label } : {}),
+            ...(url !== undefined ? { url } : {}),
+            ...(serverVersion !== undefined ? { baseVersion: serverVersion } : {}),
+            ...(force ? { force: true } : {}),
+        };
+        let res;
+        try {
+            res = await authFetch(`${serverUrl}/api/frame/deploy/direct`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal,
+            });
+        }
+        catch (err) {
+            logger?.warn("Artifact deploy request failed", { error: String(err) });
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: failed to reach the server: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        const data = (await res.json().catch(() => ({})));
+        if (res.status === 201) {
+            const deploy = data;
+            recordArtifact(sessionId, filePath, {
+                url: deploy.url,
+                slug: deploy.slug,
+                version: deploy.version,
+            });
+            const lines = [`Artifact published: ${deploy.url}`];
+            if (deploy.path)
+                lines.push(`Path: ${deploy.path}`);
+            if (deploy.title)
+                lines.push(`Title: ${deploy.title}`);
+            lines.push(`Version: ${deploy.version}`);
+            return {
+                success: true,
+                content: lines.join("\n"),
+                shortResult: `Published ${filePath} → ${deploy.url}`,
+            };
+        }
+        if (res.status === 409) {
+            const live = typeof data.live === "string" ? data.live : undefined;
+            if (live && slug) {
+                recordVersion(sessionId, slug, live);
+            }
+            const serverMessage = typeof data.message === "string"
+                ? data.message
+                : typeof data.error === "string"
+                    ? data.error
+                    : "the artifact has been updated by someone else";
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: conflict detected — ${serverMessage}${live ? ` (live version: ${live})` : ""}. Pass "force": true to overwrite the live version.`,
+            };
+        }
+        if (res.status === 413) {
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: the published content is too large (server limit is 16MB). Reduce the file or split it up.`,
+            };
+        }
+        if (res.status === 400) {
+            const serverMessage = typeof data.message === "string"
+                ? data.message
+                : typeof data.error === "string"
+                    ? data.error
+                    : "the server rejected the content";
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: the server rejected the publish — ${serverMessage}`,
+            };
+        }
+        if (res.status === 401 || res.status === 403) {
+            return {
+                success: false,
+                content: "",
+                error: `${ARTIFACT_TOOL_NAME}: authentication failed (HTTP ${res.status}). Run /login again and retry.`,
+            };
+        }
+        logger?.warn("Artifact deploy unexpected status", {
+            status: res.status,
+            statusText: res.statusText,
+        });
+        return {
+            success: false,
+            content: "",
+            error: `${ARTIFACT_TOOL_NAME}: server returned HTTP ${res.status} ${res.statusText}`,
+        };
+    },
+};

package/dist/tools/bashTool.js CHANGED Viewed

@@ -219,17 +219,14 @@ The working directory persists between commands. Try to maintain your current wo
             const { id: taskId } = backgroundTaskManager.startShell(command, undefined, context.workdir);
             const task = backgroundTaskManager.getTask(taskId);
             const outputPath = task?.outputPath;
-            const backgroundMsg = [
-                `Command started in background with ID: ${taskId}.`,
-                `You will be notified automatically when it completes.`,
-                outputPath
-                    ? `output_file: ${outputPath}`
-                    : `Use ${READ_TOOL_NAME} tool with task_id="${taskId}" to read the output.`,
-            ].join("\n");
+            const backgroundMsg = outputPath
+                ? `Command running in background with ID: ${taskId}. Output is being written to: ${outputPath}`
+                : `Command running in background with ID: ${taskId}. Use ${READ_TOOL_NAME} tool with task_id="${taskId}" to read the output.`;
             return {
                 success: true,
                 content: recoveryNotice + backgroundMsg,
                 shortResult: `Background process ${taskId} started${outputPath ? ` → ${outputPath}` : ""}`,
+                backgroundTaskId: taskId,
             };
         }
         // Foreground execution (original behavior)
@@ -303,9 +300,10 @@ The working directory persists between commands. Try to maintain your current wo
                             const outputPath = task?.outputPath;
                             resolve({
                                 success: true,
-                                content: `Command moved to background with ID: ${taskId}.${outputPath ? ` Real-time output: ${outputPath}` : ""}`,
+                                content: `Command was manually backgrounded by user with ID: ${taskId}.${outputPath ? ` Output is being written to: ${outputPath}` : ""}`,
                                 shortResult: `Process ${taskId} backgrounded`,
-                                isManuallyBackgrounded: true,
+                                backgroundedByUser: true,
+                                backgroundTaskId: taskId,
                             });
                         }
                         else {
@@ -337,8 +335,10 @@ The working directory persists between commands. Try to maintain your current wo
                             logger.info(`[Bash] Command timed out after ${timeout}ms, auto-backgrounded as ${taskId}`);
                             resolve({
                                 success: true,
-                                content: `Command timed out after ${timeout / 1000} seconds and was moved to background with ID: ${taskId}.${outputPath ? ` Real-time output: ${outputPath}` : ""}`,
-                                shortResult: `Process ${taskId} auto-backgrounded (timeout)`,
+                                content: `Command exceeded the timeout (${timeout / 1000}s) and was moved to the background with ID: ${taskId}. It is still running — you will be notified when it completes.${outputPath ? ` Output is being written to: ${outputPath}` : ""}`,
+                                shortResult: `Process ${taskId} auto-backgrounded`,
+                                assistantAutoBackgrounded: true,
+                                backgroundTaskId: taskId,
                             });
                         }
                         else {

package/dist/tools/types.d.ts CHANGED Viewed

@@ -37,7 +37,9 @@ export interface ToolResult {
         data: string;
         mediaType?: string;
     }>;
-    isManuallyBackgrounded?: boolean;
+    backgroundTaskId?: string;
+    backgroundedByUser?: boolean;
+    assistantAutoBackgrounded?: boolean;
     metadata?: Record<string, unknown>;
 }
 export interface ToolContext {

package/dist/tools/webFetchTool.js CHANGED Viewed

@@ -2,12 +2,18 @@ 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";
 // --- 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
@@ -73,6 +79,124 @@ 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,
@@ -141,6 +265,23 @@ Usage notes:
                 error: validation.error,
             };
         }
+        // Artifact URL interception: {host}/code/artifact/{slug} goes through the
+        // dedicated read channel (via=model_read + Bearer) instead of a public fetch.
+        // Only when the Artifact tool is enabled (spec 6.4: disabled = no interception).
+        if (isArtifactEnabled(context.workdir)) {
+            const artifactSlug = extractArtifactSlug(url);
+            if (artifactSlug) {
+                const readResult = await readArtifact(url, artifactSlug, context.abortSignal);
+                if (readResult.kind === "error") {
+                    return { success: false, content: "", error: readResult.error };
+                }
+                if (context.sessionId && readResult.version) {
+                    // Keep the stale-version guard in sync with what the model has seen.
+                    recordVersion(context.sessionId, artifactSlug, readResult.version);
+                }
+                return processArtifactRead(url, prompt, readResult.markdown, artifactSlug, readResult.version, context);
+            }
+        }
         try {
             const cached = cache.get(url);
             if (cached) {

package/dist/types/agent.d.ts CHANGED Viewed

@@ -25,6 +25,8 @@ export interface AgentOptions {
     fetch?: ClientOptions["fetch"];
     model?: string;
     fastModel?: string;
+    /** Vision-capable model used by the builtin vision subagent (resolved from WAVE_VISION_MODEL env var). */
+    visionModel?: string;
     maxInputTokens?: number;
     maxTokens?: number;
     /** Preferred language for agent communication */

package/dist/types/config.d.ts CHANGED Viewed

@@ -22,6 +22,8 @@ export interface ModelCapabilities {
 export interface ModelConfig {
     model?: string;
     fastModel?: string;
+    /** Vision-capable model for image recognition subagents (resolved from WAVE_VISION_MODEL env var). */
+    visionModel?: string;
     maxTokens?: number;
     permissionMode?: PermissionMode;
     capabilities?: ModelCapabilities;

package/dist/types/configuration.d.ts CHANGED Viewed

@@ -55,6 +55,8 @@ export interface WaveConfiguration {
         /** Base ref for new worktrees: "fresh" (origin/<default-branch>, default) | "head" (local HEAD) */
         baseRef?: "fresh" | "head";
     };
+    /** Whether the Artifact tool is enabled. Unset follows the code default constant (ARTIFACT_DEFAULT_ENABLED). */
+    enableArtifact?: boolean;
 }
 /**
  * Legacy alias for backward compatibility - will be deprecated

package/dist/types/messaging.d.ts CHANGED Viewed

@@ -52,7 +52,9 @@ export interface ToolBlock {
     error?: string | Error;
     compactParams?: string;
     parametersChunk?: string;
-    isManuallyBackgrounded?: boolean;
+    backgroundTaskId?: string;
+    backgroundedByUser?: boolean;
+    assistantAutoBackgrounded?: boolean;
     timestamp?: number;
 }
 export interface ImageBlock {

package/dist/types/permissions.d.ts CHANGED Viewed

@@ -36,9 +36,11 @@ export interface ToolPermissionContext {
     toolCallId?: string;
     /** The content of the plan being exited from */
     planContent?: string;
+    /** Optional warning line to surface in the confirmation UI (e.g. shared-live redeploy impact) */
+    warning?: string;
 }
 /** List of tools that require permission checks in default mode */
-export declare const RESTRICTED_TOOLS: readonly ["Edit", "Bash", "Write", "EnterPlanMode", "ExitPlanMode", "AskUserQuestion"];
+export declare const RESTRICTED_TOOLS: readonly ["Edit", "Bash", "Write", "EnterPlanMode", "ExitPlanMode", "AskUserQuestion", "Artifact"];
 /** Type for restricted tool names */
 export type RestrictedTool = (typeof RESTRICTED_TOOLS)[number];
 export declare const OPERATION_CANCELLED_BY_USER = "Operation cancelled by user";

package/dist/types/permissions.js CHANGED Viewed

@@ -2,7 +2,7 @@
  * Permission system types for Wave Agent SDK
  * Dependencies: None
  */
-import { EDIT_TOOL_NAME, BASH_TOOL_NAME, WRITE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "../constants/tools.js";
+import { EDIT_TOOL_NAME, BASH_TOOL_NAME, WRITE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, ARTIFACT_TOOL_NAME, } from "../constants/tools.js";
 /** List of tools that require permission checks in default mode */
 export const RESTRICTED_TOOLS = [
     EDIT_TOOL_NAME,
@@ -11,5 +11,6 @@ export const RESTRICTED_TOOLS = [
     ENTER_PLAN_MODE_TOOL_NAME,
     EXIT_PLAN_MODE_TOOL_NAME,
     ASK_USER_QUESTION_TOOL_NAME,
+    ARTIFACT_TOOL_NAME,
 ];
 export const OPERATION_CANCELLED_BY_USER = "Operation cancelled by user";