openbot 0.4.7 → 0.5.4

package/dist/harness/orchestrator.js

@@ -1,149 +0,0 @@
-import { storageService } from '../services/storage.js';
-import { createAgentRuntime } from './runtime-factory.js';
-import { EventNormalizer } from './event-normalizer.js';
-import { QueueProcessor } from './queue-processor.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 = (options) => {
-    pruneStopRequests();
-    return stopRequests.find((request) => {
-        if (request.runId !== options.runId)
-            return false;
-        if (request.agentId && request.agentId !== options.agentId)
-            return false;
-        if (request.channelId && request.channelId !== options.channelId)
-            return false;
-        if (request.threadId && request.threadId !== options.threadId)
-            return false;
-        return true;
-    });
-};
-export const orchestratorService = {
-    /**
-     * The primary entry point for all events coming into the system (e.g. from the API).
-     * Handles routing and initial UI message creation.
-     */
-    dispatch: async (options) => {
-        const { runId, channelId, threadId, onEvent } = options;
-        if (options.event.type === 'action:agent_run_stop') {
-            const stopEvent = options.event;
-            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 || 'system',
-                channelId,
-                threadId,
-                event: options.event,
-            });
-            await onEvent({
-                type: 'action:agent_run_stop:result',
-                data: {
-                    success: true,
-                    message: `Stop requested for run ${stopEvent.data.runId}.`,
-                },
-                meta: options.event.meta,
-            }, state);
-            return;
-        }
-        // 1. Normalize incoming event
-        const { finalEvent, finalAgentId } = await EventNormalizer.normalize(options.event, {
-            runId,
-            agentId: options.agentId,
-            channelId,
-            threadId,
-            onEvent,
-        });
-        // 2. Initialize Queue Processor
-        const processor = new QueueProcessor({
-            runId,
-            channelId,
-            threadId,
-            onEvent,
-            executeAgent: orchestratorService.executeAgent,
-            shouldStopRun: orchestratorService.shouldStopRun,
-        });
-        // 3. Enqueue initial event
-        processor.enqueue({ agentId: finalAgentId, event: finalEvent });
-        // 4. Run execution loop
-        await processor.run();
-    },
-    /**
-     * Executes a single agent runtime.
-     */
-    executeAgent: async (options) => {
-        const { runId, agentId, event, channelId, threadId, onEvent } = options;
-        let agentState;
-        try {
-            agentState = await storageService.getOpenBotState(options);
-        }
-        catch (error) {
-            if (error.code === 'AGENT_NOT_FOUND') {
-                const fallbackState = await storageService.getOpenBotState({
-                    runId,
-                    agentId: 'system',
-                    channelId,
-                    threadId,
-                    event,
-                });
-                const warning = `⚠️ Agent **${agentId}** does not exist. Please check the agent ID and try again.`;
-                await onEvent({
-                    type: 'agent:output',
-                    data: { content: warning },
-                    meta: { agentId: 'system', threadId },
-                }, fallbackState);
-                return;
-            }
-            throw error;
-        }
-        const agentRuntime = await createAgentRuntime(agentState);
-        const stopInfo = {
-            runId,
-            agentId,
-            channelId,
-            threadId,
-        };
-        try {
-            // RUN the agent runtime
-            for await (const chunk of agentRuntime.run(event, { state: agentState, runId })) {
-                const stopRequest = findStopRequest(stopInfo);
-                if (stopRequest) {
-                    await onEvent({
-                        type: 'agent:run:stopped',
-                        data: {
-                            runId,
-                            agentId,
-                            channelId,
-                            threadId,
-                            reason: stopRequest.reason,
-                        },
-                    }, agentState);
-                    break;
-                }
-                chunk.meta = { ...chunk.meta, agentId };
-                await onEvent(chunk, agentState);
-            }
-        }
-        catch (error) {
-            console.error(`[orchestrator] Agent run failed: ${agentId}`, error);
-        }
-    },
-    shouldStopRun: (options) => {
-        const request = findStopRequest(options);
-        return request ? { shouldStop: true, reason: request.reason } : { shouldStop: false };
-    },
-};

package/dist/harness/participants.js

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

@@ -1,29 +0,0 @@
-import { loadVariables } from '../app/config.js';
-/** Keys last applied from workspace `variables.json` (used to unset removed entries). */
-let lastWorkspaceVariableKeys = new Set();
-function applyVariablesList(variables) {
-    const nextKeys = new Set(variables.map((v) => v.key));
-    for (const key of lastWorkspaceVariableKeys) {
-        if (!nextKeys.has(key)) {
-            delete process.env[key];
-        }
-    }
-    for (const variable of variables) {
-        process.env[variable.key] = variable.value;
-    }
-    lastWorkspaceVariableKeys = nextKeys;
-}
-export const processService = {
-    /**
-     * Reload workspace variables from disk into `process.env`.
-     * Call after server start and whenever `variables.json` changes.
-     */
-    syncWorkspaceVariablesToProcessEnv: () => {
-        const { variables } = loadVariables();
-        applyVariablesList(variables);
-    },
-    /** Apply a variable list directly (same unset semantics as sync). Prefer `syncWorkspaceVariablesToProcessEnv` when reading from disk. */
-    applyVariablesToProcessEnv: (variables) => {
-        applyVariablesList(variables);
-    },
-};

package/dist/harness/queue-processor.js

@@ -1,187 +0,0 @@
-import { ensureEventId } from '../app/utils.js';
-import { storageService } from '../services/storage.js';
-import { advanceAfterRun } from './todo-advance.js';
-export class QueueProcessor {
-    constructor(options) {
-        this.options = options;
-        this.currentQueue = [];
-        this.MAX_ITERATIONS = 20;
-        this.currentThreadId = options.threadId;
-    }
-    enqueue(item) {
-        this.currentQueue.push(item);
-    }
-    async run() {
-        let iterations = 0;
-        while (this.currentQueue.length > 0 && iterations < this.MAX_ITERATIONS) {
-            iterations++;
-            // Group by agentId to avoid parallel state corruption for the same agent.
-            const groups = new Map();
-            for (const item of this.currentQueue) {
-                const list = groups.get(item.agentId) || [];
-                list.push(item);
-                groups.set(item.agentId, list);
-            }
-            const nextQueue = [];
-            // Run each agent group in parallel
-            await Promise.all(Array.from(groups.entries()).map(async ([agentId, items]) => {
-                // Run items for the SAME agent sequentially to preserve event order and state consistency.
-                for (const item of items) {
-                    const { event: currentEvent } = item;
-                    const stopCheck = this.options.shouldStopRun?.({
-                        runId: this.options.runId,
-                        agentId,
-                        channelId: this.options.channelId,
-                        threadId: this.currentThreadId,
-                    });
-                    if (stopCheck?.shouldStop) {
-                        const stoppedState = await storageService.getOpenBotState({
-                            runId: this.options.runId,
-                            agentId,
-                            channelId: this.options.channelId,
-                            threadId: this.currentThreadId,
-                            event: currentEvent,
-                        });
-                        await this.options.onEvent({
-                            type: 'agent:run:stopped',
-                            data: {
-                                runId: this.options.runId,
-                                agentId,
-                                channelId: this.options.channelId,
-                                threadId: this.currentThreadId,
-                                reason: stopCheck.reason,
-                            },
-                        }, stoppedState);
-                        continue;
-                    }
-                    // Track handoff requests queued in this step to avoid accidental duplicates.
-                    const queuedRequestKeys = new Set();
-                    const queuedItems = [];
-                    let lastAgentOutput;
-                    const runOnEvent = async (chunk, state) => {
-                        // 0. Filter out echoed input events to prevent duplication in the UI/storage
-                        if (chunk.type === currentEvent.type && chunk.id === currentEvent.id) {
-                            return false;
-                        }
-                        if (chunk.type === 'agent:output') {
-                            const outMeta = chunk.meta;
-                            if (outMeta?.agentId === agentId) {
-                                const content = chunk.data?.content;
-                                if (typeof content === 'string' && content.trim()) {
-                                    lastAgentOutput = content.trim();
-                                }
-                            }
-                        }
-                        // 1. Detect if a new thread was created and update the context for the rest of the loop
-                        if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
-                            this.currentThreadId = chunk.data.threadId || this.currentThreadId;
-                        }
-                        // 2. Internal routing (handoff requests are internal — not forwarded)
-                        if (chunk.type === 'handoff:request') {
-                            const request = chunk;
-                            const targetAgentId = request.data?.agentId;
-                            const requestKey = `handoff:${targetAgentId}`;
-                            if (targetAgentId &&
-                                targetAgentId !== agentId &&
-                                !queuedRequestKeys.has(requestKey)) {
-                                queuedRequestKeys.add(requestKey);
-                                const targetEvent = ensureEventId({
-                                    type: 'agent:invoke',
-                                    data: {
-                                        role: 'user',
-                                        content: request.data.content,
-                                    },
-                                    meta: {
-                                        ...(request.meta || {}),
-                                        threadId: this.currentThreadId,
-                                    },
-                                });
-                                queuedItems.push({ agentId: targetAgentId, event: targetEvent });
-                            }
-                            return false;
-                        }
-                        // If we get here, the event is accepted and should be emitted.
-                        await this.options.onEvent(chunk, state);
-                        return true;
-                    };
-                    const startState = await storageService.getOpenBotState({
-                        runId: this.options.runId,
-                        agentId,
-                        channelId: this.options.channelId,
-                        threadId: this.currentThreadId,
-                        event: currentEvent,
-                    });
-                    await this.options.onEvent({
-                        type: 'agent:run:start',
-                        data: {
-                            runId: this.options.runId,
-                            agentId,
-                            channelId: this.options.channelId,
-                            threadId: this.currentThreadId,
-                        },
-                    }, startState);
-                    try {
-                        await this.options.executeAgent({
-                            runId: this.options.runId,
-                            agentId,
-                            event: currentEvent,
-                            channelId: this.options.channelId,
-                            threadId: this.currentThreadId,
-                            onEvent: runOnEvent,
-                        });
-                    }
-                    finally {
-                        const endState = await storageService.getOpenBotState({
-                            runId: this.options.runId,
-                            agentId,
-                            channelId: this.options.channelId,
-                            threadId: this.currentThreadId,
-                            event: currentEvent,
-                        });
-                        await this.options.onEvent({
-                            type: 'agent:run:end',
-                            data: {
-                                runId: this.options.runId,
-                                agentId,
-                                channelId: this.options.channelId,
-                                threadId: this.currentThreadId,
-                            },
-                        }, endState);
-                        // Autonomous todo advance: mark this agent's in_progress todo done
-                        // and dispatch the next assignee, if any. Single trigger point,
-                        // no reliance on the LLM remembering to call `todo_update`.
-                        try {
-                            const handoff = await advanceAfterRun({
-                                storage: storageService,
-                                channelId: this.options.channelId,
-                                threadId: this.currentThreadId,
-                                endedAgentId: agentId,
-                                lastAgentOutput,
-                            });
-                            if (handoff) {
-                                const requestKey = `handoff:${handoff.agentId}`;
-                                if (!queuedRequestKeys.has(requestKey)) {
-                                    queuedRequestKeys.add(requestKey);
-                                    const targetEvent = ensureEventId({
-                                        type: 'agent:invoke',
-                                        data: { role: 'user', content: handoff.content },
-                                        meta: { threadId: this.currentThreadId },
-                                    });
-                                    queuedItems.push({ agentId: handoff.agentId, event: targetEvent });
-                                }
-                            }
-                        }
-                        catch (error) {
-                            console.warn('[queue] todo advance failed', error);
-                        }
-                    }
-                    nextQueue.push(...queuedItems);
-                }
-            }));
-            this.currentQueue = nextQueue;
-        }
-        if (iterations >= this.MAX_ITERATIONS) {
-            console.warn(`[orchestrator] Reached MAX_ITERATIONS (${this.MAX_ITERATIONS}). Stopping execution.`);
-        }
-    }
-}

package/dist/harness/run-harness.js

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

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