openbot 0.3.6 → 0.4.2

package/dist/plugins/memory/index.js

@@ -1,17 +1,31 @@
 import z from 'zod';
 /**
- * `memory` — exposes the global memory store as agent tools.
- *
- * The actual handlers live in `bus/services.ts` because memory is platform
- * infrastructure (shared across every agent on the bus); this plugin only
- * contributes the tool definitions so a runtime plugin (e.g. `ai-sdk`) can
- * surface them to the LLM.
- *
- * Scopes
- * ------
- * - `global`  (default) — visible to every agent and channel.
- * - `agent`   — visible only to the agent that wrote it.
- * - `channel` — visible only inside the active channel.
+ * Resolve a scope alias to a concrete scope string. Aliases let tools accept
+ * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
+ * them using `context.state`.
+ */
+function resolveMemoryScope(alias, state) {
+    switch (alias) {
+        case 'agent':
+            return `agent:${state.agentId}`;
+        case 'channel':
+            return `channel:${state.channelId}`;
+        case 'global':
+        case undefined:
+            return 'global';
+        default:
+            return 'global';
+    }
+}
+function resolveMemoryScopeFilter(alias, state) {
+    if (alias === 'all' || alias === undefined) {
+        return ['global', `agent:${state.agentId}`, `channel:${state.channelId}`];
+    }
+    return [resolveMemoryScope(alias, state)];
+}
+/**
+ * `memory` — exposes the global memory store as agent tools and provides
+ * platform-level memory handlers.
  */
 const memoryToolDefinitions = {
     remember: {
@@ -64,8 +78,83 @@ export const memoryPlugin = {
     name: 'Memory',
     description: 'Global long-term memory: remember/recall/forget facts across runs and agents.',
     toolDefinitions: memoryToolDefinitions,
-    factory: () => () => {
-        // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
+    factory: ({ storage }) => (builder) => {
+        builder.on('action:remember', async function* (event, context) {
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            try {
+                const { content, scope, tags } = event.data;
+                const record = await storage.appendMemory({
+                    scope: resolveMemoryScope(scope, context.state),
+                    content,
+                    tags,
+                });
+                yield {
+                    type: 'action:remember:result',
+                    data: { success: true, record },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:remember:result',
+                    data: {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
+        builder.on('action:recall', async function* (event, context) {
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            try {
+                const { query, tag, scope, limit } = event.data;
+                const records = await storage.listMemories({
+                    scopes: resolveMemoryScopeFilter(scope, context.state),
+                    query,
+                    tag,
+                    limit,
+                });
+                yield {
+                    type: 'action:recall:result',
+                    data: { success: true, records },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:recall:result',
+                    data: {
+                        success: false,
+                        records: [],
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
+        builder.on('action:forget', async function* (event, context) {
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            try {
+                const deleted = await storage.deleteMemory({ id: event.data.id });
+                yield {
+                    type: 'action:forget:result',
+                    data: { success: true, deleted },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:forget:result',
+                    data: {
+                        success: false,
+                        deleted: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
     },
 };
 export default memoryPlugin;

package/dist/plugins/memory/service.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 500;
+const getMemoryDir = () => {
+    const config = loadConfig();
+    return path.join(resolvePath(config.baseDir || DEFAULT_BASE_DIR), 'memory');
+};
+const getLogPath = () => path.join(getMemoryDir(), 'log.jsonl');
+const ensureDir = async () => {
+    await fs.mkdir(getMemoryDir(), { recursive: true });
+};
+const readLog = async () => {
+    try {
+        const raw = await fs.readFile(getLogPath(), 'utf-8');
+        return raw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => !!e);
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            return [];
+        throw e;
+    }
+};
+const replay = (entries) => {
+    const out = new Map();
+    for (const entry of entries) {
+        if (entry.op === 'add') {
+            out.set(entry.record.id, entry.record);
+        }
+        else if (entry.op === 'delete') {
+            out.delete(entry.id);
+        }
+        else if (entry.op === 'update') {
+            const existing = out.get(entry.id);
+            if (!existing)
+                continue;
+            out.set(entry.id, {
+                ...existing,
+                ...entry.patch,
+                id: existing.id,
+                updatedAt: entry.at,
+            });
+        }
+    }
+    return out;
+};
+const appendEntry = async (entry) => {
+    await ensureDir();
+    await fs.appendFile(getLogPath(), `${JSON.stringify(entry)}\n`, 'utf-8');
+};
+const matchesQuery = (record, query, tag) => {
+    if (tag) {
+        if (!record.tags || !record.tags.includes(tag))
+            return false;
+    }
+    if (query) {
+        const q = query.toLowerCase();
+        if (!record.content.toLowerCase().includes(q))
+            return false;
+    }
+    return true;
+};
+export const memoryService = {
+    appendMemory: async (args) => {
+        const now = new Date().toISOString();
+        const record = {
+            id: crypto.randomUUID(),
+            scope: args.scope,
+            content: args.content,
+            tags: args.tags?.length ? args.tags : undefined,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await appendEntry({ op: 'add', record });
+        return record;
+    },
+    updateMemory: async (args) => {
+        const entries = await readLog();
+        const map = replay(entries);
+        if (!map.has(args.id))
+            return false;
+        const at = new Date().toISOString();
+        const patch = {};
+        if (args.content !== undefined)
+            patch.content = args.content;
+        if (args.tags !== undefined)
+            patch.tags = args.tags.length ? args.tags : undefined;
+        if (Object.keys(patch).length === 0)
+            return true;
+        await appendEntry({ op: 'update', id: args.id, patch, at });
+        return true;
+    },
+    deleteMemory: async (args) => {
+        const entries = await readLog();
+        const map = replay(entries);
+        if (!map.has(args.id))
+            return false;
+        await appendEntry({ op: 'delete', id: args.id, at: new Date().toISOString() });
+        return true;
+    },
+    listMemories: async (args = {}) => {
+        const entries = await readLog();
+        const map = replay(entries);
+        const limit = Math.min(Math.max(args.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);
+        const scopeSet = (() => {
+            if (args.scope)
+                return new Set([args.scope]);
+            if (args.scopes && args.scopes.length > 0)
+                return new Set(args.scopes);
+            return null;
+        })();
+        const filtered = [];
+        for (const record of map.values()) {
+            if (scopeSet && !scopeSet.has(record.scope))
+                continue;
+            if (!matchesQuery(record, args.query, args.tag))
+                continue;
+            filtered.push(record);
+        }
+        filtered.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1));
+        return filtered.slice(0, limit);
+    },
+    /**
+     * Compact the log into a single `add` per surviving record. Cheap to call
+     * occasionally; not required for correctness.
+     */
+    compact: async () => {
+        const entries = await readLog();
+        const map = replay(entries);
+        const surviving = Array.from(map.values());
+        await ensureDir();
+        const tmp = `${getLogPath()}.tmp`;
+        const body = surviving.map((record) => JSON.stringify({ op: 'add', record })).join('\n');
+        await fs.writeFile(tmp, body ? `${body}\n` : '', 'utf-8');
+        await fs.rename(tmp, getLogPath());
+        return surviving.length;
+    },
+};

package/dist/plugins/openbot/context.js

@@ -0,0 +1,125 @@
+import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
+export const DEFAULT_CONTEXT_BUDGET = 8000;
+export const MAX_CONTEXT_FILES = 50;
+/**
+ * Returns the known context window budget (in tokens) for a given model string.
+ */
+export const getContextBudgetForModel = (modelString) => {
+    const budgets = {
+        'openai/gpt-4o': 128000,
+        'openai/gpt-4o-mini': 128000,
+        'openai/o1-preview': 128000,
+        'openai/o1-mini': 128000,
+        'anthropic/claude-3-5-sonnet-20240620': 200000,
+        'anthropic/claude-3-5-sonnet-latest': 200000,
+        'anthropic/claude-3-opus-20240229': 200000,
+        'anthropic/claude-3-sonnet-20240229': 200000,
+        'anthropic/claude-3-haiku-20240307': 200000,
+    };
+    return budgets[modelString] || DEFAULT_CONTEXT_BUDGET;
+};
+/** Built-in orchestrator agent id. */
+export const ORCHESTRATOR_AGENT_ID = 'system';
+/**
+ * Check if a channel is a solo DM (only the agent is present).
+ */
+export function isDmSoloChannel(participants, agentId) {
+    return participants.length === 0 || (participants.length === 1 && participants[0] === agentId);
+}
+/**
+ * Simplified context builder for MVP.
+ */
+export async function buildContext(state, storage) {
+    const { channelId, threadId, channelDetails, agentId, threadDetails, agentDetails } = state;
+    const participants = channelDetails?.participants || [];
+    const isDm = isDmSoloChannel(participants, agentId);
+    const sections = [];
+    // Fetch agents once if storage is available
+    const allAgents = storage?.getAgents ? await storage.getAgents().catch(() => []) : [];
+    // 1. User
+    if (state.currentUser?.userName) {
+        sections.push(`## HUMAN\n- Name: ${state.currentUser.userName}`);
+    }
+    // 2. Environment
+    let env = '## ENVIRONMENT\n';
+    if (isDm) {
+        env += '- Mode: Direct Message (Solo)\n';
+    }
+    else {
+        const channelName = channelDetails?.name || channelId;
+        env += `- Mode: Channel (#${channelName})\n`;
+        if (channelDetails?.cwd) {
+            env += `- Workspace: ${channelDetails.cwd}\n`;
+        }
+        if (threadId) {
+            env += `- Thread: ${threadDetails?.name || threadId}\n`;
+        }
+        const peerIds = participants.filter((id) => id !== agentId);
+        const participantLabels = peerIds.map((id) => {
+            const agent = allAgents.find((a) => a.id === id);
+            return agent ? `${agent.name} (${id})` : id;
+        });
+        env += `- Participants: ${participantLabels.length > 0 ? participantLabels.join(', ') : 'None'}\n`;
+    }
+    sections.push(env);
+    // 2.5 Installed Agents
+    if (allAgents.length > 0) {
+        const formatted = allAgents
+            .map((a) => `- ${a.id}: ${a.name}${a.description ? ` - ${a.description}` : ''}`)
+            .join('\n');
+        sections.push(`## INSTALLED AGENTS\n${formatted}`);
+    }
+    // 3. Channel Spec
+    const spec = channelDetails?.spec?.trim();
+    if (spec) {
+        sections.push(`## CHANNEL SPECIFICATION\n${spec}`);
+    }
+    // 4. Files
+    if (storage?.listFiles && channelId && channelDetails?.cwd) {
+        try {
+            const files = await storage.listFiles({ channelId });
+            if (files.length > 0) {
+                const limited = files.slice(0, MAX_CONTEXT_FILES);
+                const formatted = limited
+                    .map((f) => `- ${f.name}${f.isDirectory ? '/' : ''}`)
+                    .join('\n');
+                let fileSection = `## FILES\n${formatted}`;
+                if (files.length > MAX_CONTEXT_FILES) {
+                    fileSection += `\n- ... and ${files.length - MAX_CONTEXT_FILES} more files`;
+                }
+                sections.push(fileSection);
+            }
+            else {
+                sections.push('## FILES\n- (No files in workspace)');
+            }
+        }
+        catch (error) {
+            console.warn('[context] Failed to fetch files:', error);
+        }
+    }
+    // 5. Agent Instructions
+    const rawInstructions = agentDetails?.instructions?.trim();
+    if (rawInstructions &&
+        rawInstructions !== OPENBOT_SYSTEM_PROMPT.trim()) {
+        sections.push(`## Instructions\n${rawInstructions}`);
+    }
+    // 6. Memories
+    if (storage?.listMemories) {
+        try {
+            const scopes = ['global', `agent:${agentId}`];
+            if (channelId)
+                scopes.push(`channel:${channelId}`);
+            const records = await storage.listMemories({ scopes, limit: 20 });
+            if (records.length > 0) {
+                const formatted = records
+                    .map((r) => `- (${r.scope}) ${r.content}`)
+                    .join('\n');
+                sections.push(`## MEMORIES\n${formatted}`);
+            }
+        }
+        catch (error) {
+            console.warn('[context] Failed to fetch memories:', error);
+        }
+    }
+    return sections.join('\n\n');
+}

package/dist/plugins/openbot/history.js

@@ -0,0 +1,144 @@
+/**
+ * Ensures every tool-call has a matching tool-result before calling the LLM.
+ * Orphaned calls (interrupted run, missing :result event, etc.) get an empty
+ * result so the conversation can resume instead of failing validation.
+ */
+function fillMissingToolResults(messages) {
+    const filled = [];
+    const pending = new Map();
+    const flushPending = () => {
+        if (pending.size === 0)
+            return;
+        filled.push({
+            role: 'tool',
+            content: [...pending.entries()].map(([toolCallId, toolName]) => ({
+                type: 'tool-result',
+                toolCallId,
+                toolName,
+                output: { type: 'text', value: '' },
+            })),
+        });
+        pending.clear();
+    };
+    for (const message of messages) {
+        if (message.role === 'tool' && Array.isArray(message.content)) {
+            filled.push(message);
+            for (const part of message.content) {
+                if (part.type === 'tool-result') {
+                    pending.delete(part.toolCallId);
+                }
+            }
+            continue;
+        }
+        flushPending();
+        filled.push(message);
+        if (message.role === 'assistant' && Array.isArray(message.content)) {
+            for (const part of message.content) {
+                if (part.type === 'tool-call') {
+                    const toolCall = part;
+                    pending.set(toolCall.toolCallId, toolCall.toolName);
+                }
+            }
+        }
+    }
+    flushPending();
+    return filled;
+}
+/**
+ * Converts a raw event log into a valid chain of ModelMessages for the AI SDK.
+ *
+ * This is a basic implementation that maps events to messages and filters out
+ * events from sub-processes (delegation) to avoid duplication in history.
+ */
+export function eventsToModelMessages(events) {
+    const messages = [];
+    for (const event of events) {
+        // Skip events that belong to a sub-process (like delegation)
+        // so they don't pollute the main conversation history.
+        if (event.meta?.parentToolCallId) {
+            continue;
+        }
+        switch (event.type) {
+            case 'agent:output': {
+                const last = messages[messages.length - 1];
+                if (last && last.role === 'assistant' && typeof last.content === 'string') {
+                    last.content += event.data.content;
+                }
+                else {
+                    messages.push({ role: 'assistant', content: event.data.content });
+                }
+                break;
+            }
+            case 'agent:invoke': {
+                const invokeEvent = event;
+                if (invokeEvent.data?.content && invokeEvent.data?.role) {
+                    messages.push({
+                        role: invokeEvent.data.role,
+                        content: invokeEvent.data.content
+                    });
+                }
+                break;
+            }
+            default:
+                // Handle tool calls (action:*)
+                if (event.type.startsWith('action:') && !event.type.endsWith(':result')) {
+                    const toolName = event.type.slice(7);
+                    const toolCallId = event.meta?.toolCallId;
+                    if (!toolCallId)
+                        break;
+                    const toolCall = {
+                        type: 'tool-call',
+                        toolCallId,
+                        toolName,
+                        input: event.data,
+                    };
+                    const last = messages[messages.length - 1];
+                    if (last && last.role === 'assistant') {
+                        if (typeof last.content === 'string') {
+                            last.content = [
+                                { type: 'text', text: last.content },
+                                toolCall,
+                            ];
+                        }
+                        else if (Array.isArray(last.content)) {
+                            last.content.push(toolCall);
+                        }
+                    }
+                    else {
+                        messages.push({
+                            role: 'assistant',
+                            content: [toolCall],
+                        });
+                    }
+                }
+                // Handle tool results (action:*:result)
+                else if (event.type.startsWith('action:') && event.type.endsWith(':result')) {
+                    const toolName = event.type.slice(7, -7);
+                    const toolCallId = event.meta?.toolCallId;
+                    if (!toolCallId)
+                        break;
+                    const toolResult = {
+                        type: 'tool-result',
+                        toolCallId,
+                        toolName,
+                        output: {
+                            type: 'text',
+                            value: event?.data?.output || "No output", // ?.output is from delegation result
+                        },
+                    };
+                    const last = messages[messages.length - 1];
+                    if (last && last.role === 'tool' && Array.isArray(last.content)) {
+                        last.content.push(toolResult);
+                    }
+                    else {
+                        messages.push({
+                            role: 'tool',
+                            content: [toolResult],
+                        });
+                    }
+                }
+                break;
+        }
+    }
+    return fillMissingToolResults(messages);
+}

package/dist/plugins/openbot/index.js

@@ -0,0 +1,71 @@
+import { openbotRuntime } from './runtime.js';
+import { bashPlugin } from '../bash/index.js';
+import { memoryPlugin } from '../memory/index.js';
+import { approvalPlugin } from '../approval/index.js';
+import { storagePlugin } from '../storage/index.js';
+import { delegationPlugin } from '../delegation/index.js';
+import { uiPlugin } from '../ui/index.js';
+/**
+ * `openbot` — the standard, opinionated OpenBot agent runtime.
+ *
+ * This is the canonical execution loop for OpenBot agents. It handles
+ * `agent:invoke`, manages short-term memory, assembles context, and
+ * orchestrates tool calls.
+ *
+ * It comes with a "batteries-included" set of inbuilt tools: bash, memory,
+ * storage, delegation, and approval.
+ */
+export const openbotPlugin = {
+    id: 'openbot',
+    name: 'OpenBot Agent',
+    description: 'The standard OpenBot agent runtime with inbuilt tools (bash, memory, storage, delegation, and approval).',
+    configSchema: {
+        type: 'object',
+        properties: {
+            model: {
+                type: 'string',
+                description: 'Provider model string, e.g. openai/gpt-4o-mini, anthropic/claude-3-5-sonnet-20240620',
+                default: 'openai/gpt-4o-mini',
+            },
+            approval: {
+                type: 'object',
+                description: 'Configuration for the inbuilt approval plugin.',
+                properties: {
+                    actions: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'List of actions that require manual approval.',
+                    },
+                },
+            },
+        },
+    },
+    toolDefinitions: {
+        ...bashPlugin.toolDefinitions,
+        ...memoryPlugin.toolDefinitions,
+        ...storagePlugin.toolDefinitions,
+        ...delegationPlugin.toolDefinitions,
+        ...uiPlugin.toolDefinitions,
+    },
+    factory: (context) => (builder) => {
+        const { config, storage, tools, abortSignal } = context;
+        // Register inbuilt plugins
+        bashPlugin.factory(context)(builder);
+        memoryPlugin.factory(context)(builder);
+        storagePlugin.factory(context)(builder);
+        delegationPlugin.factory(context)(builder);
+        uiPlugin.factory(context)(builder);
+        // Approval plugin configuration
+        const approvalConfig = config?.approval || {
+            actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
+        };
+        approvalPlugin.factory({ ...context, config: approvalConfig })(builder);
+        return openbotRuntime({
+            model: config?.model,
+            storage,
+            toolDefinitions: tools,
+            abortSignal,
+        })(builder);
+    },
+};
+export default openbotPlugin;