@cjhyy/code-shell-core 0.7.0 → 0.7.1

package/dist/tool-system/builtin/generate-video.js

@@ -55,7 +55,14 @@ export async function __normalizeImagesForTests(images, image, uploader, creds,
 const VIDEO_PROVIDER_KINDS = ["fal"];
 const DEFAULT_POLL_INTERVAL_MS = 5_000;
 /** Safety cap so a stuck job's background loop can't poll forever. */
-const MAX_POLL_MS = 15 * 60 * 1000;
+const DEFAULT_MAX_POLL_MS = 15 * 60 * 1000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+let maxPollMs = DEFAULT_MAX_POLL_MS;
+let requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
+export function __setVideoPollingLimitsForTests(limits) {
+    maxPollMs = limits?.maxPollMs ?? DEFAULT_MAX_POLL_MS;
+    requestTimeoutMs = limits?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+}
 export const generateVideoToolDef = {
     name: "GenerateVideo",
     description: "Generate a video from a text prompt. The job runs in the background (video generation is " +
@@ -297,10 +304,35 @@ export async function generateVideoTool(args, ctx) {
     // two providers can't collide.
     const jobKey = `video-${jobId}`;
     const promptPreview = prompt.length > 80 ? `${prompt.slice(0, 80)}…` : prompt;
-    backgroundJobRegistry.start(jobKey, sessionId ?? "", `生成视频中:${promptPreview}`);
-    void pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, pollIntervalMs)
+    const controller = new AbortController();
+    let abortKind;
+    const abortTask = (kind) => {
+        if (controller.signal.aborted)
+            return;
+        abortKind = kind;
+        controller.abort();
+    };
+    const onTurnAbort = () => abortTask("cancelled");
+    if (ctx?.signal?.aborted)
+        onTurnAbort();
+    else
+        ctx?.signal?.addEventListener("abort", onTurnAbort, { once: true });
+    const totalTimer = setTimeout(() => abortTask("timeout"), maxPollMs);
+    const polling = pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, pollIntervalMs, controller.signal, () => abortKind, maxPollMs, requestTimeoutMs);
+    backgroundJobRegistry.start(jobKey, sessionId ?? "", `生成视频中:${promptPreview}`, {
+        kind: "video",
+        abort: async () => {
+            abortTask("cancelled");
+            return await polling;
+        },
+    });
+    void polling
         .then((outcome) => backgroundJobRegistry.finish(jobKey, outcome))
-        .catch((err) => backgroundJobRegistry.finish(jobKey, { status: "failed", finalText: err.message }));
+        .catch((err) => backgroundJobRegistry.finish(jobKey, { status: "failed", finalText: err.message }))
+        .finally(() => {
+        clearTimeout(totalTimer);
+        ctx?.signal?.removeEventListener("abort", onTurnAbort);
+    });
     return [
         `Video generation started in the background.`,
         `job_id: ${jobId} (internal — do not show to user)`,
@@ -310,16 +342,36 @@ export async function generateVideoTool(args, ctx) {
         `If you have no other work right now, END YOUR TURN — the system wakes you when the video is ready. NEVER run \`sleep\` or poll the provider yourself.`,
     ].join("\n");
 }
-async function pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, pollIntervalMs) {
-    const started = Date.now();
+async function pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, pollIntervalMs, signal, getAbortKind, totalTimeoutMs, perRequestTimeoutMs) {
+    let knownVideoUrl;
+    const retainedUrlOutcome = () => {
+        if (!knownVideoUrl)
+            return undefined;
+        const msg = `Video rendered successfully, but the local download did not finish. Download it from ${knownVideoUrl}`;
+        notifyVideo(sessionId, "completed", prompt, undefined, undefined, knownVideoUrl);
+        return { status: "completed", finalText: msg };
+    };
+    const abortOutcome = () => {
+        const retained = retainedUrlOutcome();
+        if (retained) {
+            return retained;
+        }
+        if (getAbortKind() === "timeout") {
+            const msg = `video job ${jobId} timed out after ${Math.round(totalTimeoutMs / 1000)}s`;
+            notifyVideo(sessionId, "failed", prompt, undefined, msg);
+            return { status: "failed", finalText: msg };
+        }
+        const msg = "Local waiting stopped; the remote service may still be rendering the video.";
+        notifyVideo(sessionId, "cancelled", prompt, undefined, msg);
+        return { status: "cancelled", finalText: msg };
+    };
     try {
         for (;;) {
-            if (Date.now() - started > MAX_POLL_MS) {
-                const msg = `video job ${jobId} timed out after ${Math.round(MAX_POLL_MS / 1000)}s`;
-                notifyVideo(sessionId, "failed", prompt, undefined, msg);
-                return { status: "failed", finalText: msg };
-            }
-            const res = await adapter.poll({ jobId, creds });
+            if (signal.aborted)
+                return abortOutcome();
+            const res = await runVideoRequest((requestSignal) => adapter.poll({ jobId, creds, signal: requestSignal }), signal, perRequestTimeoutMs);
+            if (signal.aborted)
+                return abortOutcome();
             if (!res.ok) {
                 notifyVideo(sessionId, "failed", prompt, undefined, res.error);
                 return { status: "failed", finalText: res.error };
@@ -328,27 +380,84 @@ async function pollToCompletion(adapter, jobId, creds, cwd, sessionId, prompt, p
                 notifyVideo(sessionId, "failed", prompt, undefined, res.error);
                 return { status: "failed", finalText: res.error };
             }
-            if (res.status === "succeeded")
+            if (res.status === "succeeded") {
+                knownVideoUrl = res.url;
                 break;
-            await new Promise((r) => setTimeout(r, pollIntervalMs));
+            }
+            await abortableDelay(pollIntervalMs, signal);
         }
-        const dl = await adapter.download({ jobId, creds });
+        const dl = await runVideoRequest((requestSignal) => adapter.download({
+            jobId,
+            creds,
+            signal: requestSignal,
+            onUrl: (url) => {
+                knownVideoUrl = url;
+            },
+        }), signal, perRequestTimeoutMs);
+        if (signal.aborted)
+            return abortOutcome();
         if (!dl.ok) {
+            const retained = retainedUrlOutcome();
+            if (retained)
+                return retained;
             notifyVideo(sessionId, "failed", prompt, undefined, dl.error);
             return { status: "failed", finalText: dl.error };
         }
+        knownVideoUrl = dl.url ?? knownVideoUrl;
         const dir = join(cwd, ".code-shell", "generated_videos");
         await mkdir(dir, { recursive: true });
+        if (signal.aborted)
+            return abortOutcome();
         const path = join(dir, `${Date.now()}.${dl.ext || "mp4"}`);
-        await writeFile(path, dl.bytes);
-        notifyVideo(sessionId, "completed", prompt, path, undefined, dl.url);
+        await writeFile(path, dl.bytes, { signal });
+        notifyVideo(sessionId, "completed", prompt, path, undefined, knownVideoUrl);
         return { status: "completed", finalText: path };
     }
     catch (err) {
+        const retained = retainedUrlOutcome();
+        if (retained)
+            return retained;
+        if (signal.aborted)
+            return abortOutcome();
         notifyVideo(sessionId, "failed", prompt, undefined, err.message);
         return { status: "failed", finalText: err.message };
     }
 }
+async function runVideoRequest(request, taskSignal, timeoutMs) {
+    const requestSignal = AbortSignal.any([taskSignal, AbortSignal.timeout(timeoutMs)]);
+    const promise = request(requestSignal);
+    if (requestSignal.aborted)
+        throw requestSignal.reason;
+    return await new Promise((resolve, reject) => {
+        const onAbort = () => reject(requestSignal.reason);
+        const cleanup = () => requestSignal.removeEventListener("abort", onAbort);
+        requestSignal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
+async function abortableDelay(ms, signal) {
+    if (signal.aborted)
+        throw signal.reason;
+    await new Promise((resolve, reject) => {
+        const cleanup = () => signal.removeEventListener("abort", onAbort);
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            cleanup();
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
 function notifyVideo(sessionId, status, prompt, path, error, url) {
     if (!sessionId) {
         logger.warn("video_completion_without_session", { status });
@@ -363,11 +472,19 @@ function notifyVideo(sessionId, status, prompt, path, error, url) {
         agentId: `video-${Date.now()}`,
         name: "video generation",
         description: status === "completed"
-            ? `Video generated: ${path} (prompt: ${prompt})`
-            : `Video generation failed (prompt: ${prompt})`,
+            ? path
+                ? `Video generated: ${path} (prompt: ${prompt})`
+                : `Video rendered: ${url} (local download stopped; prompt: ${prompt})`
+            : status === "cancelled"
+                ? `Stopped waiting for video generation (prompt: ${prompt})`
+                : `Video generation failed (prompt: ${prompt})`,
         status,
-        finalText: status === "completed" ? `Video saved to ${path}.${extendHint}` : undefined,
-        error: status === "failed" ? error : undefined,
+        finalText: status === "completed"
+            ? path
+                ? `Video saved to ${path}.${extendHint}`
+                : `Video rendered successfully. Download it from ${url}.${extendHint}`
+            : undefined,
+        error: status === "failed" || status === "cancelled" ? error : undefined,
         enqueuedAt: Date.now(),
     }, sessionId);
 }

package/dist/tool-system/builtin/glob.d.ts

@@ -3,5 +3,6 @@
  */
 import type { ToolDefinition } from "../../types.js";
 import type { ToolContext } from "../context.js";
+import type { ToolFailure } from "./index.js";
 export declare const globToolDef: ToolDefinition;
-export declare function globTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
+export declare function globTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string | ToolFailure>;

package/dist/tool-system/builtin/glob.js

@@ -1,9 +1,10 @@
 /**
  * Built-in Glob file search tool.
  */
-import { glob } from "glob";
+import { Glob } from "glob";
 import { stat } from "node:fs/promises";
 import * as path from "node:path";
+import { classifyPath } from "../path-policy.js";
 export const globToolDef = {
     name: "Glob",
     description: "Fast file pattern matching. Returns matching file paths sorted by modification time. " +
@@ -32,13 +33,37 @@ export async function globTool(args, ctx) {
             : path.resolve(baseDir, argPath)
         : baseDir;
     try {
-        const matches = await glob(pattern, {
+        const matcher = new Glob(pattern, {
             cwd,
             absolute: true,
             nodir: true,
             dot: false,
+            follow: false,
             ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/.next/**", "**/coverage/**"],
         });
+        for (const parsedPattern of matcher.patterns) {
+            const expandedPattern = parsedPattern.globString();
+            if (parsedPattern.isAbsolute() ||
+                path.posix.isAbsolute(expandedPattern) ||
+                path.win32.isAbsolute(expandedPattern)) {
+                return "Error: Glob pattern must be relative to the search path.";
+            }
+            if (expandedPattern.split(/[\\/]/).includes("..")) {
+                return "Error: Glob pattern cannot contain a '..' path segment.";
+            }
+        }
+        const searchRoot = classifyPath(cwd, { workspaceRoot: cwd, operation: "read" }).resolvedPath;
+        const matches = (await matcher.walk()).filter((filePath) => {
+            const resolved = classifyPath(filePath, {
+                workspaceRoot: cwd,
+                operation: "read",
+            }).resolvedPath;
+            const relativeToRoot = path.relative(searchRoot, resolved);
+            return (relativeToRoot === "" ||
+                (relativeToRoot !== ".." &&
+                    !relativeToRoot.startsWith(`..${path.sep}`) &&
+                    !path.isAbsolute(relativeToRoot)));
+        });
         if (matches.length === 0) {
             return "No files matched the pattern.";
         }
@@ -71,6 +96,6 @@ export async function globTool(args, ctx) {
         return result;
     }
     catch (err) {
-        return `Error in glob: ${err.message}`;
+        return { ok: false, error: `Error in glob: ${err.message}` };
     }
 }

package/dist/tool-system/builtin/grep.d.ts

@@ -6,6 +6,7 @@ import type { ToolContext } from "../context.js";
 type ExecFileForGrep = (file: string, args: readonly string[], options: {
     maxBuffer: number;
     timeout: number;
+    signal?: AbortSignal;
 }) => Promise<{
     stdout: string;
     stderr: string;

package/dist/tool-system/builtin/grep.js

@@ -3,12 +3,56 @@
  */
 import { execFile } from "node:child_process";
 import { readdir, readFile, stat } from "node:fs/promises";
-import { promisify } from "node:util";
 import { basename, join, relative, resolve, sep, isAbsolute } from "node:path";
-const execFileAsync = promisify(execFile);
-let execFileForTest = execFileAsync;
+import { killChildTree } from "../../runtime/spawn-common.js";
+function abortError() {
+    return Object.assign(new Error("Search aborted"), { name: "AbortError" });
+}
+const execFileAbortable = (file, args, options) => new Promise((resolvePromise, reject) => {
+    if (options.signal?.aborted) {
+        reject(abortError());
+        return;
+    }
+    let settled = false;
+    const child = execFile(file, [...args], { encoding: "utf8", maxBuffer: options.maxBuffer }, (error, stdout, stderr) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        if (error) {
+            Object.assign(error, { stdout, stderr });
+            reject(error);
+        }
+        else {
+            resolvePromise({ stdout, stderr });
+        }
+    });
+    const finishWithKill = (error) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        killChildTree(child, 1000);
+        reject(error);
+    };
+    const onAbort = () => finishWithKill(abortError());
+    const timer = setTimeout(() => {
+        const error = Object.assign(new Error(`Search timed out after ${options.timeout}ms`), {
+            code: "ETIMEDOUT",
+        });
+        finishWithKill(error);
+    }, options.timeout);
+    const cleanup = () => {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted)
+        onAbort();
+});
+let execFileForTest = execFileAbortable;
 export function _setGrepExecFileForTest(fn) {
-    execFileForTest = fn ?? execFileAsync;
+    execFileForTest = fn ?? execFileAbortable;
 }
 /**
  * Strip the cwd prefix from each line so results display as relative
@@ -39,7 +83,10 @@ export const grepToolDef = {
             pattern: { type: "string", description: "Regular expression pattern to search for" },
             path: { type: "string", description: "File or directory to search in (default: cwd)" },
             glob: { type: "string", description: 'Glob pattern to filter files (e.g. "*.ts")' },
-            context: { type: "number", description: "Lines of context around matches (only with output_mode content)" },
+            context: {
+                type: "number",
+                description: "Lines of context around matches (only with output_mode content)",
+            },
             max_results: { type: "number", description: "Maximum number of results (default: 50)" },
             output_mode: {
                 type: "string",
@@ -69,29 +116,36 @@ export async function grepTool(args, ctx) {
     const outputMode = args.output_mode || "files_with_matches";
     const caseInsensitive = args.case_insensitive || false;
     try {
-        return await runRipgrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
+        return await runRipgrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive, ctx?.signal);
     }
     catch (rgErr) {
+        if (isAbort(rgErr, ctx?.signal))
+            throw rgErr;
         // rg/grep exit code 1 = no matches (not an error)
         if (isNoMatchExit(rgErr))
             return "No matches found.";
         try {
-            return await runGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
+            return await runGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive, ctx?.signal);
         }
         catch (grepErr) {
+            if (isAbort(grepErr, ctx?.signal))
+                throw grepErr;
             if (isNoMatchExit(grepErr))
                 return "No matches found.";
             if (isCommandNotFound(rgErr) || isCommandNotFound(grepErr)) {
-                return await runNodeGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
+                return await runNodeGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive, ctx?.signal);
             }
-            return `Error in search: ${grepErr.message}`;
+            throw new Error(`Error in search: ${grepErr.message}`);
         }
     }
 }
+function isAbort(error, signal) {
+    return signal?.aborted === true || error?.name === "AbortError";
+}
 function isCommandNotFound(err) {
     return err?.code === "ENOENT";
 }
-async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
+async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive, signal) {
     const args = ["--color=never"];
     if (caseInsensitive)
         args.push("-i");
@@ -116,6 +170,7 @@ async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMo
     const { stdout } = await execFileForTest("rg", args, {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 30_000,
+        signal,
     });
     const result = relativizeOutput(stdout, path).trim();
     if (!result)
@@ -127,7 +182,7 @@ async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMo
     }
     return result;
 }
-async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
+async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive, signal) {
     const args = ["-r", "--color=never"];
     if (caseInsensitive)
         args.push("-i");
@@ -153,6 +208,7 @@ async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode,
     const { stdout } = await execFileForTest("grep", args, {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 30_000,
+        signal,
     });
     const result = relativizeOutput(stdout, path).trim();
     if (!result)
@@ -164,16 +220,18 @@ async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode,
     return result;
 }
 const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "coverage"]);
-async function runNodeGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
+async function runNodeGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive, signal) {
+    signal?.throwIfAborted();
     let regex;
     try {
         regex = new RegExp(pattern, caseInsensitive ? "i" : "");
     }
     catch (err) {
-        return `Error in search: ${err.message}`;
+        throw new Error(`Error in search: ${err.message}`);
     }
     const matches = [];
     await walkTextFiles(path, fileGlob, async (file) => {
+        signal?.throwIfAborted();
         if (matches.length >= maxResults)
             return;
         let text;
@@ -214,15 +272,17 @@ async function runNodeGrep(pattern, path, fileGlob, context, maxResults, outputM
                 }
             }
         }
-    });
+    }, signal);
     if (matches.length === 0)
         return "No matches found.";
     if (matches.length > 200)
         return matches.slice(0, 200).join("\n") + `\n\n... ${matches.length - 200} more results`;
     return matches.join("\n");
 }
-async function walkTextFiles(root, fileGlob, visit) {
+async function walkTextFiles(root, fileGlob, visit, signal) {
+    signal?.throwIfAborted();
     const info = await stat(root).catch(() => null);
+    signal?.throwIfAborted();
     if (!info)
         return;
     if (info.isFile()) {
@@ -233,11 +293,13 @@ async function walkTextFiles(root, fileGlob, visit) {
     if (!info.isDirectory())
         return;
     const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    signal?.throwIfAborted();
     for (const entry of entries) {
+        signal?.throwIfAborted();
         if (entry.isDirectory()) {
             if (IGNORED_DIRS.has(entry.name))
                 continue;
-            await walkTextFiles(join(root, entry.name), fileGlob, visit);
+            await walkTextFiles(join(root, entry.name), fileGlob, visit, signal);
         }
         else if (entry.isFile()) {
             if (!fileGlob || matchesSimpleGlob(entry.name, fileGlob))
@@ -246,6 +308,9 @@ async function walkTextFiles(root, fileGlob, visit) {
     }
 }
 function matchesSimpleGlob(name, glob) {
-    const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const escaped = glob
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
     return new RegExp(`^${escaped}$`).test(name);
 }

package/dist/tool-system/builtin/index.d.ts

@@ -13,16 +13,28 @@ import type { ToolVisibilityContext } from "../context.js";
  * ctx is optional in the signature so legacy call sites (and tests) that
  * pass only args still type-check; ToolRegistry always passes ctx at runtime.
  */
-/**
- * 内置工具返回值:大多数返回纯文本字符串。需要回传图片(或其它结构化
- * 内容块)的工具(view_image)可改为返回 `{ contentBlocks }`;此时
- * registry 会把它放进 ToolResult.contentBlocks。可选的 `result` 字段是给
- * transcript / 摘要用的纯文本镜像。沙箱执行类工具(Bash 等)可返回
- * `{ result, sandbox }`,registry 把 sandbox 透传到 ToolResult.sandbox 供 UI 显示。
- * 敏感结果可返回 `{ result, sensitive, displayResult, transcriptResult }`;
- * `result` 仅供当前模型轮使用,显示/持久化路径必须使用占位字段。
- */
-export type BuiltinToolResult = string | {
+/** Canonical tool-handler protocol. Only ToolSuccess is recorded as ok:true. */
+export interface ToolSuccess {
+    ok: true;
+    result?: string;
+    contentBlocks?: import("../../types.js").ContentBlock[];
+    sandbox?: import("../../types.js").ToolResult["sandbox"];
+    sensitive?: boolean;
+    displayResult?: string;
+    transcriptResult?: string;
+}
+export interface ToolFailure {
+    ok: false;
+    error: string;
+    sandbox?: import("../../types.js").ToolResult["sandbox"];
+    exitCode?: number | null;
+    signal?: NodeJS.Signals | null;
+    stderr?: string;
+}
+export type ToolExecutionResult = ToolSuccess | ToolFailure;
+export type BuiltinToolResult = ToolExecutionResult;
+/** Direct implementation shape, normalized before entering the registry. */
+export type BuiltinToolReturn = string | BuiltinToolResult | {
     contentBlocks: import("../../types.js").ContentBlock[];
     result?: string;
 } | {
@@ -32,7 +44,9 @@ export type BuiltinToolResult = string | {
     displayResult?: string;
     transcriptResult?: string;
 };
-export type BuiltinToolFn = (args: Record<string, unknown>, ctx?: import("../context.js").ToolContext) => Promise<BuiltinToolResult>;
+export type BuiltinToolFn = (args: Record<string, unknown>, ctx?: import("../context.js").ToolContext) => Promise<string | BuiltinToolResult>;
+/** Convert every builtin implementation into the closed discriminated protocol. */
+export declare function toToolExecutionResult(value: unknown): ToolExecutionResult;
 export type BuiltinToolGuard = (ctx: ToolVisibilityContext) => boolean;
 export interface BuiltinTool {
     definition: RegisteredTool;

package/dist/tool-system/builtin/index.js

@@ -44,7 +44,43 @@ import { browserObserveToolDef, browserObserveTool, browserActToolDef, browserAc
 import { useCredentialToolDef, useCredentialBuiltinTool, } from "../../credentials/use-credential-tool.js";
 import { injectCredentialToolDef, injectCredentialTool, isInjectCredentialAvailable, } from "../../credentials/inject-credential-tool.js";
 import { credentialAccessScope, getCredentialAccess } from "../../credentials/access.js";
-export const BUILTIN_TOOLS = [
+const FAILURE_TEXT = /^(?:error\b|failed\b|failure\b|skill\b.*(?:not found\b|disabled\b|not available\b|allowlist\b|denied\b)|(?:[a-z][\w-]*\s+){1,3}(?:error\b|failed\b|failure\b|aborted\b|timed out\b))/i;
+function failureMessage(result) {
+    if (typeof result.error === "string" && result.error)
+        return result.error;
+    if (typeof result.result === "string" && result.result)
+        return result.result;
+    return "Tool execution failed";
+}
+/** Convert every builtin implementation into the closed discriminated protocol. */
+export function toToolExecutionResult(value) {
+    if (typeof value === "string") {
+        return FAILURE_TEXT.test(value) ? { ok: false, error: value } : { ok: true, result: value };
+    }
+    if (!value || typeof value !== "object") {
+        return { ok: false, error: `Invalid tool result: ${String(value)}` };
+    }
+    const result = value;
+    if (result.ok === false || result.isError === true || "error" in result) {
+        return {
+            ...result,
+            ok: false,
+            error: failureMessage(result),
+        };
+    }
+    if (result.ok === true)
+        return result;
+    const text = typeof result.result === "string" ? result.result : undefined;
+    if (text && FAILURE_TEXT.test(text)) {
+        return {
+            ok: false,
+            error: text,
+            ...(result.sandbox ? { sandbox: result.sandbox } : {}),
+        };
+    }
+    return { ok: true, ...result };
+}
+const BUILTIN_IMPLEMENTATIONS = [
     {
         definition: {
             ...readToolDef,
@@ -155,7 +191,10 @@ export const BUILTIN_TOOLS = [
             permissionDefault: "allow",
             isReadOnly: true,
             isConcurrencySafe: true,
-            pathPolicy: [{ kind: "arg", arg: "path", operation: "read", defaultToCwd: true }],
+            pathPolicy: [
+                { kind: "arg", arg: "path", operation: "read", defaultToCwd: true },
+                { kind: "arg", arg: "pattern", operation: "read" },
+            ],
         },
         execute: globTool,
     },
@@ -730,6 +769,10 @@ export const BUILTIN_TOOLS = [
         execute: injectCredentialTool,
     },
 ];
+export const BUILTIN_TOOLS = BUILTIN_IMPLEMENTATIONS.map(({ definition, execute }) => ({
+    definition,
+    execute: async (args, ctx) => toToolExecutionResult(await execute(args, ctx)),
+}));
 /**
  * Per-tool availability predicates. A tool listed here is filtered OUT of the
  * exposed toolDefs when its predicate returns false for the active cwd (see

package/dist/tool-system/builtin/video-providers.d.ts

@@ -40,6 +40,7 @@ export type VideoPollResult = {
 } | {
     ok: true;
     status: "succeeded";
+    url?: string;
 } | {
     ok: true;
     status: "failed";
@@ -57,6 +58,14 @@ export type VideoDownloadResult = {
     ok: false;
     error: string;
 };
+export interface VideoDownloadRequest {
+    jobId: string;
+    creds: VideoProviderCreds;
+    signal?: AbortSignal;
+    /** Called as soon as the provider exposes the remote result URL, before the
+     *  potentially long byte download begins. */
+    onUrl?: (url: string) => void;
+}
 export interface VideoProvider {
     readonly kind: string;
     submit(req: VideoSubmitRequest): Promise<VideoSubmitResult>;
@@ -65,11 +74,7 @@ export interface VideoProvider {
         creds: VideoProviderCreds;
         signal?: AbortSignal;
     }): Promise<VideoPollResult>;
-    download(req: {
-        jobId: string;
-        creds: VideoProviderCreds;
-        signal?: AbortSignal;
-    }): Promise<VideoDownloadResult>;
+    download(req: VideoDownloadRequest): Promise<VideoDownloadResult>;
 }
 /**
  * Deterministic in-memory adapter for tests and local dev — no network. Models
@@ -95,11 +100,7 @@ export declare class FakeVideoProvider implements VideoProvider {
         creds?: VideoProviderCreds;
         signal?: AbortSignal;
     }): Promise<VideoPollResult>;
-    download(_req: {
-        jobId: string;
-        creds?: VideoProviderCreds;
-        signal?: AbortSignal;
-    }): Promise<VideoDownloadResult>;
+    download(_req: VideoDownloadRequest): Promise<VideoDownloadResult>;
 }
 /**
  * fal.ai video adapter — submit/poll/download against the fal queue API
@@ -138,11 +139,7 @@ export declare class FalVideoProvider implements VideoProvider {
         creds: VideoProviderCreds;
         signal?: AbortSignal;
     }): Promise<VideoPollResult>;
-    download(req: {
-        jobId: string;
-        creds: VideoProviderCreds;
-        signal?: AbortSignal;
-    }): Promise<VideoDownloadResult>;
+    download(req: VideoDownloadRequest): Promise<VideoDownloadResult>;
 }
 /** Default model per video provider kind (filled in with real adapters). */
 export declare const DEFAULT_VIDEO_MODEL: Record<string, string>;