openbot 0.4.7 → 0.5.4

package/dist/harness/runtime-factory.js

@@ -1,73 +0,0 @@
-import { melony } from 'melony';
-import { resolvePlugin } from '../registry/plugins.js';
-import { storageService } from '../services/storage.js';
-import { busServicesPlugin } from '../bus/services.js';
-const composeMelonyPlugin = (...plugins) => {
-    return (builder) => {
-        for (const plugin of plugins) {
-            plugin(builder);
-        }
-    };
-};
-/**
- * Build the Melony runtime that drives a single agent run on the OpenBot bus.
- *
- * The runtime always wires:
- *   1. `busServicesPlugin` — bus-level services (storage, channels, threads,
- *      plugin install/marketplace) shared by every agent.
- *   2. Every Plugin referenced by the agent's `plugins[]` frontmatter, in
- *      order. Tool definitions from each plugin are merged into a single map
- *      and passed to every plugin via `PluginContext.tools`. Runtime plugins
- *      (those that handle `agent:invoke`) consume the merged map; tool plugins
- *      ignore it.
- *
- * Tool name collisions across plugins log a warning; the first plugin wins.
- */
-export async function createAgentRuntime(state) {
-    const runtime = melony({
-        initialState: state,
-    });
-    runtime.use(busServicesPlugin({ storage: storageService }));
-    const refs = state.agentDetails?.pluginRefs || [];
-    if (refs.length === 0) {
-        console.warn(`[agent] Agent "${state.agentId}" has no plugins; only bus services will be active.`);
-        return runtime.build();
-    }
-    // Resolve all plugins first so we can merge tool definitions before factory calls.
-    const resolved = [];
-    for (const ref of refs) {
-        const plugin = await resolvePlugin(ref.id);
-        if (!plugin) {
-            console.warn(`[agent] Plugin "${ref.id}" for agent "${state.agentId}" could not be resolved.`);
-            continue;
-        }
-        resolved.push({ ref, plugin });
-    }
-    // Merge tool definitions; first plugin wins on collision.
-    const tools = {};
-    for (const { plugin } of resolved) {
-        if (!plugin.toolDefinitions)
-            continue;
-        for (const [name, def] of Object.entries(plugin.toolDefinitions)) {
-            if (tools[name]) {
-                console.warn(`[agent] Tool name collision for "${name}" while loading plugin "${plugin.id}"; keeping first registration.`);
-                continue;
-            }
-            tools[name] = def;
-        }
-    }
-    // Compose all plugin factories with the shared context.
-    const pluginPlugins = [];
-    for (const { ref, plugin } of resolved) {
-        const context = {
-            agentId: state.agentId,
-            agentDetails: state.agentDetails,
-            config: ref.config || {},
-            storage: storageService,
-            tools,
-        };
-        pluginPlugins.push(plugin.factory(context));
-    }
-    runtime.use(composeMelonyPlugin(...pluginPlugins));
-    return runtime.build();
-}

package/dist/harness/runtime.js

@@ -1,57 +0,0 @@
-import { melony } from 'melony';
-import { resolvePlugin } from '../registry/plugins.js';
-import { storageService } from '../services/storage.js';
-import { busServicesPlugin } from '../bus/services.js';
-const composeMelonyPlugin = (...plugins) => {
-    return (builder) => {
-        for (const plugin of plugins) {
-            plugin(builder);
-        }
-    };
-};
-/** Build the Melony runtime for a single agent turn. */
-export async function createAgentRuntime(state) {
-    const runtime = melony({
-        initialState: state,
-    });
-    runtime.use(busServicesPlugin({ storage: storageService }));
-    const refs = state.agentDetails?.pluginRefs || [];
-    if (refs.length === 0) {
-        console.warn(`[harness] Agent "${state.agentId}" has no plugins; only bus services will be active.`);
-        return runtime.build();
-    }
-    const resolved = [];
-    for (const ref of refs) {
-        const plugin = await resolvePlugin(ref.id);
-        if (!plugin) {
-            console.warn(`[harness] Plugin "${ref.id}" for agent "${state.agentId}" could not be resolved.`);
-            continue;
-        }
-        resolved.push({ ref, plugin });
-    }
-    const tools = {};
-    for (const { plugin } of resolved) {
-        if (!plugin.toolDefinitions)
-            continue;
-        for (const [name, def] of Object.entries(plugin.toolDefinitions)) {
-            if (tools[name]) {
-                console.warn(`[harness] Tool name collision for "${name}" while loading plugin "${plugin.id}"; keeping first registration.`);
-                continue;
-            }
-            tools[name] = def;
-        }
-    }
-    const pluginPlugins = [];
-    for (const { ref, plugin } of resolved) {
-        const context = {
-            agentId: state.agentId,
-            agentDetails: state.agentDetails,
-            config: ref.config || {},
-            storage: storageService,
-            tools,
-        };
-        pluginPlugins.push(plugin.factory(context));
-    }
-    runtime.use(composeMelonyPlugin(...pluginPlugins));
-    return runtime.build();
-}

package/dist/harness/todo-advance.js

@@ -1,93 +0,0 @@
-/** Stored on each todo and inlined into the next assignee's invoke payload. */
-const RESULT_MAX_CHARS = 12000;
-/**
- * Shared helpers that drive the autonomous todo loop. The queue processor
- * calls `advanceAfterRun` once per `agent:run:end`; that is the only place
- * todos are completed and dispatched, which keeps the autonomous flow
- * single-threaded and easy to reason about.
- */
-export const readTodosFromState = (state) => {
-    const raw = state?.todos;
-    return Array.isArray(raw) ? raw : [];
-};
-export function truncateTodoResult(text, maxChars = RESULT_MAX_CHARS) {
-    const trimmed = text.trim();
-    if (!trimmed)
-        return undefined;
-    if (trimmed.length <= maxChars)
-        return trimmed;
-    return `${trimmed.slice(0, maxChars)}\n…[truncated]`;
-}
-/**
- * Apply a single advance step:
- *  1. If a todo is `in_progress` and `assignee` matches the agent whose run
- *     just ended, mark it `done` and attach `result` from `lastOutput` when present.
- *  2. Pick the next `pending` todo with an `assignee` and flip it to
- *     `in_progress`. That assignee gets handed off to; `invoke content` includes
- *     the previous step output when available so agents without short-term
- *     history still see prior work.
- *
- * If a todo is already `in_progress` and the just-ended agent wasn't its
- * assignee, leave it alone — someone else is working.
- */
-export function advanceTodos(todos, endedAgentId, lastOutput) {
-    const now = Date.now();
-    const truncated = truncateTodoResult(lastOutput ?? '');
-    let completedOutput;
-    let working = todos.map((t) => {
-        if (t.status === 'in_progress' && t.assignee === endedAgentId) {
-            completedOutput = truncated;
-            return {
-                ...t,
-                status: 'done',
-                updatedAt: now,
-                ...(truncated !== undefined ? { result: truncated } : {}),
-            };
-        }
-        return t;
-    });
-    if (working.some((t) => t.status === 'in_progress')) {
-        return { todos: working, handoff: null };
-    }
-    const idx = working.findIndex((t) => t.status === 'pending' && t.assignee);
-    if (idx === -1)
-        return { todos: working, handoff: null };
-    const picked = working[idx];
-    working = working.map((t, i) => i === idx ? { ...t, status: 'in_progress', updatedAt: now } : t);
-    const invokeContent = completedOutput !== undefined && completedOutput !== ''
-        ? `${picked.content}\n\n--- Output from previous step ---\n${completedOutput}`
-        : picked.content;
-    return {
-        todos: working,
-        handoff: {
-            agentId: picked.assignee,
-            content: invokeContent,
-            todoId: picked.id,
-        },
-    };
-}
-export async function advanceAfterRun(options) {
-    const { storage, channelId, threadId, endedAgentId, lastAgentOutput } = options;
-    if (!threadId)
-        return null;
-    const details = await storage.getThreadDetails({ channelId, threadId });
-    const todos = readTodosFromState(details?.state);
-    if (todos.length === 0)
-        return null;
-    const { todos: nextList, handoff } = advanceTodos(todos, endedAgentId, lastAgentOutput);
-    const changed = nextList.length !== todos.length ||
-        nextList.some((t, i) => {
-            const u = todos[i];
-            if (!u)
-                return true;
-            return (t.status !== u.status ||
-                t.updatedAt !== u.updatedAt ||
-                t.result !== u.result ||
-                t.assignee !== u.assignee ||
-                t.content !== u.content);
-        });
-    if (changed) {
-        await storage.patchThreadState({ channelId, threadId, state: { todos: nextList } });
-    }
-    return handoff;
-}

package/dist/harness/todo-dispatch.js

@@ -1,51 +0,0 @@
-import { ORCHESTRATOR_AGENT_ID } from './context.js';
-import { hasOpenTodos, readTodosFromState } from './todos.js';
-export const ORCHESTRATOR_REVIEW_PREFIX = '[Orchestrator review]';
-export const ORCHESTRATOR_KICKOFF_PREFIX = '[Orchestrator kickoff]';
-/** After a specialist finishes — decide what's next. */
-export const ORCHESTRATOR_REVIEW_PROMPT = [
-    ORCHESTRATOR_REVIEW_PREFIX,
-    'A specialist agent just finished a step in this thread.',
-    'Review the shared todo list in your context.',
-    'Use `todo_write` to update statuses or capture results.',
-    'If more work remains, call `delegate` with a clear briefing for the right participant.',
-    'If the plan is complete, summarize outcomes for the user.',
-].join(' ');
-/** After the orchestrator wrote a plan but did not delegate — start execution. */
-export const ORCHESTRATOR_KICKOFF_PROMPT = [
-    ORCHESTRATOR_KICKOFF_PREFIX,
-    'The thread has open todos but no specialist is running yet.',
-    'Pick the next actionable item, mark it `in_progress` with `todo_write`,',
-    'and call `delegate` to the assignee (or best participant) with a concrete briefing.',
-    'Use reasonable defaults when the user did not specify a preference — do not stop at planning.',
-].join(' ');
-export function isInternalOrchestratorInvoke(content) {
-    const text = content?.trim() ?? '';
-    return (text.startsWith(ORCHESTRATOR_REVIEW_PREFIX) ||
-        text.startsWith(ORCHESTRATOR_KICKOFF_PREFIX));
-}
-export async function planOrchestratorReview(options) {
-    const { storage, channelId, threadId, endedAgentId, invokeContent, hasQueuedFollowUps, orchestratorKickoffUsed, } = options;
-    if (!threadId || hasQueuedFollowUps)
-        return { review: false };
-    if (isInternalOrchestratorInvoke(invokeContent))
-        return { review: false };
-    const details = await storage.getThreadDetails({ channelId, threadId });
-    const todos = readTodosFromState(details?.state);
-    if (!hasOpenTodos(todos))
-        return { review: false };
-    if (endedAgentId === ORCHESTRATOR_AGENT_ID) {
-        if (orchestratorKickoffUsed)
-            return { review: false };
-        return {
-            review: true,
-            reason: 'plan_not_started',
-            prompt: ORCHESTRATOR_KICKOFF_PROMPT,
-        };
-    }
-    return {
-        review: true,
-        reason: 'specialist_finished',
-        prompt: ORCHESTRATOR_REVIEW_PROMPT,
-    };
-}

package/dist/harness/todos.js

@@ -1,5 +0,0 @@
-export const readTodosFromState = (state) => {
-    const raw = state?.todos;
-    return Array.isArray(raw) ? raw : [];
-};
-export const hasOpenTodos = (todos) => todos.some((t) => t.status === 'pending' || t.status === 'in_progress');

package/dist/harness/turn.js

@@ -1,79 +0,0 @@
-import { ensureEventId } from '../app/utils.js';
-import { storageService } from '../services/storage.js';
-import { createAgentRuntime } from './runtime-factory.js';
-export function makeInternalInvoke(content, threadId) {
-    return ensureEventId({
-        type: 'agent:invoke',
-        data: { role: 'user', content },
-        meta: { threadId, internal: true },
-    });
-}
-/**
- * Run one agent turn. Yields all runtime events for persistence/streaming;
- * returns the last non-empty `agent:output` text from the target agent.
- */
-export async function* runTurn(options) {
-    const { runId, channelId, threadId, agentId, event, lifecycle = true, stream = true, shouldStop, onThreadId, } = 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;
-    }
-    if (lifecycle && stream) {
-        yield {
-            type: 'agent:run:start',
-            data: { ...target },
-            meta: { agentId, threadId },
-        };
-    }
-    let lastAgentOutput;
-    try {
-        const runtime = await createAgentRuntime(state);
-        for await (const chunk of runtime.run(event, { state, runId })) {
-            const stop = shouldStop?.();
-            if (stop) {
-                yield {
-                    type: 'agent:run:stopped',
-                    data: { ...target, reason: stop.reason },
-                };
-                break;
-            }
-            if (chunk.id === event.id && chunk.type === event.type)
-                continue;
-            if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
-                const newThreadId = chunk.data.threadId;
-                if (newThreadId)
-                    onThreadId?.(newThreadId);
-            }
-            if (chunk.type === 'agent:output') {
-                const content = chunk.data?.content;
-                if (typeof content === 'string' && content.trim()) {
-                    lastAgentOutput = content.trim();
-                }
-            }
-            if (stream) {
-                chunk.meta = { ...chunk.meta, agentId: chunk.meta?.agentId ?? agentId };
-                yield chunk;
-            }
-        }
-    }
-    catch (error) {
-        console.error(`[turn] Agent run failed: ${agentId}`, error);
-    }
-    finally {
-        if (lifecycle && stream) {
-            yield {
-                type: 'agent:run:end',
-                data: { ...target },
-                meta: { agentId, threadId },
-            };
-        }
-    }
-    return lastAgentOutput;
-}

package/dist/harness/types.js

@@ -1 +0,0 @@
-export {};

package/dist/plugins/ai-sdk/index.js

@@ -1,34 +0,0 @@
-import { aiSdkRuntime } from './runtime.js';
-/**
- * `ai-sdk` — generic LLM runtime plugin built on the Vercel AI SDK.
- *
- * Owns `agent:invoke` and consumes the merged `tools` map provided by the
- * agent loader (collected from every tool plugin attached to the same agent).
- * Pair with tool plugins like `shell`, `mcp`, `delegation`, etc.
- */
-export const aiSdkPlugin = {
-    id: 'ai-sdk',
-    name: 'AI SDK Runtime',
-    description: 'Generic LLM runtime built on the Vercel AI SDK. Consumes tools contributed by other plugins.',
-    configSchema: {
-        type: 'object',
-        properties: {
-            model: {
-                type: 'string',
-                description: 'Provider model string, e.g. openai/gpt-4o-mini, anthropic/claude-3-5-sonnet-20240620',
-                default: 'openai/gpt-4o-mini',
-            },
-        },
-    },
-    factory: ({ agentDetails, config, storage, tools }) => {
-        const model = typeof config.model === 'string' && config.model
-            ? config.model
-            : 'openai/gpt-4o-mini';
-        return aiSdkRuntime({
-            model,
-            storage,
-            toolDefinitions: tools,
-        });
-    },
-};
-export default aiSdkPlugin;