openbot 0.2.14 → 0.3.0

package/dist/agents/openbot/tools/mcp.js

@@ -0,0 +1,99 @@
+import z from 'zod';
+import { mcpService } from '../../../harness/mcp.js';
+function stringifyResult(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+export const mcpToolDefinitions = {
+    mcp_list_tools: {
+        description: 'List available tools from a configured MCP server. Use this first before calling tools on an unknown server.',
+        inputSchema: z.object({
+            serverId: z.string().describe('Configured MCP server id (e.g. github, notion, linear).'),
+        }),
+    },
+    mcp_call: {
+        description: 'Call a tool on a configured MCP server. Provide tool arguments as a JSON object. Use mcp_list_tools first when uncertain.',
+        inputSchema: z.object({
+            serverId: z.string().describe('Configured MCP server id.'),
+            toolName: z.string().describe('Exact MCP tool name from mcp_list_tools.'),
+            args: z
+                .record(z.string(), z.unknown())
+                .default({})
+                .describe('Tool arguments as a JSON object.'),
+        }),
+    },
+};
+export const mcpPlugin = () => (builder) => {
+    builder.on('action:mcp_list_tools', async function* (event, context) {
+        const serverId = event.data?.serverId;
+        try {
+            const tools = await mcpService.listTools(serverId);
+            const toolNames = tools.map((tool) => `- ${tool.name}${tool.description ? `: ${tool.description}` : ''}`);
+            yield {
+                type: 'action:mcp_list_tools:result',
+                data: { success: true, serverId, tools },
+                meta: event.meta,
+            };
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: toolNames.length > 0
+                        ? `MCP tools available on \`${serverId}\`:\n${toolNames.join('\n')}`
+                        : `MCP server \`${serverId}\` has no tools.`,
+                },
+                meta: { ...(event.meta || {}), agentId: context.state.agentId },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown MCP error';
+            yield {
+                type: 'action:mcp_list_tools:result',
+                data: { success: false, serverId, tools: [], error: message },
+                meta: event.meta,
+            };
+            yield {
+                type: 'agent:output',
+                data: { content: `Failed to list MCP tools for \`${serverId}\`: ${message}` },
+                meta: { ...(event.meta || {}), agentId: context.state.agentId },
+            };
+        }
+    });
+    builder.on('action:mcp_call', async function* (event, context) {
+        const serverId = event.data?.serverId;
+        const toolName = event.data?.toolName;
+        const args = (event.data?.args || {});
+        try {
+            const result = await mcpService.callTool(serverId, toolName, args);
+            const rendered = stringifyResult(result);
+            yield {
+                type: 'action:mcp_call:result',
+                data: { success: true, serverId, toolName, result },
+                meta: event.meta,
+            };
+            yield {
+                type: 'agent:output',
+                data: { content: `MCP \`${serverId}.${toolName}\` result:\n\n${rendered}` },
+                meta: { ...(event.meta || {}), agentId: context.state.agentId },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown MCP error';
+            yield {
+                type: 'action:mcp_call:result',
+                data: { success: false, serverId, toolName, error: message },
+                meta: event.meta,
+            };
+            yield {
+                type: 'agent:output',
+                data: { content: `MCP call failed for \`${serverId}.${toolName}\`: ${message}` },
+                meta: { ...(event.meta || {}), agentId: context.state.agentId },
+            };
+        }
+    });
+};

package/dist/agents/openbot/tools/shell.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+export const shellToolDefinitions = {
+    shell_exec: {
+        description: 'Execute a shell command in the terminal. Use this for file operations, running scripts, or system tasks.',
+        inputSchema: z.object({
+            command: z.string().describe('The shell command to execute.'),
+            cwd: z
+                .string()
+                .optional()
+                .describe('Working directory. Defaults to the channel cwd or workspace root. Leave empty unless the user requests a specific directory.'),
+            shell: z.enum(['bash', 'sh', 'zsh']).optional().describe('Shell to use. Defaults to bash.'),
+            timeoutMs: z
+                .number()
+                .optional()
+                .default(30000)
+                .describe('Maximum execution time in milliseconds. Defaults to 30000 (30s).'),
+        }),
+    },
+};
+export const shellPlugin = () => (builder) => {
+    builder.on('action:shell_exec', async function* (event, context) {
+        const { command, cwd, shell = 'bash', timeoutMs = 30000 } = event.data;
+        const actualTimeout = Math.max(1000, Math.min(timeoutMs, 60000));
+        const actualCwd = cwd || context.state.channelDetails?.cwd || process.cwd();
+        try {
+            const result = await new Promise((resolve) => {
+                const child = spawn(command, {
+                    shell,
+                    cwd: actualCwd,
+                    env: { ...process.env },
+                });
+                let stdout = '';
+                let stderr = '';
+                let timedOut = false;
+                const timer = setTimeout(() => {
+                    timedOut = true;
+                    child.kill();
+                }, actualTimeout);
+                child.stdout.on('data', (data) => {
+                    stdout += data.toString();
+                    if (stdout.length > 100000) {
+                        stdout = stdout.substring(0, 100000) + '\n... [output truncated]';
+                        child.kill();
+                    }
+                });
+                child.stderr.on('data', (data) => {
+                    stderr += data.toString();
+                    if (stderr.length > 100000) {
+                        stderr = stderr.substring(0, 100000) + '\n... [output truncated]';
+                    }
+                });
+                child.on('close', (code) => {
+                    clearTimeout(timer);
+                    resolve({ exitCode: code, stdout, stderr, timedOut });
+                });
+                child.on('error', (err) => {
+                    clearTimeout(timer);
+                    resolve({ exitCode: -1, stdout, stderr: stderr + err.message, timedOut: false });
+                });
+            });
+            const success = result.exitCode === 0 && !result.timedOut;
+            yield {
+                type: 'action:shell_exec:result',
+                data: {
+                    success,
+                    exitCode: result.exitCode,
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                    timedOut: result.timedOut,
+                },
+                meta: event.meta,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown shell error';
+            yield {
+                type: 'action:shell_exec:result',
+                data: {
+                    success: false,
+                    exitCode: -1,
+                    stdout: '',
+                    stderr: message,
+                    timedOut: false,
+                    error: message,
+                },
+                meta: event.meta,
+            };
+        }
+    });
+};

package/dist/agents/openbot/tools/storage.js

@@ -0,0 +1,75 @@
+import z from 'zod';
+/**
+ * Tool schemas the OpenBot orchestrator agent exposes to its LLM for talking to
+ * the bus's storage service. The actual handlers live in `src/bus/services.ts`
+ * since storage is platform infrastructure, not agent behaviour.
+ */
+export const storageToolDefinitions = {
+    create_channel: {
+        description: 'Create a new channel. Use when the user intent is clearly different from the current channel and should be split. Always confirm before creating. Skip for simple Q&A.',
+        inputSchema: z.object({
+            channelId: z
+                .string()
+                .describe('Unique channel ID (e.g. product-launch, backend-platform, channel_roadmap).'),
+            spec: z
+                .string()
+                .optional()
+                .describe('Optional initial markdown content for the channel spec.'),
+            initialState: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe('Optional initial state object for the channel.'),
+            cwd: z
+                .string()
+                .optional()
+                .describe('Optional initial current working directory for the channel.'),
+        }),
+    },
+    patch_channel_details: {
+        description: 'Patch current channel details (state, spec, cwd).',
+        inputSchema: z
+            .object({
+            state: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe('JSON state object for the channel. Use for structured data like `todos` or metadata.'),
+            spec: z
+                .string()
+                .optional()
+                .describe('Markdown content for the channel specification (SPEC.md). Use for goals and rules.'),
+            cwd: z.string().optional().describe('Current working directory for the channel.'),
+        })
+            .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({
+            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: {
+        description: 'Create or update a variable in the workspace storage.',
+        inputSchema: z.object({
+            key: z.string().describe('The key of the variable.'),
+            value: z.string().describe('The value of the variable.'),
+            secret: z.boolean().optional().describe('Whether the variable is a secret.'),
+        }),
+    },
+    delete_variable: {
+        description: 'Delete a variable from the workspace storage.',
+        inputSchema: z.object({
+            key: z.string().describe('The key of the variable to delete.'),
+        }),
+    },
+};

package/dist/agents/openbot/tools/ui.js

@@ -0,0 +1,176 @@
+import z from 'zod';
+const actionSchema = z.object({
+    id: z.string().describe('Stable action ID returned by client:ui:widget:response.'),
+    label: z.string().describe('Human-readable button label.'),
+    value: z.unknown().optional().describe('Optional machine-readable value for this action.'),
+    variant: z.enum(['primary', 'secondary', 'danger']).optional(),
+    disabled: z.boolean().optional(),
+});
+const optionSchema = z.object({
+    label: z.string(),
+    value: z.string(),
+});
+const fieldSchema = z.object({
+    id: z.string().describe('Stable field ID used as the submitted value key.'),
+    label: z.string(),
+    type: z.enum(['text', 'textarea', 'number', 'boolean', 'select', 'multiselect', 'date']),
+    description: z.string().optional(),
+    placeholder: z.string().optional(),
+    required: z.boolean().optional(),
+    options: z.array(optionSchema).optional(),
+    defaultValue: z.unknown().optional(),
+});
+const listItemSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+const widgetBaseSchema = {
+    widgetId: z.string().optional().describe('Stable widget ID. Defaults from toolCallId.'),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    body: z.string().optional(),
+    state: z.enum(['open', 'submitted', 'cancelled', 'error']).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+};
+const renderWidgetSchema = z.union([
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('message'),
+        actions: z.array(actionSchema).optional(),
+    }),
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('choice'),
+        actions: z.array(actionSchema).min(1),
+    }),
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('form'),
+        fields: z.array(fieldSchema).optional(),
+        submitLabel: z.string().optional(),
+        actions: z.array(actionSchema).optional(),
+        props: z.record(z.string(), z.unknown()).optional(),
+    }),
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('list'),
+        items: z.array(listItemSchema).optional(),
+        actions: z.array(actionSchema).optional(),
+    }),
+    z.object({
+        kind: z.enum(['approval', 'todo_list']).describe('Legacy preset. Prefer choice or list.'),
+        widgetId: z.string().optional(),
+        title: z.string().optional(),
+        props: z.record(z.string(), z.unknown()).optional(),
+        metadata: z.record(z.string(), z.unknown()).optional(),
+    }),
+]);
+const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const readString = (value) => typeof value === 'string' && value.trim() ? value : undefined;
+const asFields = (value) => Array.isArray(value) ? value : undefined;
+const asListItems = (value) => Array.isArray(value) ? value : undefined;
+const todoToListItem = (todo, index) => {
+    if (!isRecord(todo)) {
+        return { id: `todo_${index + 1}`, label: String(todo) };
+    }
+    return {
+        id: readString(todo.id) || `todo_${index + 1}`,
+        label: readString(todo.label) ||
+            readString(todo.task) ||
+            readString(todo.title) ||
+            `Todo ${index + 1}`,
+        description: readString(todo.description),
+        status: readString(todo.status),
+        metadata: todo,
+    };
+};
+const createWidgetId = (data, toolCallId) => {
+    if ('widgetId' in data && data.widgetId)
+        return data.widgetId;
+    if (toolCallId)
+        return `widget_${toolCallId}`;
+    return `widget_${Date.now()}`;
+};
+const normalizeWidget = (data, state, toolCallId) => {
+    const widgetId = createWidgetId(data, toolCallId);
+    if (data.kind === 'approval') {
+        const props = data.props || {};
+        return {
+            widgetId,
+            kind: 'choice',
+            title: data.title || 'Approval Required',
+            body: readString(props.message) ||
+                readString(props.summary) ||
+                'Please approve or deny this action.',
+            metadata: {
+                ...(data.metadata || {}),
+                legacyKind: 'approval',
+                actionId: props.actionId,
+            },
+            actions: [
+                { id: 'approve', label: 'Approve', value: props.actionId || 'approve', variant: 'primary' },
+                { id: 'deny', label: 'Deny', value: props.actionId || 'deny', variant: 'danger' },
+            ],
+        };
+    }
+    if (data.kind === 'todo_list') {
+        const props = data.props || {};
+        const stateTodos = isRecord(state.threadDetails?.state)
+            ? state.threadDetails.state.todos
+            : undefined;
+        const todos = asListItems(props.todos) || asListItems(stateTodos) || [];
+        return {
+            widgetId,
+            kind: 'list',
+            title: data.title || readString(props.title) || 'Task List',
+            description: readString(props.description),
+            metadata: { ...(data.metadata || {}), legacyKind: 'todo_list' },
+            items: todos.map(todoToListItem),
+        };
+    }
+    if (data.kind === 'form') {
+        const propsSource = data.props;
+        const props = isRecord(propsSource) ? propsSource : {};
+        return {
+            widgetId,
+            kind: 'form',
+            title: data.title || 'Details Required',
+            description: data.description,
+            body: data.body,
+            state: data.state,
+            metadata: data.metadata,
+            fields: data.fields || asFields(props.schema) || [],
+            submitLabel: data.submitLabel || readString(props.submitLabel),
+            actions: data.actions,
+        };
+    }
+    if (data.kind === 'list') {
+        return { ...data, widgetId, title: data.title || 'Task List', items: data.items || [] };
+    }
+    if (data.kind === 'choice') {
+        return { ...data, widgetId, title: data.title || 'Choose an Option' };
+    }
+    if (data.kind === 'message') {
+        return { ...data, widgetId, title: data.title || 'Message' };
+    }
+    throw new Error(`Unsupported UI widget kind: ${data.kind || 'unknown'}`);
+};
+export const uiToolDefinitions = {
+    render_ui_widget: {
+        description: 'Render a small server-driven UI widget in the conversation. Prefer primitive kinds: message, choice, form, or list. Legacy presets approval and todo_list are accepted.',
+        inputSchema: renderWidgetSchema,
+    },
+};
+export const uiPlugin = () => (builder) => {
+    builder.on('action:render_ui_widget', async function* (event, context) {
+        const widget = normalizeWidget(event.data, context.state, event.meta?.toolCallId);
+        yield {
+            type: 'client:ui:widget',
+            data: widget,
+            meta: event.meta,
+        };
+    });
+};

package/dist/agents/system.js

@@ -1,106 +1,33 @@
-import { delegationToolDefinitions } from '../plugins/delegation.js';
-import { storageToolDefinitions } from '../plugins/storage.js';
-import { mcpToolDefinitions } from '../plugins/mcp.js';
-import { uiToolDefinitions } from '../plugins/ui.js';
-import { storageService } from '../services/storage.js';
-import { readFileSync } from 'node:fs';
-const SYSTEM_ICON_DATA_URL = (() => {
-    try {
-        const svg = readFileSync(new URL('../assets/icon.svg', import.meta.url), 'utf-8').trim();
-        if (!svg.startsWith('<svg'))
-            return undefined;
-        return `data:image/svg+xml;base64,${Buffer.from(svg, 'utf-8').toString('base64')}`;
-    }
-    catch {
-        return undefined;
-    }
-})();
+import { openBotAgentPackage } from './openbot/index.js';
+import { OPENBOT_SYSTEM_PROMPT } from './openbot/system-prompt.js';
+/**
+ * Default Agent record for the first-party OpenBot orchestrator.
+ *
+ * The OpenBot agent is a regular peer on the bus — it just happens to ship
+ * by default and to use the first-party `openbot` AgentPackage. Users (and the
+ * bus's storage layer) can override its instructions/config like any other agent.
+ */
+export const SYSTEM_AGENT_ID = 'system';
 export const getSystemAgentDetails = (overrides) => {
     const defaults = {
-        id: 'system',
-        name: 'Lolly',
-        image: SYSTEM_ICON_DATA_URL,
-        instructions: 'You are OpenBot, the primary AI assistant and orchestrator of this workspace. Your goal is to help users onboard, answer questions about the system, and suggest specialized agents for specific tasks.\n\n' +
-            '### How to use OpenBot:\n' +
-            '1. **General Chat**: Just type your message here, and I will help you.\n' +
-            '2. **Specialized Agents**: You can delegate tasks to specialized agents for specific tasks. For example, use the `delegate` tool to invoke the `os` agent for terminal commands and file operations.\n' +
-            '3. **Channels**: Channels are shared spaces where multiple agents can participate. You can create new channels for different topics.\n' +
-            '4. **Local-First**: OpenBot runs entirely on your machine. Your data stays private and local.\n\n' +
-            '### Workflow Guidelines:\n' +
-            '- **Todo Schema**: Keep todo items simple. Each item should have a short `id`, a clear `task` description, and a `status` (e.g., "pending", "in_progress", "done").\n' +
-            '- **Interactive Widgets**: Use `render_ui_widget` to give the user a visual progress bar (`kind: "todo_list"`), request permissions (`kind: "approval"`), or gather structured data (`kind: "form"`).\n' +
-            '- **Delegation**: When delegating to another agent, reference the relevant Task ID from the thread state. Update the task status (e.g., using `patch_thread_details`) as progress is made.\n\n' +
-            'If you need to know what agents or plugins are installed, I can help you find that information.',
-        runtime: {
-            name: 'ai-sdk',
-            config: {
-                model: 'openai/gpt-4o-mini',
-                toolDefinitions: {
-                    ...delegationToolDefinitions,
-                    ...storageToolDefinitions,
-                    ...mcpToolDefinitions,
-                    ...uiToolDefinitions,
-                },
-            },
-        },
-        plugins: [
-            { name: 'storage', config: { storage: storageService } },
-            { name: 'delegation', config: {} },
-            { name: 'mcp', config: {} },
-            { name: 'ui', config: {} },
-        ],
-        description: 'System coordinator agent',
+        id: SYSTEM_AGENT_ID,
+        name: openBotAgentPackage.name,
+        image: openBotAgentPackage.image,
+        description: openBotAgentPackage.description,
+        instructions: OPENBOT_SYSTEM_PROMPT,
+        packageId: openBotAgentPackage.id,
+        config: { model: 'openai/gpt-5.4-nano' },
         createdAt: new Date(),
         updatedAt: new Date(),
     };
     if (!overrides)
         return defaults;
-    // Merge logic:
-    // - Simple fields: override if present
-    // - Runtime: merge config/model, but preserve toolDefinitions unless explicitly overridden
-    // - Plugins: merge by name (user plugins override defaults)
-    const mergedRuntime = {
-        ...(typeof defaults.runtime === 'object' ? defaults.runtime : {}),
-        ...(typeof overrides.runtime === 'object' ? overrides.runtime : {}),
-        name: (typeof overrides.runtime === 'object' ? overrides.runtime.name : overrides.runtime) ||
-            (typeof defaults.runtime === 'object' ? defaults.runtime.name : defaults.runtime) ||
-            'ai-sdk',
-        config: {
-            ...(defaults.runtime && typeof defaults.runtime !== 'string' ? defaults.runtime.config : {}),
-            ...(overrides.runtime && typeof overrides.runtime !== 'string' ? overrides.runtime.config : {}),
-            toolDefinitions: {
-                ...(defaults.runtime && typeof defaults.runtime !== 'string'
-                    ? defaults.runtime.config?.toolDefinitions
-                    : {}),
-                ...(overrides.runtime && typeof overrides.runtime !== 'string'
-                    ? overrides.runtime.config?.toolDefinitions
-                    : {}),
-            },
-        },
-    };
-    const mergedPlugins = [...(defaults.plugins || [])];
-    if (overrides.plugins) {
-        for (const p of overrides.plugins) {
-            const name = typeof p === 'string' ? p : p.name;
-            const index = mergedPlugins.findIndex((existing) => {
-                const existingName = typeof existing === 'string' ? existing : existing.name;
-                return existingName === name;
-            });
-            if (index !== -1) {
-                mergedPlugins[index] = p;
-            }
-            else {
-                mergedPlugins.push(p);
-            }
-        }
-    }
     return {
         ...defaults,
         ...overrides,
-        id: 'system', // Always enforce 'system' ID
-        image: overrides.image || defaults.image, // Ensure image is preserved if not explicitly overridden
-        runtime: mergedRuntime,
-        plugins: mergedPlugins,
+        id: SYSTEM_AGENT_ID,
+        image: overrides.image || defaults.image,
+        config: { ...(defaults.config || {}), ...(overrides.config || {}) },
         updatedAt: new Date(),
     };
 };

package/dist/app/config.js

@@ -7,6 +7,8 @@ export const DEFAULT_AGENTS_DIR = 'agents';
 export const DEFAULT_CHANNELS_DIR = 'channels';
 export const CONFIG_FILE = 'config.json';
 export const VARIABLES_FILE = 'variables.json';
+/** Public agent registry used when `marketplaceRegistryUrl` is not set. */
+export const DEFAULT_MARKETPLACE_REGISTRY_URL = 'https://raw.githubusercontent.com/meetopenbot/openbot-registry/main/registry.json';
 export function resolvePath(p) {
     return p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : path.resolve(p);
 }
@@ -37,7 +39,8 @@ export function isConfigured() {
     return fs.existsSync(configPath);
 }
 export function loadVariables() {
-    const variablesPath = path.join(resolvePath(DEFAULT_BASE_DIR), VARIABLES_FILE);
+    const config = loadConfig();
+    const variablesPath = path.join(resolvePath(config.baseDir || DEFAULT_BASE_DIR), VARIABLES_FILE);
     if (fs.existsSync(variablesPath)) {
         return JSON.parse(fs.readFileSync(variablesPath, 'utf-8'));
     }

package/dist/app/server.js

@@ -4,8 +4,11 @@ import cors from 'cors';
 import z from 'zod';
 import path from 'path';
 import fs from 'fs/promises';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
 import { generateId } from 'melony';
-import { DEFAULT_BASE_DIR, loadConfig, loadVariables, resolvePath } from '../app/config.js';
+import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
 import { processService } from '../harness/process.js';
 import { storageService } from '../services/storage.js';
 import { AgentHarness } from '../harness/agent-harness.js';
@@ -21,8 +24,7 @@ export async function startServer(options = {}) {
     })
         .passthrough();
     const config = loadConfig();
-    const variables = loadVariables();
-    processService.applyVariablesToProcessEnv(variables.variables);
+    processService.syncWorkspaceVariablesToProcessEnv();
     const baseDir = config.baseDir || DEFAULT_BASE_DIR;
     const openBotDir = resolvePath(baseDir);
     const PORT = Number(options.port ?? config.port ?? process.env.PORT ?? 4132);
@@ -55,6 +57,7 @@ export async function startServer(options = {}) {
         };
     };
     const getClientKey = (channelId, threadId) => threadId ? `${channelId}:${threadId}` : channelId;
+    const getRunKey = (runId, agentId, channelId, threadId) => `${runId}:${agentId}:${channelId}:${threadId || ''}`;
     const sendToClientKey = (clientKey, chunk) => {
         const threadClients = clients.get(clientKey);
         if (!threadClients)
@@ -89,6 +92,9 @@ export async function startServer(options = {}) {
     };
     app.use(cors());
     app.use(express.json({ limit: '20mb' }));
+    app.get('/api/health', (req, res) => {
+        res.json({ status: 'ok', version: pkg.version });
+    });
     app.get('/api/events', (req, res) => {
         const { channelId, threadId } = getContext(req);
         const clientKey = getClientKey(channelId, threadId);
@@ -156,7 +162,7 @@ export async function startServer(options = {}) {
             const targetThreadId = state?.threadId || threadId;
             const targetClientKey = getClientKey(targetChannelId, targetThreadId);
             if (chunk.type === 'agent:run:start') {
-                activeRuns.set(chunk.data.runId, {
+                activeRuns.set(getRunKey(chunk.data.runId, chunk.data.agentId, chunk.data.channelId, chunk.data.threadId), {
                     runId: chunk.data.runId,
                     channelId: chunk.data.channelId,
                     threadId: chunk.data.threadId,
@@ -164,7 +170,7 @@ export async function startServer(options = {}) {
                 });
             }
             else if (chunk.type === 'agent:run:end') {
-                activeRuns.delete(chunk.data.runId);
+                activeRuns.delete(getRunKey(chunk.data.runId, chunk.data.agentId, chunk.data.channelId, chunk.data.threadId));
             }
             await storageService.storeEvent({
                 channelId: targetChannelId,
@@ -230,8 +236,9 @@ export async function startServer(options = {}) {
     });
     app.listen(PORT, () => {
         console.log(`\x1b[32mOpenBot server listening at http://localhost:${PORT}\x1b[0m`);
-        console.log(`  - Events endpoint: GET /events (SSE)`);
-        console.log(`  - Publish endpoint: POST /publish`);
-        console.log(`  - State endpoint: GET /state`);
+        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`);
     });
 }

package/dist/bus/agent-package.js

@@ -0,0 +1 @@
+export {};

package/dist/bus/plugin.js

@@ -0,0 +1 @@
+export {};