@cjhyy/code-shell-core 0.5.0-rc.2 → 0.6.0-rc.10

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

@@ -0,0 +1,364 @@
+/**
+ * Built-in GenerateVideo tool (TODO 7.1 块3) — text-to-video via a
+ * {@link VideoProvider} adapter (submit / poll / download).
+ *
+ * Video generation is always slow (tens of seconds to minutes), so this tool
+ * is fire-and-forget by design: it submits the job, returns a handle
+ * immediately, and polls in the BACKGROUND. When the job finishes it writes
+ * the file to `<cwd>/.code-shell/generated_videos/` and enqueues a completion
+ * notification (same notificationQueue path as background agents / shells), so
+ * the main turn is never blocked (consistent with TODO 3.2 / 4.1).
+ *
+ * Concrete provider adapters (Seedance / Kling) are not wired yet — their
+ * private APIs need confirmed docs. Until then the only resolvable provider is
+ * the test-injected fake, so in production this tool is dormant (returns a
+ * "no video provider configured" message) rather than half-working.
+ */
+import { writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { SettingsManager } from "../../settings/manager.js";
+import { notificationQueue } from "./agent-notifications.js";
+import { backgroundJobRegistry } from "./background-jobs.js";
+import { logger } from "../../logging/logger.js";
+import { getVideoProvider, DEFAULT_VIDEO_MODEL, } from "./video-providers.js";
+import { getImageUploader } from "./image-uploader.js";
+import { effectiveApiKey } from "./generate-image.js";
+import { getMergedCatalog, findCatalogEntry } from "../../model-catalog/index.js";
+import { genInstancesFromConnections } from "../../model-catalog/gen-connections.js";
+const MAX_IMAGES = 9;
+/**
+ * Normalize image inputs (URLs or local paths) into public URLs the provider
+ * can consume. `images[]` wins over the single `image`. Local paths are
+ * uploaded via the injected {@link ImageUploader}; URLs pass through. Caps at
+ * {@link MAX_IMAGES} (fal reference-to-video allows up to 9).
+ */
+export async function __normalizeImagesForTests(images, image, uploader, creds, signal) {
+    const raw = images && images.length ? images : image ? [image] : [];
+    if (raw.length > MAX_IMAGES) {
+        return { ok: false, error: `too many images: ${raw.length} (max ${MAX_IMAGES})` };
+    }
+    const urls = [];
+    for (const item of raw) {
+        const r = await uploader.toUrl(item, creds, signal);
+        if (!r.ok)
+            return { ok: false, error: r.error };
+        urls.push(r.url);
+    }
+    return { ok: true, urls };
+}
+/** Video provider `kind`s that have an adapter, in resolution preference. */
+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;
+export const generateVideoToolDef = {
+    name: "GenerateVideo",
+    description: "Generate a video from a text prompt. The job runs in the background (video generation is " +
+        "slow); you are notified automatically when it finishes, and the .mp4 is saved into the " +
+        "workspace. Do NOT sleep or poll — continue with other work. Requires a configured video " +
+        "provider.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            prompt: { type: "string", description: "Description of the video to generate" },
+            provider: {
+                type: "string",
+                description: "Video provider kind to use. Defaults to the first configured video provider.",
+            },
+            model: { type: "string", description: "Video model id. Defaults to the provider's default." },
+            image: { type: "string", description: "Image URL (http/https) for image-to-video. When set, an image-to-video model is used." },
+            images: {
+                type: "array",
+                items: { type: "string" },
+                description: "Image URLs or local file paths for image/reference-to-video. 1 image → image-to-video; 2+ → reference-to-video (max 9). Local paths are auto-uploaded. Refer to them in prompt as @Image1, @Image2.",
+            },
+            videos: {
+                type: "array",
+                items: { type: "string" },
+                description: "Reference/continuation video URLs (http/https only — NOT local paths) for video extension. Forces reference-to-video (Seedance model required). Up to 3. Refer to them in prompt as @Video1, @Video2 (e.g. \"continue from @Video1\").",
+            },
+        },
+        required: ["prompt"],
+    },
+};
+// Test seam: inject a VideoProvider so the background poll loop can be tested
+// end-to-end without a real adapter or network. Null → normal resolution.
+let injectedProvider = null;
+export function __setVideoProviderForTests(p) {
+    injectedProvider = p;
+    availCache.clear();
+}
+/**
+ * Tool-visibility guard: GenerateVideo is hidden until a video provider is
+ * actually configured. With no real adapters wired yet (VIDEO_PROVIDER_KINDS
+ * is empty), this returns false in production so the model never sees a tool
+ * it can't use — the tool becomes visible automatically once an adapter +
+ * matching settings provider exist. Short TTL cache like GenerateImage.
+ */
+const availCache = new Map();
+const AVAIL_TTL_MS = 1000;
+export function isGenerateVideoAvailable(cwd = process.cwd(), nowMs = Date.now()) {
+    if (injectedProvider)
+        return true;
+    const hit = availCache.get(cwd);
+    if (hit && nowMs - hit.at < AVAIL_TTL_MS)
+        return hit.value;
+    let value = false;
+    try {
+        value = resolveVideoProvider(cwd) !== null;
+    }
+    catch {
+        value = false;
+    }
+    availCache.set(cwd, { at: nowMs, value });
+    return value;
+}
+/**
+ * List configured, usable video providers (TODO 7.1). Returns [] when no
+ * adapters are wired (VIDEO_PROVIDER_KINDS empty) or none configured.
+ */
+export function listConfiguredVideoProviders(cwd = process.cwd()) {
+    try {
+        const settings = new SettingsManager(cwd, "full").get();
+        // Canonical videoGen.providers[] first (TODO 7.1) — but only kinds that
+        // have a wired adapter (VIDEO_PROVIDER_KINDS); a configured-but-unadapted
+        // entry isn't usable yet.
+        const videoGen = settings.videoGen;
+        if (videoGen?.providers?.length) {
+            const list = videoGen.providers;
+            return list
+                .filter((p) => !!effectiveApiKey(p, list) && getVideoProvider(p.kind) !== null)
+                .map((p) => ({ id: p.id, kind: p.kind, catalogId: p.catalogId }));
+        }
+        // Legacy LLM providers[] back-compat (field dropped from schema; read via
+        // .passthrough() with an inline cast).
+        const legacyProviders = settings.providers ?? [];
+        return legacyProviders
+            .filter((p) => p.apiKey && VIDEO_PROVIDER_KINDS.includes(p.kind))
+            .map((p) => ({ kind: p.kind }));
+    }
+    catch {
+        return [];
+    }
+}
+/** Dynamic GenerateVideo description naming configured providers (TODO 7.1). */
+export function generateVideoToolDefFor(cwd) {
+    const providers = listConfiguredVideoProviders(cwd);
+    if (providers.length === 0)
+        return generateVideoToolDef;
+    const names = providers.map((p) => p.id ?? p.kind).join(", ");
+    const catalog = getMergedCatalog();
+    const paramLines = providers
+        .map((p) => {
+        const entry = findCatalogEntry(catalog, p.catalogId, p.kind);
+        return entry?.paramsDoc ? `  - ${p.id ?? p.kind}: ${entry.paramsDoc}` : null;
+    })
+        .filter((x) => x !== null);
+    const paramsBlock = paramLines.length ? `\nParams per provider:\n${paramLines.join("\n")}` : "";
+    return {
+        ...generateVideoToolDef,
+        description: generateVideoToolDef.description +
+            ` Configured provider(s): ${names}. Pass \`provider\` to pick one.` +
+            paramsBlock,
+    };
+}
+function resolveVideoProvider(cwd, preferKind) {
+    const settings = new SettingsManager(cwd, "full").get();
+    // 0. Unified store (统一模型接入方案): modelConnections (tag=video) +
+    // credentials, taking precedence over legacy videoGen.providers[].
+    const conns = settings.modelConnections;
+    const creds = settings.credentials;
+    if (Array.isArray(conns) && conns.some((c) => c.tag === "video")) {
+        const list = genInstancesFromConnections(conns, (Array.isArray(creds) ? creds : []), getMergedCatalog(), "video");
+        const def = settings.defaults?.video;
+        const usable = (p) => !!p.apiKey && getVideoProvider(p.kind) !== null;
+        const credsOf = (p) => ({ baseUrl: p.baseUrl, apiKey: p.apiKey });
+        if (preferKind) {
+            const chosen = list.find((p) => (p.id === preferKind || p.kind === preferKind) && usable(p));
+            if (chosen)
+                return { kind: chosen.kind, creds: credsOf(chosen), defaultModel: chosen.defaultModel };
+            return null;
+        }
+        const preferred = def ? list.find((p) => p.id === def) : undefined;
+        const chosen = (preferred && usable(preferred) ? preferred : undefined) ?? list.find(usable);
+        if (chosen)
+            return { kind: chosen.kind, creds: credsOf(chosen), defaultModel: chosen.defaultModel };
+        if (def || preferKind)
+            return null;
+    }
+    const videoGen = settings.videoGen;
+    if (videoGen?.providers?.length) {
+        const list = videoGen.providers;
+        const usable = (p) => !!effectiveApiKey(p, list) && getVideoProvider(p.kind) !== null;
+        const credsOf = (p) => ({ baseUrl: p.baseUrl, apiKey: effectiveApiKey(p, list) });
+        if (preferKind) {
+            const chosen = list.find((p) => (p.id === preferKind || p.kind === preferKind) && usable(p));
+            if (chosen)
+                return { kind: chosen.kind, creds: credsOf(chosen), defaultModel: chosen.defaultModel };
+            return null;
+        }
+        const preferred = videoGen.defaultProvider
+            ? list.find((p) => p.id === videoGen.defaultProvider)
+            : undefined;
+        const chosen = (preferred && usable(preferred) ? preferred : undefined) ?? list.find(usable);
+        if (chosen)
+            return { kind: chosen.kind, creds: credsOf(chosen), defaultModel: chosen.defaultModel };
+        return null;
+    }
+    // Back-compat: scan legacy LLM providers[] for a video-capable kind. The
+    // field was dropped from the schema; un-migrated settings.json still carry it
+    // via .passthrough(), so read it through an inline cast.
+    const legacyProviders = settings.providers ?? [];
+    const kinds = preferKind ? [preferKind] : VIDEO_PROVIDER_KINDS;
+    for (const kind of kinds) {
+        const provider = legacyProviders.find((p) => p.kind === kind);
+        if (provider && provider.apiKey) {
+            return { kind, creds: { baseUrl: provider.baseUrl, apiKey: provider.apiKey } };
+        }
+    }
+    return null;
+}
+export function __resolveVideoProviderForTests(cwd, preferKind) {
+    return resolveVideoProvider(cwd, preferKind);
+}
+export async function generateVideoTool(args, ctx) {
+    const prompt = args.prompt;
+    if (typeof prompt !== "string" || !prompt.trim()) {
+        return "Error: prompt is required";
+    }
+    const cwd = ctx?.cwd ?? process.cwd();
+    const sessionId = ctx?.sessionId;
+    const preferKind = typeof args.provider === "string" && args.provider ? args.provider : undefined;
+    const overrideModel = typeof args.model === "string" && args.model ? args.model : undefined;
+    const image = typeof args.image === "string" && args.image ? args.image : undefined;
+    const imagesArg = Array.isArray(args.images)
+        ? args.images.filter((x) => typeof x === "string")
+        : undefined;
+    // videos pass through verbatim to fal's video_urls (no upload) — http(s) only.
+    const videosArg = Array.isArray(args.videos)
+        ? args.videos.filter((x) => typeof x === "string")
+        : undefined;
+    const pollIntervalMs = typeof args.pollIntervalMs === "number" && args.pollIntervalMs > 0
+        ? args.pollIntervalMs
+        : DEFAULT_POLL_INTERVAL_MS;
+    // Resolve the provider + adapter. The test seam wins so the background loop
+    // is exercised without a real adapter.
+    let kind;
+    let creds;
+    let adapter;
+    let defaultModel;
+    if (injectedProvider) {
+        adapter = injectedProvider;
+        kind = injectedProvider.kind;
+        creds = { baseUrl: "test", apiKey: "test" };
+    }
+    else {
+        const resolved = resolveVideoProvider(cwd, preferKind);
+        if (!resolved) {
+            return preferKind
+                ? `Error: no video provider of kind "${preferKind}" available. Configure it (with an apiKey) in settings.`
+                : "Error: no video provider available. Video generation requires a configured video provider (none are wired yet).";
+        }
+        const a = getVideoProvider(resolved.kind);
+        if (!a)
+            return `Error: video generation is not supported for provider kind "${resolved.kind}".`;
+        adapter = a;
+        kind = resolved.kind;
+        creds = resolved.creds;
+        defaultModel = resolved.defaultModel;
+    }
+    const model = overrideModel ?? defaultModel ?? DEFAULT_VIDEO_MODEL[kind] ?? kind;
+    // Normalize image inputs (local paths → uploaded URLs) before submit. The
+    // provider only ever receives URLs and routes t2v/i2v/ref2v by count.
+    const uploader = getImageUploader(kind) ?? getImageUploader("fal");
+    const norm = await __normalizeImagesForTests(imagesArg, image, uploader, { baseUrl: creds.baseUrl, apiKey: creds.apiKey }, ctx?.signal);
+    if (!norm.ok)
+        return `Error: ${norm.error}`;
+    const submit = await adapter.submit({ prompt, model, image: undefined, images: norm.urls, videos: videosArg, creds, signal: ctx?.signal });
+    if (!submit.ok) {
+        return `Error submitting video job: ${submit.error}`;
+    }
+    const jobId = submit.jobId;
+    // Background poll → download → write → notify. Fire-and-forget: never await.
+    // Register the job so it shows up in the goal judge's background-task list
+    // (so the judge can tell "waiting on a finite render" from "nothing left to
+    // do" — the s-mqe0ox7n-a8d11c26 busy-loop bug). The video does NOT park the
+    // engine anymore; its completion notification wakes the idle session (server
+    // maybeWakeIdleSession). The registry is keyed by the fal jobId namespaced so
+    // 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)
+        .then((outcome) => backgroundJobRegistry.finish(jobKey, outcome))
+        .catch((err) => backgroundJobRegistry.finish(jobKey, { status: "failed", finalText: err.message }));
+    return [
+        `Video generation started in the background.`,
+        `job_id: ${jobId} (internal — do not show to user)`,
+        `prompt: ${prompt}`,
+        ``,
+        `It will be saved into .code-shell/generated_videos/ and you'll be notified automatically when it finishes.`,
+        `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();
+    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 (!res.ok) {
+                notifyVideo(sessionId, "failed", prompt, undefined, res.error);
+                return { status: "failed", finalText: res.error };
+            }
+            if (res.status === "failed") {
+                notifyVideo(sessionId, "failed", prompt, undefined, res.error);
+                return { status: "failed", finalText: res.error };
+            }
+            if (res.status === "succeeded")
+                break;
+            await new Promise((r) => setTimeout(r, pollIntervalMs));
+        }
+        const dl = await adapter.download({ jobId, creds });
+        if (!dl.ok) {
+            notifyVideo(sessionId, "failed", prompt, undefined, dl.error);
+            return { status: "failed", finalText: dl.error };
+        }
+        const dir = join(cwd, ".code-shell", "generated_videos");
+        await mkdir(dir, { recursive: true });
+        const path = join(dir, `${Date.now()}.${dl.ext || "mp4"}`);
+        await writeFile(path, dl.bytes);
+        notifyVideo(sessionId, "completed", prompt, path, undefined, dl.url);
+        return { status: "completed", finalText: path };
+    }
+    catch (err) {
+        notifyVideo(sessionId, "failed", prompt, undefined, err.message);
+        return { status: "failed", finalText: err.message };
+    }
+}
+function notifyVideo(sessionId, status, prompt, path, error, url) {
+    if (!sessionId) {
+        logger.warn("video_completion_without_session", { status });
+        return;
+    }
+    // Include the fal-hosted URL on success so the model can pass it to a follow-up
+    // GenerateVideo `videos:[url]` to extend this clip (no re-upload). Expiring URL.
+    const extendHint = url
+        ? ` To extend this video, call GenerateVideo again with videos:["${url}"] (Seedance model). URL may expire.`
+        : "";
+    notificationQueue.enqueue({
+        agentId: `video-${Date.now()}`,
+        name: "video generation",
+        description: status === "completed"
+            ? `Video generated: ${path} (prompt: ${prompt})`
+            : `Video generation failed (prompt: ${prompt})`,
+        status,
+        finalText: status === "completed" ? `Video saved to ${path}.${extendHint}` : undefined,
+        error: status === "failed" ? error : undefined,
+        enqueuedAt: Date.now(),
+    }, sessionId);
+}

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

@@ -4,7 +4,6 @@
 import { glob } from "glob";
 import { stat } from "node:fs/promises";
 import * as path from "node:path";
-import { enforcePathPolicy } from "../path-policy.js";
 export const globToolDef = {
     name: "Glob",
     description: "Fast file pattern matching. Returns matching file paths sorted by modification time. " +
@@ -32,12 +31,6 @@ export async function globTool(args, ctx) {
             ? argPath
             : path.resolve(baseDir, argPath)
         : baseDir;
-    // Path policy: refuse to glob a search root the policy classifies as
-    // ask/deny for read. Stops a Glob("**/*", "/home/user/.ssh") from
-    // enumerating the keys directory under the existence-check radar.
-    const blocked = enforcePathPolicy(cwd, "read", ctx?.cwd);
-    if (blocked)
-        return blocked;
     try {
         const matches = await glob(pattern, {
             cwd,

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

@@ -3,5 +3,14 @@
  */
 import type { ToolDefinition } from "../../types.js";
 import type { ToolContext } from "../context.js";
+type ExecFileForGrep = (file: string, args: readonly string[], options: {
+    maxBuffer: number;
+    timeout: number;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function _setGrepExecFileForTest(fn?: ExecFileForGrep): void;
 export declare const grepToolDef: ToolDefinition;
 export declare function grepTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
+export {};

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

@@ -2,10 +2,14 @@
  * Built-in Grep content search tool.
  */
 import { execFile } from "node:child_process";
+import { readdir, readFile, stat } from "node:fs/promises";
 import { promisify } from "node:util";
-import { resolve, sep, isAbsolute } from "node:path";
-import { enforcePathPolicy } from "../path-policy.js";
+import { basename, join, relative, resolve, sep, isAbsolute } from "node:path";
 const execFileAsync = promisify(execFile);
+let execFileForTest = execFileAsync;
+export function _setGrepExecFileForTest(fn) {
+    execFileForTest = fn ?? execFileAsync;
+}
 /**
  * Strip the cwd prefix from each line so results display as relative
  * paths (e.g. "src/ui/App.tsx" instead of an absolute path). Lines that
@@ -59,11 +63,6 @@ export async function grepTool(args, ctx) {
             ? argPath
             : resolve(baseDir, argPath)
         : baseDir;
-    // Path policy: reading file contents under ~/.ssh, ~/.aws etc. by way
-    // of grep is the same exfiltration risk as Read. Gate the search root.
-    const blocked = enforcePathPolicy(searchPath, "read", ctx?.cwd);
-    if (blocked)
-        return blocked;
     const fileGlob = args.glob;
     const context = args.context || 0;
     const maxResults = args.max_results || 50;
@@ -77,15 +76,21 @@ export async function grepTool(args, ctx) {
         if (isNoMatchExit(rgErr))
             return "No matches found.";
         try {
-            return await runGrep(pattern, searchPath, context, maxResults, outputMode, caseInsensitive);
+            return await runGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
         }
         catch (grepErr) {
             if (isNoMatchExit(grepErr))
                 return "No matches found.";
+            if (isCommandNotFound(rgErr) || isCommandNotFound(grepErr)) {
+                return await runNodeGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
+            }
             return `Error in search: ${grepErr.message}`;
         }
     }
 }
+function isCommandNotFound(err) {
+    return err?.code === "ENOENT";
+}
 async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
     const args = ["--color=never"];
     if (caseInsensitive)
@@ -108,7 +113,7 @@ async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMo
     // Ignore common non-source dirs
     args.push("--glob", "!node_modules", "--glob", "!.git", "--glob", "!dist", "--glob", "!coverage");
     args.push("--", pattern, path);
-    const { stdout } = await execFileAsync("rg", args, {
+    const { stdout } = await execFileForTest("rg", args, {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 30_000,
     });
@@ -122,7 +127,7 @@ async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMo
     }
     return result;
 }
-async function runGrep(pattern, path, context, maxResults, outputMode, caseInsensitive) {
+async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
     const args = ["-r", "--color=never"];
     if (caseInsensitive)
         args.push("-i");
@@ -138,10 +143,14 @@ async function runGrep(pattern, path, context, maxResults, outputMode, caseInsen
             args.push("-C", String(context));
     }
     args.push("-m", String(maxResults));
+    // Honor the file glob so the grep fallback matches ripgrep's --glob behavior
+    // (previously the glob was silently dropped on the fallback path).
+    if (fileGlob)
+        args.push(`--include=${fileGlob}`);
     args.push("-E", pattern);
     args.push("--exclude-dir=node_modules", "--exclude-dir=.git", "--exclude-dir=dist");
     args.push(path);
-    const { stdout } = await execFileAsync("grep", args, {
+    const { stdout } = await execFileForTest("grep", args, {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 30_000,
     });
@@ -154,3 +163,89 @@ async function runGrep(pattern, path, context, maxResults, outputMode, caseInsen
     }
     return result;
 }
+const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "coverage"]);
+async function runNodeGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
+    let regex;
+    try {
+        regex = new RegExp(pattern, caseInsensitive ? "i" : "");
+    }
+    catch (err) {
+        return `Error in search: ${err.message}`;
+    }
+    const matches = [];
+    await walkTextFiles(path, fileGlob, async (file) => {
+        if (matches.length >= maxResults)
+            return;
+        let text;
+        try {
+            text = await readFile(file, "utf8");
+        }
+        catch {
+            return;
+        }
+        const lines = text.split(/\r?\n/);
+        const matchingLines = [];
+        for (let i = 0; i < lines.length; i++) {
+            regex.lastIndex = 0;
+            if (regex.test(lines[i]))
+                matchingLines.push(i);
+        }
+        if (matchingLines.length === 0)
+            return;
+        const rel = relative(path, file) || basename(file);
+        if (outputMode === "files_with_matches") {
+            matches.push(rel);
+        }
+        else if (outputMode === "count") {
+            matches.push(`${rel}:${matchingLines.length}`);
+        }
+        else {
+            const emitted = new Set();
+            for (const lineIndex of matchingLines) {
+                const start = Math.max(0, lineIndex - context);
+                const end = Math.min(lines.length - 1, lineIndex + context);
+                for (let i = start; i <= end; i++) {
+                    if (emitted.has(i))
+                        continue;
+                    emitted.add(i);
+                    matches.push(`${rel}:${i + 1}:${lines[i]}`);
+                    if (matches.length >= maxResults)
+                        return;
+                }
+            }
+        }
+    });
+    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) {
+    const info = await stat(root).catch(() => null);
+    if (!info)
+        return;
+    if (info.isFile()) {
+        if (!fileGlob || matchesSimpleGlob(basename(root), fileGlob))
+            await visit(root);
+        return;
+    }
+    if (!info.isDirectory())
+        return;
+    const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            await walkTextFiles(join(root, entry.name), fileGlob, visit);
+        }
+        else if (entry.isFile()) {
+            if (!fileGlob || matchesSimpleGlob(entry.name, fileGlob))
+                await visit(join(root, entry.name));
+        }
+    }
+}
+function matchesSimpleGlob(name, glob) {
+    const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`).test(name);
+}

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

@@ -0,0 +1,86 @@
+/**
+ * ImageProvider — adapter interface for text-to-image generation (TODO 7.1).
+ *
+ * Lifts the hardcoded OpenAI `gpt-image-2` call out of generate-image.ts so
+ * GenerateImage can target multiple providers (OpenAI now; Gemini next) and
+ * take an optional provider/model. Each adapter takes resolved credentials +
+ * the request and returns a base64 PNG (or an error string). The tool layer
+ * owns credential resolution from settings, file writing, and user-facing
+ * formatting — adapters are pure "creds + prompt → bytes".
+ *
+ * `fetch` is injected so adapters are unit-testable without network. Production
+ * call sites pass the global `fetch`.
+ */
+export interface ImageProviderCreds {
+    baseUrl: string;
+    apiKey: string;
+}
+/** A decoded reference/input image for image-to-image (edit) requests. */
+export interface InputImage {
+    /** File name hint (used as the multipart part filename). */
+    filename: string;
+    /** MIME type, e.g. "image/png" | "image/jpeg" | "image/webp". */
+    mimeType: string;
+    /** Raw bytes (NOT base64) — the tool layer decodes the workspace file. */
+    bytes: Uint8Array;
+}
+export interface ImageGenerateRequest {
+    prompt: string;
+    size: string;
+    quality: string;
+    model: string;
+    creds: ImageProviderCreds;
+    /**
+     * Optional reference images. When present, this becomes an image-TO-image
+     * (edit) request rather than text-to-image: the provider conditions the
+     * output on these inputs (OpenAI `/images/edits`, Gemini inline_data parts).
+     * Empty/undefined = plain text-to-image.
+     */
+    inputImages?: InputImage[];
+    /** Optional cancellation signal forwarded to fetch. */
+    signal?: AbortSignal;
+}
+export type ImageGenerateResult = {
+    ok: true;
+    b64: string;
+} | {
+    ok: false;
+    error: string;
+};
+export interface ImageProvider {
+    /** Adapter id — matches the settings provider `kind` it consumes. */
+    readonly kind: string;
+    generate(req: ImageGenerateRequest): Promise<ImageGenerateResult>;
+}
+/**
+ * OpenAI Images API adapter (`/images/generations`, b64_json). Identical wire
+ * behavior to the pre-refactor generate-image.ts: POST model/prompt/size/
+ * quality/n, read data[0].b64_json.
+ */
+export declare class OpenAIImageProvider implements ImageProvider {
+    private readonly fetchImpl;
+    readonly kind = "openai";
+    constructor(fetchImpl?: typeof fetch);
+    generate(req: ImageGenerateRequest): Promise<ImageGenerateResult>;
+}
+/**
+ * Gemini Images adapter — the `generateContent` endpoint
+ * (`/models/{model}:generateContent`), API key in the `x-goog-api-key`
+ * header, prompt as a text content-part, PNG returned base64 in
+ * `candidates[].content.parts[].inline_data.data` (REST may camelCase it to
+ * `inlineData`; we read both). Wire shape per ai.google.dev image-generation
+ * docs. The OpenAI-style `size`/`quality` args don't map 1:1 to Gemini's
+ * aspectRatio/imageSize, so we only forward the prompt + IMAGE modality and
+ * leave Gemini's own defaults for dimensions (a later pass can map size →
+ * aspectRatio if needed).
+ */
+export declare class GeminiImageProvider implements ImageProvider {
+    private readonly fetchImpl;
+    readonly kind = "google";
+    constructor(fetchImpl?: typeof fetch);
+    generate(req: ImageGenerateRequest): Promise<ImageGenerateResult>;
+}
+/** Default model per provider kind when the caller doesn't specify one. */
+export declare const DEFAULT_IMAGE_MODEL: Record<string, string>;
+/** Registry of available image-provider adapters, keyed by `kind`. */
+export declare function getImageProvider(kind: string, fetchImpl?: typeof fetch): ImageProvider | null;