openbot 0.4.7 → 0.5.4

package/dist/agents/openbot/runtime.js

@@ -1,289 +0,0 @@
-import { generateText } from 'ai';
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { createDefaultContextEngine } from '../../harness/context.js';
-function resolveModel(modelString) {
-    const [provider, ...rest] = modelString.split('/');
-    const modelId = rest.join('/');
-    if (!modelId) {
-        throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
-    }
-    switch (provider) {
-        case 'openai':
-            return openai(modelId);
-        case 'anthropic':
-            return anthropic(modelId);
-        default:
-            throw new Error(`Unsupported AI provider: "${provider}"`);
-    }
-}
-const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
-    ? value
-    : {};
-const readPersistedShortTermMessages = (state) => {
-    const source = state.threadDetails?.state ?? state.channelDetails?.state;
-    const record = asRecord(source);
-    const raw = record.shortTermMessages;
-    return Array.isArray(raw) ? raw : [];
-};
-const persistShortTermMessages = async (state, storage) => {
-    if (!storage)
-        return;
-    const shortTermMessages = state.shortTermMessages ?? [];
-    if (state.threadId) {
-        await storage.patchThreadState({
-            channelId: state.channelId,
-            threadId: state.threadId,
-            state: { shortTermMessages },
-        });
-        return;
-    }
-    await storage.patchChannelState({
-        channelId: state.channelId,
-        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');
-}
-/**
- * The ai-sdk based runtime that drives OpenBot's first-party agent.
- *
- * It owns `agent:invoke`, runs the LLM, emits tool-call events and stitches
- * tool results back into the conversation. The runtime is intentionally
- * agent-package-internal: it is not a generic OpenBot abstraction.
- */
-export const openBotRuntime = (options) => (builder) => {
-    const { model: modelString = 'openai/gpt-4o-mini', system, storage, contextEngine = createDefaultContextEngine(), toolDefinitions = {}, } = options;
-    const model = resolveModel(modelString);
-    const ensureShortTermMessages = (state) => {
-        if (!state.shortTermMessages || state.shortTermMessages.length === 0) {
-            state.shortTermMessages = readPersistedShortTermMessages(state);
-        }
-    };
-    const mapToCoreMessages = (messages) => {
-        return messages.map((m) => {
-            if (m.role === 'assistant' && m.toolCalls) {
-                return {
-                    role: 'assistant',
-                    content: [
-                        { type: 'text', text: m.content || '' },
-                        ...m.toolCalls.map((tc) => ({
-                            type: 'tool-call',
-                            toolCallId: tc.id,
-                            toolName: tc.function.name,
-                            input: JSON.parse(tc.function.arguments),
-                        })),
-                    ],
-                };
-            }
-            if (m.role === 'assistant') {
-                return { role: 'assistant', content: m.content || '' };
-            }
-            if (m.role === 'tool') {
-                return {
-                    role: 'tool',
-                    content: [
-                        {
-                            type: 'tool-result',
-                            toolCallId: m.toolCallId,
-                            toolName: m.toolName,
-                            output: { type: 'text', value: JSON.stringify(m.content) },
-                        },
-                    ],
-                };
-            }
-            return m;
-        });
-    };
-    const runLLM = async function* (context, threadId) {
-        ensureShortTermMessages(context.state);
-        const systemPrompt = await buildSystemPrompt(context.state, system, context, storage, contextEngine);
-        const coreMessages = mapToCoreMessages(context.state.shortTermMessages || []);
-        try {
-            const result = await generateText({
-                model,
-                system: systemPrompt,
-                messages: coreMessages,
-                tools: toolDefinitions,
-            });
-            const toolCalls = result.toolCalls ?? [];
-            if (toolCalls.length > 0) {
-                context.state.shortTermMessages = [
-                    ...(context.state.shortTermMessages ?? []),
-                    {
-                        role: 'assistant',
-                        content: result.text || '',
-                        toolCalls: toolCalls.map((tc) => ({
-                            id: tc.toolCallId,
-                            type: 'function',
-                            function: {
-                                name: tc.toolName,
-                                arguments: JSON.stringify(tc.input),
-                            },
-                        })),
-                    },
-                ];
-                await persistShortTermMessages(context.state, storage);
-                for (const toolCall of toolCalls) {
-                    yield {
-                        type: `action:${toolCall.toolName}`,
-                        data: toolCall.input,
-                        meta: {
-                            toolCallId: toolCall.toolCallId,
-                            agentId: context.state.agentId,
-                            threadId,
-                        },
-                    };
-                }
-            }
-            if (result.text) {
-                if (toolCalls.length === 0) {
-                    context.state.shortTermMessages = [
-                        ...(context.state.shortTermMessages ?? []),
-                        { role: 'assistant', content: result.text },
-                    ];
-                    await persistShortTermMessages(context.state, storage);
-                }
-                yield {
-                    type: 'agent:output',
-                    data: { content: result.text },
-                    meta: { agentId: context.state.agentId, threadId },
-                };
-            }
-        }
-        catch (error) {
-            const errorMessage = error?.message || String(error);
-            const isApiKeyError = errorMessage.includes('API key') ||
-                errorMessage.includes('401') ||
-                errorMessage.includes('Unauthorized') ||
-                errorMessage.includes('authentication');
-            if (isApiKeyError) {
-                const provider = modelString.split('/')[0];
-                const envVar = provider === 'openai' ? 'OPENAI_API_KEY' : 'ANTHROPIC_API_KEY';
-                yield {
-                    type: 'client:ui:widget',
-                    data: {
-                        kind: 'form',
-                        widgetId: `api_key_request_${Date.now()}`,
-                        title: `${provider.toUpperCase()} API Key Required`,
-                        description: `The ${provider} API returned an authentication error. Please provide a valid API key to continue. The key never leaves your local runtime.`,
-                        fields: [
-                            {
-                                id: 'apiKey',
-                                label: 'API Key',
-                                type: 'text',
-                                placeholder: `sk-...`,
-                                required: true,
-                            },
-                        ],
-                        submitLabel: 'Save API Key',
-                        metadata: {
-                            type: 'api_key_request',
-                            provider,
-                            envVar,
-                        },
-                    },
-                    meta: { agentId: context.state.agentId, threadId },
-                };
-                return;
-            }
-            throw error;
-        }
-    };
-    builder.on('agent:invoke', async function* (event, context) {
-        const routedTo = event.data?.agentId;
-        if (typeof routedTo === 'string' && routedTo && routedTo !== context.state.agentId) {
-            return;
-        }
-        const threadId = event.meta?.threadId || context.state.threadId;
-        ensureShortTermMessages(context.state);
-        context.state.shortTermMessages = [
-            ...(context.state.shortTermMessages ?? []),
-            {
-                role: event.data?.role || 'user',
-                content: event?.data?.content || '',
-            },
-        ];
-        await persistShortTermMessages(context.state, storage);
-        yield* runLLM(context, threadId);
-    });
-    builder.on('*', async function* (event, context) {
-        if (!event.type.endsWith(':result'))
-            return;
-        if (event.meta?.agentId !== context.state.agentId)
-            return;
-        const toolCallId = event.meta?.toolCallId;
-        if (!toolCallId)
-            return;
-        ensureShortTermMessages(context.state);
-        const toolName = event.type.replace(/^action:/, '').replace(/:result$/, '');
-        const resultData = event.data;
-        const content = typeof resultData === 'string' ? resultData : JSON.stringify(resultData);
-        context.state.shortTermMessages = [
-            ...(context.state.shortTermMessages ?? []),
-            { role: 'tool', content, toolCallId, toolName },
-        ];
-        await persistShortTermMessages(context.state, storage);
-        const lastAssistant = [...(context.state.shortTermMessages ?? [])]
-            .reverse()
-            .find((m) => m.role === 'assistant' && m.toolCalls && m.toolCalls.length > 0);
-        if (lastAssistant && lastAssistant.toolCalls) {
-            const allFulfilled = lastAssistant.toolCalls.every((tc) => context.state.shortTermMessages?.some((m) => m.role === 'tool' && m.toolCallId === tc.id));
-            if (allFulfilled) {
-                // handoff terminates the current agent path; the orchestrator continues with the target agent.
-                if (toolName === 'handoff')
-                    return;
-                const threadId = event.meta?.threadId || context.state.threadId;
-                yield* runLLM(context, threadId);
-            }
-        }
-    });
-    builder.on('client:ui:widget:response', async function* (event, context) {
-        const { metadata, values } = event.data;
-        if (metadata?.type === 'api_key_request' && values?.apiKey) {
-            const key = metadata.envVar;
-            const value = values.apiKey;
-            if (storage) {
-                try {
-                    await storage.createVariable({ key, value, secret: true });
-                    yield {
-                        type: 'agent:output',
-                        data: {
-                            content: `Successfully saved ${metadata.provider} API key to workspace variables.`,
-                        },
-                        meta: { agentId: context.state.agentId },
-                    };
-                    yield {
-                        type: 'client:ui:widget',
-                        data: {
-                            widgetId: event.data.widgetId,
-                            kind: 'message',
-                            title: 'API Key Saved',
-                            body: `Successfully saved ${metadata.provider} API key. You can now continue your conversation.`,
-                            state: 'submitted',
-                            actions: [{ id: 'ok', label: 'Got it', variant: 'primary' }],
-                        },
-                        meta: { agentId: context.state.agentId },
-                    };
-                }
-                catch (error) {
-                    yield {
-                        type: 'agent:output',
-                        data: {
-                            content: `Failed to save API key: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                        },
-                        meta: { agentId: context.state.agentId },
-                    };
-                }
-            }
-        }
-    });
-};

package/dist/agents/openbot/system-prompt.js

@@ -1,32 +0,0 @@
-export const OPENBOT_SYSTEM_PROMPT = '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**: Use `handoff` when you want another agent to take over. ' +
-    'Use `delegate` when you want another agent to return results so you can continue.\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' +
-    '- **Handoff/Delegation**: Use handoff for ownership transfer and delegation for ' +
-    'subtask-return patterns. Reference the relevant Task ID from thread state and update ' +
-    'task status with `patch_thread_details` as progress is made.\n\n' +
-    'If you need to know what agents or packages are installed, I can help you find that information.';
-export const DEFAULT_OPENBOT_APPROVAL_RULES = [
-    {
-        action: 'action:shell_exec',
-        denyEvent: 'action:shell_exec:result',
-        message: 'The agent wants to run a terminal command.',
-        detailKeys: ['command', 'cwd', 'shell', 'timeoutMs'],
-        hiddenKeys: ['env'],
-        denyData: {
-            exitCode: null,
-            stdout: '',
-            stderr: 'Command execution was denied by the user.',
-            timedOut: false,
-        },
-    },
-];

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

@@ -1,78 +0,0 @@
-import z from 'zod';
-/**
- * Tool definitions for the OpenBot orchestrator's delegation/handoff capability.
- *
- * The actual cross-agent routing lives in the bus's queue processor: when this
- * plugin yields `handoff:request` / `delegation:request` events, the orchestrator
- * intercepts them and dispatches an `agent:invoke` to the target agent.
- */
-export const delegationToolDefinitions = {
-    handoff: {
-        description: 'Transfer control to another agent. The target agent continues the task and you do not wait for a tool result.',
-        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.'),
-        }),
-    },
-};
-export const delegationPlugin = () => (builder) => {
-    builder.on('action:handoff', async function* (event, context) {
-        const { agentId, content } = event.data;
-        yield {
-            type: 'agent:output',
-            data: { content: `Handing off to **${agentId}**: ${content}` },
-            meta: { ...(event.meta || {}), agentId: context.state.agentId },
-        };
-        yield {
-            type: 'handoff:request',
-            data: { agentId, content },
-            meta: { ...(event.meta || {}), agentId: context.state.agentId },
-        };
-        if (event.meta?.toolCallId) {
-            yield {
-                type: 'action:handoff:result',
-                data: { success: true, agentId, accepted: true },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-        }
-    });
-    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,
-            },
-        };
-    });
-};

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

@@ -1,99 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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.'),
-        }),
-    },
-};