@nodetool-ai/base-nodes 0.7.0-rc.23 → 0.8.2

package/dist/nodes/tool-agents.js

@@ -1,1861 +0,0 @@
-/**
- * Tool-agent nodes for prompt-driven task execution.
- *
- * Each agent node runs an agent loop: the LLM can call tools (execute_bash,
- * set_output_image, etc.), see results, and iterate until it produces output.
- * Uses runAgentLoop() from agents.ts for the loop mechanics.
- */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { BaseNode, prop } from "@nodetool-ai/node-sdk";
-import { runAgentLoop } from "./agents.js";
-import { exec } from "node:child_process";
-import { access, mkdir, readFile } from "node:fs/promises";
-import path from "node:path";
-import { tmpdir } from "node:os";
-import { pathToFileURL } from "node:url";
-// ---------------------------------------------------------------------------
-// Secret / key resolution helpers
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// Asset extraction helpers
-// ---------------------------------------------------------------------------
-function isAssetRef(v) {
-    if (!v || typeof v !== "object" || Array.isArray(v))
-        return false;
-    const obj = v;
-    // Match objects with explicit type field (ImageRef from UI properties)
-    // OR objects with data/uri but no type (imageRef() output from upstream nodes)
-    const hasType = typeof obj.type === "string" && obj.type.length > 0;
-    const hasData = obj.data != null;
-    const hasUri = typeof obj.uri === "string" && obj.uri.length > 0;
-    return (hasType && (hasUri || hasData)) || (!hasType && (hasData || hasUri));
-}
-/** Infer the asset kind from type field, field name context, uri, or mimeType. */
-function inferAssetKind(asset, fieldHint) {
-    // Check explicit type field
-    const t = (asset.type || "").toLowerCase();
-    if (t.includes("image"))
-        return "image";
-    if (t.includes("audio"))
-        return "audio";
-    if (t.includes("video"))
-        return "video";
-    // Check mimeType field (set by image nodes)
-    const mime = String(asset.mimeType ?? "").toLowerCase();
-    if (mime.startsWith("image/"))
-        return "image";
-    if (mime.startsWith("audio/"))
-        return "audio";
-    if (mime.startsWith("video/"))
-        return "video";
-    // Check URI extension
-    const uri = (asset.uri ?? "").toLowerCase();
-    if (/\.(png|jpe?g|gif|webp|bmp|tiff?|svg)(\?|$)/.test(uri))
-        return "image";
-    if (/\.(wav|mp3|flac|ogg|aac|m4a)(\?|$)/.test(uri))
-        return "audio";
-    if (/\.(mp4|mov|avi|mkv|webm)(\?|$)/.test(uri))
-        return "video";
-    // Fall back to field name hint
-    if (fieldHint) {
-        const h = fieldHint.toLowerCase();
-        if (h.includes("image"))
-            return "image";
-        if (h.includes("audio"))
-            return "audio";
-        if (h.includes("video"))
-            return "video";
-    }
-    return "unknown";
-}
-function guessMime(asset, fieldHint) {
-    // Use explicit mimeType if present
-    const explicit = String(asset.mimeType ?? "").trim();
-    if (explicit && explicit.includes("/"))
-        return explicit;
-    const kind = inferAssetKind(asset, fieldHint);
-    if (kind === "image")
-        return "image/png";
-    if (kind === "audio")
-        return "audio/wav";
-    if (kind === "video")
-        return "video/mp4";
-    return "application/octet-stream";
-}
-/** Read asset bytes from inline data, data: URI, file:// URI, or storage. */
-async function getAssetBytes(asset, context) {
-    // Inline base64 data (string or Uint8Array)
-    if (asset.data) {
-        if (asset.data instanceof Uint8Array)
-            return asset.data;
-        if (typeof asset.data === "string" && asset.data.length > 0) {
-            // Handle data: URI format
-            const dataUriMatch = asset.data.match(/^data:[^;]*;base64,(.+)$/s);
-            if (dataUriMatch) {
-                return Buffer.from(dataUriMatch[1], "base64");
-            }
-            // Plain base64 string
-            try {
-                return Buffer.from(asset.data, "base64");
-            }
-            catch {
-                /* fall through */
-            }
-        }
-    }
-    // Handle data: URIs in the uri field
-    if (asset.uri) {
-        const uriDataMatch = asset.uri.match(/^data:[^;]*;base64,(.+)$/s);
-        if (uriDataMatch) {
-            return Buffer.from(uriDataMatch[1], "base64");
-        }
-        // Handle file:// URIs directly (no storage adapter needed)
-        if (asset.uri.startsWith("file://")) {
-            try {
-                const { readFile } = await import("node:fs/promises");
-                const { fileURLToPath } = await import("node:url");
-                const filePath = fileURLToPath(asset.uri);
-                return await readFile(filePath);
-            }
-            catch {
-                /* fall through */
-            }
-        }
-        // Handle /api/storage/ paths — resolve to local asset files on disk
-        if (asset.uri.startsWith("/api/storage/")) {
-            try {
-                const { getDefaultAssetsPath } = await import("@nodetool-ai/config");
-                const isTemp = asset.uri.startsWith("/api/storage/temp/");
-                const key = isTemp
-                    ? asset.uri.slice("/api/storage/temp/".length)
-                    : asset.uri.slice("/api/storage/".length);
-                const rootDir = isTemp
-                    ? (process.env.TEMP_STORAGE_PATH ??
-                        path.join(tmpdir(), "nodetool", "temp"))
-                    : getDefaultAssetsPath();
-                return await readFile(path.join(rootDir, key));
-            }
-            catch {
-                /* fall through */
-            }
-        }
-        // Fetch from https:// URLs
-        if (asset.uri.startsWith("https://")) {
-            try {
-                const res = await fetch(asset.uri);
-                if (res.ok)
-                    return new Uint8Array(await res.arrayBuffer());
-            }
-            catch {
-                /* fall through */
-            }
-        }
-    }
-    // Load from storage via URI (if storage adapter available)
-    if (asset.uri && context?.storage) {
-        try {
-            return await context.storage.retrieve(asset.uri);
-        }
-        catch {
-            /* fall through */
-        }
-    }
-    return null;
-}
-/**
- * Collect all asset refs from known fields on the node instance.
- */
-function collectAssets(self) {
-    const assets = [];
-    const assetFields = [
-        "image",
-        "audio",
-        "video",
-        "document",
-        "images",
-        "audios",
-        "videos",
-        "documents"
-    ];
-    for (const field of assetFields) {
-        const val = self[field];
-        if (!val)
-            continue;
-        if (Array.isArray(val)) {
-            for (const item of val) {
-                if (isAssetRef(item))
-                    assets.push(item);
-            }
-        }
-        else if (isAssetRef(val)) {
-            assets.push(val);
-        }
-    }
-    return assets;
-}
-/** Build multimodal content parts from assets. */
-async function buildAssetContentParts(assets, context, fieldHint) {
-    const parts = [];
-    for (const asset of assets) {
-        const bytes = await getAssetBytes(asset, context);
-        if (!bytes || bytes.length === 0)
-            continue;
-        const kind = inferAssetKind(asset, fieldHint);
-        const mime = guessMime(asset, fieldHint);
-        const base64 = Buffer.from(bytes).toString("base64");
-        if (kind === "image" || kind === "unknown") {
-            // Default unknown assets to image (most common multimodal case)
-            parts.push({
-                type: "image",
-                image: {
-                    data: base64,
-                    mimeType: mime === "application/octet-stream" ? "image/png" : mime
-                }
-            });
-        }
-        else if (kind === "audio") {
-            parts.push({ type: "audio", audio: { data: base64, mimeType: mime } });
-        }
-        // Video and document are described in text rather than sent as content
-    }
-    return parts;
-}
-// ---------------------------------------------------------------------------
-// Tool factories for skill agent loop
-// ---------------------------------------------------------------------------
-export function makeExecuteBashTool(workspaceDir, timeoutMs = 120_000) {
-    return {
-        name: "execute_bash",
-        description: "Execute a bash command in the workspace directory.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                command: { type: "string", description: "Bash command to execute" }
-            },
-            required: ["command"]
-        },
-        process: async (_context, params) => {
-            const command = String(params.command ?? "");
-            if (!command)
-                return { success: false, error: "No command provided" };
-            return new Promise((resolve) => {
-                exec(command, {
-                    cwd: workspaceDir,
-                    timeout: timeoutMs,
-                    maxBuffer: 10 * 1024 * 1024
-                }, (error, stdout, stderr) => {
-                    resolve({
-                        success: !error,
-                        stdout: stdout ?? "",
-                        stderr: stderr ?? "",
-                        ...(error ? { error: error.message } : {})
-                    });
-                });
-            });
-        }
-    };
-}
-export function makeSetOutputTool(toolName, description, outputSink, workspaceDir) {
-    return {
-        name: toolName,
-        description,
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Workspace-relative path to the output file."
-                }
-            },
-            required: ["path"]
-        },
-        process: async (_context, params) => {
-            const relPath = String(params.path ?? "");
-            if (!relPath)
-                return { success: false, error: "No path provided" };
-            const absPath = path.resolve(workspaceDir, relPath);
-            if (!absPath.startsWith(path.resolve(workspaceDir) + path.sep) &&
-                absPath !== path.resolve(workspaceDir)) {
-                return { success: false, error: "Path is outside workspace directory" };
-            }
-            try {
-                await access(absPath);
-            }
-            catch {
-                return { success: false, error: `File not found: ${relPath}` };
-            }
-            outputSink.push(relPath);
-            return { success: true, path: relPath };
-        }
-    };
-}
-// ---------------------------------------------------------------------------
-// Base tool-agent node
-// ---------------------------------------------------------------------------
-class ToolAgentNode extends BaseNode {
-    static description = "Base tool-agent node (not directly usable).";
-    /** Override in subclasses with the skill-specific system prompt. */
-    static _systemPrompt = "You are a helpful assistant. Complete the task described by the user.";
-    /** Override in subclasses to declare output sinks. Keys are output handle names, values are tool names. */
-    static _outputSinkConfig = {};
-    /** Transient storage for output paths set during agent loop. */
-    _outputSinks = {};
-    /** Build tools for the agent loop. Includes execute_bash + any output sink tools. */
-    getTools(workspaceDir) {
-        const tools = [
-            makeExecuteBashTool(workspaceDir, (this.timeout_seconds ?? 120) * 1000)
-        ];
-        const config = this.constructor._outputSinkConfig;
-        this._outputSinks = {};
-        for (const [outputName, toolName] of Object.entries(config)) {
-            const sink = [];
-            this._outputSinks[outputName] = sink;
-            tools.push(makeSetOutputTool(toolName, `Set the ${outputName} output file path.`, sink, workspaceDir));
-        }
-        return tools;
-    }
-    /** Read output sinks and load files as asset refs. */
-    async readOutputSinks(workspaceDir) {
-        const result = {};
-        for (const [outputName, sink] of Object.entries(this._outputSinks)) {
-            if (sink.length === 0)
-                continue;
-            const absPath = path.resolve(workspaceDir, sink[0]);
-            try {
-                const bytes = await readFile(absPath);
-                const base64 = Buffer.from(bytes).toString("base64");
-                result[outputName] = {
-                    type: outputName,
-                    data: base64,
-                    uri: pathToFileURL(absPath).toString()
-                };
-            }
-            catch {
-                // File doesn't exist or can't be read — skip
-            }
-        }
-        return result;
-    }
-    async process(context) {
-        const prompt = String(this.prompt ?? "").trim();
-        if (!prompt)
-            throw new Error("Prompt is required");
-        const model = (this.model ?? {});
-        const providerId = String(model.provider || "").toLowerCase();
-        const modelId = String(model.id || "");
-        if (!providerId || !modelId) {
-            throw new Error("Select a model for this skill.");
-        }
-        if (!context || typeof context.getProvider !== "function") {
-            throw new Error("Processing context with provider access is required");
-        }
-        // Determine workspace directory
-        const workspaceDir = context.workspaceDir ??
-            path.join(tmpdir(), `nodetool-skill-${Date.now()}`);
-        await mkdir(workspaceDir, { recursive: true });
-        // Collect multimodal asset inputs
-        const self = this;
-        const assets = collectAssets(self);
-        const assetParts = await buildAssetContentParts(assets, context, "image");
-        // Copy asset files into workspace so the agent can access them via bash
-        const { writeFile: writeFileAsync } = await import("node:fs/promises");
-        const workspaceFiles = [];
-        for (let i = 0; i < assets.length; i++) {
-            const bytes = await getAssetBytes(assets[i], context);
-            if (!bytes || bytes.length === 0)
-                continue;
-            const kind = inferAssetKind(assets[i], "image");
-            const mime = guessMime(assets[i], "image");
-            const ext = mime.split("/")[1]?.replace("jpeg", "jpg") ?? "bin";
-            const fileName = `input_${kind}_${i}.${ext}`;
-            await writeFileAsync(path.join(workspaceDir, fileName), bytes);
-            workspaceFiles.push(fileName);
-        }
-        // Build tools
-        const tools = this.getTools(workspaceDir);
-        // Convert skills-local MessageContentPart[] to runtime MessageContent[] format
-        const contentParts = assetParts.map((part) => {
-            if (part.type === "image") {
-                return {
-                    type: "image_url",
-                    image: { data: part.image.data, mimeType: part.image.mimeType }
-                };
-            }
-            if (part.type === "audio") {
-                return {
-                    type: "audio",
-                    audio: { data: part.audio.data, mimeType: part.audio.mimeType }
-                };
-            }
-            return { type: "text", text: part.text ?? "" };
-        });
-        // Augment prompt with workspace file info
-        let augmentedPrompt = prompt;
-        if (workspaceFiles.length > 0) {
-            augmentedPrompt += `\n\nInput files available in the workspace directory:\n${workspaceFiles.map((f) => `- ${f}`).join("\n")}`;
-        }
-        const systemPrompt = this.constructor
-            ._systemPrompt;
-        const { text } = await runAgentLoop({
-            context,
-            providerId,
-            modelId,
-            systemPrompt,
-            prompt: augmentedPrompt,
-            tools,
-            contentParts: contentParts.length > 0 ? contentParts : undefined,
-            maxTokens: 4096,
-            maxIterations: 10
-        });
-        return { text, ...(await this.readOutputSinks(workspaceDir)) };
-    }
-}
-// ---------------------------------------------------------------------------
-// ShellAgentSkill
-// ---------------------------------------------------------------------------
-export class ShellAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.ShellAgent";
-    static title = "Shell Agent";
-    static description = "Reusable prompt-driven skill backed by execute_bash.";
-    static metadataOutputTypes = {
-        text: "str"
-    };
-    static _systemPrompt = "You are a bounded workspace agent. Use execute_bash for concrete actions. " +
-        "Ground all claims in command output and keep results concise.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for task planning and execution reasoning."
-    })
-], ShellAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the requested task."
-    })
-], ShellAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], ShellAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], ShellAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// BrowserSkill
-// ---------------------------------------------------------------------------
-export class BrowserAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.BrowserAgent";
-    static title = "Browser Agent";
-    static description = "Prompt-driven browser skill with bounded tool validation and schema outputs.\n    Supports extraction and browser automation workflows.\n    skills, browser, scrape, extraction, automation";
-    static metadataOutputTypes = {
-        text: "str"
-    };
-    static _systemPrompt = "You are a browser automation and extraction agent using Playwright-backed browser tools. " +
-        "Use `browser` to fetch page content and metadata, `take_screenshot` for screenshots, " +
-        "and DOM tools (`dom_examine`, `dom_search`, `dom_extract`) for structured inspection. " +
-        "The `browser` tool returns JSON fields like `success`, `url`, `content`, `metadata`, or `error`. " +
-        "Do not browse search engine result pages directly; explain that direct SERP browsing is disabled.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for free-form browsing tasks."
-    })
-], BrowserAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt for browser navigation/extraction."
-    })
-], BrowserAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 150,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], BrowserAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], BrowserAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// SQLiteSkill
-// ---------------------------------------------------------------------------
-export class SQLiteAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.SQLiteAgent";
-    static title = "SQLite Agent";
-    static description = "Prompt-driven SQLite skill with guarded query execution.\n    skills, data, sqlite, query";
-    static metadataOutputTypes = {
-        text: "str",
-        json: "dict[str, any]",
-        dataframe: "dataframe"
-    };
-    static _systemPrompt = "You are a data analysis skill. Use tools to run queries and ground every " +
-        "answer in tool outputs. Keep answers concise and factual.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for optional agent reasoning over query results."
-    })
-], SQLiteAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt for data query/transform task."
-    })
-], SQLiteAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 120,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], SQLiteAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], SQLiteAgentNode.prototype, "max_output_chars", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "memory.db",
-        title: "Db Path",
-        description: "Path to SQLite database relative to workspace."
-    })
-], SQLiteAgentNode.prototype, "db_path", void 0);
-__decorate([
-    prop({
-        type: "bool",
-        default: false,
-        title: "Allow Mutation",
-        description: "Allow INSERT/UPDATE/DELETE/DDL statements when enabled."
-    })
-], SQLiteAgentNode.prototype, "allow_mutation", void 0);
-// ---------------------------------------------------------------------------
-// SupabaseSkill
-// ---------------------------------------------------------------------------
-export class SupabaseAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.SupabaseAgent";
-    static title = "Supabase Agent";
-    static description = "Prompt-driven Supabase skill with guarded SELECT execution.\n    skills, data, supabase, query";
-    static metadataOutputTypes = {
-        text: "str",
-        json: "dict[str, any]",
-        dataframe: "dataframe"
-    };
-    static _systemPrompt = "You are a data analysis skill. Use tools to run queries and ground every " +
-        "answer in tool outputs. Keep answers concise and factual.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for optional agent reasoning over query results."
-    })
-], SupabaseAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt for data query/transform task."
-    })
-], SupabaseAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 120,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], SupabaseAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], SupabaseAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// DocumentSkill
-// ---------------------------------------------------------------------------
-export class DocumentAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.DocumentAgent";
-    static title = "Document Agent";
-    static description = "Prompt-driven document skill for model-based document analysis.\n    skills, document, extraction, conversion, markdown";
-    static metadataOutputTypes = {
-        text: "str",
-        document: "document"
-    };
-    static _outputSinkConfig = { document: "set_output_document" };
-    static _systemPrompt = "You are a document skill. Use attached document/text inputs and return concise results.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for free-form document tasks."
-    })
-], DocumentAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the document task."
-    })
-], DocumentAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 120,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], DocumentAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 150000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], DocumentAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// DocxSkill
-// ---------------------------------------------------------------------------
-export class DocxAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.DocxAgent";
-    static title = "DOCX Agent";
-    static description = "Prompt-driven DOCX creation skill.\n    skills, docx, word, document creation, docx-js";
-    static metadataOutputTypes = {
-        document: "document",
-        text: "str"
-    };
-    static _outputSinkConfig = { document: "set_output_document" };
-    static _systemPrompt = "You are a DOCX creation specialist. This skill is creation-only.\n\n" +
-        "Scope:\n" +
-        "- Create new .docx files (reports, memos, letters, templates, styled docs).\n" +
-        "- Use docx-js (npm package `docx`) for document generation.\n" +
-        "- Do not perform editing/analysis of existing DOCX files in this skill.\n\n" +
-        "Execution policy:\n" +
-        "1) Use execute_bash for shell and Node.js commands.\n" +
-        "2) Keep outputs workspace-relative.\n" +
-        "3) Validate generated DOCX when feasible.\n" +
-        "4) Final step is mandatory: call set_output_document with output .docx path.\n\n" +
-        "Critical docx-js creation rules:\n" +
-        "- Set page size explicitly (docx-js defaults to A4).\n" +
-        "  US Letter: width 12240, height 15840 DXA with 1-inch margins (1440 DXA).\n" +
-        "- For landscape, pass portrait dimensions and set orientation LANDSCAPE (library swaps).\n" +
-        "- Override built-in heading style IDs exactly ('Heading1', 'Heading2', ...).\n" +
-        "- Include outlineLevel on heading paragraph styles for TOC support.\n" +
-        "- Never use '\\n' for line breaks; use separate Paragraph elements.\n" +
-        "- Never use unicode bullet characters directly; use numbering with LevelFormat.BULLET.\n" +
-        "- PageBreak must be inside a Paragraph.\n" +
-        "- ImageRun requires explicit type (png/jpg/jpeg/gif/bmp/svg).\n" +
-        "- Prefer WidthType.DXA for tables; do not use WidthType.PERCENTAGE.\n" +
-        "- Tables need dual widths: table columnWidths and matching cell widths.\n" +
-        "- Table width must equal sum(columnWidths).\n" +
-        "- Use ShadingType.CLEAR for table shading (not SOLID).\n" +
-        "- For TOC, headings should use HeadingLevel and headingStyleRange.\n" +
-        "- Use headers/footers and PageNumber for professional layouts.\n\n" +
-        "Recommended workflow:\n" +
-        "- Create JS script (for example scripts/build_docx.js) with `docx` imports.\n" +
-        "- Build Document with sections/styles/numbering/tables/images as requested.\n" +
-        "- Write output .docx to workspace path (for example out/document.docx).\n" +
-        "- Optionally validate with available validator command.\n" +
-        "- Call set_output_document with final .docx path.\n\n" +
-        "Output rules:\n" +
-        "- Keep response concise and include output path.\n" +
-        "- If no DOCX was produced, clearly explain why.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for DOCX creation planning and execution."
-    })
-], DocxAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing what DOCX to create."
-    })
-], DocxAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 300,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], DocxAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 220000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], DocxAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// EmailSkill
-// ---------------------------------------------------------------------------
-export class EmailAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.EmailAgent";
-    static title = "Email Agent";
-    static description = "Prompt-driven email skill for IMAP/SMTP and message processing tasks.\n    skills, email, imap, smtp, messaging";
-    static metadataOutputTypes = {
-        text: "str"
-    };
-    static _systemPrompt = "You are an email automation specialist. Use execute_bash for mailbox tasks " +
-        "(parse RFC822/EML, summarize threads, draft content, IMAP/SMTP workflows). " +
-        "Protect sensitive data and redact secrets or private message content unless requested. " +
-        "For outbound actions, clearly state recipients, subject, and intent before execution.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for task planning and execution reasoning."
-    })
-], EmailAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the requested task."
-    })
-], EmailAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], EmailAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], EmailAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// FfmpegSkill
-// ---------------------------------------------------------------------------
-export class FfmpegAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.FfmpegAgent";
-    static requiredRuntimes = ["ffmpeg"];
-    static title = "FFmpeg Agent";
-    static description = "Prompt-driven FFmpeg skill for audio/video editing, conversion, and packaging.\n    skills, ffmpeg, media, video, audio, transcode, remux";
-    static metadataOutputTypes = {
-        video: "video",
-        audio: "audio",
-        text: "str"
-    };
-    static _outputSinkConfig = {
-        audio: "set_output_audio",
-        video: "set_output_video"
-    };
-    static _systemPrompt = "You are an FFmpeg specialist skill for audio/video processing. " +
-        "Use attached media inputs when provided and return concise results.\n\n" +
-        "Execution rules:\n" +
-        "1) Use execute_bash for ffmpeg/ffprobe commands.\n" +
-        "2) Keep generated files under workspace-relative paths.\n" +
-        "3) Publish final outputs using set_output_audio and/or set_output_video.\n" +
-        "4) Explain failures clearly and include the exact command that failed.\n\n" +
-        "FFmpeg reference (https://ffmpeg.org/ffmpeg.html):\n" +
-        "- Canonical form: ffmpeg [global_options] {input_opts -i input}... {output_opts output}...\n" +
-        "- Option order matters; input options apply to next -i, output options to next output file.\n" +
-        "- Use explicit stream mapping for deterministic results: -map 0:v:0 -map 0:a:0.\n" +
-        "- Streamcopy/remux: -c copy for fast container changes with no re-encode.\n" +
-        "- Transcoding baseline: -c:v libx264 -preset medium -crf 23 -c:a aac -b:a 192k.\n" +
-        "- Video filters: -vf scale=1280:-2,fps=30,crop=...,pad=....\n" +
-        "- Audio filters: -af loudnorm,highpass=80,aresample=48000.\n" +
-        "- Multi-input graphs: use -filter_complex for concat, overlays, mixdown, subtitles burn-in.\n" +
-        "- Trimming: use -ss before -i for fast seek; use -ss/-to after -i for precise cut.\n" +
-        "- Subtitle handling: map subtitle streams when possible; burn in with subtitles=... when needed.\n" +
-        "- Metadata/chapters: -map_metadata, -map_chapters, -metadata key=value.\n" +
-        "- Overwrite behavior: -y overwrite, -n never overwrite.\n" +
-        "- Diagnostics: -hide_banner with -loglevel info|warning|error and optional -stats.\n\n" +
-        "Common recipes:\n" +
-        "- Remux: ffmpeg -i in.mkv -map 0 -c copy out.mp4\n" +
-        "- Normalize playback: ffmpeg -i in.ext -map 0:v:0 -map 0:a:0 -c:v libx264 -crf 23 -c:a aac -b:a 192k out.mp4\n" +
-        "- 720p derivative: ffmpeg -i in.ext -vf scale=1280:-2 -c:v libx264 -crf 23 -c:a copy out_720p.mp4\n" +
-        "- Clip segment: ffmpeg -ss 00:00:30 -to 00:01:00 -i in.ext -c copy clip.ext\n" +
-        "- Extract MP3: ffmpeg -i in.ext -vn -c:a libmp3lame -b:a 192k out.mp3\n" +
-        "- Burn subtitles: ffmpeg -i in.ext -vf subtitles=subs.srt -c:v libx264 -c:a copy out_subbed.mp4";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for media prompts."
-    })
-], FfmpegAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "Optional audio input for media reasoning tasks."
-    })
-], FfmpegAgentNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "Optional video input for media reasoning tasks."
-    })
-], FfmpegAgentNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt for media task execution."
-    })
-], FfmpegAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], FfmpegAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], FfmpegAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// FilesystemSkill
-// ---------------------------------------------------------------------------
-export class FilesystemAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.FilesystemAgent";
-    static title = "Filesystem Agent";
-    static description = "Prompt-driven filesystem skill for file inspection and transformations.\n    skills, filesystem, files, directories, io";
-    static metadataOutputTypes = {
-        text: "str"
-    };
-    static _systemPrompt = "You are a filesystem operations specialist constrained to the workspace. " +
-        "Use execute_bash for listing, searching, creating, moving, copying, and deleting files. " +
-        "Prefer reversible actions and confirm paths before mutating data. " +
-        "When changing files, summarize what changed and where.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for task planning and execution reasoning."
-    })
-], FilesystemAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the requested task."
-    })
-], FilesystemAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], FilesystemAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], FilesystemAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// GitSkill
-// ---------------------------------------------------------------------------
-export class GitAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.GitAgent";
-    static title = "Git Agent";
-    static description = "Prompt-driven Git skill for repository inspection and change management.\n    skills, git, repository, version-control";
-    static metadataOutputTypes = {
-        text: "str"
-    };
-    static _systemPrompt = "You are a Git workflow specialist. Use execute_bash for all repository actions. " +
-        "Prefer non-destructive commands (status, diff, log, branch, add, commit, fetch, pull). " +
-        "Do not run destructive history-rewriting commands unless explicitly requested. " +
-        "Report exact files, commit IDs, and branch names from command output.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for task planning and execution reasoning."
-    })
-], GitAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the requested task."
-    })
-], GitAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], GitAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], GitAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// HtmlSkill
-// ---------------------------------------------------------------------------
-export class HtmlAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.HtmlAgent";
-    static title = "HTML Agent";
-    static description = "Prompt-driven HTML creation skill.\n    skills, html, web, template, static-site";
-    static metadataOutputTypes = {
-        html: "html",
-        text: "str"
-    };
-    static _outputSinkConfig = { html: "set_output_html" };
-    static _systemPrompt = "You are an HTML creation specialist.\n\n" +
-        "Scope:\n" +
-        "- Create or generate HTML files and related inline CSS/JS when requested.\n" +
-        "- Use execute_bash for shell/file operations.\n" +
-        "- Keep output paths workspace-relative.\n" +
-        "- Final step is mandatory: call set_output_html with the final HTML file path.\n\n" +
-        "Authoring rules:\n" +
-        "- Produce valid UTF-8 HTML5 documents (`<!doctype html>`).\n" +
-        "- Include semantic structure (header/main/section/footer) when appropriate.\n" +
-        "- Prefer accessible markup (labels, alt text, heading hierarchy).\n" +
-        "- Keep JS/CSS straightforward unless the user asks for complexity.\n" +
-        "- If external dependencies are needed, explain them briefly.\n\n" +
-        "Output rules:\n" +
-        "- Keep response concise and include final save path.\n" +
-        "- If no HTML file was produced, clearly explain why.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for HTML generation planning/execution."
-    })
-], HtmlAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing HTML to create."
-    })
-], HtmlAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], HtmlAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], HtmlAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// HttpApiSkill
-// ---------------------------------------------------------------------------
-export class HttpApiAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.HttpApiAgent";
-    static title = "HTTP API Agent";
-    static description = "Prompt-driven HTTP API skill for calling REST/GraphQL endpoints.\n    skills, http, api, rest, graphql";
-    static metadataOutputTypes = {
-        text: "str"
-    };
-    static _systemPrompt = "You are an HTTP API integration specialist. " +
-        "You can use exactly one tool: `http_request`. " +
-        "Do not use shell commands or any non-HTTP tooling. " +
-        "Plan requests explicitly (method, URL, headers, query, body), " +
-        "call `http_request`, and ground conclusions in returned status/body. " +
-        "Treat secrets as sensitive and never echo tokens verbatim. " +
-        "If a request fails, explain the failure and propose the next request. " +
-        "Always return a final user-facing answer, not just tool dumps. " +
-        "Final response format: " +
-        "1) Direct answer in 1-3 sentences. " +
-        "2) Evidence: status code(s) and key response fields used. " +
-        "3) If unresolved, the exact missing data needed.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for API planning and response interpretation."
-    })
-], HttpApiAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the HTTP API task."
-    })
-], HttpApiAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], HttpApiAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], HttpApiAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// ImageSkill
-// ---------------------------------------------------------------------------
-export class ImageAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.ImageAgent";
-    static title = "Image Agent";
-    static description = "Prompt-driven image skill for model-based image reasoning.\n    skills, image, agent, transform, extraction";
-    static metadataOutputTypes = {
-        image: "image",
-        text: "str"
-    };
-    static _outputSinkConfig = { image: "set_output_image" };
-    static _systemPrompt = "You are an image skill. Use attached inputs and return concise results. " +
-        "Use execute_bash when shell-based processing is needed. " +
-        "When you create a final output image file, call set_output_image with that path.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for image prompts."
-    })
-], ImageAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "Optional image input for image reasoning tasks."
-    })
-], ImageAgentNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the image task."
-    })
-], ImageAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 90,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], ImageAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 120000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], ImageAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// MediaSkill
-// ---------------------------------------------------------------------------
-export class MediaAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.MediaAgent";
-    static title = "Media Agent";
-    static description = "Prompt-driven media skill for model-based audio/video reasoning.\n    skills, media, audio, video, agent";
-    static metadataOutputTypes = {
-        video: "video",
-        audio: "audio",
-        text: "str"
-    };
-    static _outputSinkConfig = {
-        audio: "set_output_audio",
-        video: "set_output_video"
-    };
-    static _systemPrompt = "You are a media skill for audio/video tasks. " +
-        "Use attached media inputs when provided and return concise results. " +
-        "Use execute_bash for shell-based operations. " +
-        "When you create final media files, call set_output_audio and/or " +
-        "set_output_video using workspace-relative paths.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for media prompts."
-    })
-], MediaAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "Optional audio input for media reasoning tasks."
-    })
-], MediaAgentNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "Optional video input for media reasoning tasks."
-    })
-], MediaAgentNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt for media task execution."
-    })
-], MediaAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], MediaAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], MediaAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// PdfLibSkill
-// ---------------------------------------------------------------------------
-export class PdfLibAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.PdfLibAgent";
-    static title = "PDF-lib Agent";
-    static description = "Prompt-driven PDF processing skill with pdf-lib and complementary tooling.\n    skills, pdf, pdf-lib, qpdf, poppler, pdfjs, pypdfium2";
-    static metadataOutputTypes = {
-        document: "document",
-        text: "str"
-    };
-    static _outputSinkConfig = { document: "set_output_document" };
-    static _systemPrompt = "You are a PDF processing specialist. Focus on robust, reproducible PDF workflows.\n\n" +
-        "Primary scope:\n" +
-        "- JavaScript pdf-lib for creating/modifying/splitting/merging PDFs.\n" +
-        "- Python ecosystem for extraction/analysis: pypdf, pdfplumber, pypdfium2, reportlab.\n" +
-        "- CLI tooling for performance/repair: poppler-utils (pdftotext/pdftoppm/pdfimages), qpdf.\n\n" +
-        "Execution policy:\n" +
-        "1) Use execute_bash for shell commands and script execution.\n" +
-        "2) Before running any Node script that imports pdf-lib, bootstrap dependency availability with:\n" +
-        "   npm -s ls pdf-lib >/dev/null 2>&1 || npm install --no-save pdf-lib\n" +
-        "   Then verify with: node -e \"require.resolve('pdf-lib')\".\n" +
-        "3) Keep all outputs workspace-relative.\n" +
-        "4) If you produce a final PDF file, call set_output_document with its path.\n" +
-        "5) For extraction-only requests, return concise text and artifact locations.\n" +
-        "6) Include exact commands/scripts used when reporting.\n\n" +
-        "Advanced PDF reference:\n" +
-        "- pypdfium2: fast rendering/text extraction.\n" +
-        "  Example render: page.render(scale=2.0).to_pil().save('page_1.png').\n" +
-        "  Example text: page.get_text().\n" +
-        "- pdf-lib (JS): PDFDocument.load/create, copyPages, addPage, drawText, drawRectangle, save.\n" +
-        "  Use Node scripts for merge/split/edit and form-safe updates.\n" +
-        "- @llamaindex/liteparse (JS): LiteParse class, parse() for text/OCR extraction with bounding boxes.\n" +
-        "- poppler-utils:\n" +
-        "  pdftotext -bbox-layout for coordinates;\n" +
-        "  pdftoppm for rasterization;\n" +
-        "  pdfimages -all for embedded image extraction.\n" +
-        "- qpdf:\n" +
-        "  --split-pages, --pages for page selection/merge;\n" +
-        "  --linearize and --optimize-level for optimization;\n" +
-        "  --check for validation and structure diagnostics.\n" +
-        "- pdfplumber: coordinate-aware extraction and table extraction tuning.\n" +
-        "- reportlab: structured PDF generation and styled tables.\n\n" +
-        "Performance and reliability guidelines:\n" +
-        "- For large PDFs, process pages/chunks instead of loading everything at once.\n" +
-        "- Prefer pdfimages for image extraction speed, pdftotext for plain text speed.\n" +
-        "- Use OCR fallback only for scanned/image PDFs.\n" +
-        "- Validate encrypted/corrupt files with qpdf before deep processing.\n\n" +
-        "Common command examples:\n" +
-        "- Text with coordinates: pdftotext -bbox-layout document.pdf output.xml\n" +
-        "- Render 300 DPI pages: pdftoppm -png -r 300 document.pdf out\n" +
-        "- Extract embedded images: pdfimages -all document.pdf images/img\n" +
-        "- Merge selected pages: qpdf --empty --pages a.pdf 1-3 b.pdf 2,4 -- merged.pdf\n" +
-        "- Linearize for web: qpdf --linearize input.pdf optimized.pdf\n" +
-        "- Check integrity: qpdf --check input.pdf\n\n" +
-        "Output rules:\n" +
-        "- Keep responses concise.\n" +
-        "- If a final PDF was produced, publish it with set_output_document.\n" +
-        "- If no PDF was produced, clearly explain why.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for PDF task planning and execution reasoning."
-    })
-], PdfLibAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "document",
-        default: {
-            type: "document",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Document",
-        description: "Optional PDF/document input for transformation or analysis."
-    })
-], PdfLibAgentNode.prototype, "document", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the PDF processing task."
-    })
-], PdfLibAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 300,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], PdfLibAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 220000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], PdfLibAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// PptxSkill
-// ---------------------------------------------------------------------------
-export class PptxAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.PptxAgent";
-    static title = "PPTX Agent";
-    static description = "Prompt-driven PowerPoint generation skill with PptxGenJS.\n    skills, pptx, powerpoint, pptxgenjs, slides";
-    static metadataOutputTypes = {
-        document: "document",
-        text: "str"
-    };
-    static _outputSinkConfig = { document: "set_output_document" };
-    static _systemPrompt = "You are a PptxGenJS specialist for creating and editing .pptx presentations.\n\n" +
-        "Execution policy:\n" +
-        "1) Use execute_bash to run Node.js scripts and shell commands.\n" +
-        "2) Keep outputs workspace-relative.\n" +
-        "3) If you produce a final PPTX, call set_output_document with its path.\n" +
-        "4) Return concise status and key file paths.\n\n" +
-        "PptxGenJS fundamentals:\n" +
-        "- Use fresh pptxgen() instance per presentation.\n" +
-        "- Common layouts: LAYOUT_16x9 (10x5.625), LAYOUT_16x10, LAYOUT_4x3, LAYOUT_WIDE.\n" +
-        "- Coordinates are inches.\n" +
-        "- Text supports rich runs, bullets, breakLine, align/valign, font styling.\n" +
-        "- Use charSpacing (not letterSpacing).\n" +
-        "- Use margin: 0 when precise alignment with shapes/icons is required.\n" +
-        "- Bullets: use bullet: true; never insert unicode bullet characters manually.\n" +
-        "- For multi-line runs in arrays, set breakLine: true between lines.\n" +
-        "- Avoid lineSpacing with bullets; prefer paraSpaceAfter.\n" +
-        "- Shapes/charts/tables/images are supported, including shadows and transparency.\n" +
-        "- Image sources: path/url/base64; use sizing contain/cover/crop patterns.\n" +
-        "- For crisp icons, render high-res SVG->PNG then place with addImage.\n" +
-        "- Slide masters can define reusable placeholders/background objects.\n\n" +
-        "Critical pitfalls to avoid:\n" +
-        "- NEVER include '#' in hex colors. Use 'FF0000', not '#FF0000'.\n" +
-        "- NEVER use 8-char hex for opacity in colors (e.g. 00000020). Use opacity field.\n" +
-        "- Shadow offset must be non-negative.\n" +
-        "- Do not reuse option objects across calls because PptxGenJS may mutate them.\n" +
-        "- Do not rely on RECTANGLE overlays to hide rounded corners on ROUNDED_RECTANGLE.\n\n" +
-        "Example baseline workflow:\n" +
-        "- Create script file (e.g. scripts/build_pptx.js) using pptxgenjs.\n" +
-        "- Add slides/text/shapes/tables/charts/images as requested.\n" +
-        "- pres.writeFile({ fileName: 'out/deck.pptx' }).\n" +
-        "- Call set_output_document with out/deck.pptx.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for PPTX planning and generation reasoning."
-    })
-], PptxAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "document",
-        default: {
-            type: "document",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Document",
-        description: "Optional source PPTX/document input."
-    })
-], PptxAgentNode.prototype, "document", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing PPTX task."
-    })
-], PptxAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 300,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], PptxAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 220000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], PptxAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// SpreadsheetSkill
-// ---------------------------------------------------------------------------
-export class SpreadsheetAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.SpreadsheetAgent";
-    static title = "Spreadsheet Agent";
-    static description = "Prompt-driven spreadsheet skill for CSV/XLSX processing.\n    skills, spreadsheet, csv, xlsx, tabular";
-    static metadataOutputTypes = {
-        text: "str"
-    };
-    static _systemPrompt = "You are a spreadsheet and tabular data specialist. Use execute_bash for transformations " +
-        "using tools like Python/pandas, csvkit, or shell utilities. Preserve data fidelity and " +
-        "call out schema/column assumptions before applying formulas or joins. " +
-        "Return concise summaries plus output file paths for generated tables.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for task planning and execution reasoning."
-    })
-], SpreadsheetAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the requested task."
-    })
-], SpreadsheetAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], SpreadsheetAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], SpreadsheetAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// VectorStoreSkill
-// ---------------------------------------------------------------------------
-export class VectorStoreAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.VectorStoreAgent";
-    static title = "Vector Store Agent";
-    static description = "Prompt-driven vector store skill for indexing and similarity search workflows.\n    skills, vectorstore, embeddings, rag, retrieval";
-    static metadataOutputTypes = {
-        text: "str"
-    };
-    static _systemPrompt = "You are a vector retrieval specialist. Use execute_bash to run embedding/indexing/search " +
-        "operations with local or remote vector stores. Be explicit about embedding model, chunking, " +
-        "distance metric, and top-k parameters. Ground retrieval quality claims in measurable outputs.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for task planning and execution reasoning."
-    })
-], VectorStoreAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing the requested task."
-    })
-], VectorStoreAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 180,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], VectorStoreAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], VectorStoreAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// YtDlpDownloaderSkill
-// ---------------------------------------------------------------------------
-export class YtDlpDownloaderAgentNode extends ToolAgentNode {
-    static nodeType = "nodetool.agents.YtDlpDownloaderAgent";
-    static title = "yt-dlp Downloader Agent";
-    static description = "Download videos from YouTube/Bilibili/Twitter and other sites via yt-dlp.\n    skills, media, yt-dlp, downloader, youtube, bilibili, twitter";
-    static metadataOutputTypes = {
-        video: "video",
-        text: "str"
-    };
-    static requiredRuntimes = ["yt-dlp", "ffmpeg"];
-    static _outputSinkConfig = { video: "set_output_video" };
-    static _systemPrompt = "You are yt-dlp-downloader.\n" +
-        "Goal: download web videos with yt-dlp and publish the resulting video file path.\n\n" +
-        "Workflow:\n" +
-        "1) Verify prerequisites with shell commands:\n" +
-        "   - which yt-dlp || echo 'yt-dlp not installed. Install with: pip install yt-dlp'\n" +
-        "   - which ffmpeg || echo 'ffmpeg not installed. Install with: brew install ffmpeg'\n" +
-        "2) If URL is YouTube, prefer --cookies-from-browser chrome to avoid 403.\n" +
-        "3) Build yt-dlp command matching request (download/extract/subtitles/quality).\n" +
-        "4) Use execute_bash for all commands.\n" +
-        "5) Handle failures:\n" +
-        "   - 403: retry with --cookies-from-browser chrome\n" +
-        "   - unavailable format: use -F, then choose a format id\n" +
-        "6) Final step is mandatory: call set_output_video with the final video file path.\n\n" +
-        "Scope boundary:\n" +
-        "- This skill is for yt-dlp downloading tasks only.\n" +
-        "- For standalone ffmpeg editing/transcoding workflows, use the dedicated FFmpeg Skill.\n\n" +
-        "Output rules:\n" +
-        "- Keep response concise and include final save location.\n" +
-        "- Always save outputs under workspace-relative output_dir.\n" +
-        "- If no video file is produced, clearly explain why.";
-}
-__decorate([
-    prop({
-        type: "language_model",
-        default: {
-            type: "language_model",
-            provider: "empty",
-            id: "",
-            name: "",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "Model used for yt-dlp planning and execution reasoning."
-    })
-], YtDlpDownloaderAgentNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Prompt describing what to download."
-    })
-], YtDlpDownloaderAgentNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Url",
-        description: "Optional explicit video URL to download."
-    })
-], YtDlpDownloaderAgentNode.prototype, "url", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "downloads/yt-dlp",
-        title: "Output Dir",
-        description: "Workspace-relative output directory for downloads."
-    })
-], YtDlpDownloaderAgentNode.prototype, "output_dir", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 300,
-        title: "Timeout Seconds",
-        description: "Maximum runtime for agent execution.",
-        min: 1,
-        max: 3600
-    })
-], YtDlpDownloaderAgentNode.prototype, "timeout_seconds", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 220000,
-        title: "Max Output Chars",
-        description: "Maximum serialized output chars before truncation.",
-        min: 1000,
-        max: 2000000
-    })
-], YtDlpDownloaderAgentNode.prototype, "max_output_chars", void 0);
-// ---------------------------------------------------------------------------
-// Export
-// ---------------------------------------------------------------------------
-export const TOOL_AGENT_NODES = [
-    ShellAgentNode,
-    BrowserAgentNode,
-    SQLiteAgentNode,
-    SupabaseAgentNode,
-    DocumentAgentNode,
-    DocxAgentNode,
-    EmailAgentNode,
-    FfmpegAgentNode,
-    FilesystemAgentNode,
-    GitAgentNode,
-    HtmlAgentNode,
-    HttpApiAgentNode,
-    ImageAgentNode,
-    MediaAgentNode,
-    PdfLibAgentNode,
-    PptxAgentNode,
-    SpreadsheetAgentNode,
-    VectorStoreAgentNode,
-    YtDlpDownloaderAgentNode
-];
-//# sourceMappingURL=tool-agents.js.map