openbot 0.3.6 → 0.4.0

package/dist/harness/context.js

@@ -1,3 +1,26 @@
+import { isDmSoloChannel } from './channel-participants.js';
+export const DEFAULT_CONTEXT_BUDGET = 8000;
+/**
+ * Returns the known context window budget (in tokens) for a given model string.
+ * This is used to drive the context usage ring in the UI and to configure
+ * the prompt pruning budget.
+ */
+export const getContextBudgetForModel = (modelString) => {
+    const budgets = {
+        'openai/gpt-4o': 128000,
+        'openai/gpt-4o-mini': 128000,
+        'openai/o1-preview': 128000,
+        'openai/o1-mini': 128000,
+        'anthropic/claude-3-5-sonnet-20240620': 200000,
+        'anthropic/claude-3-5-sonnet-latest': 200000,
+        'anthropic/claude-3-opus-20240229': 200000,
+        'anthropic/claude-3-sonnet-20240229': 200000,
+        'anthropic/claude-3-haiku-20240307': 200000,
+    };
+    return budgets[modelString] || DEFAULT_CONTEXT_BUDGET;
+};
+/** Built-in orchestrator agent id (`~/.openbot/agents/system/AGENT.md` overrides instructions). */
+export const ORCHESTRATOR_AGENT_ID = 'system';
 /**
  * Cheap, dependency-free token estimator. Roughly char/4 — fine for budget
  * enforcement; can be swapped for a tokenizer-backed implementation later
@@ -55,71 +78,95 @@ export class ContextEngine {
  */
 export function createDefaultContextEngine() {
     const engine = new ContextEngine();
+    engine.registerProvider(new EnvironmentProvider());
+    engine.registerProvider(new ChannelSpecProvider());
     engine.registerProvider(new AgentDetailsProvider());
-    engine.registerProvider(new ChannelDetailsProvider());
-    engine.registerProvider(new ThreadDetailsProvider());
     engine.registerProvider(new TodoProvider());
     engine.registerProvider(new MemoryProvider());
-    engine.registerProvider(new RecentEventsProvider());
+    // engine.registerProvider(new RecentEventsProvider());
     engine.registerProcessor(new TokenBudgetProcessor());
     return engine;
 }
-class AgentDetailsProvider {
+class EnvironmentProvider {
     constructor() {
-        this.name = 'agent-details';
+        this.name = 'environment';
     }
     async provide(state) {
-        if (!state.agentDetails)
-            return [];
-        const instructions = state.agentDetails.instructions?.trim();
-        if (!instructions)
-            return [];
-        return [{
-                id: 'agent-details',
-                type: 'agent',
-                priority: 100,
-                content: `# ${state.agentDetails.name}\n\n${instructions}`,
-            }];
+        const { channelId, threadId, channelDetails, agentId, threadDetails } = state;
+        const participants = channelDetails?.participants || [];
+        const isDm = isDmSoloChannel(participants, agentId);
+        let content = '## ENVIRONMENT\n';
+        if (isDm) {
+            content += '- Mode: Direct Message (Solo)\n';
+            content += '- Context: You are in a private conversation. No other agents are present.\n';
+        }
+        else {
+            const channelName = channelDetails?.name || channelId;
+            content += `- Mode: Channel (#${channelName})\n`;
+            if (threadId) {
+                content += `- Thread: ${threadDetails?.name || threadId}\n`;
+            }
+            const peerIds = participants.filter((id) => id !== agentId);
+            if (peerIds.length > 0) {
+                content += `- Participants: ${peerIds.join(', ')}\n`;
+                content += `  (Use these plain ids for todo assignees and delegate_to_agent — no @ prefix.)\n`;
+            }
+        }
+        return [
+            {
+                id: 'environment',
+                type: 'environment',
+                priority: 110,
+                content,
+            },
+        ];
     }
 }
-class ChannelDetailsProvider {
+/**
+ * Injects SPEC.md (`channelDetails.spec`). Kept distinct from EnvironmentProvider
+ * so each block gets its own truncate budget and channel rules survive long
+ * participant lists under {@link ITEM_HARD_CHAR_CAP}.
+ */
+class ChannelSpecProvider {
     constructor() {
-        this.name = 'channel-details';
+        this.name = 'channel-spec';
     }
     async provide(state) {
-        if (!state.channelDetails)
+        const raw = state.channelDetails?.spec;
+        const spec = typeof raw === 'string' ? raw.trim() : '';
+        if (!spec)
             return [];
-        const participants = state.channelDetails.participants;
-        if (!participants?.length)
-            return [];
-        const channelLabel = state.channelDetails.name?.trim() || state.channelDetails.id;
-        const lines = participants.map((id) => `- \`${id}\``).join('\n');
         return [
             {
-                id: 'channel-details',
-                type: 'channel',
-                priority: 80,
-                content: `## Channel participants (${channelLabel})\n` +
-                    `Agent ids collaborating in this channel:\n${lines}`,
+                id: 'channel-spec',
+                type: 'channel-spec',
+                /** Below environment (110), above agent / {@link TokenBudgetProcessor.KEEP_FLOOR}. */
+                priority: 108,
+                content: `## CHANNEL SPECIFICATION (SPEC.md)\n` +
+                    `Channel-level goals and constraints. Prefer these unless the user contradicts them.\n\n` +
+                    `${spec}`,
             },
         ];
     }
 }
-class ThreadDetailsProvider {
+class AgentDetailsProvider {
     constructor() {
-        this.name = 'thread-details';
+        this.name = 'agent-details';
     }
     async provide(state) {
-        if (!state.threadDetails)
+        if (!state.agentDetails)
+            return [];
+        if (state.agentId === ORCHESTRATOR_AGENT_ID)
+            return [];
+        const instructions = state.agentDetails.instructions?.trim();
+        if (!instructions)
             return [];
-        // For now, this provider is a placeholder for future state-based assembly.
-        // It currently only surfaces the thread name to provide basic context.
         return [
             {
-                id: 'thread-details',
-                type: 'thread',
-                priority: 90,
-                content: `# Thread you are in: ${state.threadDetails.name}`,
+                id: 'agent-details',
+                type: 'agent',
+                priority: 100,
+                content: `## AGENT: ${state.agentDetails.name}\n\n${instructions}`,
             },
         ];
     }
@@ -135,6 +182,8 @@ class TodoProvider {
         this.name = 'todos';
     }
     async provide(state) {
+        if (state.agentId !== ORCHESTRATOR_AGENT_ID)
+            return [];
         const raw = state.threadDetails?.state?.todos;
         const todos = Array.isArray(raw) ? raw : [];
         if (todos.length === 0)
@@ -165,9 +214,7 @@ class TodoProvider {
                 id: 'todos',
                 type: 'todos',
                 priority: 92,
-                content: `## Shared todo plan (thread state)\n` +
-                    `Orchestrator authors with \`todo_write\`; assignees run one step at a time. ` +
-                    `When an item is \`done\`, its captured output appears below so every agent can see prior steps without relying on merged chat history.\n\n` +
+                content: `## SHARED TODO PLAN (thread state)\n` +
                     `${formatted}`,
             },
         ];
@@ -204,7 +251,7 @@ class MemoryProvider {
                     id: 'memory',
                     type: 'memory',
                     priority: 95,
-                    content: `## Remembered facts\nTrust these unless the user contradicts them. Use \`forget\` to remove stale ones.\n\n${formatted}`,
+                    content: `## Remembered global facts\nTrust these unless the user contradicts them. Use \`forget\` to remove stale ones.\n\n${formatted}`,
                 },
             ];
         }
@@ -280,20 +327,21 @@ class RecentEventsProvider {
 }
 /**
  * Drops the lowest-priority items until the assembled prompt fits within the
- * token budget. The first item with priority >= `keepFloor` is always kept,
+ * 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) {
+    constructor(budget = undefined, keepFloor = TokenBudgetProcessor.KEEP_FLOOR) {
         this.budget = budget;
         this.keepFloor = keepFloor;
         this.name = 'token-budget';
     }
-    async process(items) {
+    async process(items, state) {
         const sorted = [...items].sort((a, b) => b.priority - a.priority);
         const out = [];
         let used = 0;
+        const activeBudget = this.budget ?? (state.model ? getContextBudgetForModel(state.model) : TokenBudgetProcessor.DEFAULT_BUDGET);
         for (const item of sorted) {
             const cost = estimateTokens(item.content);
             if (item.priority >= this.keepFloor) {
@@ -301,7 +349,7 @@ export class TokenBudgetProcessor {
                 used += cost;
                 continue;
             }
-            if (used + cost <= this.budget) {
+            if (used + cost <= activeBudget) {
                 out.push(item);
                 used += cost;
             }
@@ -310,6 +358,6 @@ export class TokenBudgetProcessor {
     }
 }
 /** Soft prompt budget in tokens (matches gpt-4o-mini's reasonable system slice). */
-TokenBudgetProcessor.DEFAULT_BUDGET = 8000;
+TokenBudgetProcessor.DEFAULT_BUDGET = DEFAULT_CONTEXT_BUDGET;
 /** Items at or above this priority are never dropped. */
 TokenBudgetProcessor.KEEP_FLOOR = 100;

package/dist/harness/dispatch.js

@@ -0,0 +1,144 @@
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../services/storage.js';
+import { ORCHESTRATOR_AGENT_ID } from './constants.js';
+import { runTurn } from './run.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 = (target) => {
+    pruneStopRequests();
+    return stopRequests.find((r) => {
+        if (r.runId !== target.runId)
+            return false;
+        if (r.agentId && r.agentId !== target.agentId)
+            return false;
+        if (r.channelId && r.channelId !== target.channelId)
+            return false;
+        if (r.threadId && r.threadId !== target.threadId)
+            return false;
+        return true;
+    });
+};
+export async function dispatch(options) {
+    const { runId, channelId, onEvent } = options;
+    let { threadId } = options;
+    const { event } = options;
+    ensureEventId(event);
+    if (event.type === 'action:agent_run_stop') {
+        await handleStop(event, options);
+        return;
+    }
+    const agentId = options.agentId || ORCHESTRATOR_AGENT_ID;
+    let turnEvent = event;
+    if (event.type === 'user:input' || event.type === 'agent:invoke') {
+        turnEvent = await normalizeUserInput(event, { runId, channelId, threadId, onEvent });
+        if (event.type === 'user:input') {
+            threadId = turnEvent.meta?.threadId || threadId || event.id;
+        }
+    }
+    const target = { runId, agentId, channelId, threadId };
+    const preStop = findStopRequest(target);
+    if (preStop) {
+        const state = await storageService.getOpenBotState({ ...target, event: turnEvent });
+        await onEvent({ type: 'agent:run:stopped', data: { ...target, reason: preStop.reason } }, state);
+        return;
+    }
+    let state;
+    try {
+        state = await storageService.getOpenBotState({ ...target, event: turnEvent });
+    }
+    catch (error) {
+        if (error.code === 'AGENT_NOT_FOUND') {
+            const fallback = await storageService.getOpenBotState({
+                ...target,
+                agentId: ORCHESTRATOR_AGENT_ID,
+                event: turnEvent,
+            });
+            await onEvent({
+                type: 'agent:output',
+                data: {
+                    content: `⚠️ Agent **${agentId}** does not exist. Use participant ids without an @ prefix.`,
+                },
+                meta: { agentId: ORCHESTRATOR_AGENT_ID, threadId },
+            }, fallback);
+            return;
+        }
+        throw error;
+    }
+    const turn = runTurn({ runId, channelId, threadId, agentId, event: turnEvent });
+    let next = await turn.next();
+    while (!next.done) {
+        const chunk = next.value;
+        const stop = findStopRequest(target);
+        if (stop) {
+            await onEvent({ type: 'agent:run:stopped', data: { ...target, reason: stop.reason } }, state);
+            break;
+        }
+        if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
+            threadId = chunk.data.threadId || threadId;
+        }
+        await onEvent(chunk, state);
+        next = await turn.next();
+    }
+}
+async function normalizeUserInput(event, ctx) {
+    const rawContent = event.data?.content || '';
+    const userFacing = {
+        type: 'agent:invoke',
+        id: event.id,
+        data: { content: rawContent, role: 'user' },
+        meta: {
+            agentId: ORCHESTRATOR_AGENT_ID,
+            userId: event.meta?.userId,
+            userName: event.meta?.userName,
+            userAvatarUrl: event.meta?.userAvatarUrl,
+        },
+    };
+    const initialState = await storageService.getOpenBotState({
+        runId: ctx.runId,
+        agentId: ORCHESTRATOR_AGENT_ID,
+        channelId: ctx.channelId,
+        threadId: ctx.threadId,
+        event: 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 storageService.getOpenBotState({
+        runId,
+        agentId: options.agentId || ORCHESTRATOR_AGENT_ID,
+        channelId,
+        threadId,
+        event: 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/dispatcher.js

@@ -1,8 +1,8 @@
 import { ensureEventId } from '../app/utils.js';
 import { storageService } from '../services/storage.js';
-import { createAgentRuntime } from './runtime-factory.js';
-import { advanceAfterRun } from './todo-advance.js';
-const MAX_CHAIN_DEPTH = 20;
+import { ORCHESTRATOR_AGENT_ID } from './context.js';
+import { resolveMessageTargetAgent } from './channel-participants.js';
+import { runTurn } from './turn.js';
 const stopRequests = [];
 const STOP_REQUEST_TTL_MS = 30 * 60 * 1000;
 const pruneStopRequests = () => {
@@ -27,9 +27,6 @@ const findStopRequest = (target) => {
         return true;
     });
 };
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
 export async function dispatch(options) {
     const { event } = options;
     ensureEventId(event);
@@ -44,188 +41,86 @@ export async function dispatch(options) {
         onEvent: options.onEvent,
     };
     if (event.type === 'user:input' || event.type === 'agent:invoke') {
-        const invoke = await normalizeUserInput(event, ctx);
-        await runStep({ agentId: options.agentId || 'system', event: invoke }, ctx, 0);
+        const { invoke, targetAgentId } = await normalizeUserInput(event, ctx, options.agentId);
+        await executeTurn(targetAgentId, invoke, ctx);
         return;
     }
-    // Bus pass-through: route to the targeted agent's runtime once. No agent step,
-    // no advance, no follow-ups. Keeps queries (`/api/state`) cheap and idempotent.
-    await runBusEvent(event, options.agentId || 'system', ctx);
+    await executeTurn(options.agentId || ORCHESTRATOR_AGENT_ID, event, ctx, { lifecycle: false });
 }
-// ---------------------------------------------------------------------------
-// Agent step: run:start -> runtime -> run:end -> advance -> chain
-// ---------------------------------------------------------------------------
-async function runStep(step, ctx, depth) {
-    if (depth >= MAX_CHAIN_DEPTH) {
-        console.warn(`[dispatcher] Reached MAX_CHAIN_DEPTH (${MAX_CHAIN_DEPTH}); stopping chain.`);
-        return;
-    }
+async function executeTurn(agentId, event, ctx, opts = {}) {
     const target = {
         runId: ctx.runId,
-        agentId: step.agentId,
+        agentId,
         channelId: ctx.channelId,
         threadId: ctx.threadId,
     };
-    const preStop = findStopRequest(target);
+    const preStop = opts.lifecycle !== false ? findStopRequest(target) : undefined;
     if (preStop) {
-        const state = await storageService.getOpenBotState({ ...target, event: step.event });
+        const state = await storageService.getOpenBotState({ ...target, event });
         await ctx.onEvent({ type: 'agent:run:stopped', data: { ...target, reason: preStop.reason } }, state);
         return;
     }
     let state;
     try {
-        state = await storageService.getOpenBotState({ ...target, event: step.event });
+        state = await storageService.getOpenBotState({ ...target, event });
     }
     catch (error) {
         if (error.code === 'AGENT_NOT_FOUND') {
             const fallback = await storageService.getOpenBotState({
                 ...target,
-                agentId: 'system',
-                event: step.event,
+                agentId: ORCHESTRATOR_AGENT_ID,
+                event,
             });
             await ctx.onEvent({
                 type: 'agent:output',
-                data: { content: `⚠️ Agent **${step.agentId}** does not exist. Please check the agent ID and try again.` },
-                meta: { agentId: 'system', threadId: ctx.threadId },
+                data: {
+                    content: `⚠️ Agent **${agentId}** does not exist. Use participant ids without an @ prefix.`,
+                },
+                meta: { agentId: ORCHESTRATOR_AGENT_ID, threadId: ctx.threadId },
             }, fallback);
             return;
         }
         throw error;
     }
-    await ctx.onEvent({ type: 'agent:run:start', data: { ...target } }, state);
-    const followUps = [];
-    const queuedAgentIds = new Set();
-    let lastAgentOutput;
-    try {
-        const runtime = await createAgentRuntime(state);
-        for await (const chunk of runtime.run(step.event, { state, runId: ctx.runId })) {
-            const stop = findStopRequest(target);
-            if (stop) {
-                await ctx.onEvent({ type: 'agent:run:stopped', data: { ...target, reason: stop.reason } }, state);
-                break;
-            }
-            if (chunk.id === step.event.id && chunk.type === step.event.type)
-                continue;
-            if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
-                ctx.threadId = chunk.data.threadId || ctx.threadId;
-            }
-            if (chunk.type === 'agent:output' &&
-                chunk.meta?.agentId === step.agentId) {
-                const content = chunk.data?.content;
-                if (typeof content === 'string' && content.trim())
-                    lastAgentOutput = content.trim();
-            }
-            // Handoff requests are internal: queue a follow-up step instead of forwarding.
-            if (chunk.type === 'handoff:request') {
-                const req = chunk;
-                const targetAgent = req.data?.agentId;
-                if (targetAgent && targetAgent !== step.agentId && !queuedAgentIds.has(targetAgent)) {
-                    queuedAgentIds.add(targetAgent);
-                    followUps.push({
-                        agentId: targetAgent,
-                        event: makeInvoke(req.data.content, ctx.threadId, req.meta),
-                    });
-                }
-                continue;
-            }
-            chunk.meta = { ...chunk.meta, agentId: step.agentId };
-            await ctx.onEvent(chunk, state);
-        }
-    }
-    catch (error) {
-        console.error(`[dispatcher] Agent run failed: ${step.agentId}`, error);
-    }
-    finally {
-        const endState = await storageService.getOpenBotState({ ...target, event: step.event });
-        await ctx.onEvent({ type: 'agent:run:end', data: { ...target } }, endState);
-    }
-    // Autonomous todo advance: single trigger point, runs once per `agent:run:end`.
-    try {
-        const handoff = await advanceAfterRun({
-            storage: storageService,
-            channelId: ctx.channelId,
-            threadId: ctx.threadId,
-            endedAgentId: step.agentId,
-            lastAgentOutput,
-        });
-        if (handoff && !queuedAgentIds.has(handoff.agentId)) {
-            queuedAgentIds.add(handoff.agentId);
-            followUps.push({
-                agentId: handoff.agentId,
-                event: makeInvoke(handoff.content, ctx.threadId),
-            });
-        }
-    }
-    catch (error) {
-        console.warn('[dispatcher] todo advance failed', error);
-    }
-    for (const next of followUps) {
-        await runStep(next, ctx, depth + 1);
-    }
-}
-// ---------------------------------------------------------------------------
-// Bus pass-through: run an event through the targeted agent's runtime, forward
-// chunks. No run:start/end, no advance, no follow-ups.
-// ---------------------------------------------------------------------------
-async function runBusEvent(event, agentId, ctx) {
-    let state;
-    try {
-        state = await storageService.getOpenBotState({
-            runId: ctx.runId,
-            agentId,
-            channelId: ctx.channelId,
-            threadId: ctx.threadId,
-            event,
-        });
-    }
-    catch (error) {
-        if (error.code === 'AGENT_NOT_FOUND') {
-            // Silently drop: bus pass-through has no UI surface to warn into.
-            return;
-        }
-        throw error;
-    }
-    try {
-        const runtime = await createAgentRuntime(state);
-        for await (const chunk of runtime.run(event, { state, runId: ctx.runId })) {
-            if (chunk.id === event.id && chunk.type === event.type)
-                continue;
-            chunk.meta = { ...chunk.meta, agentId };
-            await ctx.onEvent(chunk, state);
-        }
-    }
-    catch (error) {
-        console.error(`[dispatcher] Bus event failed: ${event.type} (${agentId})`, error);
+    const turn = runTurn({
+        ...target,
+        event,
+        lifecycle: opts.lifecycle !== false,
+        shouldStop: () => findStopRequest(target),
+        onThreadId: (threadId) => {
+            ctx.threadId = threadId;
+        },
+    });
+    let next = await turn.next();
+    while (!next.done) {
+        await ctx.onEvent(next.value, state);
+        next = await turn.next();
     }
 }
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-async function normalizeUserInput(event, ctx) {
+async function normalizeUserInput(event, ctx, requestedAgentId) {
     const rawContent = event.data?.content || '';
-    // The user-facing copy stored/streamed for the UI.
+    const previewState = await storageService.getOpenBotState({
+        runId: ctx.runId,
+        agentId: ORCHESTRATOR_AGENT_ID,
+        channelId: ctx.channelId,
+        threadId: ctx.threadId,
+        event,
+    });
+    const participants = previewState.channelDetails?.participants ?? [];
+    const targetAgentId = resolveMessageTargetAgent(participants, ORCHESTRATOR_AGENT_ID, requestedAgentId);
     const userFacing = {
         type: 'agent:invoke',
         id: event.id,
         data: { content: rawContent, role: 'user' },
         meta: {
-            agentId: 'system',
+            agentId: targetAgentId,
             userId: event.meta?.userId,
             userName: event.meta?.userName,
             userAvatarUrl: event.meta?.userAvatarUrl,
         },
     };
-    const initialState = await storageService.getOpenBotState({
-        runId: ctx.runId,
-        agentId: 'system',
-        channelId: ctx.channelId,
-        threadId: ctx.threadId,
-        event: userFacing,
-    });
-    await ctx.onEvent(userFacing, initialState);
-    // The event actually fed to the target agent. Carries the input threadId (or the
-    // message id, used as the anchor for Slack-style new threads).
-    return {
+    await ctx.onEvent(userFacing, previewState);
+    const invoke = {
         ...event,
         type: 'agent:invoke',
         data: { ...(event.data || {}), content: rawContent, role: 'user' },
@@ -234,13 +129,7 @@ async function normalizeUserInput(event, ctx) {
             threadId: ctx.threadId || event.id,
         },
     };
-}
-function makeInvoke(content, threadId, baseMeta) {
-    return ensureEventId({
-        type: 'agent:invoke',
-        data: { role: 'user', content },
-        meta: { ...(baseMeta || {}), threadId },
-    });
+    return { invoke, targetAgentId };
 }
 async function handleStop(stopEvent, options) {
     const { runId, channelId, threadId, onEvent } = options;
@@ -254,7 +143,7 @@ async function handleStop(stopEvent, options) {
     });
     const state = await storageService.getOpenBotState({
         runId,
-        agentId: options.agentId || 'system',
+        agentId: options.agentId || ORCHESTRATOR_AGENT_ID,
         channelId,
         threadId,
         event: stopEvent,