openbot 0.2.12 → 0.2.14

package/dist/automations.js

@@ -1,52 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from "./config.js";
-function getAutomationsPath() {
-    const cfg = loadConfig();
-    const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
-    const resolvedBaseDir = resolvePath(baseDir);
-    return path.join(resolvedBaseDir, "automations.json");
-}
-export async function listAutomations() {
-    const filePath = getAutomationsPath();
-    try {
-        const raw = await fs.readFile(filePath, "utf-8");
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed))
-            return [];
-        return parsed
-            .filter((item) => item && typeof item === "object")
-            .map((item) => {
-            const targetType = item.targetType === "agent" ? "agent" : "orchestrator";
-            const agentName = typeof item.agentName === "string" && item.agentName.trim()
-                ? item.agentName.trim()
-                : undefined;
-            return {
-                id: typeof item.id === "string" ? item.id : "",
-                name: typeof item.name === "string" ? item.name : "",
-                prompt: typeof item.prompt === "string" ? item.prompt : "",
-                cron: typeof item.cron === "string" ? item.cron : "",
-                targetType,
-                agentName: targetType === "agent" ? agentName : undefined,
-                enabled: Boolean(item.enabled),
-                createdAt: typeof item.createdAt === "string" ? item.createdAt : new Date().toISOString(),
-                updatedAt: typeof item.updatedAt === "string" ? item.updatedAt : new Date().toISOString(),
-            };
-        })
-            .filter((item) => {
-            if (!item.id || !item.name || !item.prompt || !item.cron)
-                return false;
-            if (item.targetType === "agent" && !item.agentName)
-                return false;
-            return true;
-        });
-    }
-    catch {
-        return [];
-    }
-}
-export async function saveAutomations(items) {
-    const filePath = getAutomationsPath();
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(items, null, 2), "utf-8");
-}

package/dist/cli.js

@@ -1,279 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import * as readline from "node:readline/promises";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { spawn } from "node:child_process";
-import { saveConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
-import { startServer } from "./server.js";
-import { getPluginMetadata } from "./registry/plugin-loader.js";
-import { checkGitHubRepo, checkNpmPackage, parsePluginInstallSource, parseAgentInstallSource, installPluginFromSource, installAgentFromSource, } from "./installers.js";
-const program = new Command();
-const REQUIRED_NODE_VERSION = "20.12.0";
-function checkNodeVersion() {
-    const [major, minor, patch] = process.versions.node.split(".").map(Number);
-    const [reqMajor, reqMinor, reqPatch] = REQUIRED_NODE_VERSION.split(".").map(Number);
-    const isOld = major < reqMajor ||
-        (major === reqMajor && minor < reqMinor) ||
-        (major === reqMajor && minor === reqMinor && patch < reqPatch);
-    if (isOld) {
-        console.warn(`\n⚠️  WARNING: You are using Node.js ${process.version}.`);
-        console.warn(`   OpenBot works best with Node.js >=${REQUIRED_NODE_VERSION}.`);
-        console.warn(`   You may encounter "ERR_REQUIRE_ESM" or other compatibility issues on older versions.\n`);
-    }
-}
-checkNodeVersion();
-program
-    .name("openbot")
-    .description("OpenBot CLI - Secure and easy configuration")
-    .version("0.2.12");
-async function installPlugin(source, id, quiet = false) {
-    try {
-        const parsed = parsePluginInstallSource(source);
-        const name = await installPluginFromSource(parsed, { quiet, id });
-        return name;
-    }
-    catch (err) {
-        if (!quiet)
-            console.error("\n❌ Plugin installation failed:", err instanceof Error ? err.message : String(err));
-        if (!quiet)
-            process.exit(1);
-        throw err;
-    }
-}
-async function installAgent(source, id) {
-    try {
-        const parsed = parseAgentInstallSource(source);
-        const name = await installAgentFromSource(parsed, { id });
-        return name;
-    }
-    catch (err) {
-        console.error("\n❌ Agent installation failed:", err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-}
-function shellEscape(arg) {
-    // Keep simple tokens readable; quote only when needed so command
-    // tokenization remains stable when passed through concurrently.
-    if (/^[A-Za-z0-9_/:=+.-]+$/.test(arg))
-        return arg;
-    return `"${arg.replace(/(["\\$`])/g, "\\$1")}"`;
-}
-program
-    .command("configure")
-    .description("Configure OpenBot model and settings")
-    .action(async () => {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    console.log("------------------------------------------");
-    console.log("🍎 OpenBot Configuration");
-    console.log("------------------------------------------");
-    const models = [
-        { name: "GPT-5 Nano (OpenAI)", value: "openai/gpt-5-nano" },
-        { name: "GPT-4o (OpenAI)", value: "openai/gpt-4o" },
-        { name: "GPT-4o-mini (OpenAI)", value: "openai/gpt-4o-mini" },
-        { name: "Claude Opus 4.5 (Anthropic)", value: "anthropic/claude-opus-4-5-20251101" },
-        { name: "Claude Sonnet 4.5 (Anthropic)", value: "anthropic/claude-sonnet-4-5-20250929" },
-        { name: "Claude 3.7 Sonnet (Anthropic)", value: "anthropic/claude-3-7-sonnet-20250219" },
-        { name: "Claude 3.5 Sonnet (Anthropic)", value: "anthropic/claude-3-5-sonnet-20240620" },
-    ];
-    console.log("Please choose a model:");
-    models.forEach((m, i) => console.log(`${i + 1}) ${m.name}`));
-    const choice = await rl.question(`\nSelection (1-${models.length}): `);
-    const selectedIndex = parseInt(choice) - 1;
-    if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= models.length) {
-        console.error("❌ Invalid selection. Please run configure again.");
-        rl.close();
-        return;
-    }
-    const selectedModel = models[selectedIndex].value;
-    const provider = selectedModel.startsWith("openai") ? "openai" : "anthropic";
-    saveConfig({
-        model: selectedModel,
-    });
-    console.log("\n✅ Configuration saved!");
-    console.log(`Selected model: ${selectedModel}`);
-    console.log("------------------------------------------");
-    if (provider === "openai") {
-        console.log("To start the server with your OpenAI key, use:");
-        console.log(`\n  openbot server --openai-api-key YOUR_OPENAI_KEY\n`);
-    }
-    else {
-        console.log("To start the server with your Anthropic key, use:");
-        console.log(`\n  openbot server --anthropic-api-key YOUR_ANTHROPIC_KEY\n`);
-    }
-    console.log("Alternatively, you can set the environment variable:");
-    console.log(provider === "openai" ? "  export OPENAI_API_KEY=your-key" : "  export ANTHROPIC_API_KEY=your-key");
-    console.log("------------------------------------------");
-    console.log("\n🚀 TIP: Use 'openbot up' to start the server and web UI together.");
-    console.log("------------------------------------------\n");
-    rl.close();
-});
-program
-    .command("server")
-    .description("Start the OpenBot server")
-    .option("-p, --port <number>", "Port to listen on")
-    .option("--openai-api-key <key>", "OpenAI API Key")
-    .option("--anthropic-api-key <key>", "Anthropic API Key")
-    .action(async (options) => {
-    await startServer(options);
-});
-program
-    .command("up")
-    .description("Start OpenBot server and web dashboard together")
-    .option("-p, --port <number>", "Port to listen on")
-    .option("--openai-api-key <key>", "OpenAI API Key")
-    .option("--anthropic-api-key <key>", "Anthropic API Key")
-    .action(async (options) => {
-    const serverArgs = ["openbot", "server"];
-    if (options.port)
-        serverArgs.push("--port", String(options.port));
-    if (options.openaiApiKey)
-        serverArgs.push("--openai-api-key", options.openaiApiKey);
-    if (options.anthropicApiKey)
-        serverArgs.push("--anthropic-api-key", options.anthropicApiKey);
-    const serverCommand = serverArgs.map(shellEscape).join(" ");
-    await new Promise((resolve, reject) => {
-        const child = spawn("npx", [
-            "-y",
-            "concurrently",
-            "--kill-others",
-            "--names",
-            "SERVER,WEBUI",
-            "--prefix",
-            "{name}",
-            "--prefix-colors",
-            "blue.bold,green.bold",
-            serverCommand,
-            "openbot-web",
-        ], { stdio: "inherit" });
-        child.on("error", reject);
-        child.on("exit", (code) => {
-            if (typeof code === "number")
-                process.exitCode = code;
-            resolve();
-        });
-    });
-});
-program
-    .command("add <name>")
-    .description("Add an agent or plugin by name (auto-resolves to GitHub/NPM)")
-    .action(async (name) => {
-    // 1. Try as Agent
-    const agentRepo = `meetopenbot/agent-${name}`;
-    if (checkGitHubRepo(agentRepo)) {
-        await installAgent(agentRepo, `agent-${name}`);
-        return;
-    }
-    // 2. Try as Plugin
-    const baseDir = resolvePath(DEFAULT_BASE_DIR);
-    const agentPath = path.join(baseDir, "agents", name);
-    const pluginPath = path.join(baseDir, "plugins", name);
-    const agentExists = await fs.access(agentPath).then(() => true).catch(() => false);
-    const pluginExists = await fs.access(pluginPath).then(() => true).catch(() => false);
-    if (agentExists || pluginExists) {
-        console.log(`✅ Agent or Plugin "${name}" is already installed locally.`);
-        return;
-    }
-    // Check GitHub Plugin
-    const pluginGhRepo = `meetopenbot/plugin-${name}`;
-    if (checkGitHubRepo(pluginGhRepo)) {
-        await installPlugin(pluginGhRepo, `plugin-${name}`);
-        return;
-    }
-    // Check NPM Plugin
-    const pluginNpmPkg = `@melony/plugin-${name}`;
-    if (checkNpmPackage(pluginNpmPkg)) {
-        await installPlugin(pluginNpmPkg, `plugin-${name}`);
-        return;
-    }
-    console.error(`❌ Could not find agent or plugin named "${name}" in official repositories.`);
-    process.exit(1);
-});
-const plugin = program.command("plugin").description("Manage OpenBot plugins");
-plugin
-    .command("install <source>")
-    .description("Install a shared plugin from GitHub (user/repo) or a local path")
-    .action(async (source) => {
-    await installPlugin(source);
-});
-plugin
-    .command("list")
-    .description("List all installed shared plugins")
-    .action(async () => {
-    const baseDir = resolvePath(DEFAULT_BASE_DIR);
-    const pluginsDir = path.join(baseDir, "plugins");
-    try {
-        await fs.access(pluginsDir);
-    }
-    catch {
-        console.log("No shared plugins found.");
-        return;
-    }
-    const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
-    const plugins = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        if (entry.name.startsWith(".") || entry.name.startsWith("_"))
-            continue;
-        const pluginDir = path.join(pluginsDir, entry.name);
-        const { name, version, description } = await getPluginMetadata(pluginDir);
-        plugins.push({ name, version, description });
-    }
-    if (plugins.length === 0) {
-        console.log("No shared plugins found.");
-        return;
-    }
-    console.log("\n🔌 Installed Shared Plugins:");
-    console.log("------------------------------------------");
-    for (const p of plugins) {
-        console.log(`${p.name.padEnd(20)} (${p.version}) - ${p.description}`);
-    }
-    console.log("------------------------------------------\n");
-});
-const agent = program.command("agent").description("Manage OpenBot agents");
-agent
-    .command("install <source>")
-    .description("Install a custom agent from GitHub (user/repo) or a local path")
-    .action(async (source) => {
-    await installAgent(source);
-});
-agent
-    .command("list")
-    .description("List all installed custom agents")
-    .action(async () => {
-    const baseDir = resolvePath(DEFAULT_BASE_DIR);
-    const agentsDir = path.join(baseDir, "agents");
-    try {
-        await fs.access(agentsDir);
-    }
-    catch {
-        console.log("No custom agents found.");
-        return;
-    }
-    const entries = await fs.readdir(agentsDir, { withFileTypes: true });
-    const agents = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        if (entry.name.startsWith(".") || entry.name.startsWith("_"))
-            continue;
-        const agentDir = path.join(agentsDir, entry.name);
-        const { name, version, description } = await getPluginMetadata(agentDir);
-        agents.push({ name, version, description });
-    }
-    if (agents.length === 0) {
-        console.log("No custom agents found.");
-        return;
-    }
-    console.log("\n🤖 Installed Custom Agents:");
-    console.log("------------------------------------------");
-    for (const a of agents) {
-        console.log(`${a.name.padEnd(20)} (${a.version}) - ${a.description}`);
-    }
-    console.log("------------------------------------------\n");
-});
-program.parse();

package/dist/config.js

@@ -1,53 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-export const DEFAULT_BASE_DIR = "~/.openbot";
-export const DEFAULT_PLUGINS_DIR = "plugins";
-export const DEFAULT_AGENTS_DIR = "agents";
-export function loadConfig() {
-    const configPath = path.join(os.homedir(), ".openbot", "config.json");
-    if (fs.existsSync(configPath)) {
-        try {
-            return JSON.parse(fs.readFileSync(configPath, "utf-8"));
-        }
-        catch (error) {
-            console.error(`Warning: Failed to parse config at ${configPath}`, error);
-        }
-    }
-    return {};
-}
-export function saveConfig(config) {
-    const configDir = path.join(os.homedir(), ".openbot");
-    const configPath = path.join(configDir, "config.json");
-    if (!fs.existsSync(configDir)) {
-        fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-    }
-    const currentConfig = loadConfig();
-    const newConfig = { ...currentConfig, ...config };
-    fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2), { mode: 0o600 });
-}
-export function isConfigured() {
-    const configPath = path.join(os.homedir(), ".openbot", "config.json");
-    return fs.existsSync(configPath);
-}
-export function resolvePath(p) {
-    return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : path.resolve(p);
-}
-export const DEFAULT_AGENT_MD = `---
-name: Agent
-description: A specialized AI agent
-plugins:
-  - shell
-  - file-system
----
-
-# Agent Profile
-
-You are a specialized AI agent within the OpenBot system.
-Your role is defined by your configuration and the tools you have access to.
-
-## Persona
-- Helpful and precise
-- Focused on my specific domain
-- Professional in all interactions
-`;

package/dist/core/agents.js

@@ -1,41 +0,0 @@
-import { osAgent } from "../agents/os-agent.js";
-import { agentCreatorAgent } from "../agents/agent-creator.js";
-import { plannerAgent } from "../agents/planner-agent.js";
-import { shellToolDefinitions } from "../plugins/shell/index.js";
-import { fileSystemToolDefinitions } from "../plugins/file-system/index.js";
-import { AgentRegistry, discoverYamlAgents, discoverTsAgents } from "../registry/index.js";
-import path from "node:path";
-export async function setupAgentRegistry(resolvedBaseDir, pluginRegistry, model, options) {
-    const agentRegistry = new AgentRegistry();
-    agentRegistry.register({
-        name: "os",
-        description: "Handles shell commands and file system operations",
-        capabilities: {
-            ...Object.fromEntries(Object.entries(shellToolDefinitions).map(([k, v]) => [k, v.description])),
-            ...Object.fromEntries(Object.entries(fileSystemToolDefinitions).map(([k, v]) => [k, v.description])),
-        },
-        plugin: osAgent({ model }),
-    });
-    agentRegistry.register({
-        name: "agent-creator",
-        description: "Helps the user create and configure new custom OpenBot agents via natural language.",
-        capabilities: {
-            ...Object.fromEntries(Object.entries(fileSystemToolDefinitions).map(([k, v]) => [k, v.description])),
-        },
-        plugin: agentCreatorAgent({ model }),
-    });
-    agentRegistry.register({
-        name: "planner-agent",
-        description: "Creates concise execution plans from user intent for OpenBot to run.",
-        plugin: plannerAgent({ model }),
-    });
-    const agentsDir = path.join(resolvedBaseDir, "agents");
-    const [yamlAgents, tsAgents] = await Promise.all([
-        discoverYamlAgents(agentsDir, pluginRegistry, model, options),
-        discoverTsAgents(agentsDir, model, options),
-    ]);
-    for (const agent of [...yamlAgents, ...tsAgents]) {
-        agentRegistry.register(agent);
-    }
-    return agentRegistry;
-}

package/dist/core/delegation.js

@@ -1,230 +0,0 @@
-import { generateId } from "melony";
-import { uiEvent } from "../ui/block.js";
-import { widgets } from "../ui/widgets/index.js";
-/**
- * Simple helper to set a value in an object by a dot-separated path.
- */
-function setByPath(obj, path, value) {
-    const parts = path.split(".");
-    let current = obj;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (!(part in current)) {
-            current[part] = {};
-        }
-        current = current[part];
-    }
-    current[parts[parts.length - 1]] = value;
-}
-/**
- * Helper to emit a UI snapshot for a widget if applicable.
- */
-function* maybeEmitWidget(key, value) {
-    if (!value || typeof value !== "object")
-        return;
-    let widgetName = value.widget;
-    let data = value;
-    // 1. Check for nested .todos array (common pattern for planner/task agents)
-    if (!widgetName && Array.isArray(value.todos)) {
-        widgetName = "todoList";
-        data = value.todos;
-    }
-    // 2. Fallback for direct arrays if key matches known patterns
-    if (!widgetName && Array.isArray(value) && ["todos", "todoList", "project_plan"].includes(key)) {
-        widgetName = "todoList";
-        data = value;
-    }
-    // If we found a valid widget and data is an array, emit the UI event
-    if (widgetName && widgets[widgetName] && Array.isArray(data)) {
-        const isTodo = widgetName === "todoList";
-        yield uiEvent(widgets[widgetName](data, {
-            placement: isTodo ? "attention" : "sidebar",
-            id: isTodo ? `attention-${key}` : `sidebar-${key}`,
-            meta: { title: key === "project_plan" ? "Project Plan" : (key.charAt(0).toUpperCase() + key.slice(1).replace(/_/g, ' ')) }
-        }));
-    }
-}
-export function setupDelegation(builder, agentRuntimes) {
-    builder.on("action:updateSessionState", async function* (event, context) {
-        const { path, value, toolCallId } = event.data;
-        const state = context.state;
-        try {
-            setByPath(state, path, value);
-            const topLevelKey = path.split(".")[0];
-            yield* maybeEmitWidget(topLevelKey, state[topLevelKey]);
-            yield {
-                type: "action:result",
-                data: {
-                    action: "updateSessionState",
-                    result: `Successfully updated state at path "${path}".`,
-                    toolCallId,
-                },
-            };
-        }
-        catch (error) {
-            yield {
-                type: "action:result",
-                data: {
-                    action: "updateSessionState",
-                    result: `Error updating state: ${error.message}`,
-                    toolCallId,
-                },
-            };
-        }
-    });
-    builder.on("action:delegateTask", async function* (event, context) {
-        const { agentId, toolCallId, task, stateKey, attachments } = event.data;
-        const agentRuntime = agentRuntimes.get(agentId);
-        // If the agent is not found, return an error
-        if (!agentRuntime) {
-            yield {
-                type: "action:result",
-                data: {
-                    action: "delegateTask",
-                    result: `Error: Agent "${agentId}" not found.`,
-                    toolCallId,
-                },
-            };
-            return;
-        }
-        const delegationId = `del_${generateId()}`;
-        // Signal delegation start for UI
-        yield {
-            type: "delegation:start",
-            meta: { delegationId, agentName: agentId },
-            data: { agent: agentId, task },
-        };
-        // Initialize agent isolated state if not present
-        const state = context.state;
-        if (!state.agentStates)
-            state.agentStates = {};
-        if (!state.agentStates[agentId])
-            state.agentStates[agentId] = {};
-        const agentState = state.agentStates[agentId];
-        const agentIterator = agentRuntime.run({
-            type: "agent:input",
-            data: { content: task, attachments },
-        }, {
-            runId: delegationId,
-            state: agentState,
-        });
-        let lastAgentOutput = "";
-        let pendingApprovalId;
-        try {
-            for await (const agentEvent of agentIterator) {
-                // Dedicated suspend event from approval plugin.
-                // Emit included UI event (if any), then park this delegation until approve/deny.
-                if (agentEvent.type === "suspend") {
-                    const suspendData = agentEvent.data ?? {};
-                    const suspendId = typeof suspendData.id === "string" ? suspendData.id : undefined;
-                    const suspendUiEvent = suspendData.event;
-                    if (suspendUiEvent && typeof suspendUiEvent === "object" && typeof suspendUiEvent.type === "string") {
-                        yield {
-                            ...suspendUiEvent,
-                            meta: { ...suspendUiEvent.meta, delegationId, agentName: agentId },
-                        };
-                    }
-                    if (suspendId) {
-                        pendingApprovalId = suspendId;
-                    }
-                    continue;
-                }
-                // Forward agent events to the main runtime so the user sees progress.
-                // We SKIP forwarding 'agent:input' because it triggers the manager's LLM again.
-                // Instead, we yield it as 'agent:sub-input' for logging/monitoring.
-                if (agentEvent.type === "agent:input") {
-                    yield {
-                        ...agentEvent,
-                        type: "agent:sub-input",
-                        meta: { ...agentEvent.meta, delegationId, agentName: agentId },
-                    };
-                    continue;
-                }
-                // We wrap sub-agent actions to avoid triggering manager handlers if they share names.
-                if (agentEvent.type.startsWith("action:") && agentEvent.type !== "action:result") {
-                    yield {
-                        ...agentEvent,
-                        type: "agent:sub-action",
-                        meta: { ...agentEvent.meta, delegationId, agentName: agentId },
-                        data: { ...agentEvent.data, originalType: agentEvent.type },
-                    };
-                    continue;
-                }
-                // Wrap action results to avoid confusion with manager action results.
-                if (agentEvent.type === "action:result") {
-                    yield {
-                        ...agentEvent,
-                        type: "agent:sub-action-result",
-                        meta: { ...agentEvent.meta, delegationId, agentName: agentId },
-                    };
-                    continue;
-                }
-                // Wrap usage updates to avoid confusion with manager usage.
-                if (agentEvent.type === "usage:update") {
-                    yield {
-                        ...agentEvent,
-                        type: "agent:sub-usage",
-                        meta: { ...agentEvent.meta, delegationId, agentName: agentId },
-                    };
-                    continue;
-                }
-                // Pass through other events but tag them with delegationId and agentName in meta
-                yield {
-                    ...agentEvent,
-                    meta: { ...agentEvent.meta, delegationId, agentName: agentId },
-                };
-                // accumulate agent output
-                if (agentEvent.type === "agent:output") {
-                    const agentOutput = agentEvent.data;
-                    // DETERMINISTIC SYNC: If agent returns structured data and stateKey is provided
-                    const value = agentOutput?.result ?? agentOutput?.content ?? agentOutput?.message ?? agentOutput;
-                    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-                        if (stateKey) {
-                            context.state[stateKey] = value;
-                            yield* maybeEmitWidget(stateKey, value);
-                        }
-                        if (lastAgentOutput)
-                            lastAgentOutput += "\n\n";
-                        lastAgentOutput += JSON.stringify(value, null, 2);
-                    }
-                    else if (typeof value === "string") {
-                        if (lastAgentOutput)
-                            lastAgentOutput += "\n\n";
-                        lastAgentOutput += value;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error(`[delegation] Error running agent "${agentId}":`, error);
-            lastAgentOutput = `Error executing task: ${error.message}`;
-        }
-        // Option A behavior: if sub-agent suspended on approval,
-        // keep the manager tool call pending until approve/deny follow-up resolves it.
-        if (pendingApprovalId) {
-            state.pendingAgentTasks ?? (state.pendingAgentTasks = {});
-            state.pendingAgentTasks[pendingApprovalId] = {
-                toolCallId,
-                agentName: agentId,
-                delegationId,
-                stateKey: typeof stateKey === "string" ? stateKey : undefined,
-            };
-            return;
-        }
-        // Signal delegation end for UI
-        yield {
-            type: "delegation:end",
-            meta: { delegationId, agentName: agentId },
-            data: { agent: agentId, result: lastAgentOutput || "Task completed." },
-        };
-        // Feedback the result back to the manager
-        yield {
-            type: "action:result",
-            data: {
-                action: "delegateTask",
-                result: lastAgentOutput || "Task completed with no output.",
-                toolCallId,
-            },
-        };
-    });
-}