openbot 0.1.28 → 0.1.29

package/dist/cli.js

@@ -13,7 +13,7 @@ const program = new Command();
 program
     .name("openbot")
     .description("OpenBot CLI - Secure and easy configuration")
-    .version("0.1.28");
+    .version("0.1.29");
 /**
  * Check if a GitHub repository exists.
  */

package/dist/open-bot.js

@@ -16,7 +16,7 @@ import { shellPlugin, shellToolDefinitions } from "./plugins/shell/index.js";
 import { fileSystemPlugin, fileSystemToolDefinitions } from "./plugins/file-system/index.js";
 import { approvalPlugin } from "./plugins/approval/index.js";
 // Registry
-import { PluginRegistry, AgentRegistry, discoverYamlAgents, loadPluginsFromDir } from "./registry/index.js";
+import { PluginRegistry, AgentRegistry, discoverYamlAgents, discoverTsAgents, loadPluginsFromDir } from "./registry/index.js";
 /**
  * Create the OpenBot manager agent.
  *
@@ -81,8 +81,12 @@ export async function createOpenBot(options) {
         subscribe: ["manager:completion"],
     });
     // Discover community / user agents from ~/.openbot/agents/
-    const yamlAgents = await discoverYamlAgents(path.join(resolvedBaseDir, "agents"), pluginRegistry, model, options);
-    for (const agent of yamlAgents) {
+    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);
     }
     // ─── Compose the Melony App ──────────────────────────────────────
@@ -131,6 +135,61 @@ export async function createOpenBot(options) {
         return `- **${a.name}**: ${a.description}${tools ? `\n  Capabilities:\n${tools}` : ""}`;
     })
         .join("\n\n");
+    // 2.5 Command Prefix Router
+    // Allows bypassing the manager using "/agent task" (e.g. "/os list files")
+    app.on("user:text", async function* (event, { state }) {
+        const content = event.data.content.trim();
+        if (content.startsWith("/")) {
+            const firstSpace = content.indexOf(" ");
+            const prefix = firstSpace === -1 ? content.slice(1) : content.slice(1, firstSpace);
+            const task = firstSpace === -1 ? "" : content.slice(firstSpace + 1).trim();
+            if (agentNames.includes(prefix)) {
+                // Direct route to specialized agent
+                state.lastDirectAgent = prefix;
+                yield {
+                    type: `agent:${prefix}:input`,
+                    data: { content: task },
+                };
+                return;
+            }
+        }
+        // Default: send to manager for reasoning/delegation
+        state.lastDirectAgent = undefined;
+        yield { type: "manager:input", data: event.data };
+    });
+    // 2.6 Global Tool Result Dispatcher
+    // Routes tool results to the appropriate agent's internal loop.
+    // taskResult means that the loop is complete.
+    app.on("action:taskResult", async function* (event, { state, suspend }) {
+        const s = state;
+        // 1. Direct route (prefix command)
+        if (s.lastDirectAgent) {
+            // suspend not to go to infinite loop
+            // suspend({
+            //   type: `agent:${s.lastDirectAgent}:result`,
+            //   data: event.data,
+            // } as ChatEvent);
+            yield {
+                type: `agent:${s.lastDirectAgent}:result`,
+                data: event.data,
+            };
+        }
+        // 2. Delegation route (manager-led)
+        // Find which agent has a pending task
+        const pendingAgentName = Object.keys(s.pendingAgentTasks || {}).find((name) => s.pendingAgentTasks[name]);
+        if (pendingAgentName) {
+            yield {
+                type: `agent:${pendingAgentName}:result`,
+                data: event.data,
+            };
+            return;
+        }
+        // 3. Manager route (brain tools, etc.)
+        yield {
+            type: "manager:result",
+            data: event.data,
+        };
+    });
     app.use(llmPlugin({
         model: model,
         system: async (context) => {
@@ -139,21 +198,23 @@ export async function createOpenBot(options) {
             ]);
             return `${brainPrompt}
 
-## Delegation & Specialized Agents
-You are the **Manager Agent**. Your primary role is to orchestrate tasks by delegating them to specialized agents when appropriate. 
-If a task falls outside your core capabilities (memory and orchestration), you **MUST** use the \`delegateTask\` tool.
+## Core Role: Manager Agent
+You are the **Manager Agent**. You have exactly two jobs:
+1. **Task Delegation**: Orchestrate tasks by delegating them to specialized agents.
+2. **Memory & Identity**: Manage your long-term memory and identity using your core brain tools (\`remember\`, \`recall\`, \`updateIdentity\`, etc.).
+
+### Delegation & Reporting Guidelines:
+- **Delegate by Default**: If a task requires capabilities outside of memory/identity management (like shell access, file operations, web browsing), you **MUST** delegate to the appropriate agent.
+- **Be Concise**: When a sub-agent completes a task, provide a **nice, concise summary**. Sub-agents provide detailed outputs in the background; your response should be a brief, high-level answer to the user. Do not repeat details unless necessary.
+- **Detailed Delegation**: When calling \`delegateTask\`, provide a thorough description of the task so the sub-agent has full context.
 
 ### Available Agents:
 ${agentDescriptions}
 
-### Delegation Guidelines:
-1. **Choose the Best Expert**: Analyze the user's request and select the agent whose description most closely matches the required expertise.
-2. **Task Description**: When delegating, provide a clear and detailed task description. Include any context the agent might need to succeed.
-3. **No "I Can't"**: If an agent is available that can handle a request, do not tell the user you cannot do it. Simply delegate.
-4. **Summary**: Once an agent returns a result, summarize the findings or actions for the user.
-
-Example: If the user asks to "check the weather", and you see a 'browser' agent, delegate the task to it.`;
+Remember: You are the orchestrator. Let the specialized agents do the work, and you provide the concise final answer.`;
         },
+        promptInputType: "manager:input",
+        actionResultInputType: "manager:result",
         completionEventType: "manager:completion",
         toolDefinitions: {
             ...brainToolDefinitions,
@@ -184,9 +245,10 @@ Example: If the user asks to "check the weather", and you see a 'browser' agent,
             const s = state;
             const pending = s.pendingAgentTasks?.[agent.name];
             if (pending) {
+                // This was a delegated task — bridge back to the manager's tool call
                 delete s.pendingAgentTasks[agent.name];
                 yield {
-                    type: "action:taskResult",
+                    type: "manager:result",
                     data: {
                         action: "delegateTask",
                         toolCallId: pending.toolCallId,
@@ -194,6 +256,14 @@ Example: If the user asks to "check the weather", and you see a 'browser' agent,
                     },
                 };
             }
+            else {
+                // This was a direct command (prefix) — show output directly as assistant text
+                yield {
+                    type: "assistant:text",
+                    data: { content: event.data.content },
+                    meta: { agent: agent.name }
+                };
+            }
         });
     }
     // 6. Init handlers

package/dist/plugins/llm/index.js

@@ -22,10 +22,11 @@ export const llmPlugin = (options) => (builder) => {
         state.messages.push(newMessage);
         // Evaluate dynamic system prompt if it's a function
         const systemPrompt = typeof system === "function" ? await system(context) : system;
+        const recentMessages = getRecentHistory(state.messages, 20);
         const result = streamText({
             model,
             system: systemPrompt,
-            messages: getRecentHistory(state.messages, 20).map(m => m.role === "system" ? { role: "user", content: `System: ${m.content}` } : m),
+            messages: recentMessages,
             tools: toolDefinitions,
         });
         let assistantText = "";

package/dist/registry/index.js

@@ -1,4 +1,5 @@
 export { PluginRegistry } from "./plugin-registry.js";
 export { AgentRegistry } from "./agent-registry.js";
 export { discoverYamlAgents, listYamlAgents } from "./yaml-agent-loader.js";
+export { discoverTsAgents } from "./ts-agent-loader.js";
 export { loadPluginsFromDir } from "./plugin-loader.js";

package/dist/registry/ts-agent-loader.js

@@ -0,0 +1,82 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { ensurePluginReady } from "./plugin-loader.js";
+/**
+ * Discover and load TS-defined agents from a directory.
+ *
+ * Scans each subdirectory for a package.json and an index file.
+ *
+ * @param agentsDir Absolute path to the agents directory (e.g. ~/.openbot/agents)
+ * @param defaultModel Language model to use for agent LLMs
+ * @param options Optional API keys for creating specific models
+ * @returns Array of discovered agent entries ready for registration
+ */
+export async function discoverTsAgents(agentsDir, defaultModel, options) {
+    const agents = [];
+    try {
+        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+                continue;
+            const agentDir = path.join(agentsDir, entry.name);
+            // We only consider it a TS agent if it doesn't have an agent.yaml
+            // (This avoids double-loading if someone has both for some reason)
+            const yamlPath = path.join(agentDir, "agent.yaml");
+            const hasYaml = await fs.access(yamlPath).then(() => true).catch(() => false);
+            if (hasYaml)
+                continue;
+            // Check for package.json to see if it's a package
+            const pkgPath = path.join(agentDir, "package.json");
+            const hasPackageJson = await fs.access(pkgPath).then(() => true).catch(() => false);
+            if (!hasPackageJson)
+                continue;
+            try {
+                // 1. Ensure dependencies and build are ready
+                await ensurePluginReady(agentDir);
+                // 2. Find index file
+                let indexPath;
+                const possibleIndices = ["dist/index.js", "index.js", "index.ts"];
+                for (const file of possibleIndices) {
+                    try {
+                        const fullPath = path.join(agentDir, file);
+                        await fs.access(fullPath);
+                        indexPath = fullPath;
+                        break;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (!indexPath)
+                    continue;
+                // 3. Import and instantiate
+                const moduleUrl = pathToFileURL(indexPath).href;
+                const module = await import(moduleUrl);
+                // Support 'agent', 'plugin', 'default', or 'entry'
+                const definition = module.agent || module.plugin || module.default || module.entry;
+                if (definition && typeof definition.factory === "function") {
+                    const name = definition.name || entry.name;
+                    const description = definition.description || "TS Agent";
+                    agents.push({
+                        name,
+                        description,
+                        plugin: definition.factory({ ...options, model: defaultModel }),
+                        capabilities: definition.capabilities,
+                        subscribe: definition.subscribe,
+                    });
+                    console.log(`[agents] Loaded TS agent: ${name} — ${description}`);
+                }
+            }
+            catch (err) {
+                console.warn(`[agents] Failed to load TS agent package "${entry.name}":`, err);
+            }
+        }
+    }
+    catch {
+        // Agents directory doesn't exist
+    }
+    return agents;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "private": false,
   "type": "module",
   "bin": {