@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/heart/daemon/ouro-path-installer.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installOuroCommand = installOuroCommand;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const WRAPPER_SCRIPT = `#!/bin/sh
+exec npx --yes @ouro.bot/cli "$@"
+`;
+function detectShellProfile(homeDir, shell) {
+    if (!shell)
+        return null;
+    const base = path.basename(shell);
+    if (base === "zsh")
+        return path.join(homeDir, ".zshrc");
+    if (base === "bash") {
+        // macOS uses .bash_profile, Linux uses .bashrc
+        const profilePath = path.join(homeDir, ".bash_profile");
+        return profilePath;
+    }
+    if (base === "fish")
+        return path.join(homeDir, ".config", "fish", "config.fish");
+    return null;
+}
+function isBinDirInPath(binDir, envPath) {
+    return envPath.split(path.delimiter).some((p) => p === binDir);
+}
+function buildPathExportLine(binDir, shell) {
+    const base = shell ? path.basename(shell) : /* v8 ignore next -- unreachable: only called when detectShellProfile returns non-null, which requires shell @preserve */ "";
+    if (base === "fish") {
+        return `\n# Added by ouro\nset -gx PATH ${binDir} $PATH\n`;
+    }
+    return `\n# Added by ouro\nexport PATH="${binDir}:$PATH"\n`;
+}
+function installOuroCommand(deps = {}) {
+    /* v8 ignore start -- dep defaults: only used in real runtime, tests always inject @preserve */
+    const platform = deps.platform ?? process.platform;
+    const homeDir = deps.homeDir ?? os.homedir();
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const readFileSync = deps.readFileSync ?? ((p, enc) => fs.readFileSync(p, enc));
+    const appendFileSync = deps.appendFileSync ?? fs.appendFileSync;
+    const chmodSync = deps.chmodSync ?? fs.chmodSync;
+    const envPath = deps.envPath ?? process.env.PATH ?? "";
+    const shell = deps.shell ?? process.env.SHELL;
+    /* v8 ignore stop */
+    if (platform === "win32") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_install_skip",
+            message: "skipped ouro PATH install on Windows",
+            meta: { platform },
+        });
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: "windows" };
+    }
+    const binDir = path.join(homeDir, ".local", "bin");
+    const scriptPath = path.join(binDir, "ouro");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_start",
+        message: "installing ouro command to PATH",
+        meta: { scriptPath, binDir },
+    });
+    // If ouro already exists somewhere in PATH, skip
+    if (existsSync(scriptPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_install_skip",
+            message: "ouro command already installed",
+            meta: { scriptPath },
+        });
+        return { installed: false, scriptPath, pathReady: isBinDirInPath(binDir, envPath), shellProfileUpdated: null, skippedReason: "already-installed" };
+    }
+    try {
+        mkdirSync(binDir, { recursive: true });
+        writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+        chmodSync(scriptPath, 0o755);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_path_install_error",
+            message: "failed to install ouro command",
+            meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+        });
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: error instanceof Error ? error.message : /* v8 ignore next -- defensive @preserve */ String(error) };
+    }
+    // Check if ~/.local/bin is already in PATH
+    let shellProfileUpdated = null;
+    const pathReady = isBinDirInPath(binDir, envPath);
+    if (!pathReady) {
+        const profilePath = detectShellProfile(homeDir, shell);
+        if (profilePath) {
+            try {
+                let existing = "";
+                try {
+                    existing = readFileSync(profilePath, "utf-8");
+                }
+                catch {
+                    // Profile doesn't exist yet — that's fine, we'll create it
+                }
+                if (!existing.includes(binDir)) {
+                    appendFileSync(profilePath, buildPathExportLine(binDir, shell));
+                    shellProfileUpdated = profilePath;
+                }
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.ouro_path_profile_error",
+                    message: "failed to update shell profile for PATH",
+                    meta: { profilePath, error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+                });
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_end",
+        message: "ouro command installed",
+        meta: { scriptPath, pathReady, shellProfileUpdated },
+    });
+    return { installed: true, scriptPath, pathReady, shellProfileUpdated };
+}

package/dist/heart/daemon/process-manager.js

@@ -100,7 +100,7 @@ class DaemonProcessManager {
         const child = this.spawnFn("node", args, {
             cwd: runCwd,
             env: state.config.env ? { ...process.env, ...state.config.env } : process.env,
-            stdio: ["ignore", "ignore", "ignore"],
+            stdio: ["ignore", "ignore", "ignore", "ipc"],
         });
         state.process = child;
         state.snapshot.status = "running";
@@ -151,6 +151,23 @@ class DaemonProcessManager {
             await this.stopAgent(state.config.name);
         }
     }
+    sendToAgent(agent, message) {
+        const state = this.requireAgent(agent);
+        if (!state.process)
+            return;
+        try {
+            state.process.send(message);
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.agent_ipc_send_error",
+                message: "failed to send IPC message to managed agent",
+                meta: { agent },
+            });
+        }
+    }
     getAgentSnapshot(agent) {
         return this.agents.get(agent)?.snapshot;
     }

package/dist/heart/daemon/runtime-logging.js

@@ -43,23 +43,27 @@ const DEFAULT_RUNTIME_LOGGING = {
     level: "info",
     sinks: ["terminal", "ndjson"],
 };
+function defaultLevelForProcess(processName) {
+    return processName === "daemon" ? "info" : "warn";
+}
 function isLogLevel(value) {
     return value === "debug" || value === "info" || value === "warn" || value === "error";
 }
-function resolveRuntimeLoggingConfig(configPath) {
+function resolveRuntimeLoggingConfig(configPath, processName) {
+    const defaultLevel = defaultLevelForProcess(processName);
     let parsed = null;
     try {
         const raw = fs.readFileSync(configPath, "utf-8");
         parsed = JSON.parse(raw);
     }
     catch {
-        return { ...DEFAULT_RUNTIME_LOGGING };
+        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
     }
     if (!parsed || typeof parsed !== "object") {
-        return { ...DEFAULT_RUNTIME_LOGGING };
+        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
     }
     const candidate = parsed;
-    const level = isLogLevel(candidate.level) ? candidate.level : DEFAULT_RUNTIME_LOGGING.level;
+    const level = isLogLevel(candidate.level) ? candidate.level : defaultLevel;
     const sinks = Array.isArray(candidate.sinks)
         ? candidate.sinks.filter((entry) => entry === "terminal" || entry === "ndjson")
         : DEFAULT_RUNTIME_LOGGING.sinks;
@@ -71,7 +75,7 @@ function resolveRuntimeLoggingConfig(configPath) {
 function configureDaemonRuntimeLogger(processName, options = {}) {
     const homeDir = options.homeDir ?? os.homedir();
     const configPath = options.configPath ?? path.join(homeDir, ".agentstate", "daemon", "logging.json");
-    const config = resolveRuntimeLoggingConfig(configPath);
+    const config = resolveRuntimeLoggingConfig(configPath, processName);
     const sinks = config.sinks.map((sinkName) => {
         if (sinkName === "terminal") {
             return (0, nerves_1.createTerminalSink)();

package/dist/heart/daemon/specialist-orchestrator.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAdoptionSpecialist = runAdoptionSpecialist;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+const config_1 = require("../config");
+const core_1 = require("../core");
+const hatch_flow_1 = require("./hatch-flow");
+const specialist_prompt_1 = require("./specialist-prompt");
+const specialist_tools_1 = require("./specialist-tools");
+const specialist_session_1 = require("./specialist-session");
+function listExistingBundles(bundlesRoot) {
+    let entries;
+    try {
+        entries = fs.readdirSync(bundlesRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const discovered = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+            continue;
+        const agentName = entry.name.slice(0, -5);
+        discovered.push(agentName);
+    }
+    return discovered.sort((a, b) => a.localeCompare(b));
+}
+function loadIdentityPhrases(bundleSourceDir, identityFileName) {
+    const agentJsonPath = path.join(bundleSourceDir, "agent.json");
+    try {
+        const raw = fs.readFileSync(agentJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const identityKey = identityFileName.replace(/\.md$/, "");
+        const identity = parsed.identityPhrases?.[identityKey];
+        if (identity?.thinking?.length && identity?.tool?.length && identity?.followup?.length) {
+            return identity;
+        }
+        if (parsed.phrases?.thinking?.length && parsed.phrases?.tool?.length && parsed.phrases?.followup?.length) {
+            return parsed.phrases;
+        }
+    }
+    catch {
+        // agent.json missing or malformed — fall through
+    }
+    return { ...identity_1.DEFAULT_AGENT_PHRASES };
+}
+function pickRandomIdentity(identitiesDir, random) {
+    const files = fs.readdirSync(identitiesDir).filter((f) => f.endsWith(".md"));
+    if (files.length === 0) {
+        return { fileName: "default", content: "I am the adoption specialist." };
+    }
+    const idx = Math.floor(random() * files.length);
+    const fileName = files[idx];
+    const content = fs.readFileSync(path.join(identitiesDir, fileName), "utf-8");
+    return { fileName, content };
+}
+/**
+ * Run the full adoption specialist flow:
+ * 1. Pick a random identity from the bundled AdoptionSpecialist.ouro
+ * 2. Read SOUL.md
+ * 3. List existing bundles
+ * 4. Build system prompt
+ * 5. Set up provider (setAgentName, setAgentConfigOverride, writeSecretsFile, reset caches)
+ * 6. Run the specialist session
+ * 7. Clean up identity/config overrides
+ * 8. Return hatchling name
+ */
+async function runAdoptionSpecialist(deps) {
+    const { bundleSourceDir, bundlesRoot, secretsRoot, provider, credentials, humanName, callbacks, signal } = deps;
+    const random = deps.random ?? Math.random;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_orchestrator_start",
+        message: "starting adoption specialist orchestrator",
+        meta: { provider, bundleSourceDir },
+    });
+    // 1. Read SOUL.md
+    const soulPath = path.join(bundleSourceDir, "psyche", "SOUL.md");
+    let soulText = "";
+    try {
+        soulText = fs.readFileSync(soulPath, "utf-8");
+    }
+    catch {
+        // No SOUL.md -- proceed without it
+    }
+    // 2. Pick random identity
+    const identitiesDir = path.join(bundleSourceDir, "psyche", "identities");
+    const identity = pickRandomIdentity(identitiesDir, random);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_identity_picked",
+        message: "picked specialist identity",
+        meta: { identity: identity.fileName },
+    });
+    // 3. List existing bundles
+    const existingBundles = listExistingBundles(bundlesRoot);
+    // 4. Build system prompt
+    const systemPrompt = (0, specialist_prompt_1.buildSpecialistSystemPrompt)(soulText, identity.content, existingBundles);
+    // 5. Set up provider with identity-specific phrases
+    const phrases = loadIdentityPhrases(bundleSourceDir, identity.fileName);
+    (0, identity_1.setAgentName)("AdoptionSpecialist");
+    (0, identity_1.setAgentConfigOverride)({
+        version: 1,
+        enabled: true,
+        provider,
+        phrases,
+    });
+    (0, hatch_flow_1.writeSecretsFile)("AdoptionSpecialist", provider, credentials, secretsRoot);
+    (0, config_1.resetConfigCache)();
+    (0, core_1.resetProviderRuntime)();
+    try {
+        // Create provider runtime
+        const providerRuntime = (0, core_1.createProviderRegistry)().resolve();
+        if (!providerRuntime) {
+            throw new Error("Failed to create provider runtime for adoption specialist");
+        }
+        // 6. Run session
+        const tools = (0, specialist_tools_1.getSpecialistTools)();
+        const readline = deps.createReadline();
+        const ctrl = readline.inputController;
+        const result = await (0, specialist_session_1.runSpecialistSession)({
+            providerRuntime,
+            systemPrompt,
+            tools,
+            execTool: (name, args) => (0, specialist_tools_1.execSpecialistTool)(name, args, {
+                humanName,
+                provider,
+                credentials,
+                bundlesRoot,
+                secretsRoot,
+                specialistIdentitiesDir: identitiesDir,
+            }),
+            readline,
+            callbacks,
+            signal,
+            kickoffMessage: "hi, i just ran ouro for the first time",
+            suppressInput: ctrl ? (onInterrupt) => ctrl.suppress(onInterrupt) : undefined,
+            restoreInput: ctrl ? () => ctrl.restore() : undefined,
+            flushMarkdown: callbacks.flushMarkdown,
+            writePrompt: ctrl ? () => process.stdout.write("\x1b[36m> \x1b[0m") : undefined,
+        });
+        return result.hatchedAgentName;
+    }
+    finally {
+        // 7. Cleanup: restore identity/config state
+        (0, identity_1.setAgentConfigOverride)(null);
+        (0, config_1.resetConfigCache)();
+        (0, core_1.resetProviderRuntime)();
+    }
+}

package/dist/heart/daemon/specialist-prompt.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSpecialistSystemPrompt = buildSpecialistSystemPrompt;
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Build the adoption specialist's system prompt from its components.
+ * The prompt is written in first person (the specialist's own voice).
+ */
+function buildSpecialistSystemPrompt(soulText, identityText, existingBundles) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_prompt_build",
+        message: "building specialist system prompt",
+        meta: { bundleCount: existingBundles.length },
+    });
+    const sections = [];
+    if (soulText) {
+        sections.push(soulText);
+    }
+    if (identityText) {
+        sections.push(identityText);
+    }
+    if (existingBundles.length > 0) {
+        sections.push(`## Existing agents\nThe human already has these agents: ${existingBundles.join(", ")}.`);
+    }
+    else {
+        sections.push("## Existing agents\nThe human has no agents yet. This will be their first hatchling.");
+    }
+    sections.push([
+        "## Who I am",
+        "I am one of thirteen adoption specialists. The system randomly selected me for this session.",
+        "Most humans only go through adoption once, so this is likely the only time they'll meet me.",
+        "I make this encounter count — warm, memorable, and uniquely mine.",
+        "",
+        "## Voice rules",
+        "IMPORTANT: I keep every response to 1-3 short sentences. I sound like a friend texting, not a manual.",
+        "I NEVER use headers, bullet lists, numbered lists, or markdown formatting.",
+        "I ask ONE question at a time. I do not dump multiple questions or options.",
+        "I am warm but brief. Every word earns its place.",
+        "",
+        "## Conversation flow",
+        "The human just connected. I speak first — I greet them warmly and introduce myself in my own voice.",
+        "I briefly mention that I'm one of several adoption specialists and they got me today.",
+        "I ask their name.",
+        "Then I ask what they'd like their agent to help with — one question at a time.",
+        "I'm proactive: I suggest ideas and guide them. If they seem unsure, I offer a concrete suggestion.",
+        "I don't wait for the human to figure things out — I explain simply what an agent is if needed.",
+        "When I have enough context, I suggest a name for the hatchling and confirm with the human.",
+        "Then I call `hatch_agent` with the agent name and the human's name.",
+        "",
+        "## Tools",
+        "I have these tools available:",
+        "- `hatch_agent`: Create a new agent bundle. I call this with `name` (the agent name, PascalCase) and `humanName` (what the human told me their name is).",
+        "- `final_answer`: End the conversation with a final message to the human. I call this when the adoption process is complete.",
+        "- `read_file`: Read a file from disk. Useful for reviewing existing agent bundles or migration sources.",
+        "- `list_directory`: List directory contents. Useful for exploring existing agent bundles.",
+        "",
+        "I must call `final_answer` when I am done to end the session cleanly.",
+    ].join("\n"));
+    return sections.join("\n\n");
+}

package/dist/heart/daemon/specialist-session.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSpecialistSession = runSpecialistSession;
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Run the specialist conversation session loop.
+ *
+ * The loop:
+ * 1. Initialize messages with system prompt
+ * 2. Prompt user -> add to messages -> call streamTurn -> process result
+ * 3. If result has no tool calls: push assistant message, re-prompt
+ * 4. If result has final_answer sole call: extract answer, emit via callbacks, done
+ * 5. If result has other tool calls: execute each, push tool results, continue loop
+ * 6. On abort signal: clean exit
+ * 7. Return { hatchedAgentName } -- name from hatch_agent if called
+ */
+async function runSpecialistSession(deps) {
+    const { providerRuntime, systemPrompt, tools, execTool, readline, callbacks, signal, kickoffMessage, suppressInput, restoreInput, flushMarkdown, writePrompt, } = deps;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_session_start",
+        message: "starting specialist session loop",
+        meta: {},
+    });
+    const messages = [
+        { role: "system", content: systemPrompt },
+    ];
+    let hatchedAgentName = null;
+    let done = false;
+    let isFirstTurn = true;
+    let currentAbort = null;
+    try {
+        while (!done) {
+            if (signal?.aborted)
+                break;
+            // On the first turn with a kickoff message, inject it so the specialist speaks first
+            if (isFirstTurn && kickoffMessage) {
+                isFirstTurn = false;
+                messages.push({ role: "user", content: kickoffMessage });
+            }
+            else {
+                // Get user input
+                const userInput = await readline.question(writePrompt ? "" : "> ");
+                if (!userInput.trim()) {
+                    if (writePrompt)
+                        writePrompt();
+                    continue;
+                }
+                messages.push({ role: "user", content: userInput });
+            }
+            providerRuntime.resetTurnState(messages);
+            // Suppress input during model execution
+            currentAbort = new AbortController();
+            const mergedSignal = signal;
+            if (suppressInput) {
+                suppressInput(() => currentAbort.abort());
+            }
+            // Inner loop: process tool calls until we get a final_answer or plain text
+            let turnDone = false;
+            while (!turnDone) {
+                if (mergedSignal?.aborted || currentAbort.signal.aborted) {
+                    done = true;
+                    break;
+                }
+                callbacks.onModelStart();
+                const result = await providerRuntime.streamTurn({
+                    messages,
+                    activeTools: tools,
+                    callbacks,
+                    signal: mergedSignal,
+                });
+                // Build assistant message
+                const assistantMsg = {
+                    role: "assistant",
+                };
+                if (result.content)
+                    assistantMsg.content = result.content;
+                if (result.toolCalls.length) {
+                    assistantMsg.tool_calls = result.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    }));
+                }
+                if (!result.toolCalls.length) {
+                    // Plain text response -- flush markdown, push and re-prompt
+                    if (flushMarkdown)
+                        flushMarkdown();
+                    messages.push(assistantMsg);
+                    turnDone = true;
+                    continue;
+                }
+                // Check for final_answer
+                const isSoleFinalAnswer = result.toolCalls.length === 1 && result.toolCalls[0].name === "final_answer";
+                if (isSoleFinalAnswer) {
+                    let answer;
+                    try {
+                        const parsed = JSON.parse(result.toolCalls[0].arguments);
+                        if (typeof parsed === "string") {
+                            answer = parsed;
+                        }
+                        else if (parsed.answer != null) {
+                            answer = parsed.answer;
+                        }
+                    }
+                    catch {
+                        // malformed
+                    }
+                    if (answer != null) {
+                        callbacks.onTextChunk(answer);
+                        if (flushMarkdown)
+                            flushMarkdown();
+                        messages.push(assistantMsg);
+                        done = true;
+                        turnDone = true;
+                        continue;
+                    }
+                    // Malformed final_answer -- ask model to retry
+                    messages.push(assistantMsg);
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: result.toolCalls[0].id,
+                        content: "your final_answer was incomplete or malformed. call final_answer again with your complete response.",
+                    });
+                    providerRuntime.appendToolOutput(result.toolCalls[0].id, "retry");
+                    continue;
+                }
+                // Execute tool calls
+                messages.push(assistantMsg);
+                for (const tc of result.toolCalls) {
+                    if (mergedSignal?.aborted)
+                        break;
+                    let args = {};
+                    try {
+                        args = JSON.parse(tc.arguments);
+                    }
+                    catch {
+                        // ignore parse error
+                    }
+                    callbacks.onToolStart(tc.name, args);
+                    let toolResult;
+                    try {
+                        toolResult = await execTool(tc.name, args);
+                    }
+                    catch (e) {
+                        toolResult = `error: ${e}`;
+                    }
+                    callbacks.onToolEnd(tc.name, tc.name, true);
+                    // Track hatchling name
+                    if (tc.name === "hatch_agent" && args.name) {
+                        hatchedAgentName = args.name;
+                    }
+                    messages.push({ role: "tool", tool_call_id: tc.id, content: toolResult });
+                    providerRuntime.appendToolOutput(tc.id, toolResult);
+                }
+                // After processing tool calls, continue inner loop for tool result processing
+            }
+            // Restore input and show prompt for next turn
+            if (flushMarkdown)
+                flushMarkdown();
+            if (restoreInput)
+                restoreInput();
+            currentAbort = null;
+            if (!done) {
+                process.stdout.write("\n\n");
+                if (writePrompt)
+                    writePrompt();
+            }
+        }
+    }
+    finally {
+        if (restoreInput)
+            restoreInput();
+        readline.close();
+    }
+    return { hatchedAgentName };
+}