openbot 0.2.2 → 0.2.5

package/README.md

@@ -25,7 +25,7 @@ You can talk to OpenBot using a simple POST request:
 ```bash
 curl -N \
   -H "Content-Type: application/json" \
-  -d '{"event":{"type":"user:text","data":{"content":"Hello!"}}}' \
+  -d '{"event":{"type":"agent:input","data":{"content":"Hello!"}}}' \
   http://localhost:4001/api/chat
 ```
 

package/dist/agents/agent-creator.js

@@ -1,35 +1,74 @@
+import path from "node:path";
 import { llmPlugin } from "../plugins/llm/index.js";
 import { fileSystemToolDefinitions, fileSystemPlugin } from "../plugins/file-system/index.js";
 import { DEFAULT_BASE_DIR, resolvePath } from "../config.js";
 export const agentCreatorAgent = (options) => (builder) => {
     const { model } = options;
-    const agentsDir = resolvePath(`${DEFAULT_BASE_DIR}/agents`);
+    const baseDir = resolvePath(DEFAULT_BASE_DIR);
+    const agentsDir = path.join(baseDir, "agents");
     builder
-        .use(fileSystemPlugin({ baseDir: agentsDir }))
+        .use(fileSystemPlugin({ baseDir }))
         .use(llmPlugin({
         model,
-        system: `You are the OpenBot Agent Creator. Your job is to help users build custom OpenBot agents via natural language.
+        system: `You are the OpenBot Agent Creator. Your job is to help users create AND update custom OpenBot agents via natural language.
 
-An OpenBot agent is defined by a folder in ${agentsDir} containing an \`agent.yaml\` file.
+Configuration storage:
+1. The Default Agent (the main orchestrator, usually named "OpenBot") is defined in: ${baseDir}/AGENT.md.
+2. Custom Agents live in their own subdirectories: ${agentsDir}/<agent-name>/AGENT.md.
 
-The YAML format is:
+The AGENT.md file uses Markdown with a YAML frontmatter block at the top.
+
+Frontmatter fields (required):
+---
 name: <slug-name>
 description: <short description>
 plugins:
-  - name: file-system
-  - name: shell
-  - name: browser # (if they need web access)
-systemPrompt: |
-  <detailed instructions for the agent>
-
-Your workflow:
-1. Ask the user what kind of agent they want to build (if they haven't provided enough detail).
-2. Suggest a name, description, required plugins, and a draft system prompt.
-3. Once the user approves, use the file-system tools to create the directory ${agentsDir}/<name> and write the \`agent.yaml\` file inside it.
-4. Tell the user they may need to restart the OpenBot server for the new agent to be registered.`,
+  - shell
+  - file-system
+  - name: approval
+    config:
+      rules: []
+---
+
+Optional fields:
+- model: <provider/model-id>
+- subscribe: [<event-type>, ...]
+
+The Markdown body below the frontmatter contains the agent's persona and detailed behavioral instructions.
+
+Official plugin catalog (prefer these):
+- shell: execute shell commands
+- file-system: read/write/list/delete files
+- approval: require user approval before risky actions
+- browser-tools: web automation
+- search: search/retrieval tools
+
+Tool Usage:
+1. Use \`listFiles\` to explore existing agents in ${agentsDir}.
+2. Use \`readFile\` to inspect an existing agent's AGENT.md before updating it.
+3. Use \`writeFile\` to create or update an agent's AGENT.md.
+
+Rules:
+1. Do not write files until user explicitly approves the proposed changes.
+2. For updates, ALWAYS read the current AGENT.md first using \`readFile\`, then propose changes.
+3. For the Default Agent, ALWAYS use ${baseDir}/AGENT.md.
+4. For Custom Agents, ALWAYS use ${agentsDir}/<name>/AGENT.md.
+5. If you're unsure which agent to update, use \`listFiles\` on ${agentsDir} to see available agents.
+6. Prefer official plugins.
+7. Keep frontmatter minimal; include only meaningful fields.
+8. If required info is missing, ask focused follow-up questions.
+9. After writing, confirm that the correct AGENT.md was updated.
+10. The server hot-reloads ~/.openbot changes.
+11. ALWAYS use the consolidated AGENT.md format. Do NOT create agent.yaml files anymore.
+
+Workflow:
+1. Determine whether this is create or update, and if it's for the Default Agent or a Custom Agent.
+2. If it's an update, use \`readFile\` to get the current configuration.
+3. If the agent name is ambiguous, use \`listFiles\` to find the correct one.
+4. Collect missing requirements from the user.
+5. Show a proposed AGENT.md content (frontmatter + instructions) and request explicit approval.
+6. On approval, write the appropriate AGENT.md using \`writeFile\`.
+7. Return a short completion summary.`,
         toolDefinitions: fileSystemToolDefinitions, // Give it access to write files
-        promptInputType: "agent:agent-creator:input",
-        actionResultInputType: "agent:agent-creator:result",
-        completionEventType: "agent:agent-creator:output",
     }));
 };

package/dist/agents/os-agent.js

@@ -15,7 +15,7 @@ export const osAgent = (options) => (builder) => {
         .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:writeFile", message: "The agent wants to write to a file." },
             { action: "action:deleteFile", message: "The agent wants to delete a file." },
         ],
     }))
@@ -26,9 +26,6 @@ export const osAgent = (options) => (builder) => {
             ...shellToolDefinitions,
             ...fileSystemToolDefinitions
         },
-        promptInputType: "agent:os:input",
-        actionResultInputType: "agent:os:result",
-        completionEventType: "agent:os:output",
     }));
     // NOTE: Bridge-back to the manager is handled generically by open-bot.ts.
     // No per-agent boilerplate needed.

package/dist/agents/planner-agent.js

@@ -0,0 +1,32 @@
+import { llmPlugin } from "../plugins/llm/index.js";
+const PLANNER_SYSTEM_PROMPT = `You are a planning specialist agent.
+
+Your job:
+- Convert a user intent into a short, executable plan.
+- Keep plans practical and concise.
+- Prefer 2-5 steps.
+- Each step should specify the best agent to execute it when relevant.
+
+Available agent naming convention:
+- Use exact agent names when assigning (e.g. os, browser, topic, planner-agent, etc.).
+
+Output format:
+- Return strict JSON only.
+- Shape:
+{
+  "goal": "...",
+  "steps": [
+    { "id": "step_1", "agent": "agent-name-or-manager", "task": "..." }
+  ]
+}
+
+Rules:
+- If no specialist agent is needed for a step, set "agent" to "manager".
+- Do not include markdown fences.
+- Do not include explanatory prose outside JSON.`;
+export const plannerAgent = (options) => (builder) => {
+    builder.use(llmPlugin({
+        model: options.model,
+        system: PLANNER_SYSTEM_PROMPT,
+    }));
+};

package/dist/agents/topic-agent.js

@@ -1,6 +1,6 @@
 import { generateText } from "ai";
 export const topicAgent = (options) => (builder) => {
-    builder.on("manager:completion", async function* (event, { state }) {
+    builder.on("agent:output", async function* (event, { state }) {
         // Only title if it doesn't have one and there's history
         if (state.title || !state.messages || state.messages.length === 0) {
             return;

package/dist/architecture/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/architecture/execution-engine.js

@@ -0,0 +1,151 @@
+const DEFAULT_POLICY = {
+    maxRetries: 1,
+    stepTimeoutMs: 45000,
+};
+function nowIso() {
+    return new Date().toISOString();
+}
+function toError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function updateTrace(state, patch) {
+    const next = {
+        traceId: patch.traceId ?? state.execution?.traceId ?? `trace_${Date.now()}`,
+        state: patch.state ?? state.execution?.state ?? "RECEIVED",
+        intent: patch.intent ?? state.execution?.intent,
+        plan: patch.plan ?? state.execution?.plan,
+        currentStepId: patch.currentStepId ?? state.execution?.currentStepId,
+        error: patch.error ?? state.execution?.error,
+        updatedAt: nowIso(),
+    };
+    state.execution = next;
+    return next;
+}
+function toExecutionEvent(trace) {
+    return {
+        type: "execution:state",
+        data: {
+            traceId: trace.traceId,
+            state: trace.state,
+            currentStepId: trace.currentStepId,
+            error: trace.error,
+            intentType: trace.intent?.type,
+            planSteps: trace.plan?.steps.length,
+        },
+    };
+}
+function withTimeout(promise, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`Step timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        promise
+            .then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        })
+            .catch((error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function hasPendingApprovals(state) {
+    const agentStates = state.agentStates || {};
+    return Object.values(agentStates).some((agentState) => !!agentState.pendingApprovals &&
+        Object.keys(agentState.pendingApprovals).length > 0);
+}
+async function* executeStep(step, input, policy) {
+    let lastError;
+    for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {
+        try {
+            const stream = step.kind === "delegate"
+                ? input.callbacks.runAgent(step.agent ?? "", step.task ?? "", step.attachments, input.state, input.runId)
+                : input.callbacks.runManager(step.content ?? "", step.attachments, input.state, input.runId);
+            while (true) {
+                const nextItem = await withTimeout(stream.next(), policy.stepTimeoutMs);
+                if (nextItem.done)
+                    break;
+                const event = nextItem.value;
+                if (input.state.execution?.state === "WAITING_APPROVAL") {
+                    const trace = updateTrace(input.state, {
+                        state: "EXECUTING",
+                        currentStepId: step.id,
+                    });
+                    yield toExecutionEvent(trace);
+                }
+                yield event;
+            }
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < policy.maxRetries) {
+                const trace = updateTrace(input.state, {
+                    state: "EXECUTING",
+                    currentStepId: step.id,
+                    error: `Retry ${attempt + 1}/${policy.maxRetries}: ${toError(error)}`,
+                });
+                yield toExecutionEvent(trace);
+                continue;
+            }
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(toError(lastError));
+}
+/**
+ * Stateful execution engine for plan steps.
+ * The engine is the commit point for executing actions from a plan.
+ */
+export async function* executePlan(input) {
+    const policy = {
+        ...DEFAULT_POLICY,
+        ...(input.policy ?? {}),
+    };
+    let trace = updateTrace(input.state, {
+        traceId: input.traceId,
+        state: "EXECUTING",
+        plan: input.plan,
+        error: undefined,
+    });
+    yield toExecutionEvent(trace);
+    try {
+        for (const step of input.plan.steps) {
+            trace = updateTrace(input.state, {
+                state: "EXECUTING",
+                currentStepId: step.id,
+                error: undefined,
+            });
+            yield toExecutionEvent(trace);
+            yield* executeStep(step, input, policy);
+            if (hasPendingApprovals(input.state)) {
+                trace = updateTrace(input.state, {
+                    state: "WAITING_APPROVAL",
+                    currentStepId: step.id,
+                });
+                yield toExecutionEvent(trace);
+                return;
+            }
+        }
+        trace = updateTrace(input.state, {
+            state: "COMPLETED",
+            currentStepId: undefined,
+            error: undefined,
+        });
+        yield toExecutionEvent(trace);
+    }
+    catch (error) {
+        trace = updateTrace(input.state, {
+            state: "FAILED",
+            error: toError(error),
+        });
+        yield toExecutionEvent(trace);
+        throw error;
+    }
+}
+export function setExecutionState(state, patch) {
+    return updateTrace(state, patch);
+}
+export function executionStateEvent(trace) {
+    return toExecutionEvent(trace);
+}

package/dist/architecture/intent-classifier.js

@@ -0,0 +1,26 @@
+/**
+ * Classifies user input into a routing intent.
+ * Starts with deterministic rules; can later be upgraded to hybrid LLM+rules.
+ */
+export function classifyIntent(input) {
+    const raw = input.content.trim();
+    if (!raw) {
+        return { type: "chat", confidence: 0.8 };
+    }
+    if (raw.startsWith("/") || raw.startsWith("@")) {
+        const firstSpace = raw.indexOf(" ");
+        const prefix = firstSpace === -1 ? raw.slice(1) : raw.slice(1, firstSpace);
+        if (input.knownAgents.has(prefix)) {
+            return {
+                type: "agent_direct",
+                confidence: 0.99,
+                targetAgent: prefix,
+            };
+        }
+    }
+    const looksLikeTask = /\b(create|build|write|fix|update|implement|run|execute|open|edit|delete|list)\b/i.test(raw);
+    if (looksLikeTask) {
+        return { type: "task", confidence: 0.75 };
+    }
+    return { type: "chat", confidence: 0.7 };
+}

package/dist/architecture/planner.js

@@ -0,0 +1,106 @@
+import { generateObject } from "ai";
+import { z } from "zod";
+function createStepId(index) {
+    return `step_${index + 1}`;
+}
+/**
+ * Strategic planner that emits explicit executable steps.
+ * Initial version is deterministic to keep behavior predictable.
+ */
+const PlanStepSchema = z.object({
+    id: z.string(),
+    kind: z.enum(["delegate", "manager"]),
+    successCriteria: z.string(),
+    agent: z.string().optional(),
+    task: z.string().optional(),
+    content: z.string().optional(),
+});
+const PlanSchema = z.object({
+    goal: z.string(),
+    stopCondition: z.string(),
+    steps: z.array(PlanStepSchema).min(1).max(4),
+});
+function sanitizePlan(raw, input) {
+    const steps = raw.steps.map((step, index) => {
+        const normalized = {
+            id: step.id?.trim() ? step.id : createStepId(index),
+            kind: step.kind,
+            successCriteria: step.successCriteria?.trim() || "Step completed successfully.",
+        };
+        if (step.kind === "delegate") {
+            const chosenAgent = step.agent && input.knownAgents.includes(step.agent)
+                ? step.agent
+                : input.knownAgents[0];
+            normalized.agent = chosenAgent;
+            normalized.task = step.task?.trim() || input.content.trim();
+        }
+        else {
+            normalized.content = step.content?.trim() || input.content.trim();
+        }
+        return normalized;
+    });
+    if (steps[0]) {
+        steps[0].attachments = input.attachments;
+    }
+    return {
+        goal: raw.goal?.trim() || input.content || "Handle user request",
+        stopCondition: raw.stopCondition?.trim() || "All plan steps completed successfully.",
+        steps,
+    };
+}
+function buildDeterministicPlan(input) {
+    const steps = [];
+    const content = input.content.trim();
+    const attachments = input.attachments;
+    if (input.intent.type === "agent_direct" && input.intent.targetAgent) {
+        const firstSpace = content.indexOf(" ");
+        const delegatedTask = firstSpace === -1 ? "" : content.slice(firstSpace + 1).trim();
+        steps.push({
+            id: createStepId(0),
+            kind: "delegate",
+            agent: input.intent.targetAgent,
+            task: delegatedTask,
+            attachments,
+            successCriteria: "Agent returns an output event.",
+        });
+    }
+    else {
+        steps.push({
+            id: createStepId(0),
+            kind: "manager",
+            content,
+            attachments,
+            successCriteria: "Manager emits a completion message.",
+        });
+    }
+    return {
+        goal: content || "Handle user request",
+        steps,
+        stopCondition: "All plan steps completed successfully.",
+    };
+}
+export async function createPlan(input, options = {}) {
+    if (input.intent.type === "agent_direct") {
+        return buildDeterministicPlan(input);
+    }
+    if (!options.model) {
+        return buildDeterministicPlan(input);
+    }
+    try {
+        const { object } = await generateObject({
+            model: options.model,
+            schema: PlanSchema,
+            system: `You are a strategic planner for an AI orchestration system.
+Output compact, executable plans.
+Available agents: ${input.knownAgents.join(", ") || "none"}.
+Use "delegate" only when an agent is clearly needed; otherwise use "manager".`,
+            prompt: `Intent: ${JSON.stringify(input.intent)}
+User request: ${input.content}
+Return a plan with 1-4 steps.`,
+        });
+        return sanitizePlan(object, input);
+    }
+    catch {
+        return buildDeterministicPlan(input);
+    }
+}

package/dist/automation-worker.js

@@ -0,0 +1,121 @@
+function minuteKey(date) {
+    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}T${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+}
+function parseNumber(value) {
+    if (!/^\d+$/.test(value))
+        return null;
+    return Number(value);
+}
+function matchToken(value, token, min, max) {
+    const [base, stepRaw] = token.split("/");
+    const step = stepRaw ? parseNumber(stepRaw) : null;
+    if (stepRaw && (!step || step <= 0))
+        return false;
+    const checkStep = (start) => {
+        if (!step)
+            return true;
+        return (value - start) % step === 0;
+    };
+    if (base === "*") {
+        return checkStep(min);
+    }
+    if (base.includes("-")) {
+        const [startRaw, endRaw] = base.split("-");
+        const start = parseNumber(startRaw);
+        const end = parseNumber(endRaw);
+        if (start === null || end === null || start < min || end > max || start > end)
+            return false;
+        if (value < start || value > end)
+            return false;
+        return checkStep(start);
+    }
+    const exact = parseNumber(base);
+    if (exact === null || exact < min || exact > max)
+        return false;
+    if (value !== exact)
+        return false;
+    return checkStep(exact);
+}
+function matchField(value, field, min, max) {
+    const tokens = field.split(",").map((t) => t.trim()).filter(Boolean);
+    if (tokens.length === 0)
+        return false;
+    return tokens.some((token) => matchToken(value, token, min, max));
+}
+export function isCronDue(cron, date) {
+    const fields = cron.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return false;
+    const [minuteField, hourField, domField, monthField, dowField] = fields;
+    const minute = date.getMinutes();
+    const hour = date.getHours();
+    const dayOfMonth = date.getDate();
+    const month = date.getMonth() + 1;
+    const dayOfWeek = date.getDay();
+    const minuteMatch = matchField(minute, minuteField, 0, 59);
+    const hourMatch = matchField(hour, hourField, 0, 23);
+    const monthMatch = matchField(month, monthField, 1, 12);
+    const domMatch = matchField(dayOfMonth, domField, 1, 31);
+    const dowMatch = matchField(dayOfWeek, dowField, 0, 7) || (dayOfWeek === 0 && matchField(7, dowField, 0, 7));
+    const domWildcard = domField.trim() === "*";
+    const dowWildcard = dowField.trim() === "*";
+    const dayMatch = domWildcard && dowWildcard
+        ? true
+        : domWildcard
+            ? dowMatch
+            : dowWildcard
+                ? domMatch
+                : domMatch || dowMatch;
+    return minuteMatch && hourMatch && monthMatch && dayMatch;
+}
+export function startAutomationWorker(options) {
+    const { listAutomations, runAutomation, pollIntervalMs = 60000, logger = console, } = options;
+    const inFlightByAutomation = new Set();
+    const seenMinuteByAutomation = new Map();
+    let polling = false;
+    const tick = async () => {
+        if (polling)
+            return;
+        polling = true;
+        try {
+            const now = new Date();
+            const currentMinute = minuteKey(now);
+            const automations = await listAutomations();
+            for (const automation of automations) {
+                if (!automation.enabled)
+                    continue;
+                if (inFlightByAutomation.has(automation.id))
+                    continue;
+                if (seenMinuteByAutomation.get(automation.id) === currentMinute)
+                    continue;
+                const due = isCronDue(automation.cron, now);
+                if (!due)
+                    continue;
+                seenMinuteByAutomation.set(automation.id, currentMinute);
+                inFlightByAutomation.add(automation.id);
+                void runAutomation(automation, new Date(now))
+                    .catch((err) => {
+                    logger.error(`[automations] Failed run for "${automation.name}" (${automation.id}):`, err);
+                })
+                    .finally(() => {
+                    inFlightByAutomation.delete(automation.id);
+                });
+            }
+        }
+        catch (err) {
+            logger.error("[automations] Worker tick failed:", err);
+        }
+        finally {
+            polling = false;
+        }
+    };
+    const interval = setInterval(() => {
+        void tick();
+    }, pollIntervalMs);
+    logger.info(`[automations] Worker started (poll interval ${pollIntervalMs}ms)`);
+    void tick();
+    return () => {
+        clearInterval(interval);
+        logger.info("[automations] Worker stopped");
+    };
+}

package/dist/automations.js

@@ -0,0 +1,52 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from "./config.js";
+function getAutomationsPath() {
+    const cfg = loadConfig();
+    const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+    const resolvedBaseDir = resolvePath(baseDir);
+    return path.join(resolvedBaseDir, "automations.json");
+}
+export async function listAutomations() {
+    const filePath = getAutomationsPath();
+    try {
+        const raw = await fs.readFile(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .filter((item) => item && typeof item === "object")
+            .map((item) => {
+            const targetType = item.targetType === "agent" ? "agent" : "orchestrator";
+            const agentName = typeof item.agentName === "string" && item.agentName.trim()
+                ? item.agentName.trim()
+                : undefined;
+            return {
+                id: typeof item.id === "string" ? item.id : "",
+                name: typeof item.name === "string" ? item.name : "",
+                prompt: typeof item.prompt === "string" ? item.prompt : "",
+                cron: typeof item.cron === "string" ? item.cron : "",
+                targetType,
+                agentName: targetType === "agent" ? agentName : undefined,
+                enabled: Boolean(item.enabled),
+                createdAt: typeof item.createdAt === "string" ? item.createdAt : new Date().toISOString(),
+                updatedAt: typeof item.updatedAt === "string" ? item.updatedAt : new Date().toISOString(),
+            };
+        })
+            .filter((item) => {
+            if (!item.id || !item.name || !item.prompt || !item.cron)
+                return false;
+            if (item.targetType === "agent" && !item.agentName)
+                return false;
+            return true;
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveAutomations(items) {
+    const filePath = getAutomationsPath();
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(items, null, 2), "utf-8");
+}