openbot 0.3.0 → 0.3.2

package/src/bus/services.ts

@@ -1,11 +1,77 @@
 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,
+  TodoItem,
+  TodoStatus,
+  TodoWriteInput,
+} 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';
 
+const readTodos = (state: OpenBotState): TodoItem[] => {
+  const raw = (state.threadDetails?.state as Record<string, unknown> | undefined)?.todos;
+  return Array.isArray(raw) ? (raw as TodoItem[]) : [];
+};
+
+let todoCounter = 0;
+const newTodoId = (now: number, idx: number): string =>
+  `todo_${now.toString(36)}_${(todoCounter++).toString(36)}_${idx}`;
+
+async function persistTodos(
+  storage: Storage,
+  state: OpenBotState,
+  todos: TodoItem[],
+): Promise<void> {
+  if (!state.threadId) throw new Error('No active thread');
+  await storage.patchThreadState({
+    channelId: state.channelId,
+    threadId: state.threadId,
+    state: { todos },
+  });
+  state.threadDetails = await storage.getThreadDetails({
+    channelId: state.channelId,
+    threadId: state.threadId,
+  });
+}
+
+
+/**
+ * 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;
@@ -122,7 +188,7 @@ export const busServicesPlugin =
       builder.on('action:create_thread', async function* (event, context) {
         const threadId = event.meta?.threadId;
         const channelId = context.state.channelId;
-        const { threadTitle, spec, initialState } = (event as any).data;
+        const { threadTitle, initialState } = (event as any).data;
 
         if (!threadId) {
           console.warn('[bus] Cannot create thread: meta.threadId is missing');
@@ -137,7 +203,6 @@ export const busServicesPlugin =
               channelId,
               threadId,
               threadTitle,
-              spec,
               initialState: (initialState as Record<string, unknown>) || {},
             });
 
@@ -156,7 +221,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 +230,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 +254,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 +274,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 +311,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 +355,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 updatedFields: ('state')[] = [];
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         try {
           if (!context.state.threadId) {
             throw new Error('Missing threadId in state for patch_thread_details');
@@ -306,14 +381,6 @@ export const busServicesPlugin =
             });
             updatedFields.push('state');
           }
-          if (typeof (event.data as any).spec === 'string') {
-            await storage.patchThreadSpec({
-              channelId: context.state.channelId,
-              threadId: context.state.threadId,
-              spec: (event.data as any).spec,
-            });
-            updatedFields.push('spec');
-          }
 
           context.state.threadDetails = await storage.getThreadDetails({
             channelId: context.state.channelId,
@@ -323,15 +390,113 @@ 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,
           };
         }
       });
 
+      builder.on('action:todo_write', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        try {
+          if (!context.state.threadId) {
+            throw new Error('todo_write requires an active thread');
+          }
+          const existing = readTodos(context.state);
+          const byId = new Map(existing.map((t) => [t.id, t]));
+          const now = Date.now();
+          const author = context.state.agentId || 'system';
+
+          const inputs = (event.data as { todos: TodoWriteInput[] }).todos || [];
+          const next: TodoItem[] = inputs.map((raw, idx) => {
+            const prior = raw.id ? byId.get(raw.id) : undefined;
+            return {
+              id: prior?.id || raw.id || newTodoId(now, idx),
+              content: raw.content,
+              status: raw.status || prior?.status || 'pending',
+              assignee: raw.assignee ?? prior?.assignee,
+              createdBy: prior?.createdBy || author,
+              createdAt: prior?.createdAt || now,
+              updatedAt: now,
+              ...(prior?.result !== undefined ? { result: prior.result } : {}),
+            };
+          });
+
+          await persistTodos(storage, context.state, next);
+
+          yield {
+            type: 'action:todo_write:result',
+            data: { success: true, todos: next },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        } catch (error) {
+          yield {
+            type: 'action:todo_write:result',
+            data: {
+              success: false,
+              todos: readTodos(context.state),
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        }
+      });
+
+      builder.on('action:todo_update', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        const patch = event.data as {
+          id: string;
+          status?: TodoStatus;
+          content?: string;
+          assignee?: string;
+        };
+        try {
+          if (!context.state.threadId) {
+            throw new Error('todo_update requires an active thread');
+          }
+          const existing = readTodos(context.state);
+          const idx = existing.findIndex((t) => t.id === patch.id);
+          if (idx === -1) {
+            throw new Error(`Todo "${patch.id}" not found`);
+          }
+          const now = Date.now();
+          const updated: TodoItem = {
+            ...existing[idx],
+            ...(patch.content !== undefined ? { content: patch.content } : {}),
+            ...(patch.status !== undefined ? { status: patch.status } : {}),
+            ...(patch.assignee !== undefined
+              ? { assignee: patch.assignee === '' ? undefined : patch.assignee }
+              : {}),
+            updatedAt: now,
+          };
+          const next = [...existing];
+          next[idx] = updated;
+
+          await persistTodos(storage, context.state, next);
+
+          yield {
+            type: 'action:todo_update:result',
+            data: { success: true, todo: updated, todos: next },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        } catch (error) {
+          yield {
+            type: 'action:todo_update:result',
+            data: {
+              success: false,
+              todos: readTodos(context.state),
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        }
+      });
+
       builder.on('action:storage:get-channels', async function* () {
         const channels = await storage.getChannels();
         yield { type: 'action:storage:get-channels-result', data: { channels } };
@@ -615,6 +780,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.
@@ -33,7 +34,6 @@ export type PluginDescriptor = {
   /** True when bundled with the core server (`src/registry/plugins`); false for ~/.openbot/plugins installs. */
   builtIn: boolean;
   image?: string;
-  defaultInstructions?: string;
   configSchema?: ConfigSchema;
   createdAt: Date;
   updatedAt: Date;
@@ -78,7 +78,6 @@ export type ThreadDetails = {
   id: string;
   name: string;
   channelId: string;
-  spec: string;
   state: unknown;
 };
 
@@ -103,7 +102,6 @@ export interface Storage {
     channelId: string;
     threadId: string;
     threadTitle?: string;
-    spec?: string;
     initialState?: Record<string, unknown>;
   }) => Promise<void>;
   getThreads: (args: { channelId: string }) => Promise<Thread[]>;
@@ -135,7 +133,6 @@ export interface Storage {
     state: unknown;
   }) => Promise<void>;
   patchChannelSpec: (args: { channelId: string; spec: string }) => Promise<void>;
-  patchThreadSpec: (args: { channelId: string; threadId: string; spec: string }) => Promise<void>;
   getVariables: () => Promise<Record<string, string | { value: string; secret: boolean }>>;
   createVariable: (args: { key: string; value: string; secret?: boolean }) => Promise<void>;
   deleteVariable: (args: { key: string }) => Promise<void>;
@@ -144,4 +141,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>;
 }