qlogicagent 0.2.1 → 0.4.0

package/dist/skills/tools/task-tool.js

@@ -1,161 +0,0 @@
-// ============================================================
-// Task Tool — background agent task management (CRUD + output).
-// Reference: claude-code-haha/src/tools/TaskCreateTool/TaskCreateTool.ts
-//            claude-code-haha/src/tools/TaskGetTool/TaskGetTool.ts
-//            claude-code-haha/src/tools/TaskListTool/TaskListTool.ts
-//            claude-code-haha/src/tools/TaskOutputTool/TaskOutputTool.tsx
-//            claude-code-haha/src/tools/TaskStopTool/TaskStopTool.ts
-// Category: system
-// ============================================================
-export const TASK_TOOL_NAME = "task";
-export const TASK_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["create", "get", "list", "output", "stop"],
-            description: "Action to perform:\n" +
-                "- create: Spawn a new background agent task\n" +
-                "- get: Get task status and metadata by ID\n" +
-                "- list: List all tasks with their statuses\n" +
-                "- output: Get stdout/output from a running or completed task\n" +
-                "- stop: Terminate a running task",
-        },
-        taskId: {
-            type: "string",
-            description: "Task ID. Required for get/output/stop.",
-        },
-        prompt: {
-            type: "string",
-            description: "Detailed prompt for the background agent. Must contain all context needed " +
-                "to complete the task independently. Required for create.",
-        },
-        description: {
-            type: "string",
-            description: "Short (3-7 word) description of the task. Used for tracking and display.",
-        },
-        allowedTools: {
-            type: "array",
-            items: { type: "string" },
-            description: "Restrict background agent to only these tools. If omitted, inherits parent's tools.",
-        },
-        cwd: {
-            type: "string",
-            description: "Working directory for the background task (absolute path).",
-        },
-        model: {
-            type: "string",
-            description: "Model override for the task agent (e.g. 'sonnet', 'opus').",
-        },
-        maxLines: {
-            type: "number",
-            description: "Max output lines to return for the 'output' action (default: 100).",
-            minimum: 1,
-            maximum: 2000,
-        },
-    },
-    required: ["action"],
-};
-const DEFAULT_MAX_LINES = 100;
-export function createTaskTool(deps) {
-    return {
-        name: TASK_TOOL_NAME,
-        label: "Task",
-        shouldDefer: true,
-        description: "Manage background agent tasks. Use this to spawn long-running tasks (image generation, " +
-            "code refactoring, research) that run independently while you continue working. " +
-            "Actions: create (spawn), get (status check), list (all tasks), output (logs), stop (terminate).",
-        parameters: TASK_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "create": {
-                    if (!params.prompt || params.prompt.trim().length < 10) {
-                        return {
-                            content: [{ type: "text", text: "Error: 'prompt' is required for create (min 10 chars)." }],
-                        };
-                    }
-                    const task = await deps.createTask({
-                        prompt: params.prompt.trim(),
-                        description: params.description,
-                        allowedTools: params.allowedTools,
-                        cwd: params.cwd,
-                        model: params.model,
-                    });
-                    return {
-                        content: [{
-                                type: "text",
-                                text: [
-                                    `Task created successfully.`,
-                                    `ID: ${task.taskId}`,
-                                    `Status: ${task.status}`,
-                                    task.description ? `Description: ${task.description}` : "",
-                                ].filter(Boolean).join("\n"),
-                            }],
-                        details: { type: "task", action: "create", taskId: task.taskId, status: task.status },
-                    };
-                }
-                case "get": {
-                    if (!params.taskId) {
-                        return { content: [{ type: "text", text: "Error: 'taskId' is required for get." }] };
-                    }
-                    const task = await deps.getTask(params.taskId);
-                    if (!task) {
-                        return { content: [{ type: "text", text: `Error: task "${params.taskId}" not found.` }] };
-                    }
-                    const lines = [
-                        `Task: ${task.taskId}`,
-                        `Status: ${task.status}`,
-                        task.description ? `Description: ${task.description}` : "",
-                        `Created: ${new Date(task.createdAt).toISOString()}`,
-                        task.completedAt ? `Completed: ${new Date(task.completedAt).toISOString()}` : "",
-                        task.result ? `Result: ${task.result.slice(0, 500)}` : "",
-                        task.error ? `Error: ${task.error}` : "",
-                    ];
-                    return {
-                        content: [{ type: "text", text: lines.filter(Boolean).join("\n") }],
-                        details: { type: "task", action: "get", task },
-                    };
-                }
-                case "list": {
-                    const tasks = await deps.listTasks();
-                    if (tasks.length === 0) {
-                        return { content: [{ type: "text", text: "No tasks found." }] };
-                    }
-                    const lines = tasks.map(t => {
-                        const icon = t.status === "completed" ? "✅" :
-                            t.status === "running" ? "🔄" :
-                                t.status === "failed" ? "❌" :
-                                    t.status === "stopped" ? "⏹️" : "⏳";
-                        return `${icon} [${t.taskId}] ${t.description || "(no description)"} — ${t.status}`;
-                    });
-                    return {
-                        content: [{ type: "text", text: `Tasks (${tasks.length}):\n${lines.join("\n")}` }],
-                        details: { type: "task", action: "list", count: tasks.length },
-                    };
-                }
-                case "output": {
-                    if (!params.taskId) {
-                        return { content: [{ type: "text", text: "Error: 'taskId' is required for output." }] };
-                    }
-                    const output = await deps.getTaskOutput(params.taskId, params.maxLines ?? DEFAULT_MAX_LINES);
-                    return {
-                        content: [{ type: "text", text: output || "(no output yet)" }],
-                        details: { type: "task", action: "output", taskId: params.taskId },
-                    };
-                }
-                case "stop": {
-                    if (!params.taskId) {
-                        return { content: [{ type: "text", text: "Error: 'taskId' is required for stop." }] };
-                    }
-                    const stopped = await deps.stopTask(params.taskId);
-                    return {
-                        content: [{ type: "text", text: stopped ? `Task ${params.taskId} stopped.` : `Failed to stop task ${params.taskId} (may already be completed).` }],
-                        details: { type: "task", action: "stop", taskId: params.taskId, stopped },
-                    };
-                }
-                default:
-                    return { content: [{ type: "text", text: `Error: unknown action "${params.action}". Use: create/get/list/output/stop.` }] };
-            }
-        },
-    };
-}

package/dist/skills/tools/team-tool.d.ts

@@ -1,89 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const TEAM_TOOL_NAME: "team";
-export type TeamAction = "create" | "delete" | "list" | "status";
-export interface TeamMember {
-    name: string;
-    role: string;
-    tools?: string[];
-}
-export interface TeamToolParams {
-    action: TeamAction;
-    /** Team name (required for create/delete) */
-    teamName?: string;
-    /** Team description */
-    description?: string;
-    /** Members to include (for create) */
-    members?: TeamMember[];
-}
-export declare const TEAM_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["create", "delete", "list", "status"];
-            readonly description: "Team action: create (new team), delete (disband), list (all teams), status (team details).";
-        };
-        readonly teamName: {
-            readonly type: "string";
-            readonly description: "Team name. Required for create/delete/status.";
-        };
-        readonly description: {
-            readonly type: "string";
-            readonly description: "Team description/objective. Used for create.";
-        };
-        readonly members: {
-            readonly type: "array";
-            readonly description: "Team members with roles and tool restrictions.";
-            readonly items: {
-                readonly type: "object";
-                readonly properties: {
-                    readonly name: {
-                        readonly type: "string";
-                        readonly description: "Agent name/role identifier.";
-                    };
-                    readonly role: {
-                        readonly type: "string";
-                        readonly description: "Role description (e.g. 'frontend developer').";
-                    };
-                    readonly tools: {
-                        readonly type: "array";
-                        readonly items: {
-                            readonly type: "string";
-                        };
-                        readonly description: "Allowed tools for this member.";
-                    };
-                };
-                readonly required: readonly ["name", "role"];
-            };
-        };
-    };
-    readonly required: readonly ["action"];
-};
-export interface Team {
-    name: string;
-    description?: string;
-    leadId: string;
-    members: TeamMember[];
-    createdAt: string;
-}
-export interface TeamResult {
-    success: boolean;
-    team?: Team;
-    teams?: Team[];
-    error?: string;
-}
-/**
- * Host-provided team management backend.
- * Creates agent teams where members coordinate via send_message.
- */
-export interface TeamToolDeps {
-    createTeam(params: {
-        teamName: string;
-        description?: string;
-        members?: TeamMember[];
-    }): Promise<TeamResult>;
-    deleteTeam(teamName: string): Promise<TeamResult>;
-    listTeams(): Promise<TeamResult>;
-    getTeamStatus(teamName: string): Promise<TeamResult>;
-}
-export declare function createTeamTool(deps: TeamToolDeps): PortableTool<TeamToolParams>;

package/dist/skills/tools/team-tool.js

@@ -1,105 +0,0 @@
-// ============================================================
-// Team Tool — create and manage multi-agent teams (Swarm).
-// Reference: claude-code-haha/src/tools/TeamCreateTool/TeamCreateTool.ts
-//            claude-code-haha/src/tools/TeamDeleteTool/TeamDeleteTool.ts
-// Category: system
-// ============================================================
-export const TEAM_TOOL_NAME = "team";
-export const TEAM_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["create", "delete", "list", "status"],
-            description: "Team action: create (new team), delete (disband), list (all teams), status (team details).",
-        },
-        teamName: {
-            type: "string",
-            description: "Team name. Required for create/delete/status.",
-        },
-        description: {
-            type: "string",
-            description: "Team description/objective. Used for create.",
-        },
-        members: {
-            type: "array",
-            description: "Team members with roles and tool restrictions.",
-            items: {
-                type: "object",
-                properties: {
-                    name: { type: "string", description: "Agent name/role identifier." },
-                    role: { type: "string", description: "Role description (e.g. 'frontend developer')." },
-                    tools: { type: "array", items: { type: "string" }, description: "Allowed tools for this member." },
-                },
-                required: ["name", "role"],
-            },
-        },
-    },
-    required: ["action"],
-};
-export function createTeamTool(deps) {
-    return {
-        name: TEAM_TOOL_NAME,
-        label: "Team",
-        description: "Manage multi-agent teams. Create teams of specialized agents that collaborate via send_message. " +
-            "Each member has a role and optional tool restrictions. Use for complex tasks requiring parallel work.",
-        parameters: TEAM_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "create": {
-                    if (!params.teamName) {
-                        return { content: [{ type: "text", text: "Error: teamName required for create." }], details: { type: "team", error: "missing_name" } };
-                    }
-                    const r = await deps.createTeam({ teamName: params.teamName, description: params.description, members: params.members });
-                    if (!r.success) {
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "team", error: r.error } };
-                    }
-                    const lines = [`Team "${r.team.name}" created.`, `Lead: ${r.team.leadId}`, `Members: ${r.team.members.length}`];
-                    for (const m of r.team.members) {
-                        lines.push(`  - ${m.name} (${m.role})`);
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "team", action: "create", teamName: r.team.name } };
-                }
-                case "delete": {
-                    if (!params.teamName) {
-                        return { content: [{ type: "text", text: "Error: teamName required for delete." }], details: { type: "team", error: "missing_name" } };
-                    }
-                    const r = await deps.deleteTeam(params.teamName);
-                    if (!r.success) {
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "team", error: r.error } };
-                    }
-                    return { content: [{ type: "text", text: `Team "${params.teamName}" disbanded.` }], details: { type: "team", action: "delete", teamName: params.teamName } };
-                }
-                case "list": {
-                    const r = await deps.listTeams();
-                    if (!r.teams || r.teams.length === 0) {
-                        return { content: [{ type: "text", text: "No active teams." }], details: { type: "team", action: "list", count: 0 } };
-                    }
-                    const lines = [`Active teams (${r.teams.length}):`, ""];
-                    for (const t of r.teams) {
-                        lines.push(`- **${t.name}**: ${t.description || "(no description)"} — ${t.members.length} members`);
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "team", action: "list", count: r.teams.length } };
-                }
-                case "status": {
-                    if (!params.teamName) {
-                        return { content: [{ type: "text", text: "Error: teamName required for status." }], details: { type: "team", error: "missing_name" } };
-                    }
-                    const r = await deps.getTeamStatus(params.teamName);
-                    if (!r.success) {
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "team", error: r.error } };
-                    }
-                    const t = r.team;
-                    const lines = [`Team: ${t.name}`, `Description: ${t.description || "—"}`, `Lead: ${t.leadId}`, `Created: ${t.createdAt}`, "", `Members (${t.members.length}):`];
-                    for (const m of t.members) {
-                        const tools = m.tools ? ` [tools: ${m.tools.join(", ")}]` : "";
-                        lines.push(`  - ${m.name} (${m.role})${tools}`);
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "team", action: "status", teamName: t.name } };
-                }
-                default:
-                    return { content: [{ type: "text", text: `Error: unknown action "${params.action}".` }], details: { type: "team", error: "unknown_action" } };
-            }
-        },
-    };
-}

package/dist/skills/tools/tool-search-tool.d.ts

@@ -1,51 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const TOOL_SEARCH_TOOL_NAME: "tool_search";
-export interface ToolSearchToolParams {
-    query: string;
-    maxResults?: number;
-}
-export declare const TOOL_SEARCH_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly query: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly maxResults: {
-            readonly type: "number";
-            readonly description: "Maximum number of results to return (default: 5).";
-        };
-    };
-    readonly required: readonly ["query"];
-};
-export interface DeferredToolInfo {
-    name: string;
-    description: string;
-    /** Optional search hint for better discovery */
-    searchHint?: string;
-}
-export interface ToolSearchOutput {
-    matches: DeferredToolInfo[];
-    query: string;
-    totalDeferred: number;
-}
-/**
- * Host-provided deferred tool registry.
- * The host manages which tools are loaded vs deferred,
- * and handles activation when selected.
- */
-export interface ToolSearchToolDeps {
-    /**
-     * Search deferred tools by query.
-     * Supports "select:name" for direct activation and keyword search.
-     */
-    searchTools(query: string, options?: {
-        maxResults?: number;
-    }): Promise<ToolSearchOutput>;
-    /**
-     * Activate a deferred tool so it appears in subsequent turns.
-     * Returns true if activation succeeded.
-     */
-    activateTool?(name: string): Promise<boolean>;
-}
-export declare function createToolSearchTool(deps: ToolSearchToolDeps): PortableTool<ToolSearchToolParams>;

package/dist/skills/tools/tool-search-tool.js

@@ -1,110 +0,0 @@
-// ============================================================
-// Tool Search Tool — discover deferred/hidden tools by keyword.
-// Reference: claude-code-haha/src/tools/ToolSearchTool/ToolSearchTool.ts
-// Category: system
-// ============================================================
-export const TOOL_SEARCH_TOOL_NAME = "tool_search";
-export const TOOL_SEARCH_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        query: {
-            type: "string",
-            description: 'Search query for tools. Use "select:toolName" to directly activate a deferred tool, ' +
-                "or provide keywords to search tool names/descriptions. " +
-                'Prefix a term with "+" to mark it as required (all +terms must match).',
-        },
-        maxResults: {
-            type: "number",
-            description: "Maximum number of results to return (default: 5).",
-        },
-    },
-    required: ["query"],
-};
-const DEFAULT_MAX_RESULTS = 5;
-export function createToolSearchTool(deps) {
-    return {
-        name: TOOL_SEARCH_TOOL_NAME,
-        label: "Tool Search",
-        description: "Search for available tools that are not currently loaded. " +
-            "Many tools are deferred to save context tokens. " +
-            'Use "select:toolName" to directly activate a tool, ' +
-            "or provide keywords to find relevant tools. " +
-            "Activated tools become available in subsequent messages.",
-        parameters: TOOL_SEARCH_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            if (!params.query || params.query.trim().length === 0) {
-                return {
-                    content: [{ type: "text", text: "Error: query is required." }],
-                    details: { type: "tool_search", error: "empty_query" },
-                };
-            }
-            const query = params.query.trim();
-            const maxResults = params.maxResults ?? DEFAULT_MAX_RESULTS;
-            // Handle direct selection: "select:toolName" or "select:A,B,C"
-            if (query.startsWith("select:")) {
-                const names = query.slice(7).split(",").map((n) => n.trim()).filter(Boolean);
-                const activated = [];
-                const notFound = [];
-                if (deps.activateTool) {
-                    for (const name of names) {
-                        const ok = await deps.activateTool(name);
-                        if (ok)
-                            activated.push(name);
-                        else
-                            notFound.push(name);
-                    }
-                }
-                else {
-                    // No activation support — just search
-                    const result = await deps.searchTools(query, { maxResults });
-                    return formatSearchResult(result);
-                }
-                const parts = [];
-                if (activated.length > 0) {
-                    parts.push(`Activated: ${activated.join(", ")}. These tools are now available.`);
-                }
-                if (notFound.length > 0) {
-                    parts.push(`Not found: ${notFound.join(", ")}.`);
-                }
-                return {
-                    content: [{ type: "text", text: parts.join("\n") }],
-                    details: { type: "tool_search", activated, notFound, mode: "select" },
-                };
-            }
-            // Keyword search
-            const result = await deps.searchTools(query, { maxResults });
-            return formatSearchResult(result);
-        },
-    };
-}
-function formatSearchResult(result) {
-    if (result.matches.length === 0) {
-        return {
-            content: [{
-                    type: "text",
-                    text: `No tools found matching "${result.query}". ` +
-                        `Total deferred tools available: ${result.totalDeferred}.`,
-                }],
-            details: { type: "tool_search", query: result.query, matchCount: 0, totalDeferred: result.totalDeferred },
-        };
-    }
-    const lines = [
-        `Found ${result.matches.length} tool(s) matching "${result.query}" (${result.totalDeferred} total deferred):`,
-        "",
-    ];
-    for (const tool of result.matches) {
-        lines.push(`- **${tool.name}**: ${tool.description}`);
-    }
-    lines.push("");
-    lines.push('Use "select:toolName" to activate a tool for use in subsequent messages.');
-    return {
-        content: [{ type: "text", text: lines.join("\n") }],
-        details: {
-            type: "tool_search",
-            query: result.query,
-            matchCount: result.matches.length,
-            totalDeferred: result.totalDeferred,
-            matches: result.matches.map((m) => m.name),
-        },
-    };
-}

package/dist/skills/tools/tts-tool.d.ts

@@ -1,38 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const TTS_TOOL_NAME: "tts";
-export interface TtsToolParams {
-    text: string;
-    channel?: string;
-}
-export declare const TTS_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly text: {
-            readonly type: "string";
-            readonly description: "Text to convert to speech.";
-        };
-        readonly channel: {
-            readonly type: "string";
-            readonly description: "Optional channel id to pick output format (e.g. telegram).";
-        };
-    };
-    readonly required: readonly ["text"];
-};
-export interface TtsResult {
-    audioPath: string;
-    provider?: string;
-    voiceCompatible?: boolean;
-    mediaUrls: string[];
-}
-/** Deps injected by the host runtime for TTS. */
-export interface TtsToolDeps {
-    /**
-     * Convert text to speech via the configured backend.
-     * The host handles voice selection, format conversion, and storage.
-     */
-    textToSpeech(params: {
-        text: string;
-        channel?: string;
-    }): Promise<TtsResult>;
-}
-export declare function createTtsTool(deps: TtsToolDeps): PortableTool<TtsToolParams>;

package/dist/skills/tools/tts-tool.js

@@ -1,45 +0,0 @@
-// ============================================================
-// TTS Tool — text-to-speech via backend adapter.
-// Category: media
-// ============================================================
-export const TTS_TOOL_NAME = "tts";
-export const TTS_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        text: {
-            type: "string",
-            description: "Text to convert to speech.",
-        },
-        channel: {
-            type: "string",
-            description: "Optional channel id to pick output format (e.g. telegram).",
-        },
-    },
-    required: ["text"],
-};
-export function createTtsTool(deps) {
-    return {
-        name: TTS_TOOL_NAME,
-        label: "TTS",
-        description: "Convert text to speech (TTS) — read text aloud as spoken audio. " +
-            "Use for narration, voice messages, or any spoken-word output. " +
-            "DO NOT use for music, songs, or melodies — use music_generate instead.",
-        parameters: TTS_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const result = await deps.textToSpeech({
-                text: params.text,
-                channel: params.channel,
-            });
-            return {
-                content: [{ type: "text", text: "已成功生成语音。" }],
-                details: {
-                    type: "tts",
-                    audioPath: result.audioPath,
-                    provider: result.provider,
-                    voiceCompatible: result.voiceCompatible,
-                    mediaUrls: result.mediaUrls,
-                },
-            };
-        },
-    };
-}

package/dist/skills/tools/video-edit-tool.d.ts

@@ -1,69 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const VIDEO_EDIT_TOOL_NAME: "video_edit";
-export interface VideoEditToolParams {
-    prompt: string;
-    source_videos: string[];
-    reference_images?: string[];
-    duration?: number;
-    aspect_ratio?: string;
-    resolution?: string;
-}
-export declare const VIDEO_EDIT_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly prompt: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly source_videos: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-            readonly minItems: 1;
-            readonly maxItems: 3;
-            readonly description: "Video(s) to edit (1-3 URLs). Order: [0]=视频1, [1]=视频2, [2]=视频3.";
-        };
-        readonly reference_images: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-            readonly description: "Optional reference images for element replacement (up to 9).";
-        };
-        readonly duration: {
-            readonly type: "number";
-            readonly description: "Output duration in seconds (4-15s). Default: same as source.";
-        };
-        readonly aspect_ratio: {
-            readonly type: "string";
-            readonly description: "Output aspect ratio: 16:9, 9:16, 1:1, 4:3, 3:4, 21:9. Default: same as source.";
-        };
-        readonly resolution: {
-            readonly type: "string";
-            readonly description: "Output resolution: '480p' or '720p'. Default: '720p'.";
-        };
-    };
-    readonly required: readonly ["prompt", "source_videos"];
-};
-export interface VideoEditResult {
-    mediaUrls: string[];
-    model?: string;
-    durationMs?: number;
-}
-/** Deps injected by the host runtime for video editing. */
-export interface VideoEditToolDeps {
-    /**
-     * Edit a video via the configured backend (Seedance 2.0, etc.).
-     * The host handles URL resolution, model routing, and storage.
-     */
-    editVideo(params: {
-        prompt: string;
-        sourceVideos: string[];
-        referenceImages?: string[];
-        duration?: number;
-        aspectRatio?: string;
-        resolution?: string;
-    }): Promise<VideoEditResult>;
-}
-export declare function createVideoEditTool(deps: VideoEditToolDeps): PortableTool<VideoEditToolParams>;