openbot 0.2.2 → 0.2.5

package/dist/orchestrator.js

@@ -1,15 +1,47 @@
 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);
 }
-/**
- * Orchestrator coordinates isolated runtimes for the manager and each agent.
- *
- * Instead of composing all plugins into a single shared runtime (which causes
- * duplicate handlers and shared state bugs), each agent gets its own melony
- * runtime. The orchestrator routes events between them.
- */
+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;
@@ -43,11 +75,97 @@ export class Orchestrator {
             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 the input event so it gets logged and the client can render it
         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;
         }
@@ -57,43 +175,127 @@ export class Orchestrator {
             const attachments = Array.isArray(event.data.attachments)
                 ? event.data.attachments
                 : undefined;
-            if (content.startsWith("/") || 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 (this.agents.has(prefix)) {
-                    state.lastDirectAgent = prefix;
-                    yield* this.runAgentDirect(prefix, task, attachments, state, runId);
+            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;
             }
-            state.lastDirectAgent = undefined;
-            yield* this.runManagerLoop({ type: "manager:input", data: { content, attachments } }, state, runId);
-            return;
         }
         yield* this.runManagerLoop(event, state, runId);
     }
-    /**
-     * Runs the manager runtime. When it yields `action:delegateTask`,
-     * the orchestrator intercepts, runs the target agent to completion,
-     * then feeds the result back to the manager in a new run.
-     */
     async *runManagerLoop(event, state, runId) {
         const runtime = this.buildManagerRuntime();
-        for await (const yielded of runtime.run(event, { state, runId })) {
-            if (yielded.type === "action:delegateTask") {
+        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)) {
-                    yield* this.runManagerLoop({
+                    nextManagerEvent = {
                         type: "manager:result",
                         data: {
                             action: "delegateTask",
                             toolCallId,
                             result: `Error: Agent "${agentName}" not found`,
                         },
-                    }, state, runId);
-                    return;
+                    };
+                    break;
                 }
+                delegationCount += 1;
+                if (normalizedTask)
+                    delegationSignatures.add(signature);
                 if (!state.pendingAgentTasks)
                     state.pendingAgentTasks = {};
                 state.pendingAgentTasks[agentName] = { toolCallId };
@@ -105,9 +307,6 @@ export class Orchestrator {
                             agentOutput = agentEvent.data.content;
                             agentCompleted = true;
                         }
-                        // During delegation, suppress the agent's LLM text — the manager
-                        // will summarize the result for the user. Still pass through
-                        // operational events (status, UI/approval cards, etc.).
                         if (!isAgentTextEvent(agentEvent)) {
                             yield agentEvent;
                         }
@@ -119,18 +318,17 @@ export class Orchestrator {
                 }
                 if (agentCompleted) {
                     delete state.pendingAgentTasks[agentName];
-                    yield* this.runManagerLoop({
+                    nextManagerEvent = {
                         type: "manager:result",
                         data: {
                             action: "delegateTask",
                             toolCallId,
                             result: agentOutput,
                         },
-                    }, state, runId);
+                    };
                 }
-                return;
+                break;
             }
-            yield yielded;
         }
     }
     async *runAgentInternal(agentName, task, attachments, sessionState, runId) {
@@ -148,28 +346,26 @@ export class Orchestrator {
             yield yielded;
         }
     }
-    /**
-     * Direct agent invocation via prefix commands (/agent task).
-     * Wraps the agent's output event as assistant:text for the client.
-     */
     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: yielded.data.content },
+                    data: { content },
                     meta: { agent: agentName },
                 };
+                yield* this.triggerTopicRefresh(sessionState, runId);
             }
             else {
                 yield yielded;
             }
         }
     }
-    /**
-     * Routes approval/deny events to the agent that owns the pending approval.
-     * After the agent resumes, bridges back to the manager if this was a delegation.
-     */
     async *routeApproval(event, state, runId) {
         const approvalId = event.data.id;
         const agentStates = state.agentStates || {};
@@ -215,12 +411,12 @@ export class Orchestrator {
                 },
             }, state, runId);
         }
-        else if (agentCompleted && state.lastDirectAgent === targetAgent) {
-            yield {
-                type: "assistant:text",
-                data: { content: agentOutput },
-                meta: { agent: targetAgent },
-            };
-        }
+        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/approval/index.js

@@ -1,6 +1,109 @@
 import { generateId } from "melony";
 import { ui } from "@melony/ui-kit/server";
 import { widgets } from "../../ui/widgets/index.js";
+const DEFAULT_REDACTED_KEY_PATTERNS = [
+    /toolcallid/i,
+    /content/i,
+    /stdout/i,
+    /stderr/i,
+    /password/i,
+    /secret/i,
+    /token/i,
+    /api[_-]?key/i,
+    /authorization/i,
+    /cookie/i,
+];
+const MAX_VALUE_LENGTH = 240;
+const MAX_DETAILS = 8;
+function serializeValue(value) {
+    if (value === undefined || value === null)
+        return "-";
+    const serialized = typeof value === "string"
+        ? value
+        : typeof value === "number" || typeof value === "boolean"
+            ? String(value)
+            : JSON.stringify(value);
+    if (serialized.length <= MAX_VALUE_LENGTH)
+        return serialized;
+    return `${serialized.slice(0, MAX_VALUE_LENGTH - 3)}...`;
+}
+function buildActionLabel(eventType) {
+    const action = eventType.startsWith("action:") ? eventType.slice("action:".length) : eventType;
+    return action.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()).trim();
+}
+function toTitleCaseKey(key) {
+    return key
+        .replace(/([A-Z])/g, " $1")
+        .replace(/[_-]+/g, " ")
+        .replace(/^./, (c) => c.toUpperCase())
+        .trim();
+}
+function isRedactedKey(key, hiddenKeys = []) {
+    if (hiddenKeys.includes(key))
+        return true;
+    return DEFAULT_REDACTED_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+function sanitizePayload(value, hiddenKeys = []) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizePayload(item, hiddenKeys));
+    }
+    if (value && typeof value === "object") {
+        const obj = value;
+        const sanitizedEntries = Object.entries(obj).map(([key, v]) => {
+            if (isRedactedKey(key, hiddenKeys))
+                return [key, "[REDACTED]"];
+            return [key, sanitizePayload(v, hiddenKeys)];
+        });
+        return Object.fromEntries(sanitizedEntries);
+    }
+    if (typeof value === "string" && value.length > 1000) {
+        return `${value.slice(0, 997)}...`;
+    }
+    return value;
+}
+function summarizeData(data = {}, hiddenKeys = []) {
+    const safeData = sanitizePayload(data, hiddenKeys);
+    return JSON.stringify(safeData, null, 2);
+}
+function isRenderableDetailValue(value) {
+    return value !== undefined && value !== null;
+}
+function deriveDetailEntries(data, rule) {
+    const hiddenKeys = rule.hiddenKeys ?? [];
+    if (rule.detailKeys?.length) {
+        return rule.detailKeys
+            .filter((key) => key in data)
+            .filter((key) => !isRedactedKey(key, hiddenKeys))
+            .filter((key) => isRenderableDetailValue(data[key]))
+            .map((key) => ({
+            label: toTitleCaseKey(key),
+            value: serializeValue(data[key]),
+        }))
+            .slice(0, MAX_DETAILS);
+    }
+    return Object.entries(data)
+        .filter(([key]) => !isRedactedKey(key, hiddenKeys))
+        .filter(([_, value]) => isRenderableDetailValue(value))
+        .slice(0, MAX_DETAILS)
+        .map(([key, value]) => ({
+        label: toTitleCaseKey(key),
+        value: serializeValue(value),
+    }));
+}
+function buildApprovalData(event, rule) {
+    const eventType = event.type;
+    const data = (event.data ?? {});
+    const details = [
+        { label: "Action", value: buildActionLabel(eventType) },
+        { label: "Event", value: eventType },
+        ...deriveDetailEntries(data, rule),
+    ];
+    return {
+        summary: rule.message || "The agent wants to execute an action. Review details before approving.",
+        details,
+        rawPayload: summarizeData(data, rule.hiddenKeys ?? []),
+    };
+}
 /**
  * Approval Plugin for OpenBot.
  * Intercepts specific actions and requires user approval before proceeding.
@@ -31,7 +134,8 @@ export const approvalPlugin = (options) => (builder) => {
         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(widgets.approvalCard("Approval Required", rule.message || `Approval required for: ${event.type}\n\n${JSON.stringify(event.data, null, 2)}`, {
+        const approvalData = buildApprovalData(event, rule);
+        suspend(ui.event(widgets.approvalCard("Approval Required", approvalData, {
             type: "action:approve",
             data: { id: approvalId }
         }, {
@@ -65,10 +169,10 @@ export const approvalPlugin = (options) => (builder) => {
         if (originalEvent) {
             delete state.pendingApprovals[id];
             yield ui.event(widgets.status("Action denied", "error"));
-            // If it was a tool call (action:*), return a taskResult error so the LLM knows it failed
+            // If it was a tool call (action:*), return a result error so the LLM knows it failed
             if (originalEvent.data?.toolCallId) {
                 yield {
-                    type: "action:taskResult",
+                    type: "action:result",
                     data: {
                         action: originalEvent.type.replace("action:", ""),
                         toolCallId: originalEvent.data.toolCallId,