openbot 0.3.5 → 0.4.0

package/dist/harness/dispatcher.js

@@ -1,8 +1,8 @@
 import { ensureEventId } from '../app/utils.js';
 import { storageService } from '../services/storage.js';
-import { createAgentRuntime } from './runtime-factory.js';
-import { advanceAfterRun } from './todo-advance.js';
-const MAX_CHAIN_DEPTH = 20;
+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 = () => {
@@ -27,9 +27,6 @@ const findStopRequest = (target) => {
         return true;
     });
 };
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
 export async function dispatch(options) {
     const { event } = options;
     ensureEventId(event);
@@ -44,188 +41,86 @@ export async function dispatch(options) {
         onEvent: options.onEvent,
     };
     if (event.type === 'user:input' || event.type === 'agent:invoke') {
-        const invoke = await normalizeUserInput(event, ctx);
-        await runStep({ agentId: options.agentId || 'system', event: invoke }, ctx, 0);
+        const { invoke, targetAgentId } = await normalizeUserInput(event, ctx, options.agentId);
+        await executeTurn(targetAgentId, invoke, ctx);
         return;
     }
-    // Bus pass-through: route to the targeted agent's runtime once. No agent step,
-    // no advance, no follow-ups. Keeps queries (`/api/state`) cheap and idempotent.
-    await runBusEvent(event, options.agentId || 'system', ctx);
+    await executeTurn(options.agentId || ORCHESTRATOR_AGENT_ID, event, ctx, { lifecycle: false });
 }
-// ---------------------------------------------------------------------------
-// Agent step: run:start -> runtime -> run:end -> advance -> chain
-// ---------------------------------------------------------------------------
-async function runStep(step, ctx, depth) {
-    if (depth >= MAX_CHAIN_DEPTH) {
-        console.warn(`[dispatcher] Reached MAX_CHAIN_DEPTH (${MAX_CHAIN_DEPTH}); stopping chain.`);
-        return;
-    }
+async function executeTurn(agentId, event, ctx, opts = {}) {
     const target = {
         runId: ctx.runId,
-        agentId: step.agentId,
+        agentId,
         channelId: ctx.channelId,
         threadId: ctx.threadId,
     };
-    const preStop = findStopRequest(target);
+    const preStop = opts.lifecycle !== false ? findStopRequest(target) : undefined;
     if (preStop) {
-        const state = await storageService.getOpenBotState({ ...target, event: step.event });
+        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: step.event });
+        state = await storageService.getOpenBotState({ ...target, event });
     }
     catch (error) {
         if (error.code === 'AGENT_NOT_FOUND') {
             const fallback = await storageService.getOpenBotState({
                 ...target,
-                agentId: 'system',
-                event: step.event,
+                agentId: ORCHESTRATOR_AGENT_ID,
+                event,
             });
             await ctx.onEvent({
                 type: 'agent:output',
-                data: { content: `⚠️ Agent **${step.agentId}** does not exist. Please check the agent ID and try again.` },
-                meta: { agentId: 'system', threadId: ctx.threadId },
+                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;
     }
-    await ctx.onEvent({ type: 'agent:run:start', data: { ...target } }, state);
-    const followUps = [];
-    const queuedAgentIds = new Set();
-    let lastAgentOutput;
-    try {
-        const runtime = await createAgentRuntime(state);
-        for await (const chunk of runtime.run(step.event, { state, runId: ctx.runId })) {
-            const stop = findStopRequest(target);
-            if (stop) {
-                await ctx.onEvent({ type: 'agent:run:stopped', data: { ...target, reason: stop.reason } }, state);
-                break;
-            }
-            if (chunk.id === step.event.id && chunk.type === step.event.type)
-                continue;
-            if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
-                ctx.threadId = chunk.data.threadId || ctx.threadId;
-            }
-            if (chunk.type === 'agent:output' &&
-                chunk.meta?.agentId === step.agentId) {
-                const content = chunk.data?.content;
-                if (typeof content === 'string' && content.trim())
-                    lastAgentOutput = content.trim();
-            }
-            // Handoff requests are internal: queue a follow-up step instead of forwarding.
-            if (chunk.type === 'handoff:request') {
-                const req = chunk;
-                const targetAgent = req.data?.agentId;
-                if (targetAgent && targetAgent !== step.agentId && !queuedAgentIds.has(targetAgent)) {
-                    queuedAgentIds.add(targetAgent);
-                    followUps.push({
-                        agentId: targetAgent,
-                        event: makeInvoke(req.data.content, ctx.threadId, req.meta),
-                    });
-                }
-                continue;
-            }
-            chunk.meta = { ...chunk.meta, agentId: step.agentId };
-            await ctx.onEvent(chunk, state);
-        }
-    }
-    catch (error) {
-        console.error(`[dispatcher] Agent run failed: ${step.agentId}`, error);
-    }
-    finally {
-        const endState = await storageService.getOpenBotState({ ...target, event: step.event });
-        await ctx.onEvent({ type: 'agent:run:end', data: { ...target } }, endState);
-    }
-    // Autonomous todo advance: single trigger point, runs once per `agent:run:end`.
-    try {
-        const handoff = await advanceAfterRun({
-            storage: storageService,
-            channelId: ctx.channelId,
-            threadId: ctx.threadId,
-            endedAgentId: step.agentId,
-            lastAgentOutput,
-        });
-        if (handoff && !queuedAgentIds.has(handoff.agentId)) {
-            queuedAgentIds.add(handoff.agentId);
-            followUps.push({
-                agentId: handoff.agentId,
-                event: makeInvoke(handoff.content, ctx.threadId),
-            });
-        }
-    }
-    catch (error) {
-        console.warn('[dispatcher] todo advance failed', error);
-    }
-    for (const next of followUps) {
-        await runStep(next, ctx, depth + 1);
-    }
-}
-// ---------------------------------------------------------------------------
-// Bus pass-through: run an event through the targeted agent's runtime, forward
-// chunks. No run:start/end, no advance, no follow-ups.
-// ---------------------------------------------------------------------------
-async function runBusEvent(event, agentId, ctx) {
-    let state;
-    try {
-        state = await storageService.getOpenBotState({
-            runId: ctx.runId,
-            agentId,
-            channelId: ctx.channelId,
-            threadId: ctx.threadId,
-            event,
-        });
-    }
-    catch (error) {
-        if (error.code === 'AGENT_NOT_FOUND') {
-            // Silently drop: bus pass-through has no UI surface to warn into.
-            return;
-        }
-        throw error;
-    }
-    try {
-        const runtime = await createAgentRuntime(state);
-        for await (const chunk of runtime.run(event, { state, runId: ctx.runId })) {
-            if (chunk.id === event.id && chunk.type === event.type)
-                continue;
-            chunk.meta = { ...chunk.meta, agentId };
-            await ctx.onEvent(chunk, state);
-        }
-    }
-    catch (error) {
-        console.error(`[dispatcher] Bus event failed: ${event.type} (${agentId})`, 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();
     }
 }
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-async function normalizeUserInput(event, ctx) {
+async function normalizeUserInput(event, ctx, requestedAgentId) {
     const rawContent = event.data?.content || '';
-    // The user-facing copy stored/streamed for the UI.
+    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: 'system',
+            agentId: targetAgentId,
             userId: event.meta?.userId,
             userName: event.meta?.userName,
             userAvatarUrl: event.meta?.userAvatarUrl,
         },
     };
-    const initialState = await storageService.getOpenBotState({
-        runId: ctx.runId,
-        agentId: 'system',
-        channelId: ctx.channelId,
-        threadId: ctx.threadId,
-        event: userFacing,
-    });
-    await ctx.onEvent(userFacing, initialState);
-    // The event actually fed to the target agent. Carries the input threadId (or the
-    // message id, used as the anchor for Slack-style new threads).
-    return {
+    await ctx.onEvent(userFacing, previewState);
+    const invoke = {
         ...event,
         type: 'agent:invoke',
         data: { ...(event.data || {}), content: rawContent, role: 'user' },
@@ -234,13 +129,7 @@ async function normalizeUserInput(event, ctx) {
             threadId: ctx.threadId || event.id,
         },
     };
-}
-function makeInvoke(content, threadId, baseMeta) {
-    return ensureEventId({
-        type: 'agent:invoke',
-        data: { role: 'user', content },
-        meta: { ...(baseMeta || {}), threadId },
-    });
+    return { invoke, targetAgentId };
 }
 async function handleStop(stopEvent, options) {
     const { runId, channelId, threadId, onEvent } = options;
@@ -254,7 +143,7 @@ async function handleStop(stopEvent, options) {
     });
     const state = await storageService.getOpenBotState({
         runId,
-        agentId: options.agentId || 'system',
+        agentId: options.agentId || ORCHESTRATOR_AGENT_ID,
         channelId,
         threadId,
         event: stopEvent,

package/dist/harness/history.js

@@ -0,0 +1,177 @@
+/**
+ * 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/index.js

@@ -0,0 +1,91 @@
+import { melony } from 'melony';
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../plugins/storage/service.js';
+import { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../app/agent-ids.js';
+import { resolvePlugin } from '../services/plugins/registry.js';
+export { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID };
+async function emitEvent(chunk, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId, }) {
+    ensureEventId(chunk);
+    // Enrich event with parent metadata if not already present
+    if (parentAgentId || parentToolCallId) {
+        chunk.meta = {
+            ...chunk.meta,
+            parentAgentId: chunk.meta?.parentAgentId || parentAgentId,
+            parentToolCallId: chunk.meta?.parentToolCallId || parentToolCallId,
+        };
+    }
+    if (persistEvents) {
+        await storageService.storeEvent({
+            channelId: state?.channelId || channelId,
+            threadId: state?.threadId || threadId,
+            event: chunk,
+        });
+    }
+    await onEvent(chunk, state);
+}
+/**
+ * Runs a single agent turn.
+ * Fire and forget.
+ */
+export async function runAgent(options) {
+    const { runId, agentId, event, channelId, threadId, onEvent } = options;
+    const persistEvents = options.persistEvents !== false;
+    const parentAgentId = event.meta?.parentAgentId;
+    const parentToolCallId = event.meta?.parentToolCallId;
+    const agentDetails = await storageService.getAgentDetails({ agentId });
+    const state = await storageService.getOpenBotState({
+        runId,
+        agentId,
+        channelId,
+        threadId,
+        event,
+    });
+    await emitEvent({
+        type: 'agent:run:start',
+        data: { runId, agentId, channelId, threadId },
+    }, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId });
+    try {
+        const pluginRefs = agentDetails.pluginRefs ?? [];
+        const tools = {};
+        for (const ref of pluginRefs) {
+            const plugin = await resolvePlugin(ref.id);
+            if (plugin?.toolDefinitions) {
+                Object.assign(tools, plugin.toolDefinitions);
+            }
+        }
+        const builder = melony().initialState(state);
+        for (const ref of pluginRefs) {
+            const plugin = await resolvePlugin(ref.id);
+            if (!plugin)
+                continue;
+            builder.use(plugin.factory({
+                agentId,
+                agentDetails,
+                config: ref.config ?? {},
+                storage: storageService,
+                tools,
+            }));
+        }
+        const runtime = builder.build();
+        const generator = runtime.run(event, { runId, state });
+        for await (const outputEvent of generator) {
+            await emitEvent(outputEvent, state, {
+                persistEvents,
+                channelId,
+                threadId,
+                onEvent,
+                parentAgentId,
+                parentToolCallId,
+            });
+        }
+    }
+    catch (error) {
+        console.error(`[harness] Error running agent ${agentId}:`, error);
+    }
+    finally {
+        await emitEvent({
+            type: 'agent:run:end',
+            data: { runId, agentId, channelId, threadId },
+        }, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId });
+    }
+}

package/dist/harness/orchestration.js

@@ -0,0 +1,88 @@
+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;
+}

package/dist/harness/participants.js

@@ -0,0 +1,22 @@
+/**
+ * Channel `participants` (from `state.json`) scope which agents may collaborate
+ * in that channel. Used for system-prompt hints and dispatch guards.
+ */
+/** Solo DM: exactly one participant and it is the acting agent (no peer bots). */
+export function isDmSoloChannel(participants, actingAgentId) {
+    return participants.length === 1 && participants[0] === actingAgentId;
+}
+/**
+ * When `participants` is non-empty, dispatch targets must appear in that list.
+ * Solo DM forbids targeting any agent other than yourself.
+ */
+export function isParticipantDispatchAllowed(participants, actingAgentId, targetAgentId) {
+    if (participants.length === 0)
+        return true;
+    if (!participants.includes(targetAgentId))
+        return false;
+    if (isDmSoloChannel(participants, actingAgentId) && targetAgentId !== actingAgentId) {
+        return false;
+    }
+    return true;
+}