openbot 0.3.6 → 0.4.0

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,80 @@
+export const DEFAULT_CONTEXT_BUDGET = 8000;
+/**
+ * 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 = [];
+    // 1. 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 (threadId) {
+            env += `- Thread: ${threadDetails?.name || threadId}\n`;
+        }
+        const peerIds = participants.filter((id) => id !== agentId);
+        if (peerIds.length > 0) {
+            env += `- Participants: ${peerIds.join(', ')}\n`;
+        }
+    }
+    sections.push(env);
+    // 2. Channel Spec
+    const spec = channelDetails?.spec?.trim();
+    if (spec) {
+        sections.push(`## CHANNEL SPECIFICATION\n${spec}`);
+    }
+    // 3. Agent Instructions
+    if (agentDetails?.instructions) {
+        sections.push(`## AGENT: ${agentDetails?.name}\n${agentDetails.instructions}`);
+    }
+    // 4. 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,98 @@
+/**
+ * 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 messages;
+}

package/dist/plugins/openbot/index.js

@@ -0,0 +1,31 @@
+import { openbotRuntime } from './runtime.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.
+ */
+export const openbotPlugin = {
+    id: 'openbot',
+    name: 'OpenBot Agent',
+    description: 'The standard, opinionated OpenBot agent runtime. Handles the core execution loop and tool orchestration.',
+    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',
+            },
+        },
+    },
+    factory: ({ config, storage, tools }) => {
+        return openbotRuntime({
+            model: config?.model,
+            storage,
+            toolDefinitions: tools,
+        });
+    },
+};
+export default openbotPlugin;