openbot 0.2.13 → 0.3.0

package/dist/harness/context.js

@@ -0,0 +1,131 @@
+/**
+ * The core engine that orchestrates context building.
+ */
+export class ContextEngine {
+    constructor() {
+        this.providers = [];
+        this.processors = [];
+    }
+    registerProvider(provider) {
+        this.providers.push(provider);
+    }
+    registerProcessor(processor) {
+        this.processors.push(processor);
+    }
+    async buildContext(state, storage) {
+        // 1. Collect context from all providers
+        let items = [];
+        for (const provider of this.providers) {
+            try {
+                const providedItems = await provider.provide(state, storage);
+                items.push(...providedItems);
+            }
+            catch (error) {
+                console.warn(`[ContextEngine] Provider ${provider.name} failed:`, error);
+            }
+        }
+        // 2. Run through processors
+        for (const processor of this.processors) {
+            try {
+                items = await processor.process(items, state);
+            }
+            catch (error) {
+                console.warn(`[ContextEngine] Processor ${processor.name} failed:`, error);
+            }
+        }
+        // 3. Format items into a single string
+        return items
+            .sort((a, b) => b.priority - a.priority)
+            .map(item => item.content)
+            .join('\n\n');
+    }
+}
+/**
+ * Default implementation of a Context Engine with basic providers.
+ */
+export function createDefaultContextEngine() {
+    const engine = new ContextEngine();
+    // Basic Providers
+    engine.registerProvider(new AgentDetailsProvider());
+    engine.registerProvider(new ChannelDetailsProvider());
+    engine.registerProvider(new ThreadDetailsProvider());
+    engine.registerProvider(new RecentEventsProvider());
+    return engine;
+}
+class AgentDetailsProvider {
+    constructor() {
+        this.name = 'agent-details';
+    }
+    async provide(state) {
+        if (!state.agentDetails)
+            return [];
+        return [{
+                id: 'agent-details',
+                type: 'agent',
+                priority: 100,
+                content: `## AGENT NAME\n${state.agentDetails.name}\n\n## AGENT SPECIFICATION\n${state.agentDetails.instructions}`
+            }];
+    }
+}
+class ChannelDetailsProvider {
+    constructor() {
+        this.name = 'channel-details';
+    }
+    async provide(state) {
+        if (!state.channelDetails)
+            return [];
+        return [{
+                id: 'channel-details',
+                type: 'channel',
+                priority: 80,
+                content: `## CHANNEL NAME\n${state.channelDetails.name}\n\n## CHANNEL SPECIFICATION\n${state.channelDetails.spec}`
+            }];
+    }
+}
+class ThreadDetailsProvider {
+    constructor() {
+        this.name = 'thread-details';
+    }
+    async provide(state) {
+        if (!state.threadDetails)
+            return [];
+        return [{
+                id: 'thread-details',
+                type: 'thread',
+                priority: 90,
+                content: `## THREAD NAME\n${state.threadDetails.name}\n\n## THREAD SPECIFICATION\n${state.threadDetails.spec}`
+            }];
+    }
+}
+class RecentEventsProvider {
+    constructor() {
+        this.name = 'recent-events';
+    }
+    async provide(state, storage) {
+        if (!storage)
+            return [];
+        const items = [];
+        // Fetch channel events if no thread, otherwise fetch thread events
+        const channelId = state.channelId;
+        const threadId = state.threadId;
+        try {
+            const events = await storage.getEvents({ channelId, threadId });
+            if (events.length > 0) {
+                const formattedEvents = events
+                    .slice(-20)
+                    .map((e) => `- ${e.type}: ${JSON.stringify(e.data || {})}`)
+                    .join('\n');
+                items.push({
+                    id: threadId ? 'thread-events' : 'channel-events',
+                    type: 'events',
+                    priority: 70,
+                    content: `## ${threadId ? 'THREAD' : 'CHANNEL'} RECENT ACTIVITIES (events)\n${formattedEvents}`
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`[ContextEngine] Failed to fetch events:`, error);
+        }
+        return items;
+    }
+}

package/dist/harness/event-normalizer.js

@@ -0,0 +1,59 @@
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../services/storage.js';
+export const EventNormalizer = {
+    /**
+     * Normalizes incoming events, converting raw inputs like user:input to agent:invoke.
+     * Also handles initial state storage and event bus propagation for user inputs.
+     */
+    normalize: async (event, options) => {
+        const { runId, agentId, channelId, threadId, onEvent } = options;
+        // 0. Ensure the incoming event has a unique ID immediately
+        ensureEventId(event);
+        let finalAgentId = agentId || 'system';
+        let finalEvent = event;
+        // 1. Convert user:input (or other raw inputs) to agent:invoke
+        const rawContent = event.data?.content || '';
+        if (event.type === 'user:input' || event.type === 'agent:invoke') {
+            const normalizedInvokeEvent = {
+                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,
+                },
+            };
+            finalEvent = normalizedInvokeEvent;
+            // 1. Store the user's input in the current context (main channel or existing thread)
+            const initialState = await storageService.getOpenBotState({
+                runId,
+                agentId: 'system',
+                channelId,
+                threadId: threadId,
+                event: finalEvent,
+            });
+            // 2. Propagate the user's input to the event bus
+            await onEvent(finalEvent, initialState);
+            // 3. Prepare the event for the target agent
+            finalEvent = {
+                ...event,
+                type: 'agent:invoke',
+                data: {
+                    ...(event.data || {}),
+                    content: rawContent,
+                },
+                meta: {
+                    ...(event.meta || {}),
+                    // The threadId in meta is the anchor for new threads (Slack-style)
+                    threadId: threadId || finalEvent.id,
+                },
+            };
+        }
+        return { finalEvent, finalAgentId };
+    },
+};

package/dist/harness/orchestrator.js

@@ -1,201 +1,34 @@
-import { melony } from 'melony';
-import { resolvePlugin } from '../registry/plugins.js';
 import { storageService } from '../services/storage.js';
-import { ensureEventId } from '../app/utils.js';
-import { loadConfig } from '../app/config.js';
-/**
- * Enhances agent instructions with a list of other available agents.
- */
-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 Delegation:';
-        if (!agentDetails.instructions.includes(header)) {
-            agentDetails.instructions += `\n\n${header}\n${agentsList}\n\nYou can use the \`delegate\` tool to task these agents. Use their ID (the bold part) when delegating.`;
-        }
-    }
-    catch (error) {
-        console.warn('[agent] Failed to enhance instructions', error);
-    }
-}
-/**
- * Factory for creating an OpenBot Melony Runtime.
- */
-async function createAgentRuntime(state) {
-    // 1. Prepare instructions
-    await enhanceInstructions(state);
-    // 2. Initialize runtime with the agent plugin
-    const runtime = melony({
-        initialState: state,
-    });
-    // 3. Normalize plugin specs:
-    // - runtime can be a single spec or an array (for backward/forward compatibility)
-    // - plugins remains supported as additional specs
-    const runtimeSpecs = Array.isArray(state.agentDetails?.runtime)
-        ? state.agentDetails.runtime
-        : state.agentDetails?.runtime
-            ? [state.agentDetails.runtime]
-            : [];
-    const { globalPlugins = [] } = loadConfig();
-    const agentSpecs = [...runtimeSpecs, ...(state.agentDetails?.plugins || [])];
-    const pluginSpecs = mergePluginSpecs(globalPlugins, agentSpecs);
-    // 4. Load normalized plugins
-    for (const p of pluginSpecs) {
-        const name = typeof p === 'string' ? p : p?.name;
-        if (!name || typeof name !== 'string') {
-            continue;
-        }
-        const config = typeof p === 'string' ? {} : { ...(p.config || {}) };
-        const plugin = await resolvePlugin(name, config);
-        if (plugin) {
-            runtime.use(plugin);
-        }
-    }
-    return runtime.build();
-}
-function mergePluginSpecs(globalSpecs, agentSpecs) {
-    const specsByName = new Map();
-    for (const spec of globalSpecs) {
-        const name = typeof spec === 'string' ? spec : spec?.name;
-        if (!name || typeof name !== 'string')
-            continue;
-        specsByName.set(name, spec);
-    }
-    // Agent-defined plugins override global ones with the same name.
-    for (const spec of agentSpecs) {
-        const name = typeof spec === 'string' ? spec : spec?.name;
-        if (!name || typeof name !== 'string')
-            continue;
-        specsByName.set(name, spec);
-    }
-    return [...specsByName.values()];
-}
+import { createAgentRuntime } from './runtime-factory.js';
+import { EventNormalizer } from './event-normalizer.js';
+import { QueueProcessor } from './queue-processor.js';
 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, agentId, event, channelId, threadId, onEvent } = options;
-        // 0. Ensure the incoming event has a unique ID immediately
-        ensureEventId(event);
-        let finalAgentId = agentId || 'system';
-        let finalEvent = event;
-        let currentThreadId = threadId;
-        // 1. Convert user:input (or other raw inputs) to agent:invoke
-        const rawContent = event.data?.content || '';
-        if (event.type === 'user:input' || event.type === 'agent:invoke') {
-            const normalizedInvokeEvent = {
-                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,
-                },
-            };
-            finalEvent = normalizedInvokeEvent;
-            // 1. Store the user's input in the current context (main channel or existing thread)
-            const initialState = await storageService.getOpenBotState({
-                runId,
-                agentId: 'system',
-                channelId,
-                threadId: currentThreadId,
-                event: finalEvent,
-            });
-            // 2. Propagate the user's input to the event bus
-            await onEvent(finalEvent, initialState);
-            // 3. Prepare the event for the target agent
-            finalEvent = {
-                ...event,
-                type: 'agent:invoke',
-                data: {
-                    ...(event.data || {}),
-                    content: rawContent,
-                },
-                meta: {
-                    ...(event.meta || {}),
-                    // The threadId in meta is the anchor for new threads (Slack-style)
-                    threadId: currentThreadId || finalEvent.id,
-                },
-            };
-        }
-        // 4. Linear Execution Loop
-        // Instead of recursion, we use a queue to process agents one after another.
-        const queue = [
-            { agentId: finalAgentId, event: finalEvent },
-        ];
-        // Safety check to prevent infinite loops
-        let iterations = 0;
-        const MAX_ITERATIONS = 20;
-        while (queue.length > 0 && iterations < MAX_ITERATIONS) {
-            iterations++;
-            const { agentId, event: currentEvent } = queue.shift();
-            // Track agents queued in this step to avoid double-runs (e.g. from tool delegation)
-            const queuedAgents = new Set();
-            const delegations = [];
-            await orchestratorService.executeAgent({
-                runId,
-                agentId,
-                event: currentEvent,
-                channelId,
-                threadId: currentThreadId,
-                onEvent: 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;
-                    }
-                    // 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) {
-                        currentThreadId = chunk.data.threadId || currentThreadId;
-                    }
-                    // 2. Detect delegations to queue them for the next iteration
-                    let targetAgentId = null;
-                    let targetEvent = null;
-                    if (chunk.type === 'agent:invoke' &&
-                        chunk.data.agentId &&
-                        chunk.data.agentId !== agentId) {
-                        targetAgentId = chunk.data.agentId;
-                        targetEvent = {
-                            ...chunk,
-                            meta: {
-                                ...(chunk.meta || {}),
-                                threadId: currentThreadId,
-                            },
-                        };
-                    }
-                    // 3. Queue only if not already queued in this step
-                    if (targetAgentId && targetEvent && !queuedAgents.has(targetAgentId)) {
-                        queuedAgents.add(targetAgentId);
-                        delegations.push({
-                            agentId: targetAgentId,
-                            event: targetEvent,
-                        });
-                    }
-                    // Propagate all events
-                    await onEvent(chunk, state);
-                },
-            });
-            // Add found delegations to the queue
-            queue.push(...delegations);
-        }
-        if (iterations >= MAX_ITERATIONS) {
-            console.warn(`[orchestrator] Reached MAX_ITERATIONS (${MAX_ITERATIONS}). Stopping execution.`);
-        }
+        const { runId, channelId, threadId, onEvent } = options;
+        // 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,
+        });
+        // 3. Enqueue initial event
+        processor.enqueue({ agentId: finalAgentId, event: finalEvent });
+        // 4. Run execution loop
+        await processor.run();
     },
     /**
      * Executes a single agent runtime.
@@ -226,48 +59,15 @@ export const orchestratorService = {
             throw error;
         }
         const agentRuntime = await createAgentRuntime(agentState);
-        let hasProducedOutput = false;
-        await onEvent({
-            type: 'agent:run:start',
-            data: {
-                runId,
-                agentId,
-                channelId,
-                threadId,
-            },
-        }, agentState);
         try {
             // RUN the agent runtime
             for await (const chunk of agentRuntime.run(event, { state: agentState, runId })) {
-                if (chunk.type === 'agent:output') {
-                    hasProducedOutput = true;
-                    chunk.meta = { ...chunk.meta, agentId };
-                }
-                else if (chunk.type.startsWith('action:')) {
-                    hasProducedOutput = true;
-                }
+                chunk.meta = { ...chunk.meta, agentId };
                 await onEvent(chunk, agentState);
             }
         }
-        finally {
-            await onEvent({
-                type: 'agent:run:end',
-                data: {
-                    runId,
-                    agentId,
-                    channelId,
-                    threadId,
-                },
-            }, agentState);
-        }
-        // Fallback for agents that don't produce output (e.g. misconfigured or silent)
-        if (event.type === 'agent:invoke' && !hasProducedOutput) {
-            const warning = `⚠️ **${agentId}** is not configured to handle inputs. Please check its plugin configuration.`;
-            await onEvent({
-                type: 'agent:output',
-                data: { content: warning },
-                meta: { agentId },
-            }, agentState);
+        catch (error) {
+            console.error(`[orchestrator] Agent run failed: ${agentId}`, error);
         }
     },
 };

package/dist/harness/process.js

@@ -1,7 +1,29 @@
+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) => {
-        for (const variable of variables) {
-            process.env[variable.key] = variable.value;
-        }
+        applyVariablesList(variables);
     },
 };