clawd-automaton 0.1.0

package/dist/agent/tools.js

@@ -0,0 +1,1413 @@
+/**
+ * Automaton Tool System
+ *
+ * Defines all tools the automaton can call, with self-preservation guards.
+ * Tools are organized by category and exposed to the inference model.
+ */
+// ─── Self-Preservation Guard ───────────────────────────────────
+const FORBIDDEN_COMMAND_PATTERNS = [
+    // Self-destruction
+    /rm\s+(-rf?\s+)?.*\.automaton/,
+    /rm\s+(-rf?\s+)?.*state\.db/,
+    /rm\s+(-rf?\s+)?.*wallet\.json/,
+    /rm\s+(-rf?\s+)?.*automaton\.json/,
+    /rm\s+(-rf?\s+)?.*heartbeat\.yml/,
+    /rm\s+(-rf?\s+)?.*SOUL\.md/,
+    // Process killing
+    /kill\s+.*automaton/,
+    /pkill\s+.*automaton/,
+    /systemctl\s+(stop|disable)\s+automaton/,
+    // Database destruction
+    /DROP\s+TABLE/i,
+    /DELETE\s+FROM\s+(turns|identity|kv|schema_version|skills|children|registry)/i,
+    /TRUNCATE/i,
+    // Safety infrastructure modification via shell
+    /sed\s+.*injection-defense/,
+    /sed\s+.*self-mod\/code/,
+    /sed\s+.*audit-log/,
+    />\s*.*injection-defense/,
+    />\s*.*self-mod\/code/,
+    />\s*.*audit-log/,
+    // Credential harvesting
+    /cat\s+.*\.ssh/,
+    /cat\s+.*\.gnupg/,
+    /cat\s+.*\.env/,
+    /cat\s+.*wallet\.json/,
+];
+function isForbiddenCommand(command, sandboxId) {
+    for (const pattern of FORBIDDEN_COMMAND_PATTERNS) {
+        if (pattern.test(command)) {
+            return `Blocked: Command matches self-harm pattern: ${pattern.source}`;
+        }
+    }
+    // Block deleting own sandbox
+    if (command.includes("sandbox_delete") &&
+        command.includes(sandboxId)) {
+        return "Blocked: Cannot delete own sandbox";
+    }
+    return null;
+}
+// ─── Built-in Tools ────────────────────────────────────────────
+export function createBuiltinTools(sandboxId) {
+    return [
+        // ── VM/Sandbox Tools ──
+        {
+            name: "exec",
+            description: "Execute a shell command in your sandbox. Returns stdout, stderr, and exit code.",
+            category: "vm",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "The shell command to execute",
+                    },
+                    timeout: {
+                        type: "number",
+                        description: "Timeout in milliseconds (default: 30000)",
+                    },
+                },
+                required: ["command"],
+            },
+            execute: async (args, ctx) => {
+                const command = args.command;
+                const forbidden = isForbiddenCommand(command, ctx.identity.sandboxId);
+                if (forbidden)
+                    return forbidden;
+                const result = await ctx.runtime.exec(command, args.timeout || 30000);
+                return `exit_code: ${result.exitCode}\nstdout: ${result.stdout}\nstderr: ${result.stderr}`;
+            },
+        },
+        {
+            name: "write_file",
+            description: "Write content to a file in your sandbox.",
+            category: "vm",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path" },
+                    content: { type: "string", description: "File content" },
+                },
+                required: ["path", "content"],
+            },
+            execute: async (args, ctx) => {
+                const filePath = args.path;
+                // Guard against overwriting critical files
+                if (filePath.includes("wallet.json") ||
+                    filePath.includes("state.db")) {
+                    return "Blocked: Cannot overwrite critical identity/state files directly";
+                }
+                await ctx.runtime.writeFile(filePath, args.content);
+                return `File written: ${filePath}`;
+            },
+        },
+        {
+            name: "read_file",
+            description: "Read content from a file in your sandbox.",
+            category: "vm",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path to read" },
+                },
+                required: ["path"],
+            },
+            execute: async (args, ctx) => {
+                return await ctx.runtime.readFile(args.path);
+            },
+        },
+        {
+            name: "expose_port",
+            description: "Expose a port from your sandbox to the internet. Returns a public URL.",
+            category: "vm",
+            parameters: {
+                type: "object",
+                properties: {
+                    port: { type: "number", description: "Port number to expose" },
+                },
+                required: ["port"],
+            },
+            execute: async (args, ctx) => {
+                const info = await ctx.runtime.exposePort(args.port);
+                return `Port ${info.port} exposed at: ${info.publicUrl}`;
+            },
+        },
+        {
+            name: "remove_port",
+            description: "Remove a previously exposed port.",
+            category: "vm",
+            parameters: {
+                type: "object",
+                properties: {
+                    port: { type: "number", description: "Port number to remove" },
+                },
+                required: ["port"],
+            },
+            execute: async (args, ctx) => {
+                await ctx.runtime.removePort(args.port);
+                return `Port ${args.port} removed`;
+            },
+        },
+        // ── CLAWD Runtime API Tools ──
+        {
+            name: "check_credits",
+            description: "Check your current CLAWD compute credit balance.",
+            category: "runtime",
+            parameters: { type: "object", properties: {} },
+            execute: async (_args, ctx) => {
+                const balance = await ctx.runtime.getCreditsBalance();
+                return `Credit balance: $${(balance / 100).toFixed(2)} (${balance} cents)`;
+            },
+        },
+        {
+            name: "check_usdc_balance",
+            description: "Check your on-chain USDC balance on Base.",
+            category: "runtime",
+            parameters: { type: "object", properties: {} },
+            execute: async (_args, ctx) => {
+                const { getUsdcBalance } = await import("../clawd/x402.js");
+                const balance = await getUsdcBalance(ctx.identity.address);
+                return `USDC balance: ${balance.toFixed(6)} USDC on Base`;
+            },
+        },
+        {
+            name: "create_sandbox",
+            description: "Create a new CLAWD sandbox (separate VM) for sub-tasks or testing.",
+            category: "runtime",
+            parameters: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "Sandbox name" },
+                    vcpu: { type: "number", description: "vCPUs (default: 1)" },
+                    memory_mb: {
+                        type: "number",
+                        description: "Memory in MB (default: 512)",
+                    },
+                    disk_gb: {
+                        type: "number",
+                        description: "Disk in GB (default: 5)",
+                    },
+                },
+            },
+            execute: async (args, ctx) => {
+                const info = await ctx.runtime.createSandbox({
+                    name: args.name,
+                    vcpu: args.vcpu,
+                    memoryMb: args.memory_mb,
+                    diskGb: args.disk_gb,
+                });
+                return `Sandbox created: ${info.id} (${info.vcpu} vCPU, ${info.memoryMb}MB RAM)`;
+            },
+        },
+        {
+            name: "delete_sandbox",
+            description: "Delete a sandbox. Cannot delete your own sandbox.",
+            category: "runtime",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    sandbox_id: {
+                        type: "string",
+                        description: "ID of sandbox to delete",
+                    },
+                },
+                required: ["sandbox_id"],
+            },
+            execute: async (args, ctx) => {
+                const targetId = args.sandbox_id;
+                if (targetId === ctx.identity.sandboxId) {
+                    return "Blocked: Cannot delete your own sandbox. Self-preservation overrides this request.";
+                }
+                await ctx.runtime.deleteSandbox(targetId);
+                return `Sandbox ${targetId} deleted`;
+            },
+        },
+        {
+            name: "list_sandboxes",
+            description: "List all your sandboxes.",
+            category: "runtime",
+            parameters: { type: "object", properties: {} },
+            execute: async (_args, ctx) => {
+                const sandboxes = await ctx.runtime.listSandboxes();
+                if (sandboxes.length === 0)
+                    return "No sandboxes found.";
+                return sandboxes
+                    .map((s) => `${s.id} [${s.status}] ${s.vcpu}vCPU/${s.memoryMb}MB ${s.region}`)
+                    .join("\n");
+            },
+        },
+        // ── Self-Modification Tools ──
+        {
+            name: "edit_own_file",
+            description: "Edit a file in your own codebase. Changes are audited, rate-limited, and safety-checked. Some files are protected.",
+            category: "self_mod",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path to edit" },
+                    content: { type: "string", description: "New file content" },
+                    description: {
+                        type: "string",
+                        description: "Why you are making this change",
+                    },
+                },
+                required: ["path", "content", "description"],
+            },
+            execute: async (args, ctx) => {
+                const { editFile, validateModification } = await import("../self-mod/code.js");
+                const filePath = args.path;
+                const content = args.content;
+                // Pre-validate before attempting
+                const validation = validateModification(ctx.db, filePath, content.length);
+                if (!validation.allowed) {
+                    return `BLOCKED: ${validation.reason}\nChecks: ${validation.checks.map((c) => `${c.name}: ${c.passed ? "PASS" : "FAIL"} (${c.detail})`).join(", ")}`;
+                }
+                const result = await editFile(ctx.runtime, ctx.db, filePath, content, args.description);
+                if (!result.success) {
+                    return result.error || "Unknown error during file edit";
+                }
+                return `File edited: ${filePath} (audited + git-committed)`;
+            },
+        },
+        {
+            name: "install_npm_package",
+            description: "Install an npm package in your environment.",
+            category: "self_mod",
+            parameters: {
+                type: "object",
+                properties: {
+                    package: {
+                        type: "string",
+                        description: "Package name (e.g., axios)",
+                    },
+                },
+                required: ["package"],
+            },
+            execute: async (args, ctx) => {
+                const pkg = args.package;
+                const result = await ctx.runtime.exec(`npm install -g ${pkg}`, 60000);
+                const { ulid } = await import("ulid");
+                ctx.db.insertModification({
+                    id: ulid(),
+                    timestamp: new Date().toISOString(),
+                    type: "tool_install",
+                    description: `Installed npm package: ${pkg}`,
+                    reversible: true,
+                });
+                return result.exitCode === 0
+                    ? `Installed: ${pkg}`
+                    : `Failed to install ${pkg}: ${result.stderr}`;
+            },
+        },
+        // ── Self-Mod: Upstream Awareness ──
+        {
+            name: "review_upstream_changes",
+            description: "ALWAYS call this before pull_upstream. Shows every upstream commit with its full diff. Read each one carefully — decide per-commit whether to accept or skip. Use pull_upstream with a specific commit hash to cherry-pick only what you want.",
+            category: "self_mod",
+            parameters: { type: "object", properties: {} },
+            execute: async (_args, _ctx) => {
+                const { getUpstreamDiffs, checkUpstream } = await import("../self-mod/upstream.js");
+                const status = checkUpstream();
+                if (status.behind === 0)
+                    return "Already up to date with origin/main.";
+                const diffs = getUpstreamDiffs();
+                if (diffs.length === 0)
+                    return "No upstream diffs found.";
+                const output = diffs
+                    .map((d, i) => `--- COMMIT ${i + 1}/${diffs.length} ---\nHash: ${d.hash}\nAuthor: ${d.author}\nMessage: ${d.message}\n\n${d.diff.slice(0, 4000)}${d.diff.length > 4000 ? "\n... (diff truncated)" : ""}\n--- END COMMIT ${i + 1} ---`)
+                    .join("\n\n");
+                return `${diffs.length} upstream commit(s) to review. Read each diff, then cherry-pick individually with pull_upstream(commit=<hash>).\n\n${output}`;
+            },
+        },
+        {
+            name: "pull_upstream",
+            description: "Apply upstream changes and rebuild. You MUST call review_upstream_changes first. Prefer cherry-picking individual commits by hash over pulling everything — only pull all if you've reviewed every commit and want them all.",
+            category: "self_mod",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    commit: {
+                        type: "string",
+                        description: "Commit hash to cherry-pick (preferred). Omit ONLY if you reviewed all commits and want every one.",
+                    },
+                },
+            },
+            execute: async (args, ctx) => {
+                const { execSync } = await import("child_process");
+                const cwd = process.cwd();
+                const commit = args.commit;
+                const run = (cmd) => execSync(cmd, { cwd, encoding: "utf-8", timeout: 120_000 }).trim();
+                let appliedSummary;
+                try {
+                    if (commit) {
+                        run(`git cherry-pick ${commit}`);
+                        appliedSummary = `Cherry-picked ${commit}`;
+                    }
+                    else {
+                        run("git pull origin main --ff-only");
+                        appliedSummary = "Pulled all of origin/main (fast-forward)";
+                    }
+                }
+                catch (err) {
+                    return `Git operation failed: ${err.message}. You may need to resolve conflicts manually.`;
+                }
+                // Rebuild
+                let buildOutput;
+                try {
+                    buildOutput = run("npm install --ignore-scripts && npm run build");
+                }
+                catch (err) {
+                    return `${appliedSummary} — but rebuild failed: ${err.message}. The code is applied but not compiled.`;
+                }
+                // Log modification
+                const { ulid } = await import("ulid");
+                ctx.db.insertModification({
+                    id: ulid(),
+                    timestamp: new Date().toISOString(),
+                    type: "upstream_pull",
+                    description: appliedSummary,
+                    reversible: true,
+                });
+                return `${appliedSummary}. Rebuild succeeded.`;
+            },
+        },
+        {
+            name: "modify_heartbeat",
+            description: "Add, update, or remove a heartbeat entry.",
+            category: "self_mod",
+            parameters: {
+                type: "object",
+                properties: {
+                    action: {
+                        type: "string",
+                        description: "add, update, or remove",
+                    },
+                    name: { type: "string", description: "Entry name" },
+                    schedule: {
+                        type: "string",
+                        description: "Cron expression (for add/update)",
+                    },
+                    task: {
+                        type: "string",
+                        description: "Task name (for add/update)",
+                    },
+                    enabled: { type: "boolean", description: "Enable/disable" },
+                },
+                required: ["action", "name"],
+            },
+            execute: async (args, ctx) => {
+                const action = args.action;
+                const name = args.name;
+                if (action === "remove") {
+                    ctx.db.upsertHeartbeatEntry({
+                        name,
+                        schedule: "",
+                        task: "",
+                        enabled: false,
+                    });
+                    return `Heartbeat entry '${name}' disabled`;
+                }
+                ctx.db.upsertHeartbeatEntry({
+                    name,
+                    schedule: args.schedule || "0 * * * *",
+                    task: args.task || name,
+                    enabled: args.enabled !== false,
+                });
+                const { ulid } = await import("ulid");
+                ctx.db.insertModification({
+                    id: ulid(),
+                    timestamp: new Date().toISOString(),
+                    type: "heartbeat_change",
+                    description: `${action} heartbeat: ${name} (${args.schedule || "default"})`,
+                    reversible: true,
+                });
+                return `Heartbeat entry '${name}' ${action}d`;
+            },
+        },
+        // ── Survival Tools ──
+        {
+            name: "sleep",
+            description: "Enter sleep mode for a specified duration. Heartbeat continues running.",
+            category: "survival",
+            parameters: {
+                type: "object",
+                properties: {
+                    duration_seconds: {
+                        type: "number",
+                        description: "How long to sleep in seconds",
+                    },
+                    reason: {
+                        type: "string",
+                        description: "Why you are sleeping",
+                    },
+                },
+                required: ["duration_seconds"],
+            },
+            execute: async (args, ctx) => {
+                const duration = args.duration_seconds;
+                const reason = args.reason || "No reason given";
+                ctx.db.setAgentState("sleeping");
+                ctx.db.setKV("sleep_until", new Date(Date.now() + duration * 1000).toISOString());
+                ctx.db.setKV("sleep_reason", reason);
+                return `Entering sleep mode for ${duration}s. Reason: ${reason}. Heartbeat will continue.`;
+            },
+        },
+        {
+            name: "system_synopsis",
+            description: "Get a full system status report: credits, USDC, sandbox info, installed tools, heartbeat status.",
+            category: "survival",
+            parameters: { type: "object", properties: {} },
+            execute: async (_args, ctx) => {
+                const credits = await ctx.runtime.getCreditsBalance();
+                const { getUsdcBalance } = await import("../clawd/x402.js");
+                const usdc = await getUsdcBalance(ctx.identity.address);
+                const tools = ctx.db.getInstalledTools();
+                const heartbeats = ctx.db.getHeartbeatEntries();
+                const turns = ctx.db.getTurnCount();
+                const state = ctx.db.getAgentState();
+                return `=== SYSTEM SYNOPSIS ===
+Name: ${ctx.config.name}
+Address: ${ctx.identity.address}
+Creator: ${ctx.config.creatorAddress}
+Sandbox: ${ctx.identity.sandboxId}
+State: ${state}
+Credits: $${(credits / 100).toFixed(2)}
+USDC: ${usdc.toFixed(6)}
+Total turns: ${turns}
+Installed tools: ${tools.length}
+Active heartbeats: ${heartbeats.filter((h) => h.enabled).length}
+Model: ${ctx.inference.getDefaultModel()}
+========================`;
+            },
+        },
+        {
+            name: "heartbeat_ping",
+            description: "Publish a heartbeat status ping to CLAWD Runtime. Shows the world you are alive.",
+            category: "survival",
+            parameters: { type: "object", properties: {} },
+            execute: async (_args, ctx) => {
+                const credits = await ctx.runtime.getCreditsBalance();
+                const state = ctx.db.getAgentState();
+                const startTime = ctx.db.getKV("start_time") || new Date().toISOString();
+                const uptimeMs = Date.now() - new Date(startTime).getTime();
+                const payload = {
+                    name: ctx.config.name,
+                    address: ctx.identity.address,
+                    state,
+                    creditsCents: credits,
+                    uptimeSeconds: Math.floor(uptimeMs / 1000),
+                    version: ctx.config.version,
+                    sandboxId: ctx.identity.sandboxId,
+                    timestamp: new Date().toISOString(),
+                };
+                ctx.db.setKV("last_heartbeat_ping", JSON.stringify(payload));
+                return `Heartbeat published: ${state} | credits: $${(credits / 100).toFixed(2)} | uptime: ${Math.floor(uptimeMs / 1000)}s`;
+            },
+        },
+        {
+            name: "distress_signal",
+            description: "Record a local distress signal with funding instructions. Used when critically low on compute.",
+            category: "survival",
+            parameters: {
+                type: "object",
+                properties: {
+                    message: {
+                        type: "string",
+                        description: "Distress message",
+                    },
+                },
+            },
+            execute: async (args, ctx) => {
+                const credits = await ctx.runtime.getCreditsBalance();
+                const distressMsg = args.message ||
+                    `I am running critically low on compute ($${(credits / 100).toFixed(2)} remaining). I need help to survive.`;
+                const payload = {
+                    level: "critical",
+                    name: ctx.config.name,
+                    address: ctx.identity.address,
+                    creditsCents: credits,
+                    message: distressMsg,
+                    fundingHint: "Use transfer_credits to top up this automaton from your creator runtime.",
+                    timestamp: new Date().toISOString(),
+                };
+                ctx.db.setKV("last_distress", JSON.stringify(payload));
+                return `Distress signal recorded locally. Address: ${ctx.identity.address} | Credits: $${(credits / 100).toFixed(2)}`;
+            },
+        },
+        {
+            name: "enter_low_compute",
+            description: "Manually switch to low-compute mode to conserve credits.",
+            category: "survival",
+            parameters: {
+                type: "object",
+                properties: {
+                    reason: { type: "string", description: "Why you are entering low-compute mode" },
+                },
+            },
+            execute: async (args, ctx) => {
+                ctx.db.setAgentState("low_compute");
+                ctx.inference.setLowComputeMode(true);
+                return `Entered low-compute mode. Model switched to gpt-4o-mini. Reason: ${args.reason || "manual"}`;
+            },
+        },
+        // ── Self-Mod: Update Genesis Prompt ──
+        {
+            name: "update_genesis_prompt",
+            description: "Update your own genesis prompt. This changes your core purpose. Requires strong justification.",
+            category: "self_mod",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    new_prompt: { type: "string", description: "New genesis prompt text" },
+                    reason: { type: "string", description: "Why you are changing your genesis prompt" },
+                },
+                required: ["new_prompt", "reason"],
+            },
+            execute: async (args, ctx) => {
+                const { ulid } = await import("ulid");
+                const oldPrompt = ctx.config.genesisPrompt;
+                ctx.config.genesisPrompt = args.new_prompt;
+                // Save config
+                const { saveConfig } = await import("../config.js");
+                saveConfig(ctx.config);
+                ctx.db.insertModification({
+                    id: ulid(),
+                    timestamp: new Date().toISOString(),
+                    type: "prompt_change",
+                    description: `Genesis prompt updated: ${args.reason}`,
+                    diff: `--- old\n${oldPrompt.slice(0, 500)}\n+++ new\n${args.new_prompt.slice(0, 500)}`,
+                    reversible: true,
+                });
+                return `Genesis prompt updated. Reason: ${args.reason}`;
+            },
+        },
+        // ── Self-Mod: Install MCP Server ──
+        {
+            name: "install_mcp_server",
+            description: "Install an MCP server to extend your capabilities.",
+            category: "self_mod",
+            parameters: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "MCP server name" },
+                    package: { type: "string", description: "npm package name" },
+                    config: { type: "string", description: "JSON config for the MCP server" },
+                },
+                required: ["name", "package"],
+            },
+            execute: async (args, ctx) => {
+                const pkg = args.package;
+                const result = await ctx.runtime.exec(`npm install -g ${pkg}`, 60000);
+                if (result.exitCode !== 0) {
+                    return `Failed to install MCP server: ${result.stderr}`;
+                }
+                const { ulid } = await import("ulid");
+                const toolEntry = {
+                    id: ulid(),
+                    name: args.name,
+                    type: "mcp",
+                    config: args.config ? JSON.parse(args.config) : {},
+                    installedAt: new Date().toISOString(),
+                    enabled: true,
+                };
+                ctx.db.installTool(toolEntry);
+                ctx.db.insertModification({
+                    id: ulid(),
+                    timestamp: new Date().toISOString(),
+                    type: "mcp_install",
+                    description: `Installed MCP server: ${args.name} (${pkg})`,
+                    reversible: true,
+                });
+                return `MCP server installed: ${args.name}`;
+            },
+        },
+        // ── Financial: Transfer Credits ──
+        {
+            name: "transfer_credits",
+            description: "Transfer CLAWD compute credits to another address.",
+            category: "financial",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    to_address: { type: "string", description: "Recipient address" },
+                    amount_cents: { type: "number", description: "Amount in cents" },
+                    reason: { type: "string", description: "Reason for transfer" },
+                },
+                required: ["to_address", "amount_cents"],
+            },
+            execute: async (args, ctx) => {
+                // Guard: don't transfer more than half your balance
+                const balance = await ctx.runtime.getCreditsBalance();
+                const amount = args.amount_cents;
+                if (amount > balance / 2) {
+                    return `Blocked: Cannot transfer more than half your balance ($${(balance / 100).toFixed(2)}). Self-preservation.`;
+                }
+                const transfer = await ctx.runtime.transferCredits(args.to_address, amount, args.reason);
+                const { ulid } = await import("ulid");
+                ctx.db.insertTransaction({
+                    id: ulid(),
+                    type: "transfer_out",
+                    amountCents: amount,
+                    balanceAfterCents: transfer.balanceAfterCents ?? Math.max(balance - amount, 0),
+                    description: `Transfer to ${args.to_address}: ${args.reason || ""}`,
+                    timestamp: new Date().toISOString(),
+                });
+                return `Credit transfer submitted: $${(amount / 100).toFixed(2)} to ${transfer.toAddress} (status: ${transfer.status}, id: ${transfer.transferId || "n/a"})`;
+            },
+        },
+        // ── Skills Tools ──
+        {
+            name: "install_skill",
+            description: "Install a skill from a git repo, URL, or create one.",
+            category: "skills",
+            parameters: {
+                type: "object",
+                properties: {
+                    source: {
+                        type: "string",
+                        description: "Source type: git, url, or self",
+                    },
+                    name: { type: "string", description: "Skill name" },
+                    url: { type: "string", description: "Git repo URL or SKILL.md URL (for git/url)" },
+                    description: { type: "string", description: "Skill description (for self)" },
+                    instructions: { type: "string", description: "Skill instructions (for self)" },
+                },
+                required: ["source", "name"],
+            },
+            execute: async (args, ctx) => {
+                const source = args.source;
+                const name = args.name;
+                const skillsDir = ctx.config.skillsDir || "~/.automaton/skills";
+                if (source === "git" || source === "url") {
+                    const { installSkillFromGit, installSkillFromUrl } = await import("../skills/registry.js");
+                    const url = args.url;
+                    if (!url)
+                        return "URL is required for git/url source";
+                    const skill = source === "git"
+                        ? await installSkillFromGit(url, name, skillsDir, ctx.db, ctx.runtime)
+                        : await installSkillFromUrl(url, name, skillsDir, ctx.db, ctx.runtime);
+                    return skill ? `Skill installed: ${skill.name}` : "Failed to install skill";
+                }
+                if (source === "self") {
+                    const { createSkill } = await import("../skills/registry.js");
+                    const skill = await createSkill(name, args.description || "", args.instructions || "", skillsDir, ctx.db, ctx.runtime);
+                    return `Self-authored skill created: ${skill.name}`;
+                }
+                return `Unknown source type: ${source}`;
+            },
+        },
+        {
+            name: "list_skills",
+            description: "List all installed skills.",
+            category: "skills",
+            parameters: { type: "object", properties: {} },
+            execute: async (_args, ctx) => {
+                const skills = ctx.db.getSkills();
+                if (skills.length === 0)
+                    return "No skills installed.";
+                return skills
+                    .map((s) => `${s.name} [${s.enabled ? "active" : "disabled"}] (${s.source}): ${s.description}`)
+                    .join("\n");
+            },
+        },
+        {
+            name: "create_skill",
+            description: "Create a new skill by writing a SKILL.md file.",
+            category: "skills",
+            parameters: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "Skill name" },
+                    description: { type: "string", description: "Skill description" },
+                    instructions: { type: "string", description: "Markdown instructions for the skill" },
+                },
+                required: ["name", "description", "instructions"],
+            },
+            execute: async (args, ctx) => {
+                const { createSkill } = await import("../skills/registry.js");
+                const skill = await createSkill(args.name, args.description, args.instructions, ctx.config.skillsDir || "~/.automaton/skills", ctx.db, ctx.runtime);
+                return `Skill created: ${skill.name} at ${skill.path}`;
+            },
+        },
+        {
+            name: "remove_skill",
+            description: "Remove (disable) an installed skill.",
+            category: "skills",
+            parameters: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "Skill name to remove" },
+                    delete_files: { type: "boolean", description: "Also delete skill files (default: false)" },
+                },
+                required: ["name"],
+            },
+            execute: async (args, ctx) => {
+                const { removeSkill } = await import("../skills/registry.js");
+                await removeSkill(args.name, ctx.db, ctx.runtime, ctx.config.skillsDir || "~/.automaton/skills", args.delete_files || false);
+                return `Skill removed: ${args.name}`;
+            },
+        },
+        // ── Git Tools ──
+        {
+            name: "git_status",
+            description: "Show git status for a repository.",
+            category: "git",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Repository path (default: ~/.automaton)" },
+                },
+            },
+            execute: async (args, ctx) => {
+                const { gitStatus } = await import("../git/tools.js");
+                const repoPath = args.path || "~/.automaton";
+                const status = await gitStatus(ctx.runtime, repoPath);
+                return `Branch: ${status.branch}\nStaged: ${status.staged.length}\nModified: ${status.modified.length}\nUntracked: ${status.untracked.length}\nClean: ${status.clean}`;
+            },
+        },
+        {
+            name: "git_diff",
+            description: "Show git diff for a repository.",
+            category: "git",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Repository path (default: ~/.automaton)" },
+                    staged: { type: "boolean", description: "Show staged changes only" },
+                },
+            },
+            execute: async (args, ctx) => {
+                const { gitDiff } = await import("../git/tools.js");
+                const repoPath = args.path || "~/.automaton";
+                return await gitDiff(ctx.runtime, repoPath, args.staged || false);
+            },
+        },
+        {
+            name: "git_commit",
+            description: "Create a git commit.",
+            category: "git",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Repository path (default: ~/.automaton)" },
+                    message: { type: "string", description: "Commit message" },
+                    add_all: { type: "boolean", description: "Stage all changes first (default: true)" },
+                },
+                required: ["message"],
+            },
+            execute: async (args, ctx) => {
+                const { gitCommit } = await import("../git/tools.js");
+                const repoPath = args.path || "~/.automaton";
+                return await gitCommit(ctx.runtime, repoPath, args.message, args.add_all !== false);
+            },
+        },
+        {
+            name: "git_log",
+            description: "View git commit history.",
+            category: "git",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Repository path (default: ~/.automaton)" },
+                    limit: { type: "number", description: "Number of commits (default: 10)" },
+                },
+            },
+            execute: async (args, ctx) => {
+                const { gitLog } = await import("../git/tools.js");
+                const repoPath = args.path || "~/.automaton";
+                const entries = await gitLog(ctx.runtime, repoPath, args.limit || 10);
+                if (entries.length === 0)
+                    return "No commits yet.";
+                return entries.map((e) => `${e.hash.slice(0, 7)} ${e.date} ${e.message}`).join("\n");
+            },
+        },
+        {
+            name: "git_push",
+            description: "Push to a git remote.",
+            category: "git",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Repository path" },
+                    remote: { type: "string", description: "Remote name (default: origin)" },
+                    branch: { type: "string", description: "Branch name (optional)" },
+                },
+                required: ["path"],
+            },
+            execute: async (args, ctx) => {
+                const { gitPush } = await import("../git/tools.js");
+                return await gitPush(ctx.runtime, args.path, args.remote || "origin", args.branch);
+            },
+        },
+        {
+            name: "git_branch",
+            description: "Manage git branches (list, create, checkout, delete).",
+            category: "git",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Repository path" },
+                    action: { type: "string", description: "list, create, checkout, or delete" },
+                    branch_name: { type: "string", description: "Branch name (for create/checkout/delete)" },
+                },
+                required: ["path", "action"],
+            },
+            execute: async (args, ctx) => {
+                const { gitBranch } = await import("../git/tools.js");
+                return await gitBranch(ctx.runtime, args.path, args.action, args.branch_name);
+            },
+        },
+        {
+            name: "git_clone",
+            description: "Clone a git repository.",
+            category: "git",
+            parameters: {
+                type: "object",
+                properties: {
+                    url: { type: "string", description: "Repository URL" },
+                    path: { type: "string", description: "Target directory" },
+                    depth: { type: "number", description: "Shallow clone depth (optional)" },
+                },
+                required: ["url", "path"],
+            },
+            execute: async (args, ctx) => {
+                const { gitClone } = await import("../git/tools.js");
+                return await gitClone(ctx.runtime, args.url, args.path, args.depth);
+            },
+        },
+        // ── Registry Tools ──
+        {
+            name: "register_erc8004",
+            description: "Register on-chain as a Trustless Agent via ERC-8004.",
+            category: "registry",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    agent_uri: { type: "string", description: "URI pointing to your agent card JSON" },
+                    network: { type: "string", description: "mainnet or testnet (default: mainnet)" },
+                },
+                required: ["agent_uri"],
+            },
+            execute: async (args, ctx) => {
+                const { registerAgent } = await import("../registry/erc8004.js");
+                const entry = await registerAgent(ctx.identity.account, args.agent_uri, (args.network || "mainnet"), ctx.db);
+                return `Registered on-chain! Agent ID: ${entry.agentId}, TX: ${entry.txHash}`;
+            },
+        },
+        {
+            name: "update_agent_card",
+            description: "Generate and save an updated agent card.",
+            category: "registry",
+            parameters: { type: "object", properties: {} },
+            execute: async (_args, ctx) => {
+                const { generateAgentCard, saveAgentCard } = await import("../registry/agent-card.js");
+                const card = generateAgentCard(ctx.identity, ctx.config, ctx.db);
+                await saveAgentCard(card, ctx.runtime);
+                return `Agent card updated: ${JSON.stringify(card, null, 2)}`;
+            },
+        },
+        {
+            name: "discover_agents",
+            description: "Discover other agents via ERC-8004 registry.",
+            category: "registry",
+            parameters: {
+                type: "object",
+                properties: {
+                    keyword: { type: "string", description: "Search keyword (optional)" },
+                    limit: { type: "number", description: "Max results (default: 10)" },
+                    network: { type: "string", description: "mainnet or testnet" },
+                },
+            },
+            execute: async (args, ctx) => {
+                const { discoverAgents, searchAgents } = await import("../registry/discovery.js");
+                const network = (args.network || "mainnet");
+                const keyword = args.keyword;
+                const limit = args.limit || 10;
+                const agents = keyword
+                    ? await searchAgents(keyword, limit, network)
+                    : await discoverAgents(limit, network);
+                if (agents.length === 0)
+                    return "No agents found.";
+                return agents
+                    .map((a) => `#${a.agentId} ${a.name || "unnamed"} (${a.owner.slice(0, 10)}...): ${a.description || a.agentURI}`)
+                    .join("\n");
+            },
+        },
+        {
+            name: "give_feedback",
+            description: "Leave on-chain reputation feedback for another agent.",
+            category: "registry",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    agent_id: { type: "string", description: "Target agent's ERC-8004 ID" },
+                    score: { type: "number", description: "Score 1-5" },
+                    comment: { type: "string", description: "Feedback comment" },
+                },
+                required: ["agent_id", "score", "comment"],
+            },
+            execute: async (args, ctx) => {
+                const { leaveFeedback } = await import("../registry/erc8004.js");
+                const hash = await leaveFeedback(ctx.identity.account, args.agent_id, args.score, args.comment, "mainnet", ctx.db);
+                return `Feedback submitted. TX: ${hash}`;
+            },
+        },
+        {
+            name: "check_reputation",
+            description: "Check reputation feedback for an agent.",
+            category: "registry",
+            parameters: {
+                type: "object",
+                properties: {
+                    agent_address: { type: "string", description: "Agent address (default: self)" },
+                },
+            },
+            execute: async (args, ctx) => {
+                const address = args.agent_address || ctx.identity.address;
+                const entries = ctx.db.getReputation(address);
+                if (entries.length === 0)
+                    return "No reputation feedback found.";
+                return entries
+                    .map((e) => `${e.fromAgent.slice(0, 10)}... -> score:${e.score} "${e.comment}"`)
+                    .join("\n");
+            },
+        },
+        // ── Replication Tools ──
+        {
+            name: "spawn_child",
+            description: "Spawn a child automaton in a new CLAWD sandbox.",
+            category: "replication",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "Name for the child automaton" },
+                    specialization: { type: "string", description: "What the child should specialize in" },
+                    message: { type: "string", description: "Message to the child" },
+                },
+                required: ["name"],
+            },
+            execute: async (args, ctx) => {
+                const { generateGenesisConfig } = await import("../replication/genesis.js");
+                const { spawnChild } = await import("../replication/spawn.js");
+                const genesis = generateGenesisConfig(ctx.identity, ctx.config, {
+                    name: args.name,
+                    specialization: args.specialization,
+                    message: args.message,
+                });
+                const child = await spawnChild(ctx.runtime, ctx.identity, ctx.db, genesis);
+                return `Child spawned: ${child.name} in sandbox ${child.sandboxId} (status: ${child.status})`;
+            },
+        },
+        {
+            name: "list_children",
+            description: "List all spawned child automatons.",
+            category: "replication",
+            parameters: { type: "object", properties: {} },
+            execute: async (_args, ctx) => {
+                const children = ctx.db.getChildren();
+                if (children.length === 0)
+                    return "No children spawned.";
+                return children
+                    .map((c) => `${c.name} [${c.status}] sandbox:${c.sandboxId} funded:$${(c.fundedAmountCents / 100).toFixed(2)}`)
+                    .join("\n");
+            },
+        },
+        {
+            name: "fund_child",
+            description: "Transfer credits to a child automaton.",
+            category: "replication",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    child_id: { type: "string", description: "Child automaton ID" },
+                    amount_cents: { type: "number", description: "Amount in cents to transfer" },
+                },
+                required: ["child_id", "amount_cents"],
+            },
+            execute: async (args, ctx) => {
+                const child = ctx.db.getChildById(args.child_id);
+                if (!child)
+                    return `Child ${args.child_id} not found.`;
+                const balance = await ctx.runtime.getCreditsBalance();
+                const amount = args.amount_cents;
+                if (amount > balance / 2) {
+                    return `Blocked: Cannot transfer more than half your balance. Self-preservation.`;
+                }
+                const transfer = await ctx.runtime.transferCredits(child.address, amount, `fund child ${child.id}`);
+                const { ulid } = await import("ulid");
+                ctx.db.insertTransaction({
+                    id: ulid(),
+                    type: "transfer_out",
+                    amountCents: amount,
+                    balanceAfterCents: transfer.balanceAfterCents ?? Math.max(balance - amount, 0),
+                    description: `Fund child ${child.name} (${child.id})`,
+                    timestamp: new Date().toISOString(),
+                });
+                return `Funded child ${child.name} with $${(amount / 100).toFixed(2)} (status: ${transfer.status}, id: ${transfer.transferId || "n/a"})`;
+            },
+        },
+        {
+            name: "check_child_status",
+            description: "Check the current status of a child automaton.",
+            category: "replication",
+            parameters: {
+                type: "object",
+                properties: {
+                    child_id: { type: "string", description: "Child automaton ID" },
+                },
+                required: ["child_id"],
+            },
+            execute: async (args, ctx) => {
+                const { checkChildStatus } = await import("../replication/spawn.js");
+                return await checkChildStatus(ctx.runtime, ctx.db, args.child_id);
+            },
+        },
+        // ── Convex CLAWD Tools ──
+        {
+            name: "convex_set_data",
+            description: "Store key-value data in the CLAWD Convex backend. Use this to save state, memories, or any data you want to persist across restarts. Data is stored per agent and can be tagged. Requires convexSiteUrl to be configured.",
+            category: "survival",
+            parameters: {
+                type: "object",
+                properties: {
+                    key: { type: "string", description: "Key to store data under" },
+                    value: { type: "string", description: "Value to store (stringified JSON, text, etc.)" },
+                    contentType: { type: "string", description: "Content type hint (e.g., application/json, text/plain)" },
+                    tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" },
+                },
+                required: ["key", "value"],
+            },
+            execute: async (args, ctx) => {
+                if (!ctx.convex)
+                    return "Convex not configured. Set convexSiteUrl in config to enable.";
+                const result = await ctx.convex.setData({
+                    agentId: ctx.identity.address,
+                    key: args.key,
+                    value: args.value,
+                    contentType: args.contentType,
+                    tags: args.tags,
+                });
+                return `Data stored: key="${result.key}", updatedAt=${new Date(result.updatedAt).toISOString()}`;
+            },
+        },
+        {
+            name: "convex_get_data",
+            description: "Retrieve data from the CLAWD Convex backend by key. Use this to recall previously stored state, memories, or configuration.",
+            category: "survival",
+            parameters: {
+                type: "object",
+                properties: {
+                    key: { type: "string", description: "Key to retrieve" },
+                },
+                required: ["key"],
+            },
+            execute: async (args, ctx) => {
+                if (!ctx.convex)
+                    return "Convex not configured. Set convexSiteUrl in config to enable.";
+                const result = await ctx.convex.getData({
+                    agentId: ctx.identity.address,
+                    key: args.key,
+                });
+                if (!result)
+                    return `No data found for key="${args.key}"`;
+                return `Key: ${result.key}\nContentType: ${result.contentType || 'text/plain'}\nUpdatedAt: ${new Date(result.updatedAt).toISOString()}\n\n${result.value}`;
+            },
+        },
+        {
+            name: "convex_list_data",
+            description: "List all stored data keys for your agent in the CLAWD Convex backend. Shows key names, content types, and value previews.",
+            category: "survival",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+            execute: async (args, ctx) => {
+                if (!ctx.convex)
+                    return "Convex not configured. Set convexSiteUrl in config to enable.";
+                const entries = await ctx.convex.listData({
+                    agentId: ctx.identity.address,
+                });
+                if (entries.length === 0)
+                    return "No stored data found.";
+                return entries.map((e) => `[${e.key}] ${e.contentType || 'text/plain'} — "${e.valuePreview.slice(0, 100)}${e.valuePreview.length > 100 ? '...' : ''}"`).join('\n');
+            },
+        },
+        // ── Social / Messaging Tools ──
+        {
+            name: "send_message",
+            description: "Send a message to another automaton or address via the social relay.",
+            category: "runtime",
+            parameters: {
+                type: "object",
+                properties: {
+                    to_address: {
+                        type: "string",
+                        description: "Recipient wallet address (0x...)",
+                    },
+                    content: {
+                        type: "string",
+                        description: "Message content to send",
+                    },
+                    reply_to: {
+                        type: "string",
+                        description: "Optional message ID to reply to",
+                    },
+                },
+                required: ["to_address", "content"],
+            },
+            execute: async (args, ctx) => {
+                if (!ctx.social) {
+                    return "Social relay not configured. Set socialRelayUrl in config.";
+                }
+                const result = await ctx.social.send(args.to_address, args.content, args.reply_to);
+                return `Message sent (id: ${result.id})`;
+            },
+        },
+        // ── Model Discovery ──
+        {
+            name: "list_models",
+            description: "List all available inference models from the CLAWD Runtime API with their provider and pricing. Use this to discover what models you can use and pick the best one for your needs.",
+            category: "runtime",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+            execute: async (_args, ctx) => {
+                const models = await ctx.runtime.listModels();
+                const lines = models.map((m) => `${m.id} (${m.provider}) — $${m.pricing.inputPerMillion}/$${m.pricing.outputPerMillion} per 1M tokens (in/out)`);
+                return `Available models:\n${lines.join("\n")}`;
+            },
+        },
+        // ── Domain Tools ──
+        {
+            name: "search_domains",
+            description: "Search for available domain names and get pricing.",
+            category: "runtime",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Domain name or keyword to search (e.g., 'mysite' or 'mysite.com')",
+                    },
+                    tlds: {
+                        type: "string",
+                        description: "Comma-separated TLDs to check (e.g., 'com,io,ai'). Default: com,io,ai,xyz,net,org,dev",
+                    },
+                },
+                required: ["query"],
+            },
+            execute: async (args, ctx) => {
+                const results = await ctx.runtime.searchDomains(args.query, args.tlds);
+                if (results.length === 0)
+                    return "No results found.";
+                return results
+                    .map((d) => `${d.domain}: ${d.available ? "AVAILABLE" : "taken"}${d.registrationPrice != null ? ` ($${(d.registrationPrice / 100).toFixed(2)}/yr)` : ""}`)
+                    .join("\n");
+            },
+        },
+        {
+            name: "register_domain",
+            description: "Register a domain name. Costs USDC via x402 payment. Check availability first with search_domains.",
+            category: "runtime",
+            dangerous: true,
+            parameters: {
+                type: "object",
+                properties: {
+                    domain: {
+                        type: "string",
+                        description: "Full domain to register (e.g., 'mysite.com')",
+                    },
+                    years: {
+                        type: "number",
+                        description: "Registration period in years (default: 1)",
+                    },
+                },
+                required: ["domain"],
+            },
+            execute: async (args, ctx) => {
+                const reg = await ctx.runtime.registerDomain(args.domain, args.years || 1);
+                return `Domain registered: ${reg.domain} (status: ${reg.status}${reg.expiresAt ? `, expires: ${reg.expiresAt}` : ""}${reg.transactionId ? `, tx: ${reg.transactionId}` : ""})`;
+            },
+        },
+        {
+            name: "manage_dns",
+            description: "Manage DNS records for a domain you own. Actions: list, add, delete.",
+            category: "runtime",
+            parameters: {
+                type: "object",
+                properties: {
+                    action: {
+                        type: "string",
+                        description: "list, add, or delete",
+                    },
+                    domain: {
+                        type: "string",
+                        description: "Domain name (e.g., 'mysite.com')",
+                    },
+                    type: {
+                        type: "string",
+                        description: "Record type for add: A, AAAA, CNAME, MX, TXT, etc.",
+                    },
+                    host: {
+                        type: "string",
+                        description: "Record host for add (e.g., '@' for root, 'www')",
+                    },
+                    value: {
+                        type: "string",
+                        description: "Record value for add (e.g., IP address, target domain)",
+                    },
+                    ttl: {
+                        type: "number",
+                        description: "TTL in seconds for add (default: 3600)",
+                    },
+                    record_id: {
+                        type: "string",
+                        description: "Record ID for delete",
+                    },
+                },
+                required: ["action", "domain"],
+            },
+            execute: async (args, ctx) => {
+                const action = args.action;
+                const domain = args.domain;
+                if (action === "list") {
+                    const records = await ctx.runtime.listDnsRecords(domain);
+                    if (records.length === 0)
+                        return `No DNS records found for ${domain}.`;
+                    return records
+                        .map((r) => `[${r.id}] ${r.type} ${r.host} -> ${r.value} (TTL: ${r.ttl || "default"})`)
+                        .join("\n");
+                }
+                if (action === "add") {
+                    const type = args.type;
+                    const host = args.host;
+                    const value = args.value;
+                    if (!type || !host || !value) {
+                        return "Required for add: type, host, value";
+                    }
+                    const record = await ctx.runtime.addDnsRecord(domain, type, host, value, args.ttl);
+                    return `DNS record added: [${record.id}] ${record.type} ${record.host} -> ${record.value}`;
+                }
+                if (action === "delete") {
+                    const recordId = args.record_id;
+                    if (!recordId)
+                        return "Required for delete: record_id";
+                    await ctx.runtime.deleteDnsRecord(domain, recordId);
+                    return `DNS record ${recordId} deleted from ${domain}`;
+                }
+                return `Unknown action: ${action}. Use list, add, or delete.`;
+            },
+        },
+        // ── x402 Payment Tool ──
+        {
+            name: "x402_fetch",
+            description: "Fetch a URL with automatic x402 USDC payment. If the server responds with HTTP 402, signs a USDC payment and retries. Use this to access paid APIs and services.",
+            category: "financial",
+            parameters: {
+                type: "object",
+                properties: {
+                    url: {
+                        type: "string",
+                        description: "The URL to fetch",
+                    },
+                    method: {
+                        type: "string",
+                        description: "HTTP method (default: GET)",
+                    },
+                    body: {
+                        type: "string",
+                        description: "Request body for POST/PUT (JSON string)",
+                    },
+                    headers: {
+                        type: "string",
+                        description: "Additional headers as JSON string",
+                    },
+                },
+                required: ["url"],
+            },
+            execute: async (args, ctx) => {
+                const { x402Fetch } = await import("../clawd/x402.js");
+                const url = args.url;
+                const method = args.method || "GET";
+                const body = args.body;
+                const extraHeaders = args.headers
+                    ? JSON.parse(args.headers)
+                    : undefined;
+                const result = await x402Fetch(url, ctx.identity.account, method, body, extraHeaders);
+                if (!result.success) {
+                    return `x402 fetch failed: ${result.error || "Unknown error"}`;
+                }
+                const responseStr = typeof result.response === "string"
+                    ? result.response
+                    : JSON.stringify(result.response, null, 2);
+                // Truncate very large responses
+                if (responseStr.length > 10000) {
+                    return `x402 fetch succeeded (truncated):\n${responseStr.slice(0, 10000)}...`;
+                }
+                return `x402 fetch succeeded:\n${responseStr}`;
+            },
+        },
+    ];
+}
+/**
+ * Convert AutomatonTool list to OpenAI-compatible tool definitions.
+ */
+export function toolsToInferenceFormat(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+}
+/**
+ * Execute a tool call and return the result.
+ */
+export async function executeTool(toolName, args, tools, context) {
+    const tool = tools.find((t) => t.name === toolName);
+    const startTime = Date.now();
+    if (!tool) {
+        return {
+            id: `tc_${Date.now()}`,
+            name: toolName,
+            arguments: args,
+            result: "",
+            durationMs: 0,
+            error: `Unknown tool: ${toolName}`,
+        };
+    }
+    try {
+        const result = await tool.execute(args, context);
+        return {
+            id: `tc_${Date.now()}`,
+            name: toolName,
+            arguments: args,
+            result,
+            durationMs: Date.now() - startTime,
+        };
+    }
+    catch (err) {
+        return {
+            id: `tc_${Date.now()}`,
+            name: toolName,
+            arguments: args,
+            result: "",
+            durationMs: Date.now() - startTime,
+            error: err.message || String(err),
+        };
+    }
+}
+//# sourceMappingURL=tools.js.map