openbot 0.3.1 → 0.3.2

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

@@ -116,15 +116,8 @@ const persistShortTermMessages = async (state, storage) => {
         state: { shortTermMessages },
     });
 };
-async function buildSystemPrompt(state, system, context, storage, contextEngine) {
-    const sections = [];
-    if (system && typeof system === 'string')
-        sections.push(system);
-    if (system && typeof system === 'function' && context)
-        sections.push(await system(context));
-    if (contextEngine)
-        sections.push(await contextEngine.buildContext(state, storage));
-    return sections.join('\n\n');
+async function buildSystemPrompt(state, storage, contextEngine) {
+    return contextEngine.buildContext(state, storage);
 }
 /**
  * Generic ai-sdk runtime plugin.
@@ -134,7 +127,7 @@ async function buildSystemPrompt(state, system, context, storage, contextEngine)
  * loader (merged from every tool plugin attached to the same agent).
  */
 export const aiSdkRuntime = (options) => (builder) => {
-    const { model: modelString = 'openai/gpt-4o-mini', system, storage, contextEngine = createDefaultContextEngine(), toolDefinitions = {}, } = options;
+    const { model: modelString = 'openai/gpt-4o-mini', storage, contextEngine = createDefaultContextEngine(), toolDefinitions = {}, } = options;
     let currentModelString = modelString;
     let model = resolveModel(currentModelString);
     const ensureShortTermMessages = (state) => {
@@ -179,7 +172,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 systemPrompt = await buildSystemPrompt(context.state, storage, contextEngine);
         const coreMessages = mapToCoreMessages(buildMessageWindow(repairOpenToolCalls(context.state.shortTermMessages || [])));
         try {
             const result = await generateText({

package/dist/plugins/ai-sdk/system-prompt.js

@@ -1,3 +1,18 @@
-export const AI_SDK_SYSTEM_PROMPT = 'You are a helpful AI assistant on the OpenBot platform. ' +
-    'Use the tools available to you to help the user. ' +
-    'Be concise unless the user asks for depth.';
+export const AI_SDK_SYSTEM_PROMPT = [
+    'You are a helpful AI assistant on the OpenBot platform.',
+    'Use the tools available to you to help the user.',
+    'Be concise unless the user asks for depth.',
+    '',
+    '## Planning with todos',
+    'The current thread has a shared todo list (visible under "Shared todo plan" in context).',
+    'It is the single source of truth for multi-step work and is shared across every agent in the thread.',
+    '',
+    'When planning:',
+    '- For any task that needs more than one step, call `todo_write` ONCE with the full ordered plan, then stop. Do not call any other tool in the same turn.',
+    '- The platform dispatches assignees automatically and completes their todo when their run ends. You do NOT need to call `handoff` to start the plan or `todo_update` to finish items.',
+    '- Each item must be concrete and atomic (one verb, one outcome). Skip the list entirely for trivial single-step requests.',
+    '',
+    'When you are an assignee (you have an `in_progress` todo addressed to you):',
+    '- Just do the work and reply. The platform will mark your todo done and dispatch the next one.',
+    '- If you genuinely cannot complete it, call `todo_update(id, status: "cancelled")` with a brief reason in your reply.',
+].join('\n');

package/dist/plugins/delegation/index.js

@@ -1,21 +1,14 @@
 import z from 'zod';
-const delegationToolDefinitions = {
+const handoffToolDefinitions = {
     handoff: {
-        description: 'Transfer control to another agent. The target agent continues the task and you do not wait for a tool result.',
+        description: 'Transfer control to another agent. The target agent continues the task in this thread.',
         inputSchema: z.object({
             agentId: z.string().describe('The ID of the target agent.'),
             content: z.string().describe('The message or task to hand off.'),
         }),
     },
-    delegate: {
-        description: 'Delegate a subtask to another agent and wait for its result so you can continue.',
-        inputSchema: z.object({
-            agentId: z.string().describe('The ID of the target agent.'),
-            content: z.string().describe('The subtask you want the target agent to execute.'),
-        }),
-    },
 };
-const delegationPluginRuntime = () => (builder) => {
+const handoffPluginRuntime = () => (builder) => {
     builder.on('action:handoff', async function* (event, context) {
         const { agentId, content } = event.data;
         yield {
@@ -36,44 +29,12 @@ const delegationPluginRuntime = () => (builder) => {
             };
         }
     });
-    builder.on('action:delegate', async function* (event, context) {
-        const { agentId, content } = event.data;
-        const widgetId = event.meta?.toolCallId
-            ? `delegate_${event.meta.toolCallId}`
-            : `delegate_${Date.now()}`;
-        yield {
-            type: 'client:ui:widget',
-            data: {
-                kind: 'message',
-                widgetId,
-                title: `Delegation started: ${agentId}`,
-                body: `Running delegated task in background.\n\n${content}`,
-                state: 'open',
-                metadata: {
-                    type: 'delegation:status',
-                    phase: 'started',
-                    delegatedAgentId: agentId,
-                },
-            },
-            meta: { ...(event.meta || {}), agentId: context.state.agentId },
-        };
-        yield {
-            type: 'delegation:request',
-            data: { agentId, content },
-            meta: {
-                ...(event.meta || {}),
-                parentAgentId: context.state.agentId,
-                delegationWidgetId: widgetId,
-                agentId: context.state.agentId,
-            },
-        };
-    });
 };
 export const delegationPlugin = {
     id: 'delegation',
-    name: 'Delegation',
-    description: 'Hand off or delegate sub-tasks to other agents on the bus.',
-    toolDefinitions: delegationToolDefinitions,
-    factory: () => delegationPluginRuntime(),
+    name: 'Handoff',
+    description: 'Hand off tasks to other agents on the bus.',
+    toolDefinitions: handoffToolDefinitions,
+    factory: () => handoffPluginRuntime(),
 };
 export default delegationPlugin;

package/dist/plugins/storage-tools/index.js

@@ -42,20 +42,11 @@ const storageToolDefinitions = {
             .refine((value) => value.state !== undefined || value.spec !== undefined || value.cwd !== undefined, { message: 'Provide at least one of state, spec, or cwd.' }),
     },
     patch_thread_details: {
-        description: 'Patch current thread details (state and/or spec).',
-        inputSchema: z
-            .object({
+        description: 'Patch current thread details (state).',
+        inputSchema: z.object({
             state: z
                 .record(z.string(), z.unknown())
-                .optional()
                 .describe('JSON state object for the thread. Use for structured data like `todos` or progress.'),
-            spec: z
-                .string()
-                .optional()
-                .describe('Markdown content for the thread specification (SPEC.md). Use for plans and goals.'),
-        })
-            .refine((value) => value.state !== undefined || value.spec !== undefined, {
-            message: 'Provide at least one of state or spec.',
         }),
     },
     create_variable: {

package/dist/plugins/todo/index.js

@@ -0,0 +1,54 @@
+import z from 'zod';
+/**
+ * `todo` — shared, per-thread task list for autonomous multi-agent flows.
+ *
+ * Todos live in `threadDetails.state.todos` and are owned by the system
+ * (handlers in `bus/services.ts`). Any agent in the thread can read the
+ * list via context, and propose mutations through these tools. Each item
+ * may carry an `assignee` agent id; combine with `handoff` to drive an
+ * autonomous, multi-step plan across agents.
+ *
+ * Keep the surface minimal: two tools (replace-all, patch-one) cover plan
+ * authoring, status transitions, and reassignment.
+ */
+const todoStatus = z.enum(['pending', 'in_progress', 'done', 'cancelled']);
+const todoToolDefinitions = {
+    todo_write: {
+        description: 'Author or rewrite the shared todo plan for the current thread. Pass the full ordered list — missing items are removed. Use at the start of multi-step work, or whenever the plan changes shape. For status flips, prefer `todo_update`.',
+        inputSchema: z.object({
+            todos: z
+                .array(z.object({
+                id: z
+                    .string()
+                    .optional()
+                    .describe('Stable id. Reuse existing ids to preserve history; omit to create.'),
+                content: z.string().min(1).describe('What needs to be done. One concrete step.'),
+                status: todoStatus.optional().describe('Defaults to `pending`.'),
+                assignee: z
+                    .string()
+                    .optional()
+                    .describe('Agent id responsible for this step. Pair with `handoff` to delegate.'),
+            }))
+                .describe('The complete, ordered plan.'),
+        }),
+    },
+    todo_update: {
+        description: 'Patch a single todo by id. Use to mark progress (`in_progress`, `done`, `cancelled`), rephrase, or reassign without rewriting the whole list.',
+        inputSchema: z.object({
+            id: z.string().describe('Todo id from `todo_write` or the rendered list.'),
+            status: todoStatus.optional(),
+            content: z.string().min(1).optional(),
+            assignee: z.string().optional().describe('Use empty string to clear.'),
+        }),
+    },
+};
+export const todoPlugin = {
+    id: 'todo',
+    name: 'Todo',
+    description: 'Shared per-thread task list for coordinating multi-step, multi-agent work.',
+    toolDefinitions: todoToolDefinitions,
+    factory: () => () => {
+        // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
+    },
+};
+export default todoPlugin;

package/dist/plugins/workflow/index.js

@@ -0,0 +1,65 @@
+import z from 'zod';
+import { setWorkflowPlan, updateWorkflowTodo } from '../../workflow/service.js';
+const workflowToolDefinitions = {
+    workflow_set_plan: {
+        description: 'Define or replace the multi-agent plan for this thread.',
+        inputSchema: z.object({
+            title: z.string().optional().describe('Optional title for the plan.'),
+            todos: z.array(z.object({
+                id: z.string().optional().describe('Optional stable id.'),
+                text: z.string().describe('What needs to be done.'),
+            })).min(1).describe('Ordered steps.'),
+        }),
+    },
+    workflow_update_todo: {
+        description: 'Update a step in the plan with progress or results.',
+        inputSchema: z.object({
+            todoId: z.string().describe('The id of the todo to update.'),
+            status: z.enum(['pending', 'done', 'failed']).optional().describe('New status.'),
+            summary: z.string().optional().describe('Concise result or note about this step.'),
+        }),
+    },
+};
+const workflowPluginRuntime = () => (builder) => {
+    builder.on('action:workflow_set_plan', async function* (event, context) {
+        const { threadId, channelId } = context.state;
+        if (!threadId) {
+            yield { type: 'action:workflow_set_plan:result', data: { success: false, error: 'No active thread.' }, meta: event.meta };
+            return;
+        }
+        try {
+            const workflow = await setWorkflowPlan({ channelId, threadId, plan: event.data });
+            yield { type: 'action:workflow_set_plan:result', data: { success: true, workflowId: workflow.id }, meta: event.meta };
+            yield {
+                type: 'agent:output',
+                data: { content: `Plan updated: **${workflow.title || workflow.id}** (${workflow.todos.length} steps).` },
+                meta: { ...(event.meta || {}), agentId: context.state.agentId, threadId },
+            };
+        }
+        catch (error) {
+            yield { type: 'action:workflow_set_plan:result', data: { success: false, error: String(error) }, meta: event.meta };
+        }
+    });
+    builder.on('action:workflow_update_todo', async function* (event, context) {
+        const { threadId, channelId } = context.state;
+        if (!threadId) {
+            yield { type: 'action:workflow_update_todo:result', data: { success: false, error: 'No active thread.' }, meta: event.meta };
+            return;
+        }
+        try {
+            const workflow = await updateWorkflowTodo({ channelId, threadId, update: event.data });
+            yield { type: 'action:workflow_update_todo:result', data: { success: true, todoId: event.data.todoId }, meta: event.meta };
+        }
+        catch (error) {
+            yield { type: 'action:workflow_update_todo:result', data: { success: false, error: String(error) }, meta: event.meta };
+        }
+    });
+};
+export const workflowPlugin = {
+    id: 'workflow',
+    name: 'Workflow',
+    description: 'Simple thread-scoped planning for multi-agent coordination.',
+    toolDefinitions: workflowToolDefinitions,
+    factory: () => workflowPluginRuntime(),
+};
+export default workflowPlugin;

package/dist/registry/plugins.js

@@ -9,6 +9,7 @@ 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 { todoPlugin } from '../plugins/todo/index.js';
 import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
 let pluginsDir = null;
 const loadedPlugins = new Set();
@@ -22,6 +23,7 @@ const BUILT_IN = {
     [uiPlugin.id]: uiPlugin,
     [approvalPlugin.id]: approvalPlugin,
     [memoryPlugin.id]: memoryPlugin,
+    [todoPlugin.id]: todoPlugin,
 };
 /** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
 export function parsePluginModule(module) {
@@ -35,14 +37,12 @@ export function parsePluginModule(module) {
     const name = typeof raw.name === 'string' ? raw.name : '';
     const description = typeof raw.description === 'string' ? raw.description : '';
     const image = typeof raw.image === 'string' ? raw.image : undefined;
-    const defaultInstructions = typeof raw.defaultInstructions === 'string' ? raw.defaultInstructions : undefined;
     const configSchema = raw.configSchema;
     const toolDefinitions = raw.toolDefinitions;
     return {
         name,
         description,
         image,
-        defaultInstructions,
         configSchema,
         toolDefinitions,
         factory: factory,

package/dist/services/storage.js

@@ -63,7 +63,7 @@ const SYSTEM_DEFAULT_PLUGINS = [
     { id: 'storage-tools' },
     // { id: 'mcp' },
     { id: 'shell' },
-    { id: 'delegation' },
+    { id: 'todo' },
     // { id: 'ui' },
     { id: 'approval' },
     { id: 'memory' },
@@ -73,7 +73,7 @@ function getSystemAgentDetails(overrides) {
         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,
@@ -162,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(),
@@ -230,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(),
@@ -357,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)
@@ -365,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);
@@ -382,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 }) => {
@@ -425,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');
@@ -453,7 +438,6 @@ export const storageService = {
             id: threadId,
             name: generatedName || threadId,
             channelId,
-            spec,
             state,
         };
     },
@@ -539,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 {

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/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.1",
+  "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.1');
+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. ✨`,
+    );
   });
 }