openbot 0.1.27 → 0.1.29

package/dist/agents/os-agent.js

@@ -1,6 +1,7 @@
 import { llmPlugin } from "../plugins/llm/index.js";
 import { shellPlugin, shellToolDefinitions } from "../plugins/shell/index.js";
 import { fileSystemPlugin, fileSystemToolDefinitions } from "../plugins/file-system/index.js";
+import approvalPlugin from "../plugins/approval/index.js";
 const DEFAULT_SYSTEM_PROMPT = `You are an OS Agent with access to the shell and file system.
 Your job is to help the user with file operations and command execution.
 You can read, write, list, and delete files, as well as execute shell commands.
@@ -11,12 +12,19 @@ export const osAgent = (options) => (builder) => {
     builder
         .use(shellPlugin({ cwd }))
         .use(fileSystemPlugin({ baseDir: "/" }))
+        .use(approvalPlugin({
+        rules: [
+            { action: "action:executeCommand", message: "The agent wants to execute a terminal command. Please review carefully." },
+            { action: "action:writeFile", message: "The agent wants to write to a file." },
+            { action: "action:deleteFile", message: "The agent wants to delete a file." },
+        ],
+    }))
         .use(llmPlugin({
         model,
         system: systemPrompt,
         toolDefinitions: {
             ...shellToolDefinitions,
-            ...fileSystemToolDefinitions,
+            ...fileSystemToolDefinitions
         },
         promptInputType: "agent:os:input",
         actionResultInputType: "agent:os:result",

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.26");
+    .version("0.1.29");
 /**
  * Check if a GitHub repository exists.
  */

package/dist/open-bot.js

@@ -14,8 +14,9 @@ import { z } from "zod";
 // Plugin imports for the registry
 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.
  *
@@ -45,6 +46,12 @@ export async function createOpenBot(options) {
         toolDefinitions: fileSystemToolDefinitions,
         factory: () => fileSystemPlugin({ baseDir: "/" }),
     });
+    pluginRegistry.register({
+        name: "approval",
+        description: "Require user approval for specific actions",
+        toolDefinitions: {},
+        factory: (options) => approvalPlugin(options),
+    });
     // ─── Shared Plugins ──────────────────────────────────────────────
     // Load community/user plugins from ~/.openbot/plugins/
     const sharedPlugins = await loadPluginsFromDir(path.join(resolvedBaseDir, "plugins"));
@@ -74,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 ──────────────────────────────────────
@@ -124,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) => {
@@ -132,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,
@@ -177,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,
@@ -187,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/approval/index.js

@@ -0,0 +1,99 @@
+import { generateId } from "melony";
+import { ui } from "@melony/ui-kit/server";
+/**
+ * Approval Plugin for OpenBot.
+ * Intercepts specific actions and requires user approval before proceeding.
+ * Optimized using the new melony intercept() feature.
+ */
+export const approvalPlugin = (options) => (builder) => {
+    const { rules = [] } = options;
+    // Register an interceptor that runs before any handlers.
+    // This is the correct way to handle HITL/Approval in Melony.
+    builder.intercept(async (event, { state, suspend }) => {
+        // Skip if already approved or if it's an internal approval event
+        // We cast event to any to access the meta property which is used for internal state tracking
+        const meta = event.meta;
+        if (meta?.approved ||
+            event.type === "action:approve" ||
+            event.type === "action:deny" ||
+            event.type === "ui" ||
+            event.type.endsWith(":status")) {
+            return;
+        }
+        const rule = rules.find(r => event.type.startsWith(r.action));
+        if (!rule)
+            return;
+        const approvalId = `approve_${generateId()}`;
+        if (!state.pendingApprovals) {
+            state.pendingApprovals = {};
+        }
+        state.pendingApprovals[approvalId] = event;
+        // Use suspend(event) to emit the UI and halt execution of any handlers for this event.
+        // This effectively "pauses" the run for user input.
+        suspend(ui.event(ui.card({
+            title: "Approval Required",
+            description: rule.message || `Approval required for: ${event.type}`,
+        }, [
+            ui.text(JSON.stringify(event.data, null, 2), { size: "xs" }),
+            ui.row({ gap: "sm" }, [
+                ui.button({
+                    label: "Approve",
+                    variant: "primary",
+                    onClickAction: {
+                        type: "action:approve",
+                        data: { id: approvalId }
+                    }
+                }),
+                ui.button({
+                    label: "Deny",
+                    variant: "outline",
+                    onClickAction: {
+                        type: "action:deny",
+                        data: { id: approvalId }
+                    }
+                }),
+            ]),
+        ])));
+    });
+    // Handle Approval response from user
+    builder.on("action:approve", async function* (event, { state }) {
+        const { id } = event.data;
+        const originalEvent = state.pendingApprovals?.[id];
+        if (originalEvent) {
+            delete state.pendingApprovals[id];
+            yield ui.event(ui.status("Action approved", "success"));
+            // Re-emit the original event with approved: true.
+            // The interceptor will see it, but bypass because of meta.approved.
+            // Then the appropriate handlers for the event will finally run.
+            yield {
+                ...originalEvent,
+                meta: {
+                    ...originalEvent.meta,
+                    approved: true,
+                },
+            };
+        }
+    });
+    // Handle Denial response from user
+    builder.on("action:deny", async function* (event, { state }) {
+        const { id } = event.data;
+        const originalEvent = state.pendingApprovals?.[id];
+        if (originalEvent) {
+            delete state.pendingApprovals[id];
+            yield ui.event(ui.status("Action denied", "error"));
+            // If it was a tool call (action:*), return a taskResult error so the LLM knows it failed
+            if (originalEvent.data?.toolCallId) {
+                yield {
+                    type: "action:taskResult",
+                    data: {
+                        action: originalEvent.type.replace("action:", ""),
+                        toolCallId: originalEvent.data.toolCallId,
+                        result: { error: "Action denied by user" },
+                        success: false,
+                    },
+                };
+            }
+        }
+    });
+};
+export default approvalPlugin;

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/plugin-loader.js

@@ -39,7 +39,7 @@ export async function ensurePluginReady(pluginDir) {
         // 1. Install dependencies if node_modules is missing
         if (!hasNodeModules) {
             console.log(`[plugins] Installing dependencies for ${path.basename(pluginDir)}...`);
-            execSync("npm install --production", { cwd: pluginDir, stdio: "inherit" });
+            execSync("npm install", { cwd: pluginDir, stdio: "inherit" });
         }
         // 2. Run build if dist is missing but build script exists
         const distPath = path.join(pluginDir, "dist");

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/dist/ui/settings.js

@@ -32,9 +32,9 @@ export const settingsUI = async () => {
                         ui.heading("Model Configuration", 4),
                         ui.col({ gap: "sm" }, [
                             ui.input("model", undefined, {
-                                placeholder: "e.g. gpt-4o-mini",
+                                placeholder: "provider/model (e.g. openai/gpt-4o)",
                                 width: "full",
-                                defaultValue: config.model || "gpt-4o-mini"
+                                defaultValue: config.model || "openai/gpt-4o-mini"
                             }),
                         ]),
                     ]),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "private": false,
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "express": "^4.19.2",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.1",
-    "melony": "^0.2.8",
+    "melony": "^0.2.9",
     "zod": "^4.3.5"
   },
   "devDependencies": {