openbot 0.2.14 → 0.3.1

package/dist/bus/types.js

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

package/dist/harness/context.js

@@ -0,0 +1,250 @@
+/**
+ * Cheap, dependency-free token estimator. Roughly char/4 — fine for budget
+ * enforcement; can be swapped for a tokenizer-backed implementation later
+ * without touching providers.
+ */
+export const estimateTokens = (text) => Math.ceil((text?.length ?? 0) / 4);
+/**
+ * Hard cap (in characters) on a single context item. Keeps any one provider
+ * — typically the recent-events feed — from monopolising the prompt budget.
+ */
+const ITEM_HARD_CHAR_CAP = 6000;
+const truncate = (text, maxChars) => text.length <= maxChars ? text : `${text.slice(0, maxChars)}\n…[truncated]`;
+export class ContextEngine {
+    constructor() {
+        this.providers = [];
+        this.processors = [];
+    }
+    registerProvider(provider) {
+        this.providers.push(provider);
+    }
+    registerProcessor(processor) {
+        this.processors.push(processor);
+    }
+    async buildContext(state, storage) {
+        let items = [];
+        for (const provider of this.providers) {
+            try {
+                const providedItems = await provider.provide(state, storage);
+                for (const item of providedItems) {
+                    items.push({ ...item, content: truncate(item.content, ITEM_HARD_CHAR_CAP) });
+                }
+            }
+            catch (error) {
+                console.warn(`[ContextEngine] Provider ${provider.name} failed:`, error);
+            }
+        }
+        for (const processor of this.processors) {
+            try {
+                items = await processor.process(items, state);
+            }
+            catch (error) {
+                console.warn(`[ContextEngine] Processor ${processor.name} failed:`, error);
+            }
+        }
+        return items
+            .sort((a, b) => b.priority - a.priority)
+            .map((item) => item.content)
+            .join('\n\n');
+    }
+}
+/**
+ * Default context engine. Order of providers is by emit order; final ordering
+ * in the prompt is determined by `priority`. The token-budget processor runs
+ * last so dropping happens after every provider has contributed.
+ */
+export function createDefaultContextEngine() {
+    const engine = new ContextEngine();
+    engine.registerProvider(new AgentDetailsProvider());
+    engine.registerProvider(new ChannelDetailsProvider());
+    engine.registerProvider(new ThreadDetailsProvider());
+    engine.registerProvider(new MemoryProvider());
+    engine.registerProvider(new RecentEventsProvider());
+    engine.registerProcessor(new TokenBudgetProcessor());
+    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}`
+            }];
+    }
+}
+/**
+ * Fetches relevant memories (global + active agent + active channel) and
+ * surfaces them at high priority so the LLM treats them as ground truth
+ * rather than chat history.
+ */
+class MemoryProvider {
+    constructor() {
+        this.name = 'memory';
+    }
+    async provide(state, storage) {
+        if (!storage?.listMemories)
+            return [];
+        try {
+            const scopes = ['global', `agent:${state.agentId}`];
+            if (state.channelId)
+                scopes.push(`channel:${state.channelId}`);
+            const records = await storage.listMemories({ scopes, limit: 50 });
+            if (records.length === 0)
+                return [];
+            const formatted = records
+                .map((r) => {
+                const tags = r.tags?.length ? ` [${r.tags.join(', ')}]` : '';
+                const scopeLabel = r.scope === 'global' ? 'global' : r.scope;
+                return `- (${scopeLabel}${tags}) ${r.content}`;
+            })
+                .join('\n');
+            return [
+                {
+                    id: 'memory',
+                    type: 'memory',
+                    priority: 95,
+                    content: `## REMEMBERED FACTS\nThese are durable facts you previously stored with the \`remember\` tool. Trust them unless contradicted by the user. Use \`forget\` to remove ones that are stale.\n\n${formatted}`,
+                },
+            ];
+        }
+        catch (error) {
+            console.warn('[ContextEngine] MemoryProvider failed:', error);
+            return [];
+        }
+    }
+}
+/**
+ * Event types we omit from the recent-events context block. They duplicate
+ * information already in the conversation history, are infrastructural
+ * noise, or are too large to be useful as a tail summary.
+ */
+const NOISY_EVENT_PREFIXES = [
+    'agent:invoke',
+    'agent:output',
+    'agent:run',
+    'agent:active-runs',
+    'client:ui',
+    'stream:',
+    'action:storage:get-',
+    'action:storage:patch-',
+];
+const MAX_RECENT_EVENTS = 20;
+const MAX_EVENT_DATA_CHARS = 300;
+const isNoisyEvent = (event) => NOISY_EVENT_PREFIXES.some((prefix) => event.type.startsWith(prefix));
+const summarizeEvent = (event) => {
+    const data = event.data;
+    if (data === undefined)
+        return `- ${event.type}`;
+    let payload;
+    try {
+        payload = typeof data === 'string' ? data : JSON.stringify(data);
+    }
+    catch {
+        payload = '[unserialisable]';
+    }
+    if (payload.length > MAX_EVENT_DATA_CHARS) {
+        payload = `${payload.slice(0, MAX_EVENT_DATA_CHARS)}…`;
+    }
+    return `- ${event.type}: ${payload}`;
+};
+class RecentEventsProvider {
+    constructor() {
+        this.name = 'recent-events';
+    }
+    async provide(state, storage) {
+        if (!storage)
+            return [];
+        const channelId = state.channelId;
+        const threadId = state.threadId;
+        try {
+            const events = await storage.getEvents({ channelId, threadId });
+            const filtered = events.filter((e) => !isNoisyEvent(e));
+            if (filtered.length === 0)
+                return [];
+            const formatted = filtered.slice(-MAX_RECENT_EVENTS).map(summarizeEvent).join('\n');
+            return [
+                {
+                    id: threadId ? 'thread-events' : 'channel-events',
+                    type: 'events',
+                    priority: 70,
+                    content: `## ${threadId ? 'THREAD' : 'CHANNEL'} RECENT ACTIVITIES (events)\n${formatted}`,
+                },
+            ];
+        }
+        catch (error) {
+            console.warn('[ContextEngine] Failed to fetch events:', error);
+            return [];
+        }
+    }
+}
+/**
+ * Drops the lowest-priority items until the assembled prompt fits within the
+ * token budget. The first item with priority >= `keepFloor` is always kept,
+ * so the agent's own instructions can never be evicted. Stable on ties:
+ * later-emitted items go first.
+ */
+export class TokenBudgetProcessor {
+    constructor(budget = TokenBudgetProcessor.DEFAULT_BUDGET, keepFloor = TokenBudgetProcessor.KEEP_FLOOR) {
+        this.budget = budget;
+        this.keepFloor = keepFloor;
+        this.name = 'token-budget';
+    }
+    async process(items) {
+        const sorted = [...items].sort((a, b) => b.priority - a.priority);
+        const out = [];
+        let used = 0;
+        for (const item of sorted) {
+            const cost = estimateTokens(item.content);
+            if (item.priority >= this.keepFloor) {
+                out.push(item);
+                used += cost;
+                continue;
+            }
+            if (used + cost <= this.budget) {
+                out.push(item);
+                used += cost;
+            }
+        }
+        return out;
+    }
+}
+/** Soft prompt budget in tokens (matches gpt-4o-mini's reasonable system slice). */
+TokenBudgetProcessor.DEFAULT_BUDGET = 8000;
+/** Items at or above this priority are never dropped. */
+TokenBudgetProcessor.KEEP_FLOOR = 100;

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);
     },
 };