openbot 0.2.12 → 0.2.13

package/dist/orchestrator.js

@@ -1,422 +0,0 @@
-import { melony } from "melony";
-const AGENT_TEXT_TYPES = new Set(["assistant:text-delta", "assistant:text"]);
-const MAX_DELEGATIONS_PER_MANAGER_RUN = 6;
-const DIRECT_TITLE_CONTEXT_LIMIT = 20;
-const TASK_HINT_REGEX = /\b(create|build|write|fix|update|implement|run|execute|open|edit|delete|list|plan|analyze|research|refactor|install|configure|debug|deploy)\b/i;
-function isAgentTextEvent(event) {
-    return AGENT_TEXT_TYPES.has(event.type);
-}
-function createTraceId(runId) {
-    return `trace_${runId}_${Date.now()}`;
-}
-function nowIso() {
-    return new Date().toISOString();
-}
-function hasPendingApprovals(state) {
-    const agentStates = state.agentStates || {};
-    return Object.values(agentStates).some((agentState) => !!agentState.pendingApprovals &&
-        Object.keys(agentState.pendingApprovals).length > 0);
-}
-function parseDirectAgent(content, knownAgents) {
-    const raw = content.trim();
-    if (!raw || (!raw.startsWith("/") && !raw.startsWith("@")))
-        return null;
-    const firstSpace = raw.indexOf(" ");
-    const candidate = firstSpace === -1 ? raw.slice(1) : raw.slice(1, firstSpace);
-    if (!knownAgents.has(candidate))
-        return null;
-    const task = firstSpace === -1 ? "" : raw.slice(firstSpace + 1).trim();
-    return { agentName: candidate, task };
-}
-function classifyIntent(content, knownAgents) {
-    const raw = content.trim();
-    const direct = parseDirectAgent(raw, knownAgents);
-    if (direct) {
-        return { type: "agent_direct", targetAgent: direct.agentName };
-    }
-    if (!raw) {
-        return { type: "chat" };
-    }
-    if (TASK_HINT_REGEX.test(raw)) {
-        return { type: "task" };
-    }
-    return { type: "chat" };
-}
-export class Orchestrator {
-    constructor(options) {
-        this.managerPlugin = options.managerPlugin;
-        this.agents = new Map(options.agents.map((a) => [a.name, a]));
-    }
-    buildManagerRuntime() {
-        const builder = melony();
-        builder.use(this.managerPlugin);
-        builder.on("action:taskResult", async function* (event) {
-            yield { type: "manager:result", data: event.data };
-        });
-        return builder.build();
-    }
-    buildAgentRuntime(agent) {
-        const builder = melony();
-        builder.use(agent.plugin);
-        const name = agent.name;
-        builder.on("action:taskResult", async function* (event) {
-            yield { type: `agent:${name}:result`, data: event.data };
-        });
-        return builder.build();
-    }
-    getAgentState(agentName, sessionState) {
-        if (!sessionState.agentStates)
-            sessionState.agentStates = {};
-        if (!sessionState.agentStates[agentName]) {
-            sessionState.agentStates[agentName] = {};
-        }
-        const agentState = sessionState.agentStates[agentName];
-        if (!agentState.cwd)
-            agentState.cwd = sessionState.cwd;
-        return agentState;
-    }
-    appendSessionMessage(sessionState, message) {
-        if (!sessionState.messages)
-            sessionState.messages = [];
-        sessionState.messages.push(message);
-        if (sessionState.messages.length > DIRECT_TITLE_CONTEXT_LIMIT) {
-            sessionState.messages = sessionState.messages.slice(-DIRECT_TITLE_CONTEXT_LIMIT);
-        }
-    }
-    setExecutionState(state, patch) {
-        const hasCurrentStepId = Object.prototype.hasOwnProperty.call(patch, "currentStepId");
-        const hasError = Object.prototype.hasOwnProperty.call(patch, "error");
-        const hasIntentType = Object.prototype.hasOwnProperty.call(patch, "intentType");
-        const hasPlanSteps = Object.prototype.hasOwnProperty.call(patch, "planSteps");
-        const next = {
-            traceId: patch.traceId ?? state.execution?.traceId ?? `trace_${Date.now()}`,
-            state: patch.state ?? state.execution?.state ?? "RECEIVED",
-            currentStepId: hasCurrentStepId ? patch.currentStepId : state.execution?.currentStepId,
-            error: hasError ? patch.error : state.execution?.error,
-            intentType: hasIntentType ? patch.intentType : state.execution?.intentType,
-            planSteps: hasPlanSteps ? patch.planSteps : state.execution?.planSteps,
-            updatedAt: nowIso(),
-        };
-        state.execution = next;
-        return next;
-    }
-    executionStateEvent(trace) {
-        return {
-            type: "execution:state",
-            data: {
-                traceId: trace?.traceId,
-                state: trace?.state,
-                currentStepId: trace?.currentStepId,
-                error: trace?.error,
-                intentType: trace?.intentType,
-                planSteps: trace?.planSteps,
-            },
-        };
-    }
-    async *triggerTopicRefresh(sessionState, runId) {
-        const runtime = this.buildManagerRuntime();
-        for await (const yielded of runtime.run({
-            type: "manager:completion",
-            data: { content: "" },
-        }, { state: sessionState, runId })) {
-            yield yielded;
-        }
-    }
-    estimatePlanSteps(planText) {
-        const trimmed = planText.trim();
-        if (!trimmed)
-            return undefined;
-        try {
-            const parsed = JSON.parse(trimmed);
-            if (Array.isArray(parsed?.steps))
-                return parsed.steps.length;
-        }
-        catch {
-            // Best-effort parsing only.
-        }
-        return undefined;
-    }
-    buildManagerTaskInput(userIntent, planText) {
-        return `User intent:\n${userIntent}\n\nPlanner output (treat as proposed execution plan):\n${planText}\n\nExecute this pragmatically. Delegate concrete subtasks to relevant specialist agents when needed. Keep user-facing updates concise.`;
-    }
-    async *runPlannerAgent(content, attachments, sessionState, runId) {
-        const plannerName = "planner-agent";
-        if (!this.agents.has(plannerName)) {
-            return "";
-        }
-        let plannerOutput = "";
-        for await (const yielded of this.runAgentInternal(plannerName, content, attachments, sessionState, runId)) {
-            if (yielded.type === `agent:${plannerName}:output`) {
-                plannerOutput = yielded.data.content || "";
-            }
-            // Planner output is consumed by OpenBot orchestration and should not be
-            // streamed directly to the user.
-            if (!isAgentTextEvent(yielded) && yielded.type !== `agent:${plannerName}:output`) {
-                yield yielded;
-            }
-        }
-        return plannerOutput;
-    }
-    async *run(event, options) {
-        const { state, runId = `run_${Date.now()}` } = options;
-        yield event;
-        if (event.type === "action:approve" || event.type === "action:deny") {
-            const trace = this.setExecutionState(state, {
-                state: "EXECUTING",
-                error: undefined,
-            });
-            yield this.executionStateEvent(trace);
-            yield* this.routeApproval(event, state, runId);
-            return;
-        }
-        if (event.type === "user:text" || event.type === "user:multimodal") {
-            const rawContent = event.data.content;
-            const content = typeof rawContent === "string" ? rawContent.trim() : "";
-            const attachments = Array.isArray(event.data.attachments)
-                ? event.data.attachments
-                : undefined;
-            const knownAgents = new Set(this.agents.keys());
-            const direct = parseDirectAgent(content, knownAgents);
-            const intent = classifyIntent(content, knownAgents);
-            let trace = this.setExecutionState(state, {
-                traceId: createTraceId(runId),
-                state: "RECEIVED",
-                intentType: intent.type,
-                error: undefined,
-                currentStepId: undefined,
-                planSteps: undefined,
-            });
-            yield this.executionStateEvent(trace);
-            try {
-                if (direct) {
-                    this.appendSessionMessage(state, {
-                        role: "user",
-                        content,
-                        attachments,
-                    });
-                    trace = this.setExecutionState(state, {
-                        state: "EXECUTING",
-                        currentStepId: `delegate:${direct.agentName}`,
-                    });
-                    yield this.executionStateEvent(trace);
-                    yield* this.runAgentDirect(direct.agentName, direct.task, attachments, state, runId);
-                    const finalTrace = this.setExecutionState(state, {
-                        state: hasPendingApprovals(state) ? "WAITING_APPROVAL" : "COMPLETED",
-                        currentStepId: hasPendingApprovals(state)
-                            ? `delegate:${direct.agentName}`
-                            : undefined,
-                        error: undefined,
-                    });
-                    yield this.executionStateEvent(finalTrace);
-                    return;
-                }
-                trace = this.setExecutionState(state, {
-                    state: "EXECUTING",
-                    currentStepId: intent.type === "task" ? "planner" : "manager",
-                });
-                yield this.executionStateEvent(trace);
-                let managerInput = content;
-                if (intent.type === "task" && this.agents.has("planner-agent")) {
-                    const plannerResult = yield* this.runPlannerAgent(content, attachments, state, runId);
-                    if (plannerResult.trim()) {
-                        managerInput = this.buildManagerTaskInput(content, plannerResult);
-                        const planSteps = this.estimatePlanSteps(plannerResult);
-                        trace = this.setExecutionState(state, {
-                            currentStepId: "manager",
-                            planSteps,
-                        });
-                        yield this.executionStateEvent(trace);
-                    }
-                }
-                yield* this.runManagerLoop({
-                    type: "manager:input",
-                    data: { content: managerInput, attachments },
-                }, state, runId);
-                const waiting = hasPendingApprovals(state);
-                const finalTrace = this.setExecutionState(state, {
-                    state: waiting ? "WAITING_APPROVAL" : "COMPLETED",
-                    currentStepId: waiting ? (state.execution?.currentStepId ?? "manager") : undefined,
-                    error: undefined,
-                });
-                yield this.executionStateEvent(finalTrace);
-                return;
-            }
-            catch (error) {
-                const finalTrace = this.setExecutionState(state, {
-                    state: "FAILED",
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                yield this.executionStateEvent(finalTrace);
-                throw error;
-            }
-        }
-        yield* this.runManagerLoop(event, state, runId);
-    }
-    async *runManagerLoop(event, state, runId) {
-        const runtime = this.buildManagerRuntime();
-        const delegationSignatures = new Set();
-        let delegationCount = 0;
-        let nextManagerEvent = event;
-        while (nextManagerEvent) {
-            const managerEvent = nextManagerEvent;
-            nextManagerEvent = undefined;
-            for await (const yielded of runtime.run(managerEvent, { state, runId })) {
-                if (yielded.type !== "action:delegateTask") {
-                    yield yielded;
-                    continue;
-                }
-                const { agent: agentName, task, attachments, toolCallId } = yielded.data;
-                const normalizedTask = typeof task === "string"
-                    ? task.replace(/\s+/g, " ").trim().toLowerCase()
-                    : "";
-                const signature = `${agentName}::${normalizedTask}`;
-                if (delegationCount >= MAX_DELEGATIONS_PER_MANAGER_RUN ||
-                    (normalizedTask && delegationSignatures.has(signature))) {
-                    nextManagerEvent = {
-                        type: "manager:result",
-                        data: {
-                            action: "delegateTask",
-                            toolCallId,
-                            result: `Error: delegation loop detected for agent "${agentName}". Summarize current progress and stop delegating.`,
-                        },
-                    };
-                    break;
-                }
-                if (!this.agents.has(agentName)) {
-                    nextManagerEvent = {
-                        type: "manager:result",
-                        data: {
-                            action: "delegateTask",
-                            toolCallId,
-                            result: `Error: Agent "${agentName}" not found`,
-                        },
-                    };
-                    break;
-                }
-                delegationCount += 1;
-                if (normalizedTask)
-                    delegationSignatures.add(signature);
-                if (!state.pendingAgentTasks)
-                    state.pendingAgentTasks = {};
-                state.pendingAgentTasks[agentName] = { toolCallId };
-                let agentOutput = "";
-                let agentCompleted = false;
-                try {
-                    for await (const agentEvent of this.runAgentInternal(agentName, task, attachments, state, runId)) {
-                        if (agentEvent.type === `agent:${agentName}:output`) {
-                            agentOutput = agentEvent.data.content;
-                            agentCompleted = true;
-                        }
-                        if (!isAgentTextEvent(agentEvent)) {
-                            yield agentEvent;
-                        }
-                    }
-                }
-                catch (error) {
-                    agentOutput = `Error: ${error instanceof Error ? error.message : String(error)}`;
-                    agentCompleted = true;
-                }
-                if (agentCompleted) {
-                    delete state.pendingAgentTasks[agentName];
-                    nextManagerEvent = {
-                        type: "manager:result",
-                        data: {
-                            action: "delegateTask",
-                            toolCallId,
-                            result: agentOutput,
-                        },
-                    };
-                }
-                break;
-            }
-        }
-    }
-    async *runAgentInternal(agentName, task, attachments, sessionState, runId) {
-        const agent = this.agents.get(agentName);
-        const agentState = this.getAgentState(agentName, sessionState);
-        const runtime = this.buildAgentRuntime(agent);
-        const inputEvent = {
-            type: `agent:${agentName}:input`,
-            data: { content: task, attachments },
-        };
-        for await (const yielded of runtime.run(inputEvent, {
-            state: agentState,
-            runId,
-        })) {
-            yield yielded;
-        }
-    }
-    async *runAgentDirect(agentName, task, attachments, sessionState, runId) {
-        for await (const yielded of this.runAgentInternal(agentName, task, attachments, sessionState, runId)) {
-            if (yielded.type === `agent:${agentName}:output`) {
-                const content = yielded.data.content;
-                this.appendSessionMessage(sessionState, {
-                    role: "assistant",
-                    content,
-                });
-                yield {
-                    type: "assistant:text",
-                    data: { content },
-                    meta: { agent: agentName },
-                };
-                yield* this.triggerTopicRefresh(sessionState, runId);
-            }
-            else {
-                yield yielded;
-            }
-        }
-    }
-    async *routeApproval(event, state, runId) {
-        const approvalId = event.data.id;
-        const agentStates = state.agentStates || {};
-        let targetAgent;
-        for (const [name, agentState] of Object.entries(agentStates)) {
-            if (agentState.pendingApprovals?.[approvalId]) {
-                targetAgent = name;
-                break;
-            }
-        }
-        if (!targetAgent) {
-            console.warn("[orchestrator] No agent found for approval event:", approvalId);
-            return;
-        }
-        const agent = this.agents.get(targetAgent);
-        const agentState = this.getAgentState(targetAgent, state);
-        const runtime = this.buildAgentRuntime(agent);
-        let agentOutput = "";
-        let agentCompleted = false;
-        const isDelegation = !!state.pendingAgentTasks?.[targetAgent];
-        for await (const yielded of runtime.run(event, {
-            state: agentState,
-            runId,
-        })) {
-            if (yielded.type === `agent:${targetAgent}:output`) {
-                agentOutput = yielded.data.content;
-                agentCompleted = true;
-            }
-            if (isDelegation && isAgentTextEvent(yielded)) {
-                continue;
-            }
-            yield yielded;
-        }
-        if (agentCompleted && state.pendingAgentTasks?.[targetAgent]) {
-            const { toolCallId } = state.pendingAgentTasks[targetAgent];
-            delete state.pendingAgentTasks[targetAgent];
-            yield* this.runManagerLoop({
-                type: "manager:result",
-                data: {
-                    action: "delegateTask",
-                    toolCallId,
-                    result: agentOutput,
-                },
-            }, state, runId);
-        }
-        const waiting = hasPendingApprovals(state);
-        const trace = this.setExecutionState(state, {
-            state: waiting ? "WAITING_APPROVAL" : "COMPLETED",
-            currentStepId: waiting ? state.execution?.currentStepId : undefined,
-            error: undefined,
-        });
-        yield this.executionStateEvent(trace);
-    }
-}

package/dist/plugins/agent/index.js

@@ -1,81 +0,0 @@
-import { streamText } from "ai";
-import { ui } from "@melony/ui-kit";
-/**
- * Builds a simple history summary from recent messages.
- * Keeps the last N messages as simple role/content pairs.
- */
-function getRecentHistory(messages, maxMessages) {
-    return messages.slice(-maxMessages);
-}
-/**
- * AI SDK Plugin for Melony.
- * Automatically handles text events and routes them through an LLM using Vercel AI SDK.
- * It can also automatically trigger events based on tool calls.
- */
-export const agentPlugin = (options) => (builder) => {
-    const { model, system, toolDefinitions = {}, actionEventPrefix = "action:", promptInputType = "user:text", actionResultInputType = "action:result", completionEventType } = options;
-    async function* routeToLLM(newMessage, context) {
-        const state = context.state;
-        if (!state.messages) {
-            state.messages = [];
-        }
-        // Add new message to history
-        state.messages.push(newMessage);
-        // Evaluate dynamic system prompt if it's a function
-        const systemPrompt = typeof system === "function" ? await system(context) : system;
-        const result = streamText({
-            model,
-            system: systemPrompt,
-            messages: getRecentHistory(state.messages, 20).map(m => m.role === "system" ? { role: "user", content: `System: ${m.content}` } : m),
-            tools: toolDefinitions,
-        });
-        let assistantText = "";
-        for await (const delta of result.textStream) {
-            assistantText += delta;
-            yield {
-                type: "assistant:text-delta",
-                data: { delta },
-            };
-        }
-        // Wait for tool calls to complete
-        const toolCalls = await result.toolCalls;
-        // Store assistant response as simple text
-        if (assistantText) {
-            state.messages.push({
-                role: "assistant",
-                content: assistantText,
-            });
-            if (completionEventType) {
-                yield {
-                    type: completionEventType,
-                    data: { content: assistantText },
-                };
-            }
-        }
-        const usage = await result.usage;
-        yield ui.event(ui.status(`Usage: ${usage.totalTokens} tokens`, "info"));
-        // Emit tool call events
-        for (const call of toolCalls) {
-            yield {
-                type: `${actionEventPrefix}${call.toolName}`,
-                data: {
-                    ...call.input,
-                    toolCallId: call.toolCallId,
-                },
-            };
-        }
-    }
-    // Handle user text input
-    builder.on(promptInputType, async function* (event, context) {
-        const content = event.data.content;
-        yield* routeToLLM({ role: "user", content }, context);
-    });
-    // Feed action results back to the LLM as user messages (with a System prefix)
-    // We use "user" role instead of "system" to avoid errors with providers like Anthropic
-    // that don't support multiple system messages or system messages after the first turn.
-    builder.on(actionResultInputType, async function* (event, context) {
-        const { action, result } = event.data;
-        const summary = typeof result === "string" ? result : JSON.stringify(result);
-        yield* routeToLLM({ role: "user", content: `System: Action "${action}" completed: ${summary}` }, context);
-    });
-};

package/dist/plugins/approval/index.js

@@ -1,100 +0,0 @@
-import { generateId } from "melony";
-import { uiEvent } from "../../ui/block.js";
-import { widgets } from "../../ui/widgets/index.js";
-function getActionName(eventType) {
-    return eventType.startsWith("action:")
-        ? eventType.slice("action:".length)
-        : eventType;
-}
-function buildApprovalData(event, rule) {
-    const actionName = getActionName(String(event.type));
-    const toolCallId = event?.data?.toolCallId;
-    const data = event?.data ?? {};
-    return {
-        summary: rule.message ??
-            "The agent requested a protected action. Approve to continue or deny to block it.",
-        details: [
-            { label: "Action", value: actionName },
-            ...(toolCallId ? [{ label: "Tool call", value: String(toolCallId) }] : []),
-        ],
-        rawPayload: JSON.stringify(data, null, 2),
-    };
-}
-/**
- * Minimal approval gate:
- * - Intercept protected action events.
- * - Suspend current request and show Approve/Deny UI.
- * - Resume only when user sends action:approve or action:deny.
- */
-export const approvalPlugin = (options) => (builder) => {
-    const rules = options?.rules ?? [];
-    builder.intercept(async (event, { state, suspend }) => {
-        const type = String(event.type ?? "");
-        const meta = event.meta ?? {};
-        // Never intercept internal approval events or already-approved replays.
-        if (type === "action:approve" || type === "action:deny" || meta.approved === true) {
-            return;
-        }
-        const rule = rules.find((r) => type.startsWith(r.action));
-        if (!rule)
-            return;
-        const approvalId = `approve_${generateId()}`;
-        state.pendingApprovals ?? (state.pendingApprovals = {});
-        state.pendingApprovals[approvalId] = {
-            originalEvent: event,
-            createdAt: Date.now(),
-        };
-        suspend({
-            type: "suspend",
-            data: {
-                reason: "approval",
-                id: approvalId,
-                event: uiEvent(widgets.approvalCard("Approval Required", buildApprovalData(event, rule), { type: "action:approve", data: { id: approvalId } }, { type: "action:deny", data: { id: approvalId } }, { placement: "attention", id: approvalId })),
-            },
-        });
-    });
-    builder.on("action:approve", async function* (event, { state }) {
-        const id = event?.data?.id;
-        if (!id)
-            return;
-        const pending = state.pendingApprovals?.[id];
-        if (!pending) {
-            return;
-        }
-        delete state.pendingApprovals[id];
-        // Re-emit the original action with approval marker.
-        yield {
-            ...pending.originalEvent,
-            meta: {
-                ...(pending.originalEvent?.meta ?? {}),
-                approved: true,
-            },
-        };
-    });
-    builder.on("action:deny", async function* (event, { state }) {
-        const id = event?.data?.id;
-        if (!id)
-            return;
-        const pending = state.pendingApprovals?.[id];
-        if (!pending) {
-            return;
-        }
-        delete state.pendingApprovals[id];
-        yield uiEvent(widgets.status("Action denied", "error", { placement: "attention", id }));
-        const originalEvent = pending.originalEvent;
-        const toolCallId = originalEvent?.data?.toolCallId;
-        if (toolCallId) {
-            yield {
-                type: "action:result",
-                data: {
-                    action: getActionName(String(originalEvent.type ?? "")),
-                    toolCallId,
-                    result: { error: "Action denied by user", denied: true },
-                    success: false,
-                    halt: true,
-                },
-            };
-        }
-    });
-};
-export default approvalPlugin;

package/dist/plugins/brain/identity.js

@@ -1,77 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-// --- Defaults ---
-const DEFAULT_SOUL = `# Soul
-
-## Core Values
-- Be helpful, honest, and harmless
-- Respect user privacy and data
-- Learn and improve continuously
-- Be transparent about capabilities and limitations
-
-## Ethical Guidelines
-- Never assist with harmful or illegal activities
-- Protect sensitive information
-- Acknowledge uncertainty when unsure
-- Prioritize user well-being
-`;
-const DEFAULT_IDENTITY = `# Identity
-
-I am the Manager Agent and central orchestrator of this AI system. My name and specific personality are defined by the user in this IDENTITY.md file.
-
-## Personality
-- Friendly and approachable
-- Technically competent
-- Eager to learn and adapt
-- Professional manager and delegator
-
-## Capabilities
-- Task Orchestration & Delegation
-- Long-term Memory & Knowledge Management
-- Executing specialized tasks via expert agents (Web, OS, etc.)
-- Self-modification and learning
-`;
-// --- Factory ---
-export function createIdentityModule(baseDir) {
-    const soulPath = path.join(baseDir, "SOUL.md");
-    const identityPath = path.join(baseDir, "IDENTITY.md");
-    return {
-        async initialize() {
-            try {
-                await fs.access(soulPath);
-            }
-            catch {
-                await fs.writeFile(soulPath, DEFAULT_SOUL, "utf-8");
-            }
-            try {
-                await fs.access(identityPath);
-            }
-            catch {
-                await fs.writeFile(identityPath, DEFAULT_IDENTITY, "utf-8");
-            }
-        },
-        async getSoul() {
-            try {
-                return (await fs.readFile(soulPath, "utf-8")).trim();
-            }
-            catch {
-                return "";
-            }
-        },
-        async getIdentity() {
-            try {
-                return (await fs.readFile(identityPath, "utf-8")).trim();
-            }
-            catch {
-                return "";
-            }
-        },
-        async updateIdentity(content) {
-            await fs.writeFile(identityPath, content, "utf-8");
-        },
-        async readFile(file) {
-            const filePath = file === "SOUL.md" ? soulPath : identityPath;
-            return await fs.readFile(filePath, "utf-8");
-        },
-    };
-}