openbot 0.4.7 → 0.5.5

package/dist/harness/dispatch.js

@@ -1,144 +0,0 @@
-import { ensureEventId } from '../app/utils.js';
-import { storageService } from '../services/storage.js';
-import { ORCHESTRATOR_AGENT_ID } from './constants.js';
-import { runTurn } from './run.js';
-const stopRequests = [];
-const STOP_REQUEST_TTL_MS = 30 * 60 * 1000;
-const pruneStopRequests = () => {
-    const now = Date.now();
-    for (let i = stopRequests.length - 1; i >= 0; i -= 1) {
-        if (now - stopRequests[i].requestedAt > STOP_REQUEST_TTL_MS) {
-            stopRequests.splice(i, 1);
-        }
-    }
-};
-const findStopRequest = (target) => {
-    pruneStopRequests();
-    return stopRequests.find((r) => {
-        if (r.runId !== target.runId)
-            return false;
-        if (r.agentId && r.agentId !== target.agentId)
-            return false;
-        if (r.channelId && r.channelId !== target.channelId)
-            return false;
-        if (r.threadId && r.threadId !== target.threadId)
-            return false;
-        return true;
-    });
-};
-export async function dispatch(options) {
-    const { runId, channelId, onEvent } = options;
-    let { threadId } = options;
-    const { event } = options;
-    ensureEventId(event);
-    if (event.type === 'action:agent_run_stop') {
-        await handleStop(event, options);
-        return;
-    }
-    const agentId = options.agentId || ORCHESTRATOR_AGENT_ID;
-    let turnEvent = event;
-    if (event.type === 'user:input' || event.type === 'agent:invoke') {
-        turnEvent = await normalizeUserInput(event, { runId, channelId, threadId, onEvent });
-        if (event.type === 'user:input') {
-            threadId = turnEvent.meta?.threadId || threadId || event.id;
-        }
-    }
-    const target = { runId, agentId, channelId, threadId };
-    const preStop = findStopRequest(target);
-    if (preStop) {
-        const state = await storageService.getOpenBotState({ ...target, event: turnEvent });
-        await onEvent({ type: 'agent:run:stopped', data: { ...target, reason: preStop.reason } }, state);
-        return;
-    }
-    let state;
-    try {
-        state = await storageService.getOpenBotState({ ...target, event: turnEvent });
-    }
-    catch (error) {
-        if (error.code === 'AGENT_NOT_FOUND') {
-            const fallback = await storageService.getOpenBotState({
-                ...target,
-                agentId: ORCHESTRATOR_AGENT_ID,
-                event: turnEvent,
-            });
-            await onEvent({
-                type: 'agent:output',
-                data: {
-                    content: `⚠️ Agent **${agentId}** does not exist. Use participant ids without an @ prefix.`,
-                },
-                meta: { agentId: ORCHESTRATOR_AGENT_ID, threadId },
-            }, fallback);
-            return;
-        }
-        throw error;
-    }
-    const turn = runTurn({ runId, channelId, threadId, agentId, event: turnEvent });
-    let next = await turn.next();
-    while (!next.done) {
-        const chunk = next.value;
-        const stop = findStopRequest(target);
-        if (stop) {
-            await onEvent({ type: 'agent:run:stopped', data: { ...target, reason: stop.reason } }, state);
-            break;
-        }
-        if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
-            threadId = chunk.data.threadId || threadId;
-        }
-        await onEvent(chunk, state);
-        next = await turn.next();
-    }
-}
-async function normalizeUserInput(event, ctx) {
-    const rawContent = event.data?.content || '';
-    const userFacing = {
-        type: 'agent:invoke',
-        id: event.id,
-        data: { content: rawContent, role: 'user' },
-        meta: {
-            agentId: ORCHESTRATOR_AGENT_ID,
-            userId: event.meta?.userId,
-            userName: event.meta?.userName,
-            userAvatarUrl: event.meta?.userAvatarUrl,
-        },
-    };
-    const initialState = await storageService.getOpenBotState({
-        runId: ctx.runId,
-        agentId: ORCHESTRATOR_AGENT_ID,
-        channelId: ctx.channelId,
-        threadId: ctx.threadId,
-        event: userFacing,
-    });
-    await ctx.onEvent(userFacing, initialState);
-    return {
-        ...event,
-        type: 'agent:invoke',
-        data: { ...(event.data || {}), content: rawContent, role: 'user' },
-        meta: {
-            ...(event.meta || {}),
-            threadId: ctx.threadId || event.id,
-        },
-    };
-}
-async function handleStop(stopEvent, options) {
-    const { runId, channelId, threadId, onEvent } = options;
-    stopRequests.push({
-        runId: stopEvent.data.runId,
-        agentId: stopEvent.data.agentId,
-        channelId: stopEvent.data.channelId || channelId,
-        threadId: stopEvent.data.threadId || threadId,
-        reason: stopEvent.data.reason,
-        requestedAt: Date.now(),
-    });
-    const state = await storageService.getOpenBotState({
-        runId,
-        agentId: options.agentId || ORCHESTRATOR_AGENT_ID,
-        channelId,
-        threadId,
-        event: stopEvent,
-    });
-    await onEvent({
-        type: 'action:agent_run_stop:result',
-        data: { success: true, message: `Stop requested for run ${stopEvent.data.runId}.` },
-        meta: stopEvent.meta,
-    }, state);
-}

package/dist/harness/dispatcher.js

@@ -1,156 +0,0 @@
-import { ensureEventId } from '../app/utils.js';
-import { storageService } from '../services/storage.js';
-import { ORCHESTRATOR_AGENT_ID } from './context.js';
-import { resolveMessageTargetAgent } from './channel-participants.js';
-import { runTurn } from './turn.js';
-const stopRequests = [];
-const STOP_REQUEST_TTL_MS = 30 * 60 * 1000;
-const pruneStopRequests = () => {
-    const now = Date.now();
-    for (let i = stopRequests.length - 1; i >= 0; i -= 1) {
-        if (now - stopRequests[i].requestedAt > STOP_REQUEST_TTL_MS) {
-            stopRequests.splice(i, 1);
-        }
-    }
-};
-const findStopRequest = (target) => {
-    pruneStopRequests();
-    return stopRequests.find((r) => {
-        if (r.runId !== target.runId)
-            return false;
-        if (r.agentId && r.agentId !== target.agentId)
-            return false;
-        if (r.channelId && r.channelId !== target.channelId)
-            return false;
-        if (r.threadId && r.threadId !== target.threadId)
-            return false;
-        return true;
-    });
-};
-export async function dispatch(options) {
-    const { event } = options;
-    ensureEventId(event);
-    if (event.type === 'action:agent_run_stop') {
-        await handleStop(event, options);
-        return;
-    }
-    const ctx = {
-        runId: options.runId,
-        channelId: options.channelId,
-        threadId: options.threadId,
-        onEvent: options.onEvent,
-    };
-    if (event.type === 'user:input' || event.type === 'agent:invoke') {
-        const { invoke, targetAgentId } = await normalizeUserInput(event, ctx, options.agentId);
-        await executeTurn(targetAgentId, invoke, ctx);
-        return;
-    }
-    await executeTurn(options.agentId || ORCHESTRATOR_AGENT_ID, event, ctx, { lifecycle: false });
-}
-async function executeTurn(agentId, event, ctx, opts = {}) {
-    const target = {
-        runId: ctx.runId,
-        agentId,
-        channelId: ctx.channelId,
-        threadId: ctx.threadId,
-    };
-    const preStop = opts.lifecycle !== false ? findStopRequest(target) : undefined;
-    if (preStop) {
-        const state = await storageService.getOpenBotState({ ...target, event });
-        await ctx.onEvent({ type: 'agent:run:stopped', data: { ...target, reason: preStop.reason } }, state);
-        return;
-    }
-    let state;
-    try {
-        state = await storageService.getOpenBotState({ ...target, event });
-    }
-    catch (error) {
-        if (error.code === 'AGENT_NOT_FOUND') {
-            const fallback = await storageService.getOpenBotState({
-                ...target,
-                agentId: ORCHESTRATOR_AGENT_ID,
-                event,
-            });
-            await ctx.onEvent({
-                type: 'agent:output',
-                data: {
-                    content: `⚠️ Agent **${agentId}** does not exist. Use participant ids without an @ prefix.`,
-                },
-                meta: { agentId: ORCHESTRATOR_AGENT_ID, threadId: ctx.threadId },
-            }, fallback);
-            return;
-        }
-        throw error;
-    }
-    const turn = runTurn({
-        ...target,
-        event,
-        lifecycle: opts.lifecycle !== false,
-        shouldStop: () => findStopRequest(target),
-        onThreadId: (threadId) => {
-            ctx.threadId = threadId;
-        },
-    });
-    let next = await turn.next();
-    while (!next.done) {
-        await ctx.onEvent(next.value, state);
-        next = await turn.next();
-    }
-}
-async function normalizeUserInput(event, ctx, requestedAgentId) {
-    const rawContent = event.data?.content || '';
-    const previewState = await storageService.getOpenBotState({
-        runId: ctx.runId,
-        agentId: ORCHESTRATOR_AGENT_ID,
-        channelId: ctx.channelId,
-        threadId: ctx.threadId,
-        event,
-    });
-    const participants = previewState.channelDetails?.participants ?? [];
-    const targetAgentId = resolveMessageTargetAgent(participants, ORCHESTRATOR_AGENT_ID, requestedAgentId);
-    const userFacing = {
-        type: 'agent:invoke',
-        id: event.id,
-        data: { content: rawContent, role: 'user' },
-        meta: {
-            agentId: targetAgentId,
-            userId: event.meta?.userId,
-            userName: event.meta?.userName,
-            userAvatarUrl: event.meta?.userAvatarUrl,
-        },
-    };
-    await ctx.onEvent(userFacing, previewState);
-    const invoke = {
-        ...event,
-        type: 'agent:invoke',
-        data: { ...(event.data || {}), content: rawContent, role: 'user' },
-        meta: {
-            ...(event.meta || {}),
-            threadId: ctx.threadId || event.id,
-        },
-    };
-    return { invoke, targetAgentId };
-}
-async function handleStop(stopEvent, options) {
-    const { runId, channelId, threadId, onEvent } = options;
-    stopRequests.push({
-        runId: stopEvent.data.runId,
-        agentId: stopEvent.data.agentId,
-        channelId: stopEvent.data.channelId || channelId,
-        threadId: stopEvent.data.threadId || threadId,
-        reason: stopEvent.data.reason,
-        requestedAt: Date.now(),
-    });
-    const state = await storageService.getOpenBotState({
-        runId,
-        agentId: options.agentId || ORCHESTRATOR_AGENT_ID,
-        channelId,
-        threadId,
-        event: stopEvent,
-    });
-    await onEvent({
-        type: 'action:agent_run_stop:result',
-        data: { success: true, message: `Stop requested for run ${stopEvent.data.runId}.` },
-        meta: stopEvent.meta,
-    }, state);
-}

package/dist/harness/event-normalizer.js

@@ -1,59 +0,0 @@
-import { ensureEventId } from '../app/utils.js';
-import { storageService } from '../services/storage.js';
-export const EventNormalizer = {
-    /**
-     * Normalizes incoming events, converting raw inputs like user:input to agent:invoke.
-     * Also handles initial state storage and event bus propagation for user inputs.
-     */
-    normalize: async (event, options) => {
-        const { runId, agentId, channelId, threadId, onEvent } = options;
-        // 0. Ensure the incoming event has a unique ID immediately
-        ensureEventId(event);
-        let finalAgentId = agentId || 'system';
-        let finalEvent = event;
-        // 1. Convert user:input (or other raw inputs) to agent:invoke
-        const rawContent = event.data?.content || '';
-        if (event.type === 'user:input' || event.type === 'agent:invoke') {
-            const normalizedInvokeEvent = {
-                type: 'agent:invoke',
-                id: event.id,
-                data: {
-                    content: rawContent,
-                    role: 'user',
-                },
-                meta: {
-                    agentId: 'system',
-                    userId: event.meta?.userId,
-                    userName: event.meta?.userName,
-                    userAvatarUrl: event.meta?.userAvatarUrl,
-                },
-            };
-            finalEvent = normalizedInvokeEvent;
-            // 1. Store the user's input in the current context (main channel or existing thread)
-            const initialState = await storageService.getOpenBotState({
-                runId,
-                agentId: 'system',
-                channelId,
-                threadId: threadId,
-                event: finalEvent,
-            });
-            // 2. Propagate the user's input to the event bus
-            await onEvent(finalEvent, initialState);
-            // 3. Prepare the event for the target agent
-            finalEvent = {
-                ...event,
-                type: 'agent:invoke',
-                data: {
-                    ...(event.data || {}),
-                    content: rawContent,
-                },
-                meta: {
-                    ...(event.meta || {}),
-                    // The threadId in meta is the anchor for new threads (Slack-style)
-                    threadId: threadId || finalEvent.id,
-                },
-            };
-        }
-        return { finalEvent, finalAgentId };
-    },
-};

package/dist/harness/history.js

@@ -1,177 +0,0 @@
-/**
- * Sliding window: max number of messages we replay to the model on each
- * invocation. Older turns stay on disk but are not sent. Keeps both the
- * recent prompts and the prompt token budget bounded.
- */
-const MAX_WINDOW_MESSAGES = 80;
-/**
- * Reconstructs a valid `OpenBotMessage[]` chain from a raw event log.
- * Handles grouping tool calls into assistant messages and matching results.
- *
- * This replaces the old `shortTermMessages` concept by treating the event log
- * as the single source of truth for conversation history.
- */
-export function reconstructHistory(events) {
-    const messages = [];
-    for (const event of events) {
-        switch (event.type) {
-            case 'user:input':
-                messages.push({ role: 'user', content: event.data.content });
-                break;
-            case 'agent:output': {
-                const last = messages[messages.length - 1];
-                if (last && last.role === 'assistant') {
-                    if (typeof last.content === 'string') {
-                        last.content += '\n' + event.data.content;
-                    }
-                    else if (Array.isArray(last.content)) {
-                        const textPart = last.content.find((p) => p.type === 'text');
-                        if (textPart && textPart.type === 'text') {
-                            textPart.text += '\n' + event.data.content;
-                        }
-                        else {
-                            last.content.unshift({ type: 'text', text: event.data.content });
-                        }
-                    }
-                }
-                else {
-                    messages.push({ role: 'assistant', content: event.data.content });
-                }
-                break;
-            }
-            case 'agent:invoke': {
-                const invokeEvent = event;
-                // Only treat as a message if it has content and is explicitly from a role
-                if (invokeEvent.data?.content && invokeEvent.data?.role) {
-                    const role = invokeEvent.data.role;
-                    messages.push({ role, content: invokeEvent.data.content });
-                }
-                break;
-            }
-            default:
-                // Handle tool calls (action:*)
-                if (event.type.startsWith('action:') && !event.type.endsWith(':result')) {
-                    const toolName = event.type.slice(7);
-                    const toolCallId = event.meta?.toolCallId;
-                    if (!toolCallId)
-                        break;
-                    const toolCall = {
-                        type: 'tool-call',
-                        toolCallId,
-                        toolName,
-                        input: event.data,
-                    };
-                    const last = messages[messages.length - 1];
-                    if (last && last.role === 'assistant') {
-                        if (typeof last.content === 'string') {
-                            last.content = [
-                                { type: 'text', text: last.content },
-                                toolCall,
-                            ];
-                        }
-                        else {
-                            last.content.push(toolCall);
-                        }
-                    }
-                    else {
-                        messages.push({
-                            role: 'assistant',
-                            content: [toolCall],
-                        });
-                    }
-                }
-                // Handle tool results (action:*:result)
-                else if (event.type.startsWith('action:') && event.type.endsWith(':result')) {
-                    const toolName = event.type.slice(7, -7);
-                    const toolCallId = event.meta?.toolCallId;
-                    if (!toolCallId)
-                        break;
-                    const last = messages[messages.length - 1];
-                    if (last && last.role === 'tool' && Array.isArray(last.content)) {
-                        last.content.push({
-                            type: 'tool-result',
-                            toolCallId,
-                            toolName,
-                            output: event.data,
-                        });
-                    }
-                    else {
-                        messages.push({
-                            role: 'tool',
-                            content: [
-                                {
-                                    type: 'tool-result',
-                                    toolCallId,
-                                    toolName,
-                                    output: event.data,
-                                },
-                            ],
-                        });
-                    }
-                }
-                break;
-        }
-    }
-    return repairAndWindow(messages);
-}
-/**
- * Self-healing pass: every assistant tool_call must have a matching tool
- * result before the next user/assistant turn. Also applies the sliding window.
- */
-function repairAndWindow(messages) {
-    const fulfilled = new Set();
-    for (const m of messages) {
-        if (m.role === 'tool' && Array.isArray(m.content)) {
-            for (const part of m.content) {
-                if (part.type === 'tool-result') {
-                    fulfilled.add(part.toolCallId);
-                }
-            }
-        }
-    }
-    const repaired = [];
-    for (const m of messages) {
-        repaired.push(m);
-        if (m.role !== 'assistant' || typeof m.content === 'string')
-            continue;
-        const missingResults = [];
-        for (const part of m.content) {
-            if (part.type === 'tool-call' && !fulfilled.has(part.toolCallId)) {
-                missingResults.push({
-                    type: 'tool-result',
-                    toolCallId: part.toolCallId,
-                    toolName: part.toolName,
-                    output: {
-                        success: false,
-                        error: 'Tool result was lost (handler did not emit a matching :result event).',
-                    },
-                });
-                fulfilled.add(part.toolCallId);
-            }
-        }
-        if (missingResults.length > 0) {
-            repaired.push({
-                role: 'tool',
-                content: missingResults,
-            });
-        }
-    }
-    if (repaired.length <= MAX_WINDOW_MESSAGES)
-        return repaired;
-    const tail = repaired.slice(-MAX_WINDOW_MESSAGES);
-    // Ensure the tail doesn't start with an orphan tool result
-    const knownAssistantCallIds = new Set();
-    for (const m of tail) {
-        if (m.role === 'assistant' && Array.isArray(m.content)) {
-            for (const part of m.content) {
-                if (part.type === 'tool-call')
-                    knownAssistantCallIds.add(part.toolCallId);
-            }
-        }
-    }
-    return tail.filter((m) => {
-        if (m.role !== 'tool' || typeof m.content === 'string')
-            return true;
-        return m.content.some((part) => part.type === 'tool-result' && knownAssistantCallIds.has(part.toolCallId));
-    });
-}

package/dist/harness/mcp.js

@@ -1,61 +0,0 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { loadConfig } from '../app/config.js';
-class MCPService {
-    constructor() {
-        this.clients = new Map();
-        this.transports = new Map();
-    }
-    getServerConfig(serverId) {
-        const config = loadConfig();
-        const server = (config.mcpServers || []).find((s) => s.id === serverId);
-        if (!server) {
-            throw new Error(`MCP server "${serverId}" is not configured`);
-        }
-        return server;
-    }
-    async getClient(serverId) {
-        const existing = this.clients.get(serverId);
-        if (existing) {
-            return existing;
-        }
-        const server = this.getServerConfig(serverId);
-        const client = new Client({
-            name: 'openbot-v2',
-            version: '0.1.0',
-        }, {
-            capabilities: {},
-        });
-        const transport = new StdioClientTransport({
-            command: server.command,
-            args: server.args || [],
-            env: server.env,
-            cwd: server.cwd,
-        });
-        await client.connect(transport);
-        this.clients.set(serverId, client);
-        this.transports.set(serverId, transport);
-        return client;
-    }
-    async listServers() {
-        const config = loadConfig();
-        return (config.mcpServers || []).map((server) => server.id);
-    }
-    async listTools(serverId) {
-        const client = await this.getClient(serverId);
-        const result = await client.listTools();
-        return (result.tools || []).map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            inputSchema: tool.inputSchema,
-        }));
-    }
-    async callTool(serverId, toolName, args) {
-        const client = await this.getClient(serverId);
-        return client.callTool({
-            name: toolName,
-            arguments: args,
-        });
-    }
-}
-export const mcpService = new MCPService();

package/dist/harness/orchestration.js

@@ -1,88 +0,0 @@
-import { ORCHESTRATOR_AGENT_ID } from './context.js';
-const readThreadState = (state) => state.threadDetails?.state ?? {};
-export const readTodosFromState = (state) => {
-    const raw = readThreadState(state).todos;
-    return Array.isArray(raw) ? raw : [];
-};
-export const readOrchestration = (state) => {
-    const raw = readThreadState(state).orchestration;
-    if (!raw || typeof raw !== 'object')
-        return { active: false };
-    return raw;
-};
-export const isOrchestrationActive = (orch) => orch.active === true;
-export const hasActiveTodos = (state) => readTodosFromState(state).some((t) => t.status === 'pending' || t.status === 'in_progress');
-export const readPendingDelegation = (state) => readOrchestration(state).pendingDelegation;
-async function patchOrchestration(storage, state, patch) {
-    if (!state.threadId)
-        throw new Error('No active thread');
-    const current = readOrchestration(state);
-    const next = { ...current, ...patch };
-    await storage.patchThreadState({
-        channelId: state.channelId,
-        threadId: state.threadId,
-        state: { orchestration: next },
-    });
-    state.threadDetails = await storage.getThreadDetails({
-        channelId: state.channelId,
-        threadId: state.threadId,
-    });
-}
-export async function activateOrchestration(storage, state) {
-    const current = readOrchestration(state);
-    if (current.active)
-        return;
-    await patchOrchestration(storage, state, { active: true, startedAt: Date.now() });
-}
-export async function deactivateOrchestration(storage, state) {
-    const current = readOrchestration(state);
-    if (!current.active)
-        return;
-    await patchOrchestration(storage, state, {
-        active: false,
-        pendingDelegation: undefined,
-    });
-}
-export async function queueDelegation(storage, state, delegation) {
-    await patchOrchestration(storage, state, {
-        active: true,
-        startedAt: readOrchestration(state).startedAt ?? Date.now(),
-        pendingDelegation: delegation,
-    });
-}
-export async function clearPendingDelegation(storage, state) {
-    const current = readOrchestration(state);
-    if (!current.pendingDelegation)
-        return;
-    await patchOrchestration(storage, state, { pendingDelegation: undefined });
-}
-export function buildWorkerReviewPrompt(workerAgentId, output) {
-    const body = output && output.trim()
-        ? output.trim()
-        : '(The worker produced no text output.)';
-    return [
-        '[Orchestrator — worker step completed]',
-        '',
-        `Worker: @${workerAgentId}`,
-        'Output:',
-        '---',
-        body,
-        '---',
-        '',
-        'Review the shared todo plan, update statuses with `todo_write` if needed,',
-        'tell the user if appropriate, then either call `delegate_to_agent` for the next step',
-        'or confirm the goal is complete.',
-    ].join('\n');
-}
-export function buildPlanContinuePrompt() {
-    return [
-        '[Orchestrator — continue plan execution]',
-        '',
-        'You have an active todo plan with remaining work.',
-        'Review the plan and either call `delegate_to_agent` for the next step',
-        'or handle the work yourself. Update todos to reflect progress.',
-    ].join('\n');
-}
-export function isOrchestratorAgent(agentId) {
-    return agentId === ORCHESTRATOR_AGENT_ID;
-}