openbot 0.3.6 → 0.4.0

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;
+}

package/dist/harness/run-harness.js

@@ -0,0 +1,154 @@
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../services/storage.js';
+import { createAgentRuntime } from './runtime-factory.js';
+const stopRequests = [];
+const STOP_TTL_MS = 30 * 60 * 1000;
+const pruneStops = () => {
+    const cutoff = Date.now() - STOP_TTL_MS;
+    for (let i = stopRequests.length - 1; i >= 0; i -= 1) {
+        if (stopRequests[i].requestedAt < cutoff)
+            stopRequests.splice(i, 1);
+    }
+};
+const findStop = (target) => {
+    pruneStops();
+    return stopRequests.find((r) => r.runId === target.runId &&
+        (!r.agentId || r.agentId === target.agentId) &&
+        (!r.channelId || r.channelId === target.channelId) &&
+        (!r.threadId || r.threadId === target.threadId));
+};
+const target = (ctx, agentId) => ({ ...ctx, agentId });
+const loadState = (t, event) => storageService.getOpenBotState({ ...t, event });
+export async function runHarness(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,
+    };
+    const agentId = options.agentId || 'system';
+    if (event.type === 'user:input' || event.type === 'agent:invoke') {
+        await runStep(ctx, agentId, await prepareInvoke(event, ctx));
+        return;
+    }
+    await runPassThrough(ctx, agentId, event);
+}
+async function runStep(ctx, agentId, event) {
+    const t = target(ctx, agentId);
+    const early = findStop(t);
+    if (early) {
+        const state = await loadState(t, event);
+        await ctx.onEvent({ type: 'agent:run:stopped', data: { ...t, reason: early.reason } }, state);
+        return;
+    }
+    let state;
+    try {
+        state = await loadState(t, event);
+    }
+    catch (error) {
+        if (error.code !== 'AGENT_NOT_FOUND')
+            throw error;
+        const fallback = await loadState(target(ctx, 'system'), event);
+        await ctx.onEvent({
+            type: 'agent:output',
+            data: {
+                content: `⚠️ Agent **${agentId}** does not exist. Please check the agent ID and try again.`,
+            },
+            meta: { agentId: 'system', threadId: ctx.threadId },
+        }, fallback);
+        return;
+    }
+    await ctx.onEvent({ type: 'agent:run:start', data: { ...t } }, state);
+    try {
+        await streamEvents(ctx, t, event, state, true);
+    }
+    catch (error) {
+        console.error(`[run-harness] Agent run failed: ${agentId}`, error);
+    }
+    finally {
+        const after = await loadState(t, event);
+        await ctx.onEvent({ type: 'agent:run:end', data: { ...t } }, after);
+    }
+}
+async function runPassThrough(ctx, agentId, event) {
+    const t = target(ctx, agentId);
+    let state;
+    try {
+        state = await loadState(t, event);
+    }
+    catch (error) {
+        if (error.code === 'AGENT_NOT_FOUND')
+            return;
+        throw error;
+    }
+    try {
+        await streamEvents(ctx, t, event, state, false);
+    }
+    catch (error) {
+        console.error(`[run-harness] Event failed: ${event.type} (${agentId})`, error);
+    }
+}
+async function streamEvents(ctx, t, event, state, step) {
+    const runtime = await createAgentRuntime(state);
+    for await (const chunk of runtime.run(event, { state, runId: ctx.runId })) {
+        if (step) {
+            const stop = findStop(t);
+            if (stop) {
+                await ctx.onEvent({ type: 'agent:run:stopped', data: { ...t, reason: stop.reason } }, state);
+                break;
+            }
+        }
+        if (chunk.id === event.id && chunk.type === event.type)
+            continue;
+        if (step && chunk.type === 'action:create_thread:result' && chunk.data.success) {
+            ctx.threadId = chunk.data.threadId || ctx.threadId;
+        }
+        chunk.meta = { ...chunk.meta, agentId: t.agentId };
+        await ctx.onEvent(chunk, state);
+    }
+}
+async function prepareInvoke(event, ctx) {
+    const rawContent = event.data?.content || '';
+    const userFacing = {
+        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,
+        },
+    };
+    const initialState = await loadState(target(ctx, 'system'), 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 loadState({ runId, channelId, threadId, onEvent, agentId: options.agentId || 'system' }, 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/run.js

@@ -0,0 +1,98 @@
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../services/storage.js';
+import { createAgentRuntime } from './runtime.js';
+const TODO_RESULT_MAX_CHARS = 12000;
+const readTodos = (state) => {
+    const raw = state.threadDetails?.state?.todos;
+    return Array.isArray(raw) ? raw : [];
+};
+function truncateTodoResult(text, maxChars = TODO_RESULT_MAX_CHARS) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, maxChars)}\n…[truncated]`;
+}
+function resolveTodoIdForWorker(todos, workerId, delegationTodoId) {
+    if (delegationTodoId && todos.some((t) => t.id === delegationTodoId)) {
+        return delegationTodoId;
+    }
+    const inProgress = todos.find((t) => t.status === 'in_progress' && t.assignee === workerId);
+    if (inProgress)
+        return inProgress.id;
+    const assigned = todos.find((t) => (t.status === 'pending' || t.status === 'in_progress') && t.assignee === workerId);
+    return assigned?.id;
+}
+async function recordWorkerTodoResult(state, workerId, output, delegationTodoId) {
+    if (!state.threadId)
+        return;
+    const result = truncateTodoResult(output ?? '');
+    if (!result)
+        return;
+    const todos = readTodos(state);
+    if (todos.length === 0)
+        return;
+    const todoId = resolveTodoIdForWorker(todos, workerId, delegationTodoId);
+    if (!todoId)
+        return;
+    const prior = todos.find((t) => t.id === todoId);
+    if (prior?.result === result)
+        return;
+    const now = Date.now();
+    const next = todos.map((t) => (t.id === todoId ? { ...t, result, updatedAt: now } : t));
+    await storageService.patchThreadState({
+        channelId: state.channelId,
+        threadId: state.threadId,
+        state: { todos: next },
+    });
+}
+export function makeInternalInvoke(content, threadId) {
+    return ensureEventId({
+        type: 'agent:invoke',
+        data: { role: 'user', content },
+        meta: { threadId, internal: true },
+    });
+}
+/**
+ * Run one agent turn. Yields runtime events for persistence/streaming;
+ * returns the last non-empty `agent:output` text when used as a worker.
+ */
+export async function* runTurn(options) {
+    const { runId, channelId, threadId, agentId, event, delegationTodoId } = options;
+    const target = { runId, agentId, channelId, threadId };
+    let state;
+    try {
+        state = await storageService.getOpenBotState({ ...target, event });
+    }
+    catch (error) {
+        if (error.code === 'AGENT_NOT_FOUND') {
+            return undefined;
+        }
+        throw error;
+    }
+    yield { type: 'agent:run:start', data: { ...target } };
+    let lastAgentOutput;
+    try {
+        const runtime = await createAgentRuntime(state);
+        for await (const chunk of runtime.run(event, { state, runId })) {
+            if (chunk.id === event.id && chunk.type === event.type)
+                continue;
+            if (chunk.type === 'agent:output' &&
+                chunk.meta?.agentId === agentId) {
+                const content = chunk.data?.content;
+                if (typeof content === 'string' && content.trim()) {
+                    lastAgentOutput = content.trim();
+                }
+            }
+            chunk.meta = { ...chunk.meta, agentId };
+            yield chunk;
+        }
+    }
+    finally {
+        const stateAfterRun = await storageService.getOpenBotState({ ...target, event });
+        yield { type: 'agent:run:end', data: { ...target } };
+        await recordWorkerTodoResult(stateAfterRun, agentId, lastAgentOutput, delegationTodoId);
+    }
+    return lastAgentOutput;
+}

package/dist/harness/runtime-factory.js

@@ -2,39 +2,6 @@ import { melony } from 'melony';
 import { resolvePlugin } from '../registry/plugins.js';
 import { storageService } from '../services/storage.js';
 import { busServicesPlugin } from '../bus/services.js';
-/**
- * Enhances the agent's instructions with a list of other available agents the
- * orchestrator can hand off to. Agents that include the `delegation` plugin
- * will surface peers; agents without it can ignore this.
- */
-export async function enhanceInstructions(state) {
-    const { agentId, agentDetails } = state;
-    if (!agentDetails)
-        return;
-    try {
-        const agents = await storageService.getAgents();
-        const otherAgents = agents.filter((a) => a.id !== agentId);
-        if (otherAgents.length === 0)
-            return;
-        const agentsList = otherAgents
-            .map((a) => `- **${a.id}**${a.description ? `: ${a.description}` : ''}`)
-            .join('\n');
-        const header = '### Available Agents:';
-        if (!agentDetails.instructions.includes(header)) {
-            const hasHandoff = (agentDetails.pluginRefs || []).some((r) => r.id === 'delegation');
-            const hasTodo = (agentDetails.pluginRefs || []).some((r) => r.id === 'todo');
-            const usage = hasTodo
-                ? 'Use these ids as `assignee` when calling `todo_write` to plan multi-agent work.'
-                : hasHandoff
-                    ? 'Use `handoff` to transfer control to another agent in this thread.'
-                    : '';
-            agentDetails.instructions += `\n\n${header}\n${agentsList}${usage ? `\n\n${usage}` : ''}`;
-        }
-    }
-    catch (error) {
-        console.warn('[agent] Failed to enhance instructions', error);
-    }
-}
 const composeMelonyPlugin = (...plugins) => {
     return (builder) => {
         for (const plugin of plugins) {
@@ -57,7 +24,6 @@ const composeMelonyPlugin = (...plugins) => {
  * Tool name collisions across plugins log a warning; the first plugin wins.
  */
 export async function createAgentRuntime(state) {
-    await enhanceInstructions(state);
     const runtime = melony({
         initialState: state,
     });