openbot 0.3.0 → 0.3.2

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();
@@ -62,16 +63,17 @@ const SYSTEM_DEFAULT_PLUGINS = [
     { id: 'storage-tools' },
     // { id: 'mcp' },
     { id: 'shell' },
-    { id: 'delegation' },
+    { id: 'todo' },
     // { id: 'ui' },
     { id: 'approval' },
+    { id: 'memory' },
 ];
 function getSystemAgentDetails(overrides) {
     const defaults = {
         id: SYSTEM_AGENT_ID,
         name: 'OpenBot',
         image: undefined,
-        description: 'First-party orchestration agent for OpenBot. Coordinates other agents via handoff and delegation.',
+        description: 'First-party orchestration agent for OpenBot. Coordinates other agents via handoff.',
         instructions: AI_SDK_SYSTEM_PROMPT,
         plugins: SYSTEM_DEFAULT_PLUGINS.map((ref) => ref.id),
         pluginRefs: SYSTEM_DEFAULT_PLUGINS,
@@ -160,7 +162,6 @@ const listBuiltInPluginDescriptors = async () => {
         description: plugin.description,
         builtIn: true,
         image: plugin.image,
-        defaultInstructions: plugin.defaultInstructions,
         configSchema: plugin.configSchema,
         createdAt: new Date(),
         updatedAt: new Date(),
@@ -228,7 +229,6 @@ const listPluginsFromDisk = async () => {
                 description: parsed.description || '',
                 builtIn: false,
                 image: parsed.image || image,
-                defaultInstructions: parsed.defaultInstructions,
                 configSchema: parsed.configSchema,
                 createdAt: new Date(),
                 updatedAt: new Date(),
@@ -355,7 +355,7 @@ export const storageService = {
             `# ${normalizedChannelId}\n\nDefine the goals and rules for this channel here.\n`);
         await fs.writeFile(statePath, JSON.stringify(finalState, null, 2));
     },
-    createThread: async ({ channelId, threadId, threadTitle, spec, initialState, }) => {
+    createThread: async ({ channelId, threadId, threadTitle, initialState, }) => {
         const normalizedChannelId = channelId.trim();
         const normalizedThreadId = threadId.trim();
         if (!normalizedChannelId)
@@ -363,7 +363,6 @@ export const storageService = {
         if (!normalizedThreadId)
             throw new Error('threadId is required');
         const threadDir = getConversationDir(normalizedChannelId, normalizedThreadId);
-        const specPath = `${threadDir}/SPEC.md`;
         const statePath = `${threadDir}/state.json`;
         try {
             await fs.access(threadDir);
@@ -380,8 +379,6 @@ export const storageService = {
             baseState.generatedName = threadTitle.trim();
         }
         await fs.mkdir(threadDir, { recursive: true });
-        await fs.writeFile(specPath, spec?.trim() ||
-            `# ${normalizedThreadId}\n\nDefine the goals and plan for this thread here.\n`);
         await fs.writeFile(statePath, JSON.stringify(baseState, null, 2));
     },
     getThreads: async ({ channelId }) => {
@@ -423,17 +420,7 @@ export const storageService = {
     },
     getThreadDetails: async ({ channelId, threadId, }) => {
         const threadDir = getConversationDir(channelId, threadId);
-        const specPath = `${threadDir}/SPEC.md`;
         const statePath = `${threadDir}/state.json`;
-        let spec = '';
-        try {
-            spec = await fs.readFile(specPath, 'utf-8');
-        }
-        catch (error) {
-            if (error?.code !== 'ENOENT') {
-                console.error(`Failed to read thread spec for channel ${channelId} thread ${threadId}`, error);
-            }
-        }
         let state = {};
         try {
             const stateContent = await fs.readFile(statePath, 'utf-8');
@@ -451,7 +438,6 @@ export const storageService = {
             id: threadId,
             name: generatedName || threadId,
             channelId,
-            spec,
             state,
         };
     },
@@ -537,18 +523,6 @@ export const storageService = {
             throw error;
         }
     },
-    patchThreadSpec: async ({ channelId, threadId, spec, }) => {
-        const threadDir = getConversationDir(channelId, threadId);
-        const specPath = `${threadDir}/SPEC.md`;
-        try {
-            await fs.mkdir(threadDir, { recursive: true });
-            await fs.writeFile(specPath, spec);
-        }
-        catch (error) {
-            console.error(`Failed to patch thread spec for channel ${channelId} thread ${threadId}`, error);
-            throw error;
-        }
-    },
     getAgents: async () => {
         const agentsDir = resolvePath(resolveBaseDir() + '/' + DEFAULT_AGENTS_DIR);
         try {
@@ -935,6 +909,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/dist/workflow/service.js

@@ -0,0 +1,106 @@
+import { generateId } from 'melony';
+import { storageService } from '../services/storage.js';
+import { WORKFLOW_SCHEMA_VERSION, WORKFLOW_THREAD_STATE_KEY, } from './types.js';
+const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : {};
+const isTodoStatus = (value) => value === 'pending' || value === 'done' || value === 'failed';
+const parseTodo = (value) => {
+    const record = asRecord(value);
+    if (typeof record.id !== 'string' || !record.id)
+        return null;
+    if (typeof record.text !== 'string' || !record.text)
+        return null;
+    if (!isTodoStatus(record.status))
+        return null;
+    return {
+        id: record.id,
+        text: record.text,
+        status: record.status,
+        summary: typeof record.summary === 'string' ? record.summary : undefined,
+    };
+};
+export const parseThreadWorkflow = (state) => {
+    const record = asRecord(state);
+    const raw = record[WORKFLOW_THREAD_STATE_KEY];
+    const workflow = asRecord(raw);
+    if (typeof workflow.id !== 'string' || !workflow.id)
+        return null;
+    if (!Array.isArray(workflow.todos))
+        return null;
+    const todos = workflow.todos
+        .map((todo) => parseTodo(todo))
+        .filter((todo) => todo !== null);
+    if (todos.length === 0 && !workflow.title)
+        return null;
+    return {
+        version: typeof workflow.version === 'number' ? workflow.version : WORKFLOW_SCHEMA_VERSION,
+        id: workflow.id,
+        title: typeof workflow.title === 'string' ? workflow.title : undefined,
+        todos,
+        updatedAt: typeof workflow.updatedAt === 'string' ? workflow.updatedAt : new Date().toISOString(),
+    };
+};
+export const loadThreadWorkflow = async (channelId, threadId) => {
+    const details = await storageService.getThreadDetails({ channelId, threadId });
+    return parseThreadWorkflow(details.state);
+};
+export const persistWorkflow = async (channelId, threadId, workflow) => {
+    const next = {
+        ...workflow,
+        version: WORKFLOW_SCHEMA_VERSION,
+        updatedAt: new Date().toISOString(),
+    };
+    await storageService.patchThreadState({
+        channelId,
+        threadId,
+        state: { [WORKFLOW_THREAD_STATE_KEY]: next },
+    });
+    return next;
+};
+export const setWorkflowPlan = async (options) => {
+    const { channelId, threadId, plan } = options;
+    const workflow = {
+        version: WORKFLOW_SCHEMA_VERSION,
+        id: `wf_${generateId()}`,
+        title: plan.title,
+        todos: plan.todos.map((t) => ({
+            id: t.id || `todo_${generateId()}`,
+            text: t.text,
+            status: 'pending',
+        })),
+        updatedAt: new Date().toISOString(),
+    };
+    return persistWorkflow(channelId, threadId, workflow);
+};
+export const updateWorkflowTodo = async (options) => {
+    const { channelId, threadId, update } = options;
+    const workflow = await loadThreadWorkflow(channelId, threadId);
+    if (!workflow)
+        throw new Error('No active workflow found.');
+    const todos = workflow.todos.map((todo) => {
+        if (todo.id !== update.todoId)
+            return todo;
+        return {
+            ...todo,
+            ...(update.status ? { status: update.status } : {}),
+            ...(update.summary !== undefined ? { summary: update.summary } : {}),
+        };
+    });
+    return persistWorkflow(channelId, threadId, { ...workflow, todos });
+};
+export const formatWorkflowForPrompt = (workflow) => {
+    const lines = [
+        '## Current Workflow Plan',
+        workflow.title ? `Title: ${workflow.title}` : '',
+        'This plan is for your internal coordination. Update it as you progress.',
+        '',
+    ].filter(Boolean);
+    for (const todo of workflow.todos) {
+        lines.push(`- [${todo.status}] ${todo.id}: ${todo.text}`);
+        if (todo.summary) {
+            lines.push(`  Result: ${todo.summary}`);
+        }
+    }
+    return lines.join('\n');
+};

package/dist/workflow/types.js

@@ -0,0 +1,3 @@
+export const WORKFLOW_SCHEMA_VERSION = 3;
+export const WORKFLOW_THREAD_STATE_KEY = 'workflow';
+export const OPENBOT_SYSTEM_AGENT_ID = 'system';

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/docs/plugins.md

@@ -20,7 +20,6 @@ export interface Plugin {
   name: string;
   description: string;
   image?: string;
-  defaultInstructions?: string;
   configSchema?: ConfigSchema;
   toolDefinitions?: Record<string, ToolDefinition>;
   factory: (context: PluginContext) => MelonyPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "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.2');
 
 program
   .command('start')

package/src/app/server.ts

@@ -289,9 +289,8 @@ export async function startServer(options: ServerOptions = {}) {
 
   app.listen(PORT, () => {
     console.log(`\x1b[32mOpenBot server listening at http://localhost:${PORT}\x1b[0m`);
-    console.log(`  - Health endpoint: GET /health`);
-    console.log(`  - Events endpoint: GET /api/events (SSE)`);
-    console.log(`  - Publish endpoint: POST /api/publish`);
-    console.log(`  - State endpoint: GET /api/state`);
+    console.log(
+      `🌐 Visit \x1b[96m\x1b[1mhttps://openbot.one\x1b[0m to connect to this runtime and manage everything from there. ✨`,
+    );
   });
 }

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;
@@ -289,7 +290,6 @@ export type PatchThreadDetailsEvent = BaseEvent & {
   type: 'action:patch_thread_details';
   data: {
     state?: Record<string, unknown>;
-    spec?: string;
   };
 };
 
@@ -297,7 +297,7 @@ export type PatchThreadDetailsResultEvent = BaseEvent & {
   type: 'action:patch_thread_details:result';
   data: {
     success: boolean;
-    updatedFields: ('state' | 'spec')[];
+    updatedFields: ('state')[];
   };
 };
 
@@ -380,7 +380,6 @@ export type CreateThreadEvent = BaseEvent & {
   type: 'action:create_thread';
   data: {
     threadTitle: string;
-    spec?: string;
     initialState?: Record<string, unknown>;
   };
   meta: {
@@ -569,34 +568,7 @@ export type HandoffResultEvent = BaseEvent & {
   };
 };
 
-export type DelegateEvent = BaseEvent & {
-  type: 'action:delegate';
-  data: {
-    agentId: string;
-    content: string;
-  };
-  meta?: {
-    toolCallId?: string;
-    [key: string]: any;
-  };
-};
-
-export type DelegateResultEvent = BaseEvent & {
-  type: 'action:delegate:result';
-  data: {
-    success: boolean;
-    agentId: string;
-    summary: string;
-  };
-  meta: {
-    toolCallId: string;
-    agentId: string;
-    threadId?: string;
-    [key: string]: any;
-  };
-};
-
-/** Internal routing: delegation plugin → orchestrator only (not stored or broadcast). */
+/** Internal routing: handoff plugin → orchestrator only (not stored or broadcast). */
 export type HandoffRequestEvent = BaseEvent & {
   type: 'handoff:request';
   data: {
@@ -606,16 +578,6 @@ export type HandoffRequestEvent = BaseEvent & {
   meta?: Record<string, unknown>;
 };
 
-/** Internal routing: delegation plugin → orchestrator only (not stored or broadcast). */
-export type DelegationRequestEvent = BaseEvent & {
-  type: 'delegation:request';
-  data: {
-    agentId: string;
-    content: string;
-  };
-  meta?: Record<string, unknown>;
-};
-
 export type MCPListToolsEvent = BaseEvent & {
   type: 'action:mcp_list_tools';
   data: {
@@ -766,6 +728,132 @@ 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 TodoStatus = 'pending' | 'in_progress' | 'done' | 'cancelled';
+
+/**
+ * A single unit of work tracked in thread state. Todos are owned by the
+ * system (bus services); agents can only mutate them by calling the
+ * `todo_write` / `todo_update` tools so every change is observable on the
+ * event stream and audit-friendly.
+ */
+export interface TodoItem {
+  id: string;
+  content: string;
+  status: TodoStatus;
+  /** Optional agent id responsible for this item — drives autonomous handoffs. */
+  assignee?: string;
+  /** Agent id that created the todo (or "system"). */
+  createdBy: string;
+  createdAt: number;
+  updatedAt: number;
+  /**
+   * Captured final reply when this item reaches `done` (last `agent:output`
+   * from the assignee for that run). Lets downstream agents rely on thread
+   * state instead of merged short-term messages.
+   */
+  result?: string;
+}
+
+export type TodoWriteInput = {
+  id?: string;
+  content: string;
+  status?: TodoStatus;
+  assignee?: string;
+};
+
+export type TodoWriteEvent = BaseEvent & {
+  type: 'action:todo_write';
+  data: {
+    todos: TodoWriteInput[];
+  };
+  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
+};
+
+export type TodoWriteResultEvent = BaseEvent & {
+  type: 'action:todo_write:result';
+  data: {
+    success: boolean;
+    todos: TodoItem[];
+    error?: string;
+  };
+  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
+};
+
+export type TodoUpdateEvent = BaseEvent & {
+  type: 'action:todo_update';
+  data: {
+    id: string;
+    status?: TodoStatus;
+    content?: string;
+    assignee?: string;
+  };
+  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
+};
+
+export type TodoUpdateResultEvent = BaseEvent & {
+  type: 'action:todo_update:result';
+  data: {
+    success: boolean;
+    todo?: TodoItem;
+    todos: TodoItem[];
+    error?: string;
+  };
+  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
+};
+
 export type OpenBotEvent =
   | UserInputEvent
   | AgentInvokeEvent
@@ -825,10 +913,7 @@ export type OpenBotEvent =
   | UIWidgetResponseEvent
   | HandoffEvent
   | HandoffResultEvent
-  | DelegateEvent
-  | DelegateResultEvent
   | HandoffRequestEvent
-  | DelegationRequestEvent
   | MCPListToolsEvent
   | MCPListToolsResultEvent
   | MCPCallEvent
@@ -842,4 +927,14 @@ export type OpenBotEvent =
   | ListMarketplaceAgentsEvent
   | ListMarketplaceAgentsResultEvent
   | InstallAgentEvent
-  | InstallAgentResultEvent;
+  | InstallAgentResultEvent
+  | RememberEvent
+  | RememberResultEvent
+  | RecallEvent
+  | RecallResultEvent
+  | ForgetEvent
+  | ForgetResultEvent
+  | TodoWriteEvent
+  | TodoWriteResultEvent
+  | TodoUpdateEvent
+  | TodoUpdateResultEvent;

package/src/bus/plugin.ts

@@ -56,8 +56,6 @@ export interface Plugin {
   name: string;
   description: string;
   image?: string;
-  /** Optional system-prompt body suggested when this plugin is used as the runtime. */
-  defaultInstructions?: string;
   /** JSON-schema-like description of `config` accepted in AGENT.md `plugins[].config`. */
   configSchema?: ConfigSchema;
   /** Tool definitions contributed to any runtime plugin attached to the same agent. */