openbot 0.2.9 → 0.2.11

package/dist/agents/topic-agent.js

@@ -1,19 +1,33 @@
 import { generateText } from "ai";
+function getTitleSourceMessages(state, event) {
+    if (Array.isArray(state.messages) && state.messages.length >= 2) {
+        return state.messages;
+    }
+    const agentName = event.meta?.agentName;
+    if (!agentName)
+        return [];
+    const agentMessages = state.agentStates?.[agentName]?.messages;
+    if (Array.isArray(agentMessages) && agentMessages.length >= 2) {
+        return agentMessages;
+    }
+    return [];
+}
 export const topicAgent = (options) => (builder) => {
     builder.on("agent:output", async function* (event, { state }) {
         // Only title if it doesn't have one and there's history
-        if (state.title || !state.messages || state.messages.length === 0) {
+        if (state.title) {
             return;
         }
+        const messagesForTitle = getTitleSourceMessages(state, event);
         // Don't title if there are too few messages
-        if (state.messages.length < 2) {
+        if (messagesForTitle.length < 2) {
             return;
         }
         try {
             const { text } = await generateText({
                 model: options.model,
                 system: "You are a Topic Agent. Create a very concise (3-5 words) title for the conversation based on the user's intent. Do not use quotes or special characters.",
-                prompt: `Analyze these messages and provide a title: ${JSON.stringify(state.messages.slice(0, 6))}`,
+                prompt: `Analyze these messages and provide a title: ${JSON.stringify(messagesForTitle.slice(0, 6))}`,
             });
             const newTitle = text.replace(/["']/g, "").trim();
             if (newTitle) {

package/dist/cli.js

@@ -26,7 +26,7 @@ checkNodeVersion();
 program
     .name("openbot")
     .description("OpenBot CLI - Secure and easy configuration")
-    .version("0.2.9");
+    .version("0.2.11");
 async function installPlugin(source, id, quiet = false) {
     try {
         const parsed = parsePluginInstallSource(source);

package/dist/core/delegation.js

@@ -1,15 +1,87 @@
 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 { agent: agentName, toolCallId, task, attachments } = event.data;
-        const agentRuntime = agentRuntimes.get(agentName);
+        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 "${agentName}" not found.`,
+                    result: `Error: Agent "${agentId}" not found.`,
                     toolCallId,
                 },
             };
@@ -19,16 +91,16 @@ export function setupDelegation(builder, agentRuntimes) {
         // Signal delegation start for UI
         yield {
             type: "delegation:start",
-            meta: { delegationId, agentName },
-            data: { agent: agentName, task },
+            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[agentName])
-            state.agentStates[agentName] = {};
-        const agentState = state.agentStates[agentName];
+        if (!state.agentStates[agentId])
+            state.agentStates[agentId] = {};
+        const agentState = state.agentStates[agentId];
         const agentIterator = agentRuntime.run({
             type: "agent:input",
             data: { content: task, attachments },
@@ -37,8 +109,26 @@ export function setupDelegation(builder, agentRuntimes) {
             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.
@@ -46,7 +136,7 @@ export function setupDelegation(builder, agentRuntimes) {
                     yield {
                         ...agentEvent,
                         type: "agent:sub-input",
-                        meta: { ...agentEvent.meta, delegationId, agentName },
+                        meta: { ...agentEvent.meta, delegationId, agentName: agentId },
                     };
                     continue;
                 }
@@ -55,7 +145,7 @@ export function setupDelegation(builder, agentRuntimes) {
                     yield {
                         ...agentEvent,
                         type: "agent:sub-action",
-                        meta: { ...agentEvent.meta, delegationId, agentName },
+                        meta: { ...agentEvent.meta, delegationId, agentName: agentId },
                         data: { ...agentEvent.data, originalType: agentEvent.type },
                     };
                     continue;
@@ -65,7 +155,7 @@ export function setupDelegation(builder, agentRuntimes) {
                     yield {
                         ...agentEvent,
                         type: "agent:sub-action-result",
-                        meta: { ...agentEvent.meta, delegationId, agentName },
+                        meta: { ...agentEvent.meta, delegationId, agentName: agentId },
                     };
                     continue;
                 }
@@ -74,42 +164,58 @@ export function setupDelegation(builder, agentRuntimes) {
                     yield {
                         ...agentEvent,
                         type: "agent:sub-usage",
-                        meta: { ...agentEvent.meta, delegationId, agentName },
+                        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 },
+                    meta: { ...agentEvent.meta, delegationId, agentName: agentId },
                 };
                 // accumulate agent output
                 if (agentEvent.type === "agent:output") {
                     const agentOutput = agentEvent.data;
-                    // THIS NEEDS TO BE IMPROVED. WE NEED TO KEEP A SINGLE AGENT OUTPUT VARIABLE.
-                    const value = agentOutput?.result ?? agentOutput?.content ?? agentOutput?.message;
-                    if (typeof value === "string") {
+                    // 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 += value;
+                        lastAgentOutput += JSON.stringify(value, null, 2);
                     }
-                    else if (typeof value === "object" && value !== null) {
+                    else if (typeof value === "string") {
                         if (lastAgentOutput)
                             lastAgentOutput += "\n\n";
-                        lastAgentOutput += JSON.stringify(value, null, 2);
+                        lastAgentOutput += value;
                     }
                 }
             }
         }
         catch (error) {
-            console.error(`[delegation] Error running agent "${agentName}":`, 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 },
-            data: { agent: agentName, result: lastAgentOutput || "Task completed." },
+            meta: { delegationId, agentName: agentId },
+            data: { agent: agentId, result: lastAgentOutput || "Task completed." },
         };
         // Feedback the result back to the manager
         yield {

package/dist/core/manager.js

@@ -3,7 +3,7 @@ import { memoryPlugin, memoryToolDefinitions, createMemoryPromptBuilder } from "
 import { topicAgent } from "../agents/topic-agent.js";
 import { llmPlugin } from "../plugins/llm/index.js";
 export function createManagerPlugin(model, resolvedModelId, resolvedBaseDir, registry) {
-    const agentNames = registry.getAgentNames();
+    const agentIds = registry.getAgentIds();
     const allAgents = registry.getAgents();
     const buildMemoryPrompt = createMemoryPromptBuilder(resolvedBaseDir);
     const agentDescriptions = allAgents
@@ -13,12 +13,14 @@ export function createManagerPlugin(model, resolvedModelId, resolvedBaseDir, reg
                 .map(([name, desc]) => `    - ${name}: ${desc}`)
                 .join("\n")
             : "";
-        return `<agent name="${a.name}">
+        return `<agent id="${a.id}" name="${a.name}">
   <description>${a.description}</description>
 ${tools ? `  <capabilities>\n${tools}\n  </capabilities>` : ""}
 </agent>`;
     })
         .join("\n\n");
+    console.log("agentIds", agentIds);
+    console.log("agentDescriptions", agentDescriptions);
     return (builder) => {
         builder
             .use(memoryPlugin({
@@ -31,33 +33,47 @@ ${tools ? `  <capabilities>\n${tools}\n  </capabilities>` : ""}
             usageScope: "manager",
             system: async (context) => {
                 const memoryPrompt = await buildMemoryPrompt(context);
-                return `
+                const state = context.state;
+                // Deterministically inject any custom state keys into the prompt
+                const standardKeys = ["messages", "agentStates", "usage", "cwd", "workspaceRoot", "title", "sessionId", "pendingAgentTasks"];
+                const customState = {};
+                for (const key of Object.keys(state)) {
+                    if (!standardKeys.includes(key)) {
+                        customState[key] = state[key];
+                    }
+                }
+                const statePrompt = Object.keys(customState).length > 0
+                    ? `\n\n<session_state>\n${JSON.stringify(customState, null, 2)}\n</session_state>`
+                    : "";
+                const finalSystemPrompt = `
 
 <orchestrator>
 Your goal is to solve user requests by delegating tasks to expert sub-agents.
 
 **Directives**:
 1. **Delegate**: Use \`delegateTask\` for any task matching an agent's description.
-2. **Plan**: For multi-step tasks, use \`planner-agent\` first to create a roadmap.
 3. **Context**: Provide a clear, detailed task for the sub-agent. Pass any relevant user attachments.
 4. **Report**: Summarize the sub-agent's work concisely for the user.
 5. **Memory**: Use your memory tools (\`remember\`, \`recall\`) to maintain context across sessions.
+6. **State**: Use \`updateSessionState\` to modify any value in the <session_state>.
 </orchestrator>
 
+${statePrompt}
+
 <agents>
 ${agentDescriptions}
 </agents>${memoryPrompt}`;
+                // console.log("finalSystemPrompt:::::", finalSystemPrompt);
+                return finalSystemPrompt;
             },
-            promptInputType: "agent:input",
-            actionResultInputType: "action:result",
-            completionEventType: "agent:output",
             toolDefinitions: {
                 ...memoryToolDefinitions,
                 delegateTask: {
                     description: `Delegate a task to a specialized expert agent.`,
                     inputSchema: z.object({
-                        agent: z.enum(agentNames).describe("The name of the agent to use"),
+                        agentId: z.enum(agentIds).describe("The ID of the agent to use"),
                         task: z.string().describe("The task for the agent to perform"),
+                        stateKey: z.string().optional().describe("Optional key to store structured JSON result in the session state"),
                         attachments: z.array(z.object({
                             id: z.string(),
                             name: z.string(),
@@ -67,6 +83,13 @@ ${agentDescriptions}
                         })).optional().describe("Attachments to pass through to the agent"),
                     }),
                 },
+                updateSessionState: {
+                    description: "Update a value in the session state using a JSON path.",
+                    inputSchema: z.object({
+                        path: z.string().describe("The JSON path to the value (e.g. 'project_plan.todos.0.status')"),
+                        value: z.any().describe("The new value to set"),
+                    }),
+                },
             },
         }));
     };

package/dist/core/plugins.js

@@ -3,7 +3,6 @@ import { fileSystemPlugin, fileSystemToolDefinitions } from "../plugins/file-sys
 import { approvalPlugin } from "../plugins/approval/index.js";
 import { osAgent } from "../agents/os-agent.js";
 import { agentCreatorAgent } from "../agents/agent-creator.js";
-import { plannerAgent } from "../agents/planner-agent.js";
 import { PluginRegistry, discoverPlugins } from "../registry/index.js";
 import path from "node:path";
 /**
@@ -16,6 +15,7 @@ export async function setupPluginRegistry(resolvedBaseDir, model, options) {
     const registry = new PluginRegistry();
     // ── Built-in tools ───────────────────────────────────────────────
     registry.register({
+        id: "shell",
         name: "shell",
         description: "Execute shell commands",
         type: "tool",
@@ -24,6 +24,7 @@ export async function setupPluginRegistry(resolvedBaseDir, model, options) {
         isBuiltIn: true,
     });
     registry.register({
+        id: "file-system",
         name: "file-system",
         description: "Read, write, list, and delete files",
         type: "tool",
@@ -32,6 +33,7 @@ export async function setupPluginRegistry(resolvedBaseDir, model, options) {
         isBuiltIn: true,
     });
     registry.register({
+        id: "approval",
         name: "approval",
         description: "Require user approval for specific actions",
         type: "tool",
@@ -41,6 +43,7 @@ export async function setupPluginRegistry(resolvedBaseDir, model, options) {
     });
     // ── Built-in agents ──────────────────────────────────────────────
     registry.register({
+        id: "os",
         name: "os",
         description: "Handles shell commands and file system operations",
         type: "agent",
@@ -52,6 +55,7 @@ export async function setupPluginRegistry(resolvedBaseDir, model, options) {
         isBuiltIn: true,
     });
     registry.register({
+        id: "agent-creator",
         name: "agent-creator",
         description: "Helps the user create and update custom OpenBot agents via natural language.",
         type: "agent",
@@ -61,13 +65,6 @@ export async function setupPluginRegistry(resolvedBaseDir, model, options) {
         plugin: agentCreatorAgent({ model }),
         isBuiltIn: true,
     });
-    registry.register({
-        name: "planner-agent",
-        description: "Creates concise execution plans from user intent for OpenBot to run.",
-        type: "agent",
-        plugin: plannerAgent({ model }),
-        isBuiltIn: true,
-    });
     // ── Custom agents and plugins ────────────────────────────────────
     const agentsDir = path.join(resolvedBaseDir, "agents");
     const pluginsDir = path.join(resolvedBaseDir, "plugins");

package/dist/core/router.js

@@ -1,21 +1,131 @@
-export async function* runOpenBot(event, context, managerRuntime, agentRuntimes) {
+function summarizeAgentEventValue(event) {
+    if (!event)
+        return undefined;
+    const value = event?.data?.result ?? event?.data?.content ?? event?.data?.message ?? event?.data;
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "object" && value !== null)
+        return JSON.stringify(value, null, 2);
+    return undefined;
+}
+export async function* runOpenBot(event, context, managerRuntime, agentRuntimes, registry) {
     const { state } = context;
+    const allAgents = registry.getAgents();
     // Initialize state
     if (!state.messages)
         state.messages = [];
     if (!state.agentStates)
         state.agentStates = {};
-    // 1. Direct agent routing (e.g. "@os list files")
+    // 1. Route non-user events directly (pluggable).
+    //    If an event is tagged with meta.agentName, send it to that agent runtime.
+    //    Otherwise, pass it to manager runtime unchanged.
+    if (event.type !== "agent:input") {
+        const targetAgent = event.meta?.agentName;
+        if (targetAgent) {
+            const runtime = agentRuntimes.get(targetAgent);
+            if (runtime) {
+                if (!state.agentStates[targetAgent])
+                    state.agentStates[targetAgent] = {};
+                let resumedOutput = "";
+                for await (const agentChunk of runtime.run(event, {
+                    runId: context.runId,
+                    state: state.agentStates[targetAgent],
+                })) {
+                    // Preserve sub-agent attribution when resuming after approval/deny
+                    // so UI does not fall back to manager identity.
+                    yield {
+                        ...agentChunk,
+                        meta: {
+                            ...agentChunk?.meta,
+                            ...(event.meta?.delegationId ? { delegationId: event.meta.delegationId } : {}),
+                            agentName: targetAgent,
+                        },
+                    };
+                    if (agentChunk.type === "agent:output" || agentChunk.type === "action:result") {
+                        const summary = summarizeAgentEventValue(agentChunk);
+                        if (summary) {
+                            if (resumedOutput)
+                                resumedOutput += "\n\n";
+                            resumedOutput += summary;
+                        }
+                    }
+                }
+                // Resolve pending delegated tool call after approval follow-up.
+                const maybeApprovalId = event?.data?.id;
+                const shouldResolvePending = (event.type === "action:approve" || event.type === "action:deny")
+                    && typeof maybeApprovalId === "string";
+                if (shouldResolvePending) {
+                    const pending = state.pendingAgentTasks?.[maybeApprovalId];
+                    if (pending) {
+                        const wasDenied = event.type === "action:deny";
+                        const delegateResult = wasDenied
+                            ? { error: "Action denied by user", denied: true }
+                            : (resumedOutput || "Task completed with no output.");
+                        delete state.pendingAgentTasks[maybeApprovalId];
+                        yield {
+                            type: "delegation:end",
+                            meta: { delegationId: pending.delegationId, agentName: pending.agentName },
+                            data: {
+                                agent: pending.agentName,
+                                result: wasDenied ? "Action denied by user." : (resumedOutput || "Task completed."),
+                            },
+                        };
+                        yield* managerRuntime.run({
+                            type: "action:result",
+                            data: {
+                                action: "delegateTask",
+                                result: delegateResult,
+                                toolCallId: pending.toolCallId,
+                                success: !wasDenied,
+                                halt: wasDenied,
+                            },
+                        }, {
+                            runId: context.runId,
+                            state: state,
+                        });
+                    }
+                }
+                return;
+            }
+        }
+        yield* managerRuntime.run(event, {
+            runId: context.runId,
+            state: state,
+        });
+        return;
+    }
+    // 2. Direct agent routing for user input (e.g. "@os list files" or "@Codex Agent list files")
     if (event.type === "agent:input") {
         const content = event.data.content;
-        if (content?.startsWith("@")) {
-            const match = content.match(/^@([a-zA-Z0-9_-]+)\s*(.*)$/);
-            if (match) {
-                const [, agentName, remaining] = match;
-                const runtime = agentRuntimes.get(agentName);
+        if (content?.trim().startsWith("@")) {
+            const trimmedContent = content.trim();
+            const afterAt = trimmedContent.slice(1);
+            // Find the longest matching agent (by ID or Name) at the start of the message
+            // This handles agent names with spaces like "Codex Agent"
+            let bestMatch;
+            for (const agent of allAgents) {
+                const idMatches = afterAt.toLowerCase().startsWith(agent.id.toLowerCase());
+                const nameMatches = afterAt.toLowerCase().startsWith(agent.name.toLowerCase());
+                if (idMatches || nameMatches) {
+                    const matchPrefix = idMatches ? agent.id : agent.name;
+                    const prefixLength = matchPrefix.length;
+                    // Next char must be space, end of string, or the match length must be at least 
+                    // the current best match length (prefer longer names like "Codex Agent" over "Codex")
+                    const nextChar = afterAt[prefixLength];
+                    if (!nextChar || nextChar === " ") {
+                        if (!bestMatch || prefixLength > bestMatch.prefixLength) {
+                            bestMatch = { id: agent.id, name: agent.name, prefixLength };
+                        }
+                    }
+                }
+            }
+            if (bestMatch) {
+                const targetAgent = bestMatch.id;
+                const remaining = afterAt.slice(bestMatch.prefixLength).trim();
+                const runtime = agentRuntimes.get(targetAgent);
                 if (runtime) {
-                    if (!state.agentStates[agentName])
-                        state.agentStates[agentName] = {};
+                    if (!state.agentStates[targetAgent])
+                        state.agentStates[targetAgent] = {};
                     const agentEvent = {
                         ...event,
                         data: {
@@ -23,16 +133,57 @@ export async function* runOpenBot(event, context, managerRuntime, agentRuntimes)
                             attachments: event.data.attachments,
                         },
                     };
-                    yield* runtime.run(agentEvent, {
+                    let lastAgentOutput = "";
+                    for await (const agentChunk of runtime.run(agentEvent, {
                         runId: context.runId,
-                        state: state.agentStates[agentName],
-                    });
+                        state: state.agentStates[targetAgent],
+                    })) {
+                        if (agentChunk.type === "agent:output" || agentChunk.type === "agent:output-delta") {
+                            const summary = summarizeAgentEventValue(agentChunk);
+                            if (summary)
+                                lastAgentOutput = summary;
+                        }
+                        yield {
+                            ...agentChunk,
+                            meta: {
+                                ...agentChunk?.meta,
+                                agentName: targetAgent,
+                            },
+                        };
+                    }
+                    // Direct "@agent" routing bypasses manager handlers entirely.
+                    // Trigger manager-side post-processing (e.g. topic/title generation)
+                    // without producing a manager reply.
+                    if (!state.title) {
+                        for await (const _ of managerRuntime.run({
+                            type: "agent:output",
+                            meta: { agentName: targetAgent },
+                            data: { content: lastAgentOutput || "" },
+                        }, {
+                            runId: context.runId,
+                            state: state,
+                        })) {
+                            // side-effects only
+                        }
+                    }
                     return;
                 }
             }
+            else {
+                // If the user used @ but the agent wasn't found, stop here to avoid
+                // falling back to the manager and burning tokens for a failed routing attempt.
+                const agentPrefixMatch = afterAt.split(" ")[0];
+                yield {
+                    type: "agent:output",
+                    data: {
+                        content: `Agent "@${agentPrefixMatch}" not found. Available agents:\n${allAgents.map(a => `- ${a.name} (@${a.id})`).join("\n")}`
+                    },
+                };
+                return;
+            }
         }
     }
-    // 2. Default routing: translate user event to manager input
+    // 3. Default routing: translate user input to manager input
     yield* managerRuntime.run({ ...event, type: "agent:input" }, {
         runId: context.runId,
         state: state,

package/dist/open-bot.js

@@ -24,7 +24,7 @@ export async function createOpenBot(options) {
     for (const agent of registry.getAgents()) {
         const builder = melony();
         builder.use(agent.plugin);
-        agentRuntimes.set(agent.name, builder.build());
+        agentRuntimes.set(agent.id, builder.build());
     }
     // 3. Initialize manager runtime
     const managerBuilder = melony();
@@ -46,6 +46,6 @@ export async function createOpenBot(options) {
     // 6. Return the runtime
     return {
         registry,
-        run: (event, context) => runOpenBot(event, context, managerRuntime, agentRuntimes),
+        run: (event, context) => runOpenBot(event, context, managerRuntime, agentRuntimes, registry),
     };
 }