openbot 0.3.0 → 0.3.1

package/dist/services/memory.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/services/storage.js

@@ -7,6 +7,7 @@ import { aiSdkPlugin } from '../plugins/ai-sdk/index.js';
 import { AI_SDK_SYSTEM_PROMPT } from '../plugins/ai-sdk/system-prompt.js';
 import { listBuiltInPlugins, parsePluginModule } from '../registry/plugins.js';
 import { processService } from '../harness/process.js';
+import { memoryService } from './memory.js';
 import { pathToFileURL } from 'node:url';
 const resolveBaseDir = () => {
     const config = loadConfig();
@@ -65,6 +66,7 @@ const SYSTEM_DEFAULT_PLUGINS = [
     { id: 'delegation' },
     // { id: 'ui' },
     { id: 'approval' },
+    { id: 'memory' },
 ];
 function getSystemAgentDetails(overrides) {
     const defaults = {
@@ -935,6 +937,10 @@ export const storageService = {
         }
         return fs.readFile(targetFile, 'utf-8');
     },
+    appendMemory: memoryService.appendMemory,
+    listMemories: memoryService.listMemories,
+    deleteMemory: memoryService.deleteMemory,
+    updateMemory: memoryService.updateMemory,
     /**
      * Hydrates the full OpenBot state from disk/storage before a run.
      */

package/docs/agents.md

@@ -47,7 +47,21 @@ plugins like `shell` or `mcp` to them has no effect. Pair tool plugins with
 
 OpenBot ships a built-in `system` agent (the orchestrator) with the
 `ai-sdk` runtime plus the standard tool plugins (storage, shell, mcp,
-delegation, ui, approval). It cannot be deleted.
+delegation, ui, approval, memory). It cannot be deleted.
+
+## Memory
+
+The `memory` plugin gives every agent three tools — `remember`, `recall`,
+`forget` — backed by an append-only JSONL log at `~/.openbot/memory/log.jsonl`.
+Memories are scoped:
+
+- `global` (default) — visible to every agent everywhere.
+- `agent` — visible only to the agent that wrote it.
+- `channel` — visible only inside the active channel.
+
+On every LLM turn the runtime injects matching memories into the system prompt
+via the `MemoryProvider` in the context engine, so the model treats remembered
+facts as ground truth without needing to call `recall` first.
 
 ## Installing community agents
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "private": false,
   "type": "module",
   "engines": {

package/src/app/cli.ts

@@ -25,7 +25,7 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.3.0');
+program.name('openbot').description('OpenBot CLI').version('0.3.1');
 
 program
   .command('start')

package/src/app/types.ts

@@ -8,6 +8,7 @@ import {
   ThreadDetails,
 } from '../bus/types.js';
 import type { PluginRef } from '../bus/plugin.js';
+import type { MemoryRecord } from '../services/memory.js';
 
 export interface OpenBotState {
   agentId: string;
@@ -766,6 +767,59 @@ export type InstallAgentResultEvent = BaseEvent & {
   };
 };
 
+export type MemoryScopeAlias = 'global' | 'agent' | 'channel';
+
+export type RememberEvent = BaseEvent & {
+  type: 'action:remember';
+  data: {
+    content: string;
+    scope?: MemoryScopeAlias;
+    tags?: string[];
+  };
+};
+
+export type RememberResultEvent = BaseEvent & {
+  type: 'action:remember:result';
+  data: {
+    success: boolean;
+    record?: MemoryRecord;
+    error?: string;
+  };
+};
+
+export type RecallEvent = BaseEvent & {
+  type: 'action:recall';
+  data: {
+    query?: string;
+    tag?: string;
+    scope?: MemoryScopeAlias | 'all';
+    limit?: number;
+  };
+};
+
+export type RecallResultEvent = BaseEvent & {
+  type: 'action:recall:result';
+  data: {
+    success: boolean;
+    records: MemoryRecord[];
+    error?: string;
+  };
+};
+
+export type ForgetEvent = BaseEvent & {
+  type: 'action:forget';
+  data: { id: string };
+};
+
+export type ForgetResultEvent = BaseEvent & {
+  type: 'action:forget:result';
+  data: {
+    success: boolean;
+    deleted: boolean;
+    error?: string;
+  };
+};
+
 export type OpenBotEvent =
   | UserInputEvent
   | AgentInvokeEvent
@@ -842,4 +896,10 @@ export type OpenBotEvent =
   | ListMarketplaceAgentsEvent
   | ListMarketplaceAgentsResultEvent
   | InstallAgentEvent
-  | InstallAgentResultEvent;
+  | InstallAgentResultEvent
+  | RememberEvent
+  | RememberResultEvent
+  | RecallEvent
+  | RecallResultEvent
+  | ForgetEvent
+  | ForgetResultEvent;

package/src/bus/services.ts

@@ -1,11 +1,43 @@
 import { MelonyPlugin } from 'melony';
 import { DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig } from '../app/config.js';
-import { OpenBotEvent, OpenBotState } from '../app/types.js';
+import { OpenBotEvent, OpenBotState, MemoryScopeAlias } from '../app/types.js';
 import type { PluginRef } from './plugin.js';
 import { Storage } from './types.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: MemoryScopeAlias | undefined,
+  state: OpenBotState,
+): string {
+  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: MemoryScopeAlias | 'all' | undefined,
+  state: OpenBotState,
+): string[] | undefined {
+  if (alias === 'all' || alias === undefined) {
+    return ['global', `agent:${state.agentId}`, `channel:${state.channelId}`];
+  }
+  return [resolveMemoryScope(alias, state)];
+}
+
 /** One marketplace entry; matches `action:marketplace:list:result` agent shape. */
 export type MarketplaceAgentListing = {
   id: string;
@@ -156,7 +188,7 @@ export const busServicesPlugin =
         yield {
           type: 'action:create_thread:result',
           data: { success: true, threadId, threadTitle },
-          meta: { threadId },
+          meta: { ...(event.meta || {}), threadId, agentId: context.state.agentId },
         } as OpenBotEvent;
       });
 
@@ -165,10 +197,13 @@ export const busServicesPlugin =
         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,
           } as OpenBotEvent;
           return;
         }
@@ -186,20 +221,19 @@ export const busServicesPlugin =
           yield {
             type: 'action:create_channel:result',
             data: { success: true, channelId: rawChannelId, channelUrl },
+            meta: resultMeta,
           } as OpenBotEvent;
 
           yield {
             type: 'agent:output',
             data: { content: `Created channel \`${rawChannelId}\`.` },
-            meta: {
-              ...(event.meta || {}),
-              agentId: context.state.agentId,
-            },
+            meta: resultMeta,
           } as OpenBotEvent;
         } catch {
           yield {
             type: 'action:create_channel:result',
             data: { success: false, channelId: rawChannelId, channelUrl },
+            meta: resultMeta,
           } as OpenBotEvent;
         }
       });
@@ -207,11 +241,13 @@ export const busServicesPlugin =
       builder.on('action:update_channel', async function* (event, context) {
         const data = (event.data || {}) as { channelId?: string; name?: string; cwd?: string };
         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: [] as string[] },
+            meta: resultMeta,
           } as OpenBotEvent;
           return;
         }
@@ -242,17 +278,20 @@ export const busServicesPlugin =
           yield {
             type: 'action:update_channel:result',
             data: { success: true, channelId: targetChannelId, updatedFields },
+            meta: resultMeta,
           } as OpenBotEvent;
         } catch {
           yield {
             type: 'action:update_channel:result',
             data: { success: false, channelId: targetChannelId, updatedFields },
+            meta: resultMeta,
           } as OpenBotEvent;
         }
       });
 
       builder.on('action:patch_channel_details', async function* (event, context) {
         const updatedFields: ('state' | 'spec' | 'cwd')[] = [];
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         try {
           if ((event.data as any).state !== undefined) {
             await storage.patchChannelState({
@@ -283,17 +322,20 @@ export const busServicesPlugin =
           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: ('state' | 'spec')[] = [];
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         try {
           if (!context.state.threadId) {
             throw new Error('Missing threadId in state for patch_thread_details');
@@ -323,11 +365,13 @@ export const busServicesPlugin =
           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,
           };
         }
       });
@@ -615,6 +659,82 @@ export const busServicesPlugin =
         } as OpenBotEvent;
       });
 
+      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,
+          } as OpenBotEvent;
+        } catch (error) {
+          yield {
+            type: 'action:remember:result',
+            data: {
+              success: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        }
+      });
+
+      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,
+          } as OpenBotEvent;
+        } catch (error) {
+          yield {
+            type: 'action:recall:result',
+            data: {
+              success: false,
+              records: [],
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        }
+      });
+
+      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,
+          } as OpenBotEvent;
+        } catch (error) {
+          yield {
+            type: 'action:forget:result',
+            data: {
+              success: false,
+              deleted: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        }
+      });
+
       builder.on('action:agent:install', async function* (event) {
         try {
           const { agentId, name, description, instructions, plugins } = event.data;

package/src/bus/types.ts

@@ -1,5 +1,6 @@
 import type { OpenBotEvent } from '../app/types.js';
 import type { PluginRef } from './plugin.js';
+import type { MemoryRecord, ListMemoriesArgs } from '../services/memory.js';
 
 /**
  * Public data types exposed by the OpenBot bus.
@@ -144,4 +145,16 @@ export interface Storage {
     path?: string;
   }) => Promise<Array<{ name: string; isDirectory: boolean }>>;
   readFile: (args: { channelId: string; path: string }) => Promise<string>;
+  /** Persist a memory record into the global memory log. */
+  appendMemory: (args: {
+    scope: string;
+    content: string;
+    tags?: string[];
+  }) => Promise<MemoryRecord>;
+  /** Read memories matching the given filter. */
+  listMemories: (args?: ListMemoriesArgs) => Promise<MemoryRecord[]>;
+  /** Soft-delete a memory by id. Returns true if a record was deleted. */
+  deleteMemory: (args: { id: string }) => Promise<boolean>;
+  /** Update a memory's content/tags by id. Returns true if a record was updated. */
+  updateMemory: (args: { id: string; content?: string; tags?: string[] }) => Promise<boolean>;
 }