openbot 0.2.13 → 0.3.0

package/dist/harness/queue-processor.js

@@ -0,0 +1,227 @@
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../services/storage.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, delegationContext } = item;
+                    // Track delegation/handoff requests queued in this step to avoid accidental duplicates.
+                    const queuedRequestKeys = new Set();
+                    const queuedItems = [];
+                    const runOutputs = [];
+                    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;
+                        }
+                        // 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/delegation requests are internal — not forwarded)
+                        if (chunk.type === 'handoff:request' || chunk.type === 'delegation:request') {
+                            const isHandoff = chunk.type === 'handoff:request';
+                            const request = isHandoff
+                                ? chunk
+                                : chunk;
+                            const targetAgentId = request.data?.agentId;
+                            const toolCallId = typeof request.meta?.toolCallId === 'string'
+                                ? request.meta.toolCallId
+                                : undefined;
+                            const requestKey = isHandoff
+                                ? `handoff:${targetAgentId}:${request.data?.content ?? ''}`
+                                : `delegate:${toolCallId ?? 'missing'}:${targetAgentId}:${request.data?.content ?? ''}`;
+                            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,
+                                    },
+                                });
+                                if (isHandoff) {
+                                    queuedItems.push({ agentId: targetAgentId, event: targetEvent });
+                                }
+                                else {
+                                    if (!toolCallId) {
+                                        // Emit error output (this triggers run start if not already started)
+                                        await runOnEvent(ensureEventId({
+                                            type: 'agent:output',
+                                            data: {
+                                                content: 'Delegation request ignored: missing toolCallId. Please retry delegation.',
+                                            },
+                                            meta: {
+                                                agentId,
+                                                threadId: this.currentThreadId,
+                                            },
+                                        }), state);
+                                        return true;
+                                    }
+                                    const parentAgentId = typeof request.meta?.parentAgentId === 'string'
+                                        ? request.meta.parentAgentId
+                                        : agentId;
+                                    const delegationWidgetId = typeof request.meta?.delegationWidgetId === 'string'
+                                        ? request.meta.delegationWidgetId
+                                        : undefined;
+                                    queuedItems.push({
+                                        agentId: targetAgentId,
+                                        event: targetEvent,
+                                        delegationContext: {
+                                            parentAgentId,
+                                            toolCallId,
+                                            delegationWidgetId,
+                                        },
+                                    });
+                                }
+                            }
+                            return false;
+                        }
+                        if (chunk.type === 'agent:output') {
+                            const content = chunk.data?.content;
+                            if (typeof content === 'string' && content.trim().length > 0) {
+                                runOutputs.push(content.trim());
+                            }
+                        }
+                        // For delegate mode, child agent execution is internal:
+                        // capture outputs for parent tool result, but don't stream child events to clients/storage.
+                        if (delegationContext) {
+                            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);
+                    }
+                    if (delegationContext) {
+                        const summary = runOutputs.length > 0
+                            ? runOutputs.join('\n\n').slice(0, 4000)
+                            : `Delegated agent "${agentId}" completed with no textual output.`;
+                        const delegateResultEvent = ensureEventId({
+                            type: 'action:delegate:result',
+                            data: {
+                                success: true,
+                                agentId,
+                                summary,
+                            },
+                            meta: {
+                                toolCallId: delegationContext.toolCallId,
+                                agentId: delegationContext.parentAgentId,
+                                threadId: this.currentThreadId,
+                            },
+                        });
+                        if (delegationContext.delegationWidgetId) {
+                            await this.options.onEvent(ensureEventId({
+                                type: 'client:ui:widget',
+                                data: {
+                                    kind: 'message',
+                                    widgetId: delegationContext.delegationWidgetId,
+                                    title: `Delegation complete: ${agentId}`,
+                                    body: runOutputs.length > 0
+                                        ? 'Delegated task finished. Parent agent is preparing final response.'
+                                        : 'Delegated task finished with no textual output. Parent agent will continue.',
+                                    state: 'submitted',
+                                    metadata: {
+                                        type: 'delegation:status',
+                                        phase: 'completed',
+                                        delegatedAgentId: agentId,
+                                    },
+                                },
+                                meta: {
+                                    agentId: delegationContext.parentAgentId,
+                                    threadId: this.currentThreadId,
+                                },
+                            }), await storageService.getOpenBotState({
+                                runId: this.options.runId,
+                                agentId: delegationContext.parentAgentId,
+                                channelId: this.options.channelId,
+                                threadId: this.currentThreadId,
+                                event: delegateResultEvent,
+                            }));
+                        }
+                        nextQueue.push({
+                            agentId: delegationContext.parentAgentId,
+                            event: delegateResultEvent,
+                        });
+                    }
+                    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/runtime-factory.js

@@ -0,0 +1,103 @@
+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 / delegate 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 for Handoff/Delegation:';
+        if (!agentDetails.instructions.includes(header)) {
+            agentDetails.instructions +=
+                `\n\n${header}\n${agentsList}\n\n` +
+                    'Use `handoff` to transfer control to another agent. ' +
+                    'Use `delegate` when you need a sub-result from another agent and want to continue after it returns.';
+        }
+    }
+    catch (error) {
+        console.warn('[agent] Failed to enhance instructions', error);
+    }
+}
+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) {
+    await enhanceInstructions(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/plugins/ai-sdk/index.js

@@ -0,0 +1,37 @@
+import { aiSdkRuntime } from './runtime.js';
+import { AI_SDK_SYSTEM_PROMPT } from './system-prompt.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.',
+    defaultInstructions: AI_SDK_SYSTEM_PROMPT,
+    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,
+            system: agentDetails.instructions || AI_SDK_SYSTEM_PROMPT,
+            storage,
+            toolDefinitions: tools,
+        });
+    },
+};
+export default aiSdkPlugin;