qlogicagent 2.13.3 → 2.13.5

package/dist/cli/tool-bootstrap.background-exec.test.js

@@ -0,0 +1,83 @@
+/**
+ * Real-chain integration: exec(background=true) spawns a REAL process,
+ * registers it in the unified BackgroundTaskManager, and the task tool
+ * reads its status/output by task id. No LLM, no mocks on the exec path.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterAll, describe, expect, it } from "vitest";
+import { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
+import { TaskStore } from "../runtime/infra/task-runtime.js";
+import { createToolCatalogFixture } from "./test-support/tool-catalog-fixture.js";
+import { getAllBaseTools, setBackgroundTaskRuntime } from "./tool-bootstrap.js";
+const tmpRoots = [];
+afterAll(() => {
+    setBackgroundTaskRuntime(null);
+    for (const root of tmpRoots.splice(0)) {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+});
+function createWorkdir() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "qla-bg-exec-"));
+    tmpRoots.push(dir);
+    return dir;
+}
+async function waitFor(predicate, timeoutMs = 15_000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (await predicate())
+            return;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    throw new Error("waitFor timeout");
+}
+describe("background exec → unified task registry → task tool (real chain)", () => {
+    it("runs a real background command and exposes lifecycle + output through the task tool", async () => {
+        const store = new TaskStore();
+        const manager = new BackgroundTaskManager(store);
+        setBackgroundTaskRuntime(manager);
+        const toolCatalog = createToolCatalogFixture();
+        const tools = getAllBaseTools({ workdir: createWorkdir(), toolCatalog });
+        const execTool = tools.find((t) => t.name === "exec");
+        const taskTool = tools.find((t) => t.name === "task");
+        expect(execTool).toBeDefined();
+        expect(taskTool).toBeDefined();
+        // 1. Launch a real background command
+        const launch = await execTool.execute("c1", {
+            command: "echo background-exec-proof",
+            background: true,
+            description: "background proof",
+        });
+        const launchText = launch.content.map((c) => c.text ?? "").join("\n");
+        const taskId = launch.details.backgroundTaskId;
+        expect(taskId, `background launch failed: ${launchText}`).toBeTruthy();
+        expect(taskId).toMatch(/^b[a-z0-9]{8}$/); // unified id scheme (local_bash prefix)
+        expect(launchText).toContain(`task(action="output", taskId="${taskId}")`);
+        // 2. The registry tracks it in the shared TaskStore
+        const registered = store.getTask(taskId);
+        expect(registered).toBeDefined();
+        expect(registered?.type).toBe("local_bash");
+        // 3. Wait for the real process to exit and settle the task
+        await waitFor(() => {
+            const t = store.getTask(taskId);
+            return t?.lifecycle === "completed" || t?.lifecycle === "failed";
+        });
+        expect(store.getTask(taskId)?.lifecycle).toBe("completed");
+        // 4. The LLM-facing query path returns the real output
+        const output = await taskTool.execute("c2", { action: "output", taskId });
+        const outputText = output.content.map((c) => c.text ?? "").join("\n");
+        expect(outputText).toContain("completed");
+        expect(outputText).toContain("background-exec-proof");
+    }, 30_000);
+    it("refuses background execution loudly when no registry is bound", async () => {
+        setBackgroundTaskRuntime(null);
+        const toolCatalog = createToolCatalogFixture();
+        const tools = getAllBaseTools({ workdir: createWorkdir(), toolCatalog });
+        const execTool = tools.find((t) => t.name === "exec");
+        const result = await execTool.execute("c3", { command: "echo nope", background: true });
+        const body = result.content.map((c) => c.text ?? "").join("\n");
+        expect(body).toContain("background execution is not available");
+        expect(result.details.error).toBe("background_unavailable");
+    });
+});

package/dist/cli/tool-bootstrap.cwd.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/tool-bootstrap.cwd.test.js

@@ -0,0 +1,37 @@
+/**
+ * CWD single-source contract: file tools resolve relative paths against the
+ * SAME session CWD that exec mutates via `cd`. Before the fix these were two
+ * independent module variables, so `exec("cd sub")` + `write("./x")` disagreed.
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { setBootstrapWorkdir } from "./tool-bootstrap.js";
+import { getCwd, setCwd, initCwd } from "../skills/tools/shell/shell-exec.js";
+describe("CWD single source", () => {
+    it("setBootstrapWorkdir seeds the shell CWD read by file tools", () => {
+        const root = path.join(os.tmpdir(), "qla-cwd-root");
+        setBootstrapWorkdir(root);
+        expect(path.resolve(getCwd())).toBe(path.resolve(root));
+    });
+    it("an exec `cd` (setCwd) moves the base that file tools resolve against", () => {
+        const root = path.join(os.tmpdir(), "qla-cwd-root2");
+        setBootstrapWorkdir(root);
+        // Simulate `exec("cd sub")` updating the session CWD.
+        const sub = path.join(root, "sub");
+        setCwd(sub);
+        // A file tool resolving "./proof.txt" must now land under sub/, not root/.
+        const resolved = path.resolve(getCwd(), "./proof.txt");
+        expect(resolved).toBe(path.resolve(sub, "proof.txt"));
+        expect(resolved).not.toBe(path.resolve(root, "proof.txt"));
+    });
+    it("initCwd resets both the seed and the live value to one source", () => {
+        const a = path.join(os.tmpdir(), "qla-cwd-a");
+        const b = path.join(os.tmpdir(), "qla-cwd-b");
+        initCwd(a);
+        expect(path.resolve(getCwd())).toBe(path.resolve(a));
+        setCwd(path.join(a, "deep"));
+        initCwd(b); // e.g. project switch
+        expect(path.resolve(getCwd())).toBe(path.resolve(b));
+    });
+});

package/dist/cli/tool-bootstrap.d.ts

@@ -0,0 +1,63 @@
+import type { PortableTool } from "../skills/portable-tool.js";
+import type { PermissionMode } from "../runtime/ports/permission-contracts.js";
+import type { TaskToolHooks } from "../skills/tools/task-tool.js";
+import type { ExecProgress } from "../skills/tools/exec-tool.js";
+import type { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
+import type { ModelPurpose } from "../runtime/infra/model-registry.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+import type { AgentLogger } from "../agent/types.js";
+import type { AskUserQuestion } from "../skills/tools/ask-user-tool.js";
+import type { PathService, ToolCatalog } from "../runtime/ports/index.js";
+export { setMediaClientConfig, setProviderToolAPI } from "./media-runtime-facade.js";
+export { setGroupSecurityMode, validateExecCommand } from "./tool-bootstrap-core-registration.js";
+export { enforceAbsoluteFloors } from "./tool-bootstrap-paths.js";
+export interface SandboxPermissionSnapshot {
+    mode: PermissionMode;
+    workdir: string;
+    allowedDirs: string[];
+    /** cut7c: current turn is an untrusted community-skill turn → tighten the sandbox. */
+    communityTurn: boolean;
+}
+/** Wire the OS-sandbox permission source (live rule-engine snapshot), or null to clear. */
+export declare function setSandboxPermissionSource(source: (() => SandboxPermissionSnapshot | undefined) | null): void;
+/**
+ * Set task tool lifecycle hooks. Called from stdio-server when session starts.
+ * Connects planning-task events to the HookRegistry.
+ */
+export declare function setTaskToolHooks(hooks: TaskToolHooks | undefined): void;
+/**
+ * Set the unified background task registry. Called from stdio-server at startup.
+ * exec(background=true) and the task tool's output/cancel actions route through it.
+ * Hosts that never set it get a loud error from those paths (no silent fakes).
+ */
+export declare function setBackgroundTaskRuntime(manager: BackgroundTaskManager | null): void;
+/**
+ * Set the ask_user callback. The host (Electron / test harness) provides
+ * an implementation that presents questions to the user and returns answers.
+ * If null, ask_user returns "user declined" to the LLM.
+ */
+export declare function setAskUserCallback(callback: ((questions: AskUserQuestion[]) => Promise<Record<string, string> | null>) | null): void;
+export declare function setBootstrapWorkdir(newWorkdir: string): void;
+export interface BootstrapConfig {
+    workdir?: string;
+    toolCatalog?: ToolCatalog;
+    pathService?: PathService;
+    log?: AgentLogger;
+    /** Called during foreground shell execution with incremental progress. */
+    onExecProgress?(progress: ExecProgress): void;
+    /** host 多档 LLM 解析(web_answer/web_research 用);未提供则不注册这些工具(零孤立)。 */
+    resolveClientForPurpose?(purpose: ModelPurpose): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+}
+/**
+ * Create all locally-executable tools and install into centralized tool pool.
+ *
+ * CC parity: getAllBaseTools() returns flat array, installed via setToolPool().
+ * Tools execute IN-PROCESS (zero IPC).
+ *
+ * @alias initToolDeps -kept for backward compat with existing call sites.
+ */
+export declare function getAllBaseTools(config?: BootstrapConfig): PortableTool[];

package/dist/cli/tool-bootstrap.instructions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/tool-bootstrap.instructions.test.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getAllBaseTools } from "./tool-bootstrap.js";
+import * as projectStore from "../runtime/infra/project-store.js";
+const tempDirs = [];
+function makeTempDir(prefix) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    tempDirs.push(dir);
+    return dir;
+}
+afterEach(() => {
+    vi.unstubAllEnvs();
+    for (const dir of tempDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("tool bootstrap instructions tool", () => {
+    it("writes project instruction files into the single-track project rules directory", async () => {
+        const home = makeTempDir("qlogicagent-tool-home-");
+        const workspace = makeTempDir("qlogicagent-tool-workspace-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const project = projectStore.createProject({ name: "Design", workspaceDir: workspace });
+        const tool = getAllBaseTools({ workdir: workspace }).find((candidate) => candidate.name === "instructions");
+        await tool?.execute("instructions-write", {
+            action: "write",
+            project_id: project.id,
+            filename: "review.md",
+            content: "# Review\nUse the v0.15 single-track rules path.",
+        });
+        expect(fs.readFileSync(path.join(workspace, ".qlogicagent", "rules", "review.md"), "utf8"))
+            .toContain("single-track rules path");
+        expect(fs.existsSync(path.join(home, "projects", project.id, ".instructions", "review.md"))).toBe(false);
+    });
+});

package/dist/cli/tool-bootstrap.js

@@ -0,0 +1,255 @@
+// ============================================================
+// Tool Bootstrap -populate tool pool with locally-executable tools.
+//
+// CC alignment: tools are registered once via getAllBaseTools().
+//
+// CC reference: claude-code-haha/src/tools.ts (getAllBaseTools)
+// ============================================================
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { execFileSync } from "node:child_process";
+import { getTaskOutputDir } from "../skills/tools/shell/task-output.js";
+import { resolveLandlockHelper } from "../skills/tools/shell/sandbox/helper-resolver.js";
+import { setShellProvider, initCwd, getCwd, createBashProvider, createPowerShellProvider, isPowerShellToolEnabled, } from "../skills/tools/shell/index.js";
+import { IMAGE_GENERATE_TOOL_NAME } from "../skills/tools/image-generate-tool.js";
+import { TTS_TOOL_NAME } from "../skills/tools/tts-tool.js";
+import { VIDEO_GENERATE_TOOL_NAME } from "../skills/tools/video-generate-tool.js";
+import { MUSIC_GENERATE_TOOL_NAME } from "../skills/tools/music-generate-tool.js";
+import { PETDEX_CREATE_TOOL_NAME } from "../skills/tools/petdex-create-tool.js";
+import * as projectStore from "../runtime/infra/project-store.js";
+import { createLegacyToolCatalog } from "./tool-registry-adapter.js";
+import { localCoreToolRegistrationModule } from "./tool-bootstrap-core-registration.js";
+import { localWebToolRegistrationModule } from "./tool-bootstrap-web-registration.js";
+import { localWorkflowToolRegistrationModule } from "./tool-bootstrap-workflow-registration.js";
+import { localMediaToolRegistrationModule } from "./tool-bootstrap-media-registration.js";
+export { setMediaClientConfig, setProviderToolAPI } from "./media-runtime-facade.js";
+export { setGroupSecurityMode, validateExecCommand } from "./tool-bootstrap-core-registration.js";
+export { enforceAbsoluteFloors } from "./tool-bootstrap-paths.js";
+let _sandboxPermissionSource = null;
+/** Wire the OS-sandbox permission source (live rule-engine snapshot), or null to clear. */
+export function setSandboxPermissionSource(source) {
+    _sandboxPermissionSource = source;
+}
+function sandboxExecAvailable() {
+    if (process.platform !== "darwin")
+        return false;
+    try {
+        execFileSync("which", ["sandbox-exec"], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Build the per-exec SandboxConfig from the live permission snapshot; undefined → no sandbox. */
+function resolveSandboxConfig() {
+    const snap = _sandboxPermissionSource?.();
+    if (!snap)
+        return undefined;
+    const tmpBase = os.tmpdir();
+    return {
+        mode: snap.mode,
+        workdir: snap.workdir,
+        // cut7c: community (untrusted) turns confine writes to the workdir only (drop the
+        // user's persistent/approved external dirs) — defense-in-depth on POSIX.
+        allowedDirs: snap.communityTurn ? [] : snap.allowedDirs,
+        // Tool bookkeeping (task output + snapshot/cwd temp roots) must stay writable.
+        bookkeepingDirs: [getTaskOutputDir(), tmpBase],
+        tmpDir: path.join(tmpBase, "qla-sandbox"),
+        helperPath: resolveLandlockHelper(),
+        sandboxExecAvailable: sandboxExecAvailable(),
+        // Community turns deny outbound network from the sandboxed child (egress containment).
+        netPolicy: snap.communityTurn ? "deny" : "allow",
+    };
+}
+// Media config (CC isEnabled gate)
+// Provider Tool API (C-level cascade)
+// Ask User callback (host provides UI)
+let askUserCallback = null;
+// Task Tool hooks (late-binding, set per session)
+let taskToolHooks;
+/**
+ * Set task tool lifecycle hooks. Called from stdio-server when session starts.
+ * Connects planning-task events to the HookRegistry.
+ */
+export function setTaskToolHooks(hooks) {
+    taskToolHooks = hooks;
+}
+// Background task runtime (late-binding, set by the host that owns the TaskStore)
+let backgroundTaskRuntime = null;
+/**
+ * Set the unified background task registry. Called from stdio-server at startup.
+ * exec(background=true) and the task tool's output/cancel actions route through it.
+ * Hosts that never set it get a loud error from those paths (no silent fakes).
+ */
+export function setBackgroundTaskRuntime(manager) {
+    backgroundTaskRuntime = manager;
+}
+/**
+ * Set the ask_user callback. The host (Electron / test harness) provides
+ * an implementation that presents questions to the user and returns answers.
+ * If null, ask_user returns "user declined" to the LLM.
+ */
+export function setAskUserCallback(callback) {
+    askUserCallback = callback;
+}
+// Shared CWD/project helpers
+//
+// CWD single-source: the shell layer's session CWD is the source of truth for
+// local tool relative paths. Domain-specific deps live in registration modules.
+export function setBootstrapWorkdir(newWorkdir) {
+    initCwd(newWorkdir);
+}
+/** Project root (where .qlogicagent/ lives), independent of shell CWD drift. */
+function activeProjectRoot() {
+    return projectStore.getActiveProject()?.workspaceDir ?? getCwd();
+}
+// Shell provider init
+let _shellProviderInitialized = false;
+function initShellProvider() {
+    if (_shellProviderInitialized)
+        return;
+    _shellProviderInitialized = true;
+    if (isPowerShellToolEnabled()) {
+        // Windows PowerShell mode
+        const psPath = process.env.QLOGICAGENT_POWERSHELL_PATH ?? "powershell.exe";
+        setShellProvider(createPowerShellProvider(psPath));
+    }
+    else if (process.platform === "win32") {
+        // Windows default: Git Bash
+        const bashPath = findBashOnWindows();
+        setShellProvider(createBashProvider(bashPath));
+    }
+    else {
+        // Unix: /bin/bash or $SHELL
+        const bashPath = process.env.SHELL?.endsWith("bash")
+            ? process.env.SHELL
+            : "/bin/bash";
+        setShellProvider(createBashProvider(bashPath));
+    }
+}
+function findBashOnWindows() {
+    // Check explicit env var first
+    const explicit = process.env.QLOGICAGENT_BASH_PATH;
+    if (explicit && fs.existsSync(explicit))
+        return explicit;
+    // Try common Git Bash locations
+    const candidates = [
+        "C:\\Program Files\\Git\\bin\\bash.exe",
+        "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+    ];
+    // Derive from `git` in PATH
+    const gitDir = process.env.ProgramFiles
+        ? path.join(process.env.ProgramFiles, "Git", "bin", "bash.exe")
+        : null;
+    if (gitDir && !candidates.includes(gitDir))
+        candidates.unshift(gitDir);
+    for (const p of candidates) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    // Fallback: hope it's in PATH
+    return "bash";
+}
+const TOOL_CATEGORY_BY_NAME = {
+    task: "orchestration",
+    ask_user: "orchestration",
+    exec: "developer",
+    read: "filesystem",
+    write: "filesystem",
+    edit: "filesystem",
+    patch: "filesystem",
+    search: "search",
+    web_fetch: "web",
+    web_search: "web",
+    web_answer: "web",
+    web_research: "web",
+    instructions: "filesystem",
+    worktree: "developer",
+    notebook_edit: "developer",
+    workflow: "automation",
+    sleep: "automation",
+    tool_search: "search",
+    [IMAGE_GENERATE_TOOL_NAME]: "media",
+    [PETDEX_CREATE_TOOL_NAME]: "media",
+    [TTS_TOOL_NAME]: "media",
+    [VIDEO_GENERATE_TOOL_NAME]: "media",
+    [MUSIC_GENERATE_TOOL_NAME]: "media",
+    video_edit: "media",
+    video_merge: "media",
+    video_upscale: "media",
+    three_d_generate: "media",
+    stt: "media",
+    voice_clone: "media",
+    media_cancel: "media",
+    file_upload: "filesystem",
+    file_query: "filesystem",
+    file_delete: "filesystem",
+};
+function declareToolUiContracts(tools) {
+    for (const tool of tools) {
+        tool.category ??= TOOL_CATEGORY_BY_NAME[tool.name] ?? "other";
+        tool.displayName ??= {
+            key: `capability.tool.${tool.name}.name`,
+            fallback: tool.label,
+        };
+        tool.displayDescription ??= {
+            key: `capability.tool.${tool.name}.description`,
+            fallback: "",
+        };
+    }
+}
+/**
+ * Create all locally-executable tools and install into centralized tool pool.
+ *
+ * CC parity: getAllBaseTools() returns flat array, installed via setToolPool().
+ * Tools execute IN-PROCESS (zero IPC).
+ *
+ * @alias initToolDeps -kept for backward compat with existing call sites.
+ */
+export function getAllBaseTools(config) {
+    const toolCatalog = config?.toolCatalog ?? createLegacyToolCatalog();
+    const listToolNames = () => toolCatalog.getToolNames();
+    const findRegisteredTool = (name) => toolCatalog.findTool(name);
+    const activateRegisteredTool = (name) => toolCatalog.activateTool(name);
+    // Shell provider (must be set before exec tool is used).
+    // initCwd seeds the single CWD source; getCwd() is read everywhere thereafter.
+    initShellProvider();
+    if (config?.workdir)
+        initCwd(config.workdir);
+    const tools = [];
+    localCoreToolRegistrationModule.register({
+        tools,
+        taskToolHooks,
+        backgroundTaskRuntime,
+        askUserCallback,
+        onExecProgress: config?.onExecProgress,
+        getCwd,
+        activeProjectRoot,
+        resolveSandboxConfig,
+        pathService: config?.pathService,
+        log: config?.log,
+        listToolNames,
+        findRegisteredTool,
+        activateRegisteredTool,
+    });
+    localWebToolRegistrationModule.register({
+        tools,
+        resolveClientForPurpose: config?.resolveClientForPurpose,
+    });
+    localWorkflowToolRegistrationModule.register({
+        tools,
+        activeProjectRoot,
+    });
+    localMediaToolRegistrationModule.register({
+        tools,
+        getCwd,
+        activeProjectRoot,
+    });
+    declareToolUiContracts(tools);
+    // Install into the runtime catalog. The module facade remains for legacy callers.
+    toolCatalog.setTools(tools);
+    config?.log?.info(`[tool-bootstrap] Registered ${tools.length} local tools (${tools.filter(t => t.isEnabled?.() !== false).length} enabled): ${listToolNames().join(", ")}`);
+    return tools;
+}

package/dist/cli/tool-bootstrap.media-provider-alias.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/tool-bootstrap.media-provider-alias.test.js

@@ -0,0 +1,90 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createToolCatalogFixture } from "./test-support/tool-catalog-fixture.js";
+import { getAllBaseTools, setMediaClientConfig } from "./tool-bootstrap.js";
+const tmpRoots = [];
+function createWorkdir() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "qlogicagent-tools-"));
+    tmpRoots.push(root);
+    return root;
+}
+function createMediaClient() {
+    return {
+        getTransport(providerId) {
+            return providerId === "doubao" || providerId === "volcengine" ? {} : undefined;
+        },
+        resolveModelById(providerId, modelId, mediaType) {
+            if ((providerId === "doubao" || providerId === "volcengine") && mediaType === "video") {
+                return {
+                    providerId,
+                    mediaType,
+                    providerDef: { id: "volcengine" },
+                    modelInfo: {
+                        id: modelId,
+                        name: "Doubao Seedance 2.0 Fast",
+                        mediaType: "video",
+                        mediaCapabilities: {
+                            type: "video",
+                            operations: ["text2video", "img2video", "video2video", "edit", "merge", "upscale"],
+                        },
+                    },
+                };
+            }
+            if ((providerId === "doubao" || providerId === "volcengine") && mediaType === "image") {
+                return {
+                    providerId,
+                    mediaType,
+                    providerDef: { id: "volcengine" },
+                    modelInfo: {
+                        id: modelId,
+                        name: "Doubao Seedream",
+                        mediaType: "image",
+                        mediaCapabilities: {
+                            type: "image",
+                            operations: ["text2image", "img2img"],
+                        },
+                    },
+                };
+            }
+            return undefined;
+        },
+    };
+}
+describe("tool-bootstrap media provider key resolution", () => {
+    afterEach(() => {
+        setMediaClientConfig(undefined);
+        for (const root of tmpRoots.splice(0)) {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("keeps Seedance tools visible when media provider and key use the same providerId", () => {
+        const toolCatalog = createToolCatalogFixture();
+        getAllBaseTools({ workdir: createWorkdir(), toolCatalog });
+        setMediaClientConfig(createMediaClient(), { volcengine: "test-key" }, undefined, { video: { provider: "volcengine", model: "doubao-seedance-2-0-fast-260128" } });
+        const tools = toolCatalog.getToolManifest(true).map((tool) => tool.function.name);
+        expect(tools).toContain("video_generate");
+        expect(tools).toContain("video_edit");
+        expect(tools).toContain("video_merge");
+        expect(tools).toContain("video_upscale");
+    });
+    it("does not expose Seedance tools when media provider uses a different providerId than the key", () => {
+        const toolCatalog = createToolCatalogFixture();
+        getAllBaseTools({ workdir: createWorkdir(), toolCatalog });
+        setMediaClientConfig(createMediaClient(), { volcengine: "test-key" }, undefined, { video: { provider: "doubao", model: "doubao-seedance-2-0-fast-260128" } });
+        const tools = toolCatalog.getToolManifest(true).map((tool) => tool.function.name);
+        expect(tools).not.toContain("video_generate");
+        expect(tools).not.toContain("video_edit");
+        expect(tools).not.toContain("video_merge");
+        expect(tools).not.toContain("video_upscale");
+    });
+    it("exposes the Petdex creator when the image model supports reference images", () => {
+        const toolCatalog = createToolCatalogFixture();
+        getAllBaseTools({ workdir: createWorkdir(), toolCatalog });
+        setMediaClientConfig(createMediaClient(), { volcengine: "test-key" }, undefined, { image: { provider: "volcengine", model: "doubao-seedream-4-5" } });
+        const tools = toolCatalog.getToolManifest(true).map((tool) => tool.function.name);
+        expect(tools).toContain("image_generate");
+        expect(tools).toContain("petdex_create");
+    });
+});

package/dist/cli/tool-bootstrap.test.d.ts

@@ -0,0 +1 @@
+export {};