openbot 0.2.12 → 0.2.13

package/dist/core/manager.js

@@ -1,96 +0,0 @@
-import { z } from "zod";
-import { memoryPlugin, memoryToolDefinitions, createMemoryPromptBuilder } from "../plugins/memory/index.js";
-import { topicAgent } from "../agents/topic-agent.js";
-import { llmPlugin } from "../plugins/llm/index.js";
-export function createManagerPlugin(model, resolvedModelId, resolvedBaseDir, registry) {
-    const agentIds = registry.getAgentIds();
-    const allAgents = registry.getAgents();
-    const buildMemoryPrompt = createMemoryPromptBuilder(resolvedBaseDir);
-    const agentDescriptions = allAgents
-        .map((a) => {
-        const tools = a.capabilities
-            ? Object.entries(a.capabilities)
-                .map(([name, desc]) => `    - ${name}: ${desc}`)
-                .join("\n")
-            : "";
-        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({
-            baseDir: resolvedBaseDir,
-        }))
-            .use(topicAgent({ model: model }))
-            .use(llmPlugin({
-            model: model,
-            modelId: resolvedModelId,
-            usageScope: "manager",
-            system: async (context) => {
-                const memoryPrompt = await buildMemoryPrompt(context);
-                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.
-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;
-            },
-            toolDefinitions: {
-                ...memoryToolDefinitions,
-                delegateTask: {
-                    description: `Delegate a task to a specialized expert agent.`,
-                    inputSchema: z.object({
-                        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(),
-                            mimeType: z.string(),
-                            size: z.number(),
-                            url: z.string(),
-                        })).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

@@ -1,74 +0,0 @@
-import { shellPlugin, shellToolDefinitions } from "../plugins/shell/index.js";
-import { fileSystemPlugin, fileSystemToolDefinitions } from "../plugins/file-system/index.js";
-import { approvalPlugin } from "../plugins/approval/index.js";
-import { osAgent } from "../agents/os-agent.js";
-import { agentCreatorAgent } from "../agents/agent-creator.js";
-import { PluginRegistry, discoverPlugins } from "../registry/index.js";
-import path from "node:path";
-/**
- * Build the unified plugin registry.
- *
- * Registers built-in tools and agents, then discovers community
- * plugins (tools + agents) from ~/.openbot/plugins/.
- */
-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",
-        toolDefinitions: shellToolDefinitions,
-        plugin: () => shellPlugin({ cwd: process.cwd() }),
-        isBuiltIn: true,
-    });
-    registry.register({
-        id: "file-system",
-        name: "file-system",
-        description: "Read, write, list, and delete files",
-        type: "tool",
-        toolDefinitions: fileSystemToolDefinitions,
-        plugin: () => fileSystemPlugin({ baseDir: "/" }),
-        isBuiltIn: true,
-    });
-    registry.register({
-        id: "approval",
-        name: "approval",
-        description: "Require user approval for specific actions",
-        type: "tool",
-        toolDefinitions: {},
-        plugin: (opts) => approvalPlugin(opts),
-        isBuiltIn: true,
-    });
-    // ── Built-in agents ──────────────────────────────────────────────
-    registry.register({
-        id: "os",
-        name: "os",
-        description: "Handles shell commands and file system operations",
-        type: "agent",
-        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 }),
-        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",
-        capabilities: {
-            ...Object.fromEntries(Object.entries(fileSystemToolDefinitions).map(([k, v]) => [k, v.description])),
-        },
-        plugin: agentCreatorAgent({ model }),
-        isBuiltIn: true,
-    });
-    // ── Custom agents and plugins ────────────────────────────────────
-    const agentsDir = path.join(resolvedBaseDir, "agents");
-    const pluginsDir = path.join(resolvedBaseDir, "plugins");
-    await discoverPlugins(pluginsDir, registry, model, options);
-    await discoverPlugins(agentsDir, registry, model, options);
-    return registry;
-}

package/dist/core/router.js

@@ -1,191 +0,0 @@
-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. 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?.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[targetAgent])
-                        state.agentStates[targetAgent] = {};
-                    const agentEvent = {
-                        ...event,
-                        data: {
-                            content: remaining || "Hello",
-                            attachments: event.data.attachments,
-                        },
-                    };
-                    let lastAgentOutput = "";
-                    for await (const agentChunk of runtime.run(agentEvent, {
-                        runId: context.runId,
-                        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;
-            }
-        }
-    }
-    // 3. Default routing: translate user input to manager input
-    yield* managerRuntime.run({ ...event, type: "agent:input" }, {
-        runId: context.runId,
-        state: state,
-    });
-}

package/dist/handlers/init.js

@@ -1,29 +0,0 @@
-import { sidebarOnlyUI, tabOnlyUI } from "../ui/layout.js";
-/**
- * Initial application layout handler
- */
-export async function* initHandler(event, { state }) {
-    // Initialize path state if not already present
-    if (!state.cwd) {
-        state.cwd = process.cwd();
-    }
-    if (!state.workspaceRoot) {
-        state.workspaceRoot = process.cwd();
-    }
-    const tab = event.data?.tab || "chat";
-    // For init, return both sidebar and content
-    yield {
-        type: "ui",
-        meta: {
-            type: "sidebar",
-        },
-        data: await sidebarOnlyUI({ sessionId: state.sessionId })
-    };
-    yield {
-        type: "ui",
-        meta: {
-            type: "content",
-        },
-        data: await tabOnlyUI({ tab })
-    };
-}

package/dist/handlers/session-change.js

@@ -1,21 +0,0 @@
-import { sidebarOnlyUI, tabOnlyUI } from "../ui/layout.js";
-/**
- * Session change handler
- */
-export async function* sessionChangeHandler(event, { state }) {
-    const tab = event.data?.tab || "chat";
-    yield {
-        type: "ui",
-        meta: {
-            type: "sidebar",
-        },
-        data: await sidebarOnlyUI({ sessionId: state.sessionId })
-    };
-    yield {
-        type: "ui",
-        meta: {
-            type: "content",
-        },
-        data: await tabOnlyUI({ tab })
-    };
-}

package/dist/handlers/settings.js

@@ -1,47 +0,0 @@
-import { saveConfig } from "../config.js";
-import { tabOnlyUI } from "../ui/layout.js";
-import { exec } from "node:child_process";
-import os from "node:os";
-/**
- * Handle settings updates (like API keys)
- */
-export async function* updateSettingsHandler(event, { state }) {
-    const { openai_api_key, anthropic_api_key, model } = event.data;
-    const updates = {};
-    if (model) {
-        updates.model = model.trim();
-    }
-    if (openai_api_key && openai_api_key !== "••••••••••••••••") {
-        updates.openaiApiKey = openai_api_key.trim();
-    }
-    if (anthropic_api_key && anthropic_api_key !== "••••••••••••••••") {
-        updates.anthropicApiKey = anthropic_api_key.trim();
-    }
-    if (Object.keys(updates).length > 0) {
-        saveConfig(updates);
-        // Refresh the settings UI to show the "saved" state (masking the keys)
-        yield {
-            type: "ui",
-            meta: {
-                type: "content",
-            },
-            data: await tabOnlyUI({ tab: "settings" })
-        };
-    }
-}
-/**
- * Handle opening an agent's folder in the native file explorer
- */
-export async function* openAgentFolderHandler(event) {
-    const { folder } = event.data;
-    if (folder) {
-        const command = os.platform() === "win32" ? `explorer "${folder}"` :
-            os.platform() === "darwin" ? `open "${folder}"` :
-                `xdg-open "${folder}"`;
-        exec(command, (error) => {
-            if (error) {
-                console.error(`Failed to open folder: ${error.message}`);
-            }
-        });
-    }
-}

package/dist/handlers/tab-change.js

@@ -1,14 +0,0 @@
-import { tabOnlyUI } from "../ui/layout.js";
-/**
- * Tab change handler
- */
-export async function* tabChangeHandler(event, { state }) {
-    const tab = event.data?.tab || "chat";
-    yield {
-        type: "ui",
-        meta: {
-            type: "content",
-        },
-        data: await tabOnlyUI({ tab })
-    };
-}

package/dist/installers.js

@@ -1,156 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { execFileSync } from "node:child_process";
-import { tmpdir } from "node:os";
-import { resolvePath, DEFAULT_BASE_DIR, loadConfig } from "./config.js";
-import { readAgentConfig, ensurePluginReady } from "./registry/plugin-loader.js";
-const BUILT_IN_PLUGIN_NAMES = new Set(["shell", "file-system", "approval"]);
-function run(command, args, options) {
-    execFileSync(command, args, {
-        cwd: options?.cwd,
-        stdio: options?.quiet ? "ignore" : "inherit",
-    });
-}
-function log(message, quiet) {
-    if (!quiet)
-        console.log(message);
-}
-function getBaseDir() {
-    const cfg = loadConfig();
-    const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
-    return resolvePath(baseDir);
-}
-async function directoryExists(targetPath) {
-    return fs.access(targetPath).then(() => true).catch(() => false);
-}
-export function checkGitHubRepo(repo) {
-    try {
-        const url = `https://github.com/${repo}.git`;
-        run("git", ["ls-remote", url], { quiet: true });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function checkNpmPackage(pkg) {
-    try {
-        run("npm", ["show", pkg, "version"], { quiet: true });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function parseSource(source) {
-    const normalized = source.trim();
-    const isGithub = (normalized.includes("/") || normalized.startsWith("github:"))
-        && !normalized.startsWith("/")
-        && !normalized.startsWith(".");
-    const isNpm = normalized.startsWith("@") || normalized.startsWith("npm:");
-    if (isGithub) {
-        return {
-            type: "github",
-            value: normalized.startsWith("github:") ? normalized.slice(7) : normalized,
-        };
-    }
-    if (isNpm) {
-        return {
-            type: "npm",
-            value: normalized.startsWith("npm:") ? normalized.slice(4) : normalized,
-        };
-    }
-    return { type: "local", value: path.resolve(normalized) };
-}
-export async function installExtension(type, source, options = {}) {
-    const quiet = !!options.quiet;
-    const baseDir = getBaseDir();
-    const targetRoot = path.join(baseDir, type === "agent" ? "agents" : "plugins");
-    await fs.mkdir(targetRoot, { recursive: true });
-    // 1. Determine the folder name (the "id") - ALWAYS based on source or explicit id
-    let id = options.id;
-    if (!id) {
-        if (source.type === "github") {
-            id = path.basename(source.value); // e.g. "agent-browser"
-        }
-        else if (source.type === "npm") {
-            id = source.value.split("/").pop(); // e.g. "@melony/plugin-test" -> "plugin-test"
-        }
-        else {
-            id = path.basename(source.value);
-        }
-    }
-    const targetDir = path.join(targetRoot, id);
-    const tempDir = path.join(tmpdir(), `openbot-install-${Date.now()}-${id}`);
-    try {
-        log(`📦 Installing ${type} "${id}" from ${source.type}...`, quiet);
-        if (source.type === "github") {
-            const url = `https://github.com/${source.value}.git`;
-            run("git", ["clone", "--depth", "1", url, tempDir], { quiet });
-        }
-        else if (source.type === "npm") {
-            await fs.mkdir(tempDir, { recursive: true });
-            run("npm", ["install", source.value, "--prefix", tempDir], { quiet });
-            const pkgFolder = path.join(tempDir, "node_modules", source.value);
-            const moveTemp = path.join(tmpdir(), `openbot-npm-move-${Date.now()}`);
-            await fs.rename(pkgFolder, moveTemp);
-            await fs.rm(tempDir, { recursive: true, force: true });
-            await fs.rename(moveTemp, tempDir);
-        }
-        else {
-            await fs.mkdir(tempDir, { recursive: true });
-            await fs.cp(source.value, tempDir, { recursive: true });
-        }
-        if (await directoryExists(targetDir)) {
-            log(`⚠️  Removing existing folder: ${targetDir}`, quiet);
-            await fs.rm(targetDir, { recursive: true, force: true });
-        }
-        await fs.rename(tempDir, targetDir);
-        log(`✅ Installed to: ${targetDir}`, quiet);
-        // Prepare dependencies and build
-        await ensurePluginReady(targetDir);
-        // If it's an agent, check for missing plugins
-        if (type === "agent") {
-            await installMissingPluginsFromAgent(targetDir, { quiet });
-        }
-        log(`🎉 Successfully installed ${type}: ${id}`, quiet);
-        return id;
-    }
-    catch (error) {
-        await fs.rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
-        throw error;
-    }
-}
-// Backward compatibility aliases
-export const installPluginFromSource = (source, opts) => installExtension("plugin", source, opts);
-export const installAgentFromSource = (source, opts) => installExtension("agent", source, opts);
-export const parsePluginInstallSource = parseSource;
-export const parseAgentInstallSource = parseSource;
-export async function installMissingPluginsFromAgent(agentFolder, options = {}) {
-    const quiet = !!options.quiet;
-    const config = await readAgentConfig(agentFolder);
-    const baseDir = getBaseDir();
-    for (const pluginItem of config.plugins || []) {
-        const pluginName = typeof pluginItem === "string" ? pluginItem : pluginItem.name;
-        if (!pluginName || BUILT_IN_PLUGIN_NAMES.has(pluginName))
-            continue;
-        // Check if it already exists as a folder in plugins/
-        const pluginPath = path.join(baseDir, "plugins", pluginName);
-        const prefixedPluginPath = path.join(baseDir, "plugins", `plugin-${pluginName}`);
-        if (await (directoryExists(pluginPath)) || await (directoryExists(prefixedPluginPath))) {
-            continue;
-        }
-        log(`🔍 Agent needs plugin "${pluginName}". Searching...`, quiet);
-        const ghRepo = `meetopenbot/plugin-${pluginName}`;
-        if (checkGitHubRepo(ghRepo)) {
-            await installExtension("plugin", { type: "github", value: ghRepo }, { quiet });
-            continue;
-        }
-        const npmPkg = `@melony/plugin-${pluginName}`;
-        if (checkNpmPackage(npmPkg)) {
-            await installExtension("plugin", { type: "npm", value: npmPkg }, { quiet });
-            continue;
-        }
-        log(`⚠️  Could not find plugin "${pluginName}" for this agent.`, quiet);
-    }
-}