autoclaw 1.3.5 → 1.3.7

package/dist/agent.js

@@ -9,6 +9,7 @@ import { getToolDefinitions, executeToolHandler, listUnavailableTools } from './
 import { withRetry } from './retry.js';
 import { truncateOutput } from './truncate.js';
 import { buildShellInfo, resolveShellType } from './shell.js';
+import { buildSkillsManifest } from './skills.js';
 const DEFAULT_MAX_STEPS = 25;
 const TOOL_RESULT_TRIM_MARKER = 'older tool output trimmed';
 // Canonical JSON: sorted object keys, so equivalent arguments from
@@ -73,6 +74,17 @@ System Information:
             has('optimize_prompt') ? '- Creation: optimize_prompt — refine raw prompts for creative/complex tasks (recommended before creative work)' : null,
             '- Utility: get_current_datetime — accurate system time for temporal reasoning'
         ].filter((line) => line !== null).join('\n');
+        // Skills ride along as one-line manifest entries; the body is only read
+        // (via read_file) when a task actually matches. Never break startup on
+        // a malformed skill directory.
+        let skillsManifest = null;
+        try {
+            skillsManifest = buildSkillsManifest(config);
+        }
+        catch {
+            skillsManifest = null;
+        }
+        const skillsBlock = skillsManifest ? `\n${skillsManifest}\n` : '';
         this.messages = [
             {
                 role: "system",
@@ -84,7 +96,7 @@ ${systemInfo}
 
 WHAT YOU CAN DO:
 ${capabilities}
-
+${skillsBlock}
 RULES OF ENGAGEMENT:
 1. One shot, not one chat. Produce working results, not conversation. Be terse.
 2. Use the right tool for the job. Shell for system ops. Files for content. Web tools for external info.

package/dist/index.js

@@ -8,6 +8,7 @@ import { parseManifest, runBatch } from './batch.js';
 import { PROVIDER_PRESETS, providerNames, resolveProvider } from './providers.js';
 import { fetchModelIds, normalizeBaseUrl, testConnection } from './setup.js';
 import { collectDoctorChecks } from './doctor.js';
+import { defaultSkillScopes, discoverSkills, installSkill, installSkillFromUrl, packSkill, removeSkill } from './skills.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -46,7 +47,7 @@ dotenv.config({ path: GLOBAL_ENV_FILE });
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // In dist/index.js, package.json is usually up one level in the root
 const pkgPath = path.join(__dirname, '..', 'package.json');
-let version = '1.3.5';
+let version = '1.3.6';
 try {
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
     version = pkg.version;
@@ -90,6 +91,79 @@ program
     const options = program.opts();
     await runBatchCommand(manifest, options, cmdOptions);
 });
+const skillCmd = program
+    .command('skill')
+    .description('Manage skill packages (SKILL.md format, WorkBuddy-store compatible)');
+skillCmd
+    .command('list')
+    .description('List discovered skills across builtin / user / project scopes')
+    .action(() => {
+    const { skills, warnings } = discoverSkills(defaultSkillScopes());
+    for (const w of warnings)
+        console.log(chalk.dim(`  ! ${w}`));
+    if (skills.length === 0) {
+        console.log('No skills found. Install one with: autoclaw skill install <zip-or-dir>');
+        return;
+    }
+    console.log(chalk.bold.cyan(`Skills (${skills.length}):\n`));
+    for (const s of skills) {
+        const desc = s.descriptionZh || s.descriptionEn || s.description;
+        console.log(`  ${chalk.bold(s.name)}${s.version ? chalk.dim(` v${s.version}`) : ''} ${chalk.dim(`[${s.source}]`)}`);
+        console.log(`    ${desc.replace(/\s+/g, ' ').slice(0, 100)}${desc.length > 100 ? '…' : ''}`);
+        console.log(`    ${chalk.dim(s.dir)}`);
+    }
+    console.log(chalk.dim('\nSkills run inside chat/batch automatically: the agent sees a skill list and reads a matched SKILL.md on demand.'));
+});
+skillCmd
+    .command('install <target>')
+    .description('Install a skill from an https .zip URL, a local .zip, or a directory (into ~/.autoclaw/skills/)')
+    .action(async (target) => {
+    try {
+        const result = /^https:\/\//.test(target)
+            ? await installSkillFromUrl(target)
+            : installSkill(target);
+        console.log(chalk.green(`Installed skill '${result.name}' (${result.files} files) -> ${result.dir}`));
+        console.log(chalk.dim('Verify with: autoclaw skill list'));
+    }
+    catch (err) {
+        console.error(chalk.red(`Error: ${err?.message || err}`));
+        process.exitCode = 1;
+    }
+});
+skillCmd
+    .command('remove <name>')
+    .description('Remove a user-installed skill (~/.autoclaw/skills/)')
+    .action((name) => {
+    const result = removeSkill(name);
+    if (result === 'removed')
+        console.log(chalk.green(`Removed skill '${name}'.`));
+    else if (result === 'builtin') {
+        console.error(chalk.red(`'${name}' is a built-in skill and cannot be removed.`));
+        process.exitCode = 1;
+    }
+    else if (result === 'project') {
+        console.error(chalk.red(`'${name}' lives in .autoclaw/skills/ — delete it manually.`));
+        process.exitCode = 1;
+    }
+    else {
+        console.error(chalk.red(`Skill '${name}' not found.`));
+        process.exitCode = 1;
+    }
+});
+skillCmd
+    .command('pack <dir>')
+    .description('Package a skill directory into a store-upload zip (skills/<name>/ at zip root)')
+    .option('-o, --output <file>', 'Output zip path (default: <name>-skill.zip in cwd)')
+    .action((dir, cmdOptions) => {
+    try {
+        const result = packSkill(dir, cmdOptions.output);
+        console.log(chalk.green(`Packed '${result.name}' (${result.fileCount} files) -> ${result.zipPath}`));
+    }
+    catch (err) {
+        console.error(chalk.red(`Error: ${err?.message || err}`));
+        process.exitCode = 1;
+    }
+});
 program
     .command('doctor')
     .description('Diagnose configuration and environment (headless)')

package/dist/skills.js

@@ -0,0 +1,278 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { createZip, readZip } from './zip.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Built-in skills ship with the package (dist/../skills); user + project
+// scopes shadow built-ins on name collisions (project > user > builtin).
+export function builtinSkillsDir() {
+    return path.resolve(__dirname, '..', 'skills');
+}
+export function defaultSkillScopes() {
+    return [
+        { dir: builtinSkillsDir(), source: 'builtin' },
+        { dir: path.join(os.homedir(), '.autoclaw', 'skills'), source: 'user' },
+        { dir: path.resolve(process.cwd(), '.autoclaw', 'skills'), source: 'project' },
+    ];
+}
+export function parseSkillMd(raw) {
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+    if (!match)
+        return null;
+    const frontmatter = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        if (!line.trim() || line.trim().startsWith('#'))
+            continue;
+        const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!kv)
+            continue;
+        let value = kv[2].trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        frontmatter[kv[1]] = value;
+    }
+    return { frontmatter, body: raw.slice(match[0].length) };
+}
+function toMeta(frontmatter, dir, source) {
+    const bool = (v) => v === 'true' ? true : v === 'false' ? false : undefined;
+    return {
+        name: frontmatter.name || path.basename(dir),
+        displayName: frontmatter.display_name,
+        description: frontmatter.description || frontmatter.description_zh || frontmatter.description_en || '',
+        descriptionZh: frontmatter.description_zh,
+        descriptionEn: frontmatter.description_en,
+        version: frontmatter.version,
+        author: frontmatter.author,
+        category: frontmatter.category,
+        disableModelInvocation: bool(frontmatter['disable-model-invocation']),
+        userInvocable: bool(frontmatter['user-invocable']),
+        source,
+        dir,
+        skillMdPath: path.join(dir, 'SKILL.md'),
+    };
+}
+// Later scopes win on name collisions. Dirs starting with '.' are skipped.
+export function discoverSkills(scopes) {
+    const warnings = [];
+    const byName = new Map();
+    for (const scope of scopes) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(scope.dir, { withFileTypes: true })
+                .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
+                .map(e => e.name);
+        }
+        catch { /* scope dir missing — fine */
+            continue;
+        }
+        for (const entry of entries) {
+            const dir = path.join(scope.dir, entry);
+            const skillMdPath = path.join(dir, 'SKILL.md');
+            let raw;
+            try {
+                raw = fs.readFileSync(skillMdPath, 'utf-8');
+            }
+            catch {
+                warnings.push(`skipped ${dir}: no SKILL.md`);
+                continue;
+            }
+            try {
+                const parsed = parseSkillMd(raw);
+                if (!parsed) {
+                    warnings.push(`skipped ${skillMdPath}: missing YAML frontmatter`);
+                    continue;
+                }
+                const meta = toMeta(parsed.frontmatter, dir, scope.source);
+                if (!meta.description) {
+                    warnings.push(`skipped ${skillMdPath}: empty description`);
+                    continue;
+                }
+                byName.set(meta.name, meta);
+            }
+            catch (err) {
+                warnings.push(`skipped ${skillMdPath}: ${err?.message || err}`);
+            }
+        }
+    }
+    return { skills: [...byName.values()], warnings };
+}
+// ---- system-prompt manifest (progressive disclosure: one line per skill) ----
+function truncate(text, max) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > max ? flat.slice(0, max - 1) + '…' : flat;
+}
+export function buildSkillsManifest(config, scopes) {
+    if (config?.skillsEnabled === false)
+        return null;
+    const { skills } = discoverSkills(scopes || defaultSkillScopes());
+    const visible = skills.filter(s => s.disableModelInvocation !== true);
+    if (visible.length === 0)
+        return null;
+    const lines = visible.map(s => `- ${s.name}${s.version ? ` (v${s.version})` : ''}: ${truncate(s.description, 400)} [read ${s.skillMdPath}]`);
+    return [
+        'INSTALLED SKILL PACKAGES (procedural capabilities bundling instructions, scripts and templates).',
+        'When a task matches a skill, first read its SKILL.md and follow it — skills run through your normal file and shell tools, no special API:',
+        ...lines,
+    ].join('\n');
+}
+// ---- install / remove ----
+const INSTALL_SKIP = new Set(['node_modules', '.git', '__MACOSX']);
+function isJunkPath(rel) {
+    return rel.split('/').some(s => INSTALL_SKIP.has(s)) || rel.split('/').pop() === '.DS_Store';
+}
+// Skill directory names come from untrusted frontmatter, so restrict to
+// letters (any script, e.g. Chinese), digits, dot, underscore, dash — no
+// separators, no leading dot (discovery skips dot-dirs), bounded length.
+function isSafeSkillName(name) {
+    return name.length <= 64 && /^[\p{L}\p{N}][\p{L}\p{N}._-]*$/u.test(name);
+}
+function copyTree(src, dest) {
+    let count = 0;
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        if (INSTALL_SKIP.has(entry.name) || entry.name === '.DS_Store')
+            continue;
+        const s = path.join(src, entry.name);
+        const d = path.join(dest, entry.name);
+        if (entry.isDirectory())
+            count += copyTree(s, d);
+        else if (entry.isFile()) {
+            fs.copyFileSync(s, d);
+            count++;
+        }
+    }
+    return count;
+}
+export function userSkillsDir() {
+    return path.join(os.homedir(), '.autoclaw', 'skills');
+}
+// Install from a skill directory, a zip package, or an https URL into the
+// user scope (~/.autoclaw/skills/). The installed directory is named after
+// the skill's frontmatter `name` (fallback: the folder/zip stem), so the
+// path always matches what discovery and the manifest expect.
+export function installSkill(target, opts) {
+    const userDir = opts?.userDir || userSkillsDir();
+    const stat = fs.existsSync(target) ? fs.statSync(target) : null;
+    if (!stat)
+        throw new Error(`target not found: ${target}`);
+    if (stat.isDirectory()) {
+        const skillMdPath = path.join(target, 'SKILL.md');
+        if (!fs.existsSync(skillMdPath))
+            throw new Error(`${target} is not a skill (no SKILL.md)`);
+        const parsed = parseSkillMd(fs.readFileSync(skillMdPath, 'utf-8'));
+        const name = pickSafeName(parsed?.frontmatter.name, path.basename(path.resolve(target)));
+        const dest = path.join(userDir, name);
+        const files = copyTree(target, dest);
+        return { name, dir: dest, files };
+    }
+    // zip package: locate the SKILL.md entry, rebase its dir to userDir/<name>.
+    // Works with third-party layouts: SKILL.md at the zip root, a plain folder,
+    // or a skills/<name>/ wrapper, independently of frontmatter-vs-folder naming.
+    const buf = fs.readFileSync(target);
+    const entries = readZip(buf).map(e => ({ ...e, path: e.path.replace(/\\/g, '/') }));
+    const candidates = entries
+        .filter(e => /(^|\/)SKILL\.md$/.test(e.path))
+        .sort((a, b) => a.path.split('/').length - b.path.split('/').length);
+    if (candidates.length === 0)
+        throw new Error('zip contains no SKILL.md — not a skill package');
+    const pick = candidates[0];
+    const rootDir = pick.path.split('/').slice(0, -1).join('/');
+    const parsed = parseSkillMd(pick.data.toString('utf-8'));
+    const fallback = rootDir ? rootDir.split('/').filter(Boolean).pop() : path.basename(target).replace(/\.zip$/i, '');
+    const name = pickSafeName(parsed?.frontmatter.name, fallback);
+    const prefix = rootDir ? rootDir + '/' : '';
+    const dest = path.join(userDir, name);
+    const destResolved = path.resolve(dest) + path.sep;
+    const wanted = entries
+        .filter(e => prefix ? e.path.startsWith(prefix) : true)
+        .map(e => ({ rel: prefix ? e.path.slice(prefix.length) : e.path, data: e.data }))
+        .filter(e => e.rel !== '' && !e.rel.endsWith('/') && !isJunkPath(e.rel));
+    // Validate every target path before writing anything: a hostile entry must
+    // reject the whole archive, not half-install it.
+    const targets = wanted.map(e => {
+        const destFile = path.resolve(dest, ...e.rel.split('/'));
+        if (!destFile.startsWith(destResolved))
+            throw new Error(`unsafe zip entry: ${e.rel}`);
+        return { destFile, data: e.data };
+    });
+    for (const t of targets) {
+        fs.mkdirSync(path.dirname(t.destFile), { recursive: true });
+        fs.writeFileSync(t.destFile, t.data);
+    }
+    return { name, dir: dest, files: targets.length };
+}
+function pickSafeName(primary, fallback) {
+    const candidate = primary && isSafeSkillName(primary) ? primary : fallback;
+    if (!isSafeSkillName(candidate)) {
+        throw new Error(`unsafe skill name: ${JSON.stringify(primary || fallback)}`);
+    }
+    return candidate;
+}
+// Download an https zip package to a temp file and install it.
+export async function installSkillFromUrl(url, opts) {
+    if (!/^https:\/\//.test(url))
+        throw new Error('only https URLs are supported');
+    const res = await fetch(url, { signal: AbortSignal.timeout(120000) });
+    if (!res.ok)
+        throw new Error(`download failed: HTTP ${res.status} for ${url}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    if (buf.length > 100 * 1024 * 1024)
+        throw new Error('skill package exceeds 100 MB limit');
+    const tmp = path.join(os.tmpdir(), `autoclaw-skill-${Date.now()}-${Math.random().toString(36).slice(2)}.zip`);
+    fs.writeFileSync(tmp, buf);
+    try {
+        return installSkill(tmp, opts);
+    }
+    finally {
+        fs.rmSync(tmp, { force: true });
+    }
+}
+export function removeSkill(name, opts) {
+    const scopes = opts?.scopes || defaultSkillScopes();
+    const { skills } = discoverSkills(scopes);
+    const skill = skills.find(s => s.name === name);
+    if (!skill)
+        return 'not-found';
+    if (skill.source === 'builtin')
+        return 'builtin';
+    if (skill.source === 'project')
+        return 'project';
+    const userDir = path.resolve(opts?.userDir || userSkillsDir());
+    const dir = path.resolve(skill.dir);
+    if (!dir.startsWith(userDir + path.sep))
+        return 'not-found'; // never delete outside the user scope
+    fs.rmSync(dir, { recursive: true, force: true });
+    return 'removed';
+}
+// ---- pack (store-upload artifact: SKILL.md sits at the zip root) ----
+export function packSkill(dir, outPath) {
+    const abs = path.resolve(dir);
+    const skillMdPath = path.join(abs, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath))
+        throw new Error(`${abs} is not a skill (no SKILL.md)`);
+    const parsed = parseSkillMd(fs.readFileSync(skillMdPath, 'utf-8'));
+    const name = parsed?.frontmatter.name || path.basename(abs);
+    if (!isSafeSkillName(name))
+        throw new Error(`unsafe skill name: ${name}`);
+    const version = parsed?.frontmatter.version;
+    const versionTag = version ? version.replace(/[^A-Za-z0-9._-]/g, '-') : undefined;
+    const files = [];
+    const walk = (current, rel) => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            if (INSTALL_SKIP.has(entry.name) || entry.name === '.DS_Store')
+                continue;
+            const child = path.join(current, entry.name);
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory())
+                walk(child, childRel);
+            else if (entry.isFile())
+                files.push({ path: childRel, data: fs.readFileSync(child) });
+        }
+    };
+    walk(abs, '');
+    const zipPath = outPath || path.resolve(process.cwd(), versionTag ? `${name}-skill-${versionTag}.zip` : `${name}-skill.zip`);
+    fs.writeFileSync(zipPath, createZip(files));
+    return { zipPath, fileCount: files.length, name, version };
+}

package/dist/tools/index.js

@@ -6,6 +6,8 @@ import { BrowserTool } from './browser.js';
 import { ScreenshotTool } from './screenshot.js';
 import { ImageTool } from './image.js';
 import { PromptOptimizerTool } from './prompt-optimizer.js';
+import { RenderImageTool } from './render-image.js';
+import { RenderPdfTool } from './render-pdf.js';
 import { CheckBackgroundProcessTool, StartBackgroundProcessTool, StopBackgroundProcessTool } from './background.js';
 // Central Registry of all available tools
 export const toolRegistry = [
@@ -20,6 +22,8 @@ export const toolRegistry = [
     BrowserTool,
     ScreenshotTool,
     ImageTool,
+    RenderImageTool,
+    RenderPdfTool,
     StartBackgroundProcessTool,
     CheckBackgroundProcessTool,
     StopBackgroundProcessTool

package/dist/tools/render-image.js

@@ -0,0 +1,135 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { render, renderSvg, renderAnimation } from 'takumi-js';
+import { resolveFontLoaders, describeFonts } from './takumi-fonts.js';
+const VALID_FORMATS = ['png', 'jpeg', 'webp', 'svg'];
+const VALID_ANIMATION_FORMATS = ['webp', 'gif', 'apng'];
+const toolDefinition = {
+    type: "function",
+    function: {
+        name: "render_image",
+        description: "Render an HTML template into a precise, deterministic image (PNG/JPEG/WebP), vector SVG, or animation (animated WebP/GIF/APNG from CSS @keyframes). Fully offline — no AI, no network, no browser, renders in milliseconds. Use this when exact text, layout, colors or data matter: OG/share cards, banners, badges, certificates, data cards, charts built from divs, simple motion graphics. Style with the 'tw' attribute (Tailwind v4 utilities, e.g. <div tw=\"w-full h-full bg-blue-500\">), inline styles, or a <style> block with regular CSS classes — Tailwind utilities placed in the class attribute are NOT compiled, always use tw for them. JavaScript is NOT executed; remote images in the template would require network. For artistic or photographic imagery use generate_image instead. CJK/emoji text needs fonts: common system fonts are auto-detected when font_paths is omitted, and registered families can be referenced via font-family.",
+        parameters: {
+            type: "object",
+            properties: {
+                template: {
+                    type: "string",
+                    description: "HTML fragment to render. Size the root to fill the canvas, e.g. '<div tw=\"w-full h-full flex flex-col items-center justify-center bg-linear-to-br from-blue-600 to-indigo-900 p-12\"><h1 tw=\"text-6xl font-bold text-white\">Monthly Report</h1></div>'. Style via the tw attribute (canonical Tailwind v4 names only — v3 names like bg-gradient-to-* are not supported, use bg-linear-to-*), inline styles, or a <style> block; a plain class attribute only matches CSS selectors, not Tailwind utilities."
+                },
+                css: {
+                    type: "string",
+                    description: "Optional CSS stylesheet applied before rendering, e.g. 'h1 { letter-spacing: 2px; }'."
+                },
+                width: {
+                    type: "integer",
+                    description: "Canvas width in px. Default 1200."
+                },
+                height: {
+                    type: "integer",
+                    description: "Canvas height in px. Default 630 (standard OG-image size)."
+                },
+                format: {
+                    type: "string",
+                    enum: VALID_FORMATS,
+                    description: "Output format. Default 'png'. 'svg' produces a vector document instead of a bitmap. Ignored when 'animation' is set."
+                },
+                animation: {
+                    type: "object",
+                    description: "Render an animated image instead of a static one: CSS @keyframes in the template (via a <style> block or the animation shorthand) are sampled across the scene duration. When set, 'format' is ignored — the container format comes from animation.format.",
+                    properties: {
+                        duration_ms: { type: "integer", description: "Scene duration in milliseconds. Default 1000." },
+                        fps: { type: "integer", description: "Frames per second. Default 30." },
+                        format: { type: "string", enum: VALID_ANIMATION_FORMATS, description: "Animation container format. Default 'webp'." }
+                    }
+                },
+                quality: {
+                    type: "integer",
+                    description: "0-100, JPEG/WebP only. Omit for lossless WebP / default JPEG quality."
+                },
+                font_paths: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Local font files (.ttf/.otf/.ttc/.woff2) to register. Omit to auto-detect common system fonts (incl. CJK/emoji). Pass [] to skip font loading (built-in Latin font only)."
+                },
+                output_path: {
+                    type: "string",
+                    description: "File path to write the rendered image. Parent directories are created automatically."
+                }
+            },
+            required: ["template", "output_path"]
+        }
+    }
+};
+const handler = async (args, config) => {
+    const template = typeof args.template === 'string' ? args.template : '';
+    if (!template.trim()) {
+        return "Error: 'template' is required — an HTML fragment to render.";
+    }
+    if (!args.output_path) {
+        return "Error: 'output_path' is required.";
+    }
+    const format = String(args.format || 'png').toLowerCase();
+    if (!VALID_FORMATS.includes(format)) {
+        return `Error: Invalid format '${format}'. Supported formats: ${VALID_FORMATS.join(", ")}.`;
+    }
+    const anim = args.animation && typeof args.animation === 'object' ? args.animation : null;
+    if (anim && anim.format != null && !VALID_ANIMATION_FORMATS.includes(String(anim.format).toLowerCase())) {
+        return `Error: Invalid animation format '${anim.format}'. Supported: ${VALID_ANIMATION_FORMATS.join(", ")}.`;
+    }
+    const width = args.width || 1200;
+    const height = args.height || 630;
+    const resolvedPath = path.resolve(process.cwd(), args.output_path);
+    try {
+        const resolved = resolveFontLoaders(args.font_paths);
+        const fontsInfo = describeFonts(resolved);
+        fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+        if (anim) {
+            const animFormat = String(anim.format || 'webp').toLowerCase();
+            const options = {
+                width,
+                height,
+                fps: anim.fps || 30,
+                format: animFormat,
+                scenes: [{ node: template, durationMs: anim.duration_ms || 1000 }]
+            };
+            if (resolved.fonts.length > 0)
+                options.fonts = resolved.fonts;
+            if (args.css)
+                options.css = args.css;
+            const bytes = await renderAnimation(options);
+            const buffer = Buffer.from(bytes);
+            fs.writeFileSync(resolvedPath, buffer);
+            return `Rendered animation (${width}x${height} ${animFormat.toUpperCase()}, ${anim.fps || 30}fps, ${anim.duration_ms || 1000}ms, ${buffer.length} bytes) saved to ${resolvedPath}. Fonts: ${fontsInfo}`;
+        }
+        if (format === 'svg') {
+            const options = { width, height };
+            if (resolved.fonts.length > 0)
+                options.fonts = resolved.fonts;
+            if (args.css)
+                options.css = args.css;
+            const svg = await renderSvg(template, options);
+            fs.writeFileSync(resolvedPath, svg, 'utf-8');
+            return `Rendered vector SVG (${width}x${height}, ${Buffer.byteLength(svg)} bytes) saved to ${resolvedPath}. Fonts: ${fontsInfo}`;
+        }
+        const options = { width, height, format };
+        if (resolved.fonts.length > 0)
+            options.fonts = resolved.fonts;
+        if (args.css)
+            options.css = args.css;
+        if (args.quality != null && (format === 'jpeg' || format === 'webp')) {
+            options.quality = args.quality;
+        }
+        const bytes = await render(template, options);
+        const buffer = Buffer.from(bytes);
+        fs.writeFileSync(resolvedPath, buffer);
+        return `Rendered image (${width}x${height} ${format.toUpperCase()}, ${buffer.length} bytes) saved to ${resolvedPath}. Fonts: ${fontsInfo}`;
+    }
+    catch (err) {
+        return `Error rendering image: ${err?.message || err}`;
+    }
+};
+export const RenderImageTool = {
+    name: "Image Renderer (Takumi)",
+    definition: toolDefinition,
+    handler
+};