openbot 0.3.0 → 0.3.1

package/dist/app/cli.js

@@ -16,7 +16,7 @@ function checkNodeVersion() {
     }
 }
 checkNodeVersion();
-program.name('openbot').description('OpenBot CLI').version('0.2.14');
+program.name('openbot').description('OpenBot CLI').version('0.3.1');
 program
     .command('start')
     .description('Start the OpenBot harness')

package/dist/bus/services.js

@@ -1,6 +1,30 @@
 import { DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig } from '../app/config.js';
 import { storageService } from '../services/storage.js';
 import { pluginService } from '../services/plugins.js';
+/**
+ * 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)];
+}
 const DEFAULT_MARKETPLACE_AGENTS = [
     {
         id: 'researcher',
@@ -117,17 +141,19 @@ export const busServicesPlugin = (options) => (builder) => {
         yield {
             type: 'action:create_thread:result',
             data: { success: true, threadId, threadTitle },
-            meta: { threadId },
+            meta: { ...(event.meta || {}), threadId, agentId: context.state.agentId },
         };
     });
     builder.on('action:create_channel', async function* (event, context) {
         const { channelId, spec, initialState, cwd } = event.data;
         const rawChannelId = (channelId || '').trim();
         const channelSpec = typeof spec === 'string' ? spec : '';
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         if (!rawChannelId) {
             yield {
                 type: 'action:create_channel:result',
                 data: { success: false, channelId: '', channelUrl: '' },
+                meta: resultMeta,
             };
             return;
         }
@@ -142,30 +168,31 @@ export const busServicesPlugin = (options) => (builder) => {
             yield {
                 type: 'action:create_channel:result',
                 data: { success: true, channelId: rawChannelId, channelUrl },
+                meta: resultMeta,
             };
             yield {
                 type: 'agent:output',
                 data: { content: `Created channel \`${rawChannelId}\`.` },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
+                meta: resultMeta,
             };
         }
         catch {
             yield {
                 type: 'action:create_channel:result',
                 data: { success: false, channelId: rawChannelId, channelUrl },
+                meta: resultMeta,
             };
         }
     });
     builder.on('action:update_channel', async function* (event, context) {
         const data = (event.data || {});
         const targetChannelId = (data.channelId || context.state.channelId || '').trim();
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         if (!targetChannelId) {
             yield {
                 type: 'action:update_channel:result',
                 data: { success: false, channelId: '', updatedFields: [] },
+                meta: resultMeta,
             };
             return;
         }
@@ -191,17 +218,20 @@ export const busServicesPlugin = (options) => (builder) => {
             yield {
                 type: 'action:update_channel:result',
                 data: { success: true, channelId: targetChannelId, updatedFields },
+                meta: resultMeta,
             };
         }
         catch {
             yield {
                 type: 'action:update_channel:result',
                 data: { success: false, channelId: targetChannelId, updatedFields },
+                meta: resultMeta,
             };
         }
     });
     builder.on('action:patch_channel_details', async function* (event, context) {
         const updatedFields = [];
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         try {
             if (event.data.state !== undefined) {
                 await storage.patchChannelState({
@@ -230,17 +260,20 @@ export const busServicesPlugin = (options) => (builder) => {
             yield {
                 type: 'action:patch_channel_details:result',
                 data: { success: true, updatedFields },
+                meta: resultMeta,
             };
         }
         catch {
             yield {
                 type: 'action:patch_channel_details:result',
                 data: { success: false, updatedFields },
+                meta: resultMeta,
             };
         }
     });
     builder.on('action:patch_thread_details', async function* (event, context) {
         const updatedFields = [];
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         try {
             if (!context.state.threadId) {
                 throw new Error('Missing threadId in state for patch_thread_details');
@@ -268,12 +301,14 @@ export const busServicesPlugin = (options) => (builder) => {
             yield {
                 type: 'action:patch_thread_details:result',
                 data: { success: true, updatedFields },
+                meta: resultMeta,
             };
         }
         catch {
             yield {
                 type: 'action:patch_thread_details:result',
                 data: { success: false, updatedFields },
+                meta: resultMeta,
             };
         }
     });
@@ -549,6 +584,82 @@ export const busServicesPlugin = (options) => (builder) => {
             data: { success: true, agents },
         };
     });
+    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,
+            };
+        }
+    });
     builder.on('action:agent:install', async function* (event) {
         try {
             const { agentId, name, description, instructions, plugins } = event.data;

package/dist/harness/context.js

@@ -1,6 +1,15 @@
 /**
- * The core engine that orchestrates context building.
+ * Cheap, dependency-free token estimator. Roughly char/4 — fine for budget
+ * enforcement; can be swapped for a tokenizer-backed implementation later
+ * without touching providers.
  */
+export const estimateTokens = (text) => Math.ceil((text?.length ?? 0) / 4);
+/**
+ * Hard cap (in characters) on a single context item. Keeps any one provider
+ * — typically the recent-events feed — from monopolising the prompt budget.
+ */
+const ITEM_HARD_CHAR_CAP = 6000;
+const truncate = (text, maxChars) => text.length <= maxChars ? text : `${text.slice(0, maxChars)}\n…[truncated]`;
 export class ContextEngine {
     constructor() {
         this.providers = [];
@@ -13,18 +22,18 @@ export class ContextEngine {
         this.processors.push(processor);
     }
     async buildContext(state, storage) {
-        // 1. Collect context from all providers
         let items = [];
         for (const provider of this.providers) {
             try {
                 const providedItems = await provider.provide(state, storage);
-                items.push(...providedItems);
+                for (const item of providedItems) {
+                    items.push({ ...item, content: truncate(item.content, ITEM_HARD_CHAR_CAP) });
+                }
             }
             catch (error) {
                 console.warn(`[ContextEngine] Provider ${provider.name} failed:`, error);
             }
         }
-        // 2. Run through processors
         for (const processor of this.processors) {
             try {
                 items = await processor.process(items, state);
@@ -33,23 +42,25 @@ export class ContextEngine {
                 console.warn(`[ContextEngine] Processor ${processor.name} failed:`, error);
             }
         }
-        // 3. Format items into a single string
         return items
             .sort((a, b) => b.priority - a.priority)
-            .map(item => item.content)
+            .map((item) => item.content)
             .join('\n\n');
     }
 }
 /**
- * Default implementation of a Context Engine with basic providers.
+ * Default context engine. Order of providers is by emit order; final ordering
+ * in the prompt is determined by `priority`. The token-budget processor runs
+ * last so dropping happens after every provider has contributed.
  */
 export function createDefaultContextEngine() {
     const engine = new ContextEngine();
-    // Basic Providers
     engine.registerProvider(new AgentDetailsProvider());
     engine.registerProvider(new ChannelDetailsProvider());
     engine.registerProvider(new ThreadDetailsProvider());
+    engine.registerProvider(new MemoryProvider());
     engine.registerProvider(new RecentEventsProvider());
+    engine.registerProcessor(new TokenBudgetProcessor());
     return engine;
 }
 class AgentDetailsProvider {
@@ -97,6 +108,81 @@ class ThreadDetailsProvider {
             }];
     }
 }
+/**
+ * Fetches relevant memories (global + active agent + active channel) and
+ * surfaces them at high priority so the LLM treats them as ground truth
+ * rather than chat history.
+ */
+class MemoryProvider {
+    constructor() {
+        this.name = 'memory';
+    }
+    async provide(state, storage) {
+        if (!storage?.listMemories)
+            return [];
+        try {
+            const scopes = ['global', `agent:${state.agentId}`];
+            if (state.channelId)
+                scopes.push(`channel:${state.channelId}`);
+            const records = await storage.listMemories({ scopes, limit: 50 });
+            if (records.length === 0)
+                return [];
+            const formatted = records
+                .map((r) => {
+                const tags = r.tags?.length ? ` [${r.tags.join(', ')}]` : '';
+                const scopeLabel = r.scope === 'global' ? 'global' : r.scope;
+                return `- (${scopeLabel}${tags}) ${r.content}`;
+            })
+                .join('\n');
+            return [
+                {
+                    id: 'memory',
+                    type: 'memory',
+                    priority: 95,
+                    content: `## REMEMBERED FACTS\nThese are durable facts you previously stored with the \`remember\` tool. Trust them unless contradicted by the user. Use \`forget\` to remove ones that are stale.\n\n${formatted}`,
+                },
+            ];
+        }
+        catch (error) {
+            console.warn('[ContextEngine] MemoryProvider failed:', error);
+            return [];
+        }
+    }
+}
+/**
+ * Event types we omit from the recent-events context block. They duplicate
+ * information already in the conversation history, are infrastructural
+ * noise, or are too large to be useful as a tail summary.
+ */
+const NOISY_EVENT_PREFIXES = [
+    'agent:invoke',
+    'agent:output',
+    'agent:run',
+    'agent:active-runs',
+    'client:ui',
+    'stream:',
+    'action:storage:get-',
+    'action:storage:patch-',
+];
+const MAX_RECENT_EVENTS = 20;
+const MAX_EVENT_DATA_CHARS = 300;
+const isNoisyEvent = (event) => NOISY_EVENT_PREFIXES.some((prefix) => event.type.startsWith(prefix));
+const summarizeEvent = (event) => {
+    const data = event.data;
+    if (data === undefined)
+        return `- ${event.type}`;
+    let payload;
+    try {
+        payload = typeof data === 'string' ? data : JSON.stringify(data);
+    }
+    catch {
+        payload = '[unserialisable]';
+    }
+    if (payload.length > MAX_EVENT_DATA_CHARS) {
+        payload = `${payload.slice(0, MAX_EVENT_DATA_CHARS)}…`;
+    }
+    return `- ${event.type}: ${payload}`;
+};
 class RecentEventsProvider {
     constructor() {
         this.name = 'recent-events';
@@ -104,28 +190,61 @@ class RecentEventsProvider {
     async provide(state, storage) {
         if (!storage)
             return [];
-        const items = [];
-        // Fetch channel events if no thread, otherwise fetch thread events
         const channelId = state.channelId;
         const threadId = state.threadId;
         try {
             const events = await storage.getEvents({ channelId, threadId });
-            if (events.length > 0) {
-                const formattedEvents = events
-                    .slice(-20)
-                    .map((e) => `- ${e.type}: ${JSON.stringify(e.data || {})}`)
-                    .join('\n');
-                items.push({
+            const filtered = events.filter((e) => !isNoisyEvent(e));
+            if (filtered.length === 0)
+                return [];
+            const formatted = filtered.slice(-MAX_RECENT_EVENTS).map(summarizeEvent).join('\n');
+            return [
+                {
                     id: threadId ? 'thread-events' : 'channel-events',
                     type: 'events',
                     priority: 70,
-                    content: `## ${threadId ? 'THREAD' : 'CHANNEL'} RECENT ACTIVITIES (events)\n${formattedEvents}`
-                });
-            }
+                    content: `## ${threadId ? 'THREAD' : 'CHANNEL'} RECENT ACTIVITIES (events)\n${formatted}`,
+                },
+            ];
         }
         catch (error) {
-            console.warn(`[ContextEngine] Failed to fetch events:`, error);
+            console.warn('[ContextEngine] Failed to fetch events:', error);
+            return [];
+        }
+    }
+}
+/**
+ * Drops the lowest-priority items until the assembled prompt fits within the
+ * token budget. The first item with priority >= `keepFloor` is always kept,
+ * so the agent's own instructions can never be evicted. Stable on ties:
+ * later-emitted items go first.
+ */
+export class TokenBudgetProcessor {
+    constructor(budget = TokenBudgetProcessor.DEFAULT_BUDGET, keepFloor = TokenBudgetProcessor.KEEP_FLOOR) {
+        this.budget = budget;
+        this.keepFloor = keepFloor;
+        this.name = 'token-budget';
+    }
+    async process(items) {
+        const sorted = [...items].sort((a, b) => b.priority - a.priority);
+        const out = [];
+        let used = 0;
+        for (const item of sorted) {
+            const cost = estimateTokens(item.content);
+            if (item.priority >= this.keepFloor) {
+                out.push(item);
+                used += cost;
+                continue;
+            }
+            if (used + cost <= this.budget) {
+                out.push(item);
+                used += cost;
+            }
         }
-        return items;
+        return out;
     }
 }
+/** Soft prompt budget in tokens (matches gpt-4o-mini's reasonable system slice). */
+TokenBudgetProcessor.DEFAULT_BUDGET = 8000;
+/** Items at or above this priority are never dropped. */
+TokenBudgetProcessor.KEEP_FLOOR = 100;

package/dist/plugins/ai-sdk/runtime.js

@@ -21,6 +21,78 @@ function resolveModel(modelString) {
 const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
     ? value
     : {};
+/** Per-message hard cap (in characters) on tool-result payloads we feed back
+ *  to the model. Prevents one huge tool output from eating the context window;
+ *  the original event remains intact in storage. */
+const TOOL_RESULT_MAX_CHARS = 8000;
+/** Sliding window: max number of messages we replay to the model on each
+ *  invocation. Older turns stay on disk but are not sent. Keeps both the
+ *  recent prompts and the prompt token budget bounded. */
+const MAX_WINDOW_MESSAGES = 80;
+const truncateToolPayload = (raw) => {
+    const serialized = typeof raw === 'string' ? raw : JSON.stringify(raw);
+    if (serialized.length <= TOOL_RESULT_MAX_CHARS)
+        return serialized;
+    const dropped = serialized.length - TOOL_RESULT_MAX_CHARS;
+    return `${serialized.slice(0, TOOL_RESULT_MAX_CHARS)}\n…[truncated ${dropped} chars]`;
+};
+/**
+ * Trim the message history to a sliding window while preserving tool-call
+ * integrity. Drops any leading orphan `tool` messages whose matching
+ * assistant call was sliced off, since most providers reject that.
+ */
+const buildMessageWindow = (messages) => {
+    if (messages.length <= MAX_WINDOW_MESSAGES)
+        return messages;
+    const tail = messages.slice(-MAX_WINDOW_MESSAGES);
+    const knownAssistantCallIds = new Set();
+    for (const m of tail) {
+        if (m.role === 'assistant' && m.toolCalls) {
+            for (const tc of m.toolCalls)
+                knownAssistantCallIds.add(tc.id);
+        }
+    }
+    return tail.filter((m) => m.role !== 'tool' || knownAssistantCallIds.has(m.toolCallId));
+};
+/**
+ * Self-healing pass: every assistant tool_call must have a matching tool
+ * result before the next user/assistant turn, or providers (OpenAI in
+ * particular) reject the request with "Tool result is missing for tool call".
+ *
+ * This can happen when a handler emits a `:result` event without `meta`
+ * (orphaning the call), the process restarts mid-run, or a tool handler
+ * crashes. Rather than refuse to continue, we inject synthetic tool messages
+ * with a clear error payload — the LLM can then explain the failure to the
+ * user and proceed.
+ */
+const repairOpenToolCalls = (messages) => {
+    const fulfilled = new Set();
+    for (const m of messages) {
+        if (m.role === 'tool')
+            fulfilled.add(m.toolCallId);
+    }
+    const repaired = [];
+    for (const m of messages) {
+        repaired.push(m);
+        if (m.role !== 'assistant' || !m.toolCalls)
+            continue;
+        for (const tc of m.toolCalls) {
+            if (fulfilled.has(tc.id))
+                continue;
+            repaired.push({
+                role: 'tool',
+                toolCallId: tc.id,
+                toolName: tc.function.name,
+                content: JSON.stringify({
+                    success: false,
+                    error: 'Tool result was lost (handler did not emit a matching :result event).',
+                }),
+            });
+            fulfilled.add(tc.id);
+        }
+    }
+    return repaired;
+};
 const readPersistedShortTermMessages = (state) => {
     const source = state.threadDetails?.state ?? state.channelDetails?.state;
     const record = asRecord(source);
@@ -108,7 +180,7 @@ export const aiSdkRuntime = (options) => (builder) => {
     const runLLM = async function* (context, threadId) {
         ensureShortTermMessages(context.state);
         const systemPrompt = await buildSystemPrompt(context.state, system, context, storage, contextEngine);
-        const coreMessages = mapToCoreMessages(context.state.shortTermMessages || []);
+        const coreMessages = mapToCoreMessages(buildMessageWindow(repairOpenToolCalls(context.state.shortTermMessages || [])));
         try {
             const result = await generateText({
                 model,
@@ -246,7 +318,7 @@ export const aiSdkRuntime = (options) => (builder) => {
         ensureShortTermMessages(context.state);
         const toolName = event.type.replace(/^action:/, '').replace(/:result$/, '');
         const resultData = event.data;
-        const content = typeof resultData === 'string' ? resultData : JSON.stringify(resultData);
+        const content = truncateToolPayload(resultData);
         context.state.shortTermMessages = [
             ...(context.state.shortTermMessages ?? []),
             { role: 'tool', content, toolCallId, toolName },

package/dist/plugins/memory/index.js

@@ -0,0 +1,71 @@
+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.
+ */
+const memoryToolDefinitions = {
+    remember: {
+        description: 'Persist a durable fact, preference, or note to long-term memory so it can be recalled in future turns and runs. Use for stable information (user preferences, project conventions, contact details, decisions); avoid using it for transient chatter or per-step scratch state — that belongs in thread state. Keep entries short and self-contained.',
+        inputSchema: z.object({
+            content: z
+                .string()
+                .min(1)
+                .describe('The fact to remember, written so it makes sense out of context (e.g. "User prefers TypeScript over JavaScript.").'),
+            scope: z
+                .enum(['global', 'agent', 'channel'])
+                .optional()
+                .describe('Visibility: `global` (default, all agents everywhere), `agent` (only this agent), `channel` (only this channel).'),
+            tags: z
+                .array(z.string())
+                .optional()
+                .describe('Optional tags for filtering with `recall`.'),
+        }),
+    },
+    recall: {
+        description: 'Search long-term memory for facts you previously stored with `remember`. Returns up to `limit` matching records with their ids so you can `forget` stale ones.',
+        inputSchema: z.object({
+            query: z
+                .string()
+                .optional()
+                .describe('Case-insensitive substring filter against memory content.'),
+            tag: z.string().optional().describe('Only return memories that include this tag.'),
+            scope: z
+                .enum(['global', 'agent', 'channel', 'all'])
+                .optional()
+                .describe('Restrict the search to a single scope. Default `all` returns global + this agent + this channel.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(50)
+                .optional()
+                .describe('Maximum records to return (default 20, max 50).'),
+        }),
+    },
+    forget: {
+        description: 'Delete a memory by id. Use after the user asks to forget something or when a previously remembered fact is now wrong. Get ids from `recall`.',
+        inputSchema: z.object({
+            id: z.string().describe('The memory record id (returned by `recall`/`remember`).'),
+        }),
+    },
+};
+export const memoryPlugin = {
+    id: 'memory',
+    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.
+    },
+};
+export default memoryPlugin;

package/dist/registry/plugins.js

@@ -8,6 +8,7 @@ import { delegationPlugin } from '../plugins/delegation/index.js';
 import { storageToolsPlugin } from '../plugins/storage-tools/index.js';
 import { uiPlugin } from '../plugins/ui/index.js';
 import { approvalPlugin } from '../plugins/approval/index.js';
+import { memoryPlugin } from '../plugins/memory/index.js';
 import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
 let pluginsDir = null;
 const loadedPlugins = new Set();
@@ -20,6 +21,7 @@ const BUILT_IN = {
     [storageToolsPlugin.id]: storageToolsPlugin,
     [uiPlugin.id]: uiPlugin,
     [approvalPlugin.id]: approvalPlugin,
+    [memoryPlugin.id]: memoryPlugin,
 };
 /** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
 export function parsePluginModule(module) {