openbot 0.3.6 → 0.4.2

package/dist/harness/agent-invoke-run.js

@@ -0,0 +1,44 @@
+import { createAgentRuntime } from './runtime-factory.js';
+/**
+ * Shared `runtime.run(agent:invoke)` loop: tags chunks with `agentId`, skips echo of the
+ * trigger event, optionally polls for stop, tracks last `agent:output` text.
+ *
+ * Does not emit `agent:run:start` / `agent:run:end` — callers bracket those.
+ */
+export async function* streamTaggedAgentInvokeRuntime(options) {
+    const { target, event, state, pollInterrupt } = options;
+    const { runId, agentId } = target;
+    let lastAgentOutput;
+    const runtime = await createAgentRuntime(state);
+    for await (const chunk of runtime.run(event, { state, runId })) {
+        const interrupt = pollInterrupt?.();
+        if (interrupt) {
+            yield interrupt;
+            break;
+        }
+        if (chunk.id === event.id && chunk.type === event.type)
+            continue;
+        if (chunk.type === 'agent:output' &&
+            chunk.meta?.agentId === agentId) {
+            const content = chunk.data?.content;
+            if (typeof content === 'string' && content.trim()) {
+                lastAgentOutput = content.trim();
+            }
+        }
+        chunk.meta = { ...chunk.meta, agentId };
+        yield chunk;
+    }
+    return { lastAgentOutput };
+}
+/**
+ * Drive {@link streamTaggedAgentInvokeRuntime} with a callback per chunk (dispatcher path).
+ */
+export async function consumeAgentInvokeStream(options, onChunk) {
+    const gen = streamTaggedAgentInvokeRuntime(options);
+    let step = await gen.next();
+    while (!step.done) {
+        await onChunk(step.value);
+        step = await gen.next();
+    }
+    return step.value;
+}

package/dist/harness/agent-turn.js

@@ -0,0 +1,99 @@
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../services/storage.js';
+import { createAgentRuntime } from './runtime-factory.js';
+const TODO_RESULT_MAX_CHARS = 12000;
+const readThreadState = (state) => state.threadDetails?.state ?? {};
+const readTodos = (state) => {
+    const raw = readThreadState(state).todos;
+    return Array.isArray(raw) ? raw : [];
+};
+function truncateTodoResult(text, maxChars = TODO_RESULT_MAX_CHARS) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, maxChars)}\n…[truncated]`;
+}
+function resolveTodoIdForWorker(todos, workerId, delegationTodoId) {
+    if (delegationTodoId && todos.some((t) => t.id === delegationTodoId)) {
+        return delegationTodoId;
+    }
+    const inProgress = todos.find((t) => t.status === 'in_progress' && t.assignee === workerId);
+    if (inProgress)
+        return inProgress.id;
+    const assigned = todos.find((t) => (t.status === 'pending' || t.status === 'in_progress') && t.assignee === workerId);
+    return assigned?.id;
+}
+export async function recordWorkerTodoResult(state, workerId, output, delegationTodoId) {
+    if (!state.threadId)
+        return;
+    const result = truncateTodoResult(output ?? '');
+    if (!result)
+        return;
+    const todos = readTodos(state);
+    if (todos.length === 0)
+        return;
+    const todoId = resolveTodoIdForWorker(todos, workerId, delegationTodoId);
+    if (!todoId)
+        return;
+    const prior = todos.find((t) => t.id === todoId);
+    if (prior?.result === result)
+        return;
+    const now = Date.now();
+    const next = todos.map((t) => (t.id === todoId ? { ...t, result, updatedAt: now } : t));
+    await storageService.patchThreadState({
+        channelId: state.channelId,
+        threadId: state.threadId,
+        state: { todos: next },
+    });
+}
+export function makeInternalInvoke(content, threadId) {
+    return ensureEventId({
+        type: 'agent:invoke',
+        data: { role: 'user', content },
+        meta: { threadId, internal: true },
+    });
+}
+/**
+ * Run one agent turn (no dispatcher chaining). Yields all runtime events for
+ * persistence/streaming; returns the last non-empty `agent:output` text.
+ */
+export async function* runAgentTurn(options) {
+    const { runId, channelId, threadId, agentId, event, delegationTodoId } = 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;
+    }
+    yield { type: 'agent:run:start', data: { ...target } };
+    let lastAgentOutput;
+    try {
+        const runtime = await createAgentRuntime(state);
+        for await (const chunk of runtime.run(event, { state, runId })) {
+            if (chunk.id === event.id && chunk.type === event.type)
+                continue;
+            if (chunk.type === 'agent:output' &&
+                chunk.meta?.agentId === agentId) {
+                const content = chunk.data?.content;
+                if (typeof content === 'string' && content.trim()) {
+                    lastAgentOutput = content.trim();
+                }
+            }
+            chunk.meta = { ...chunk.meta, agentId };
+            yield chunk;
+        }
+    }
+    finally {
+        const stateAfterRun = await storageService.getOpenBotState({ ...target, event });
+        yield { type: 'agent:run:end', data: { ...target } };
+        await recordWorkerTodoResult(stateAfterRun, agentId, lastAgentOutput, delegationTodoId);
+    }
+    return lastAgentOutput;
+}

package/dist/harness/channel-participants.js

@@ -0,0 +1,40 @@
+/**
+ * Channel `participants` (from `state.json`) scope which agents may collaborate
+ * in that channel. Used for system-prompt hints and dispatch guards.
+ */
+/** Multi-participant channel: user messages always route to the orchestrator. */
+export function isMultiAgentChannel(participants) {
+    return participants.length > 1;
+}
+/** Solo DM: exactly one participant and it is the acting agent (no peer bots). */
+export function isDmSoloChannel(participants, actingAgentId) {
+    return participants.length === 1 && participants[0] === actingAgentId;
+}
+/**
+ * Resolve which agent handles an incoming user message.
+ * Multi-participant channels always route to the orchestrator (hub-and-spoke).
+ */
+export function resolveMessageTargetAgent(participants, orchestratorAgentId, requestedAgentId) {
+    if (isMultiAgentChannel(participants)) {
+        return orchestratorAgentId;
+    }
+    if (participants.length === 1) {
+        return requestedAgentId || participants[0];
+    }
+    return requestedAgentId || orchestratorAgentId;
+}
+/**
+ * When `participants` is non-empty, todo dispatch targets must appear
+ * in that list. Solo DM forbids targeting any agent other than yourself (for
+ * chained steps); there are no peer bots.
+ */
+export function isParticipantDispatchAllowed(participants, actingAgentId, targetAgentId) {
+    if (participants.length === 0)
+        return true;
+    if (!participants.includes(targetAgentId))
+        return false;
+    if (isDmSoloChannel(participants, actingAgentId) && targetAgentId !== actingAgentId) {
+        return false;
+    }
+    return true;
+}

package/dist/harness/constants.js

@@ -0,0 +1,2 @@
+/** Built-in orchestrator agent id (`~/.openbot/agents/system/AGENT.md` overrides instructions). */
+export const ORCHESTRATOR_AGENT_ID = 'system';

package/dist/harness/context-meter.js

@@ -0,0 +1,97 @@
+import { OPENBOT_SYSTEM_PROMPT } from '../plugins/openbot/system-prompt.js';
+import { ORCHESTRATOR_AGENT_ID, estimateTokens, } from './context.js';
+import { reconstructHistory } from './history.js';
+/** Reserved headroom for model output when computing fill percentage. */
+export const CONTEXT_METER_OUTPUT_RESERVE = 4096;
+const DEFAULT_CONTEXT_LIMIT = 128000;
+const MODEL_CONTEXT_LIMITS = {
+    'gpt-4o': 128000,
+    'gpt-4o-mini': 128000,
+    'gpt-4-turbo': 128000,
+    'gpt-4': 128000,
+    'gpt-3.5-turbo': 16385,
+    'claude-3-5-sonnet-20240620': 200000,
+    'claude-3-5-sonnet-20241022': 200000,
+    'claude-3-opus-20240229': 200000,
+    'claude-3-haiku-20240307': 200000,
+};
+export function getModelContextLimit(modelString) {
+    const modelId = modelString.split('/').slice(1).join('/');
+    if (MODEL_CONTEXT_LIMITS[modelId])
+        return MODEL_CONTEXT_LIMITS[modelId];
+    if (modelId.includes('claude'))
+        return 200000;
+    return DEFAULT_CONTEXT_LIMIT;
+}
+function buildInstructions(state) {
+    if (state.agentId === ORCHESTRATOR_AGENT_ID) {
+        return state.agentDetails?.instructions?.trim() || OPENBOT_SYSTEM_PROMPT;
+    }
+    return OPENBOT_SYSTEM_PROMPT;
+}
+function estimateMessagesTokens(messages) {
+    if (messages.length === 0)
+        return 0;
+    return estimateTokens(JSON.stringify(messages));
+}
+function estimateToolsTokens(tools) {
+    const names = Object.keys(tools);
+    if (names.length === 0)
+        return 0;
+    return estimateTokens(JSON.stringify(tools));
+}
+function applyTrigger(messages, trigger) {
+    const triggerContent = trigger?.data?.content?.trim();
+    if (!triggerContent || !trigger)
+        return messages;
+    const role = (trigger.data?.role || 'user');
+    const last = messages[messages.length - 1];
+    const alreadyLast = last &&
+        last.role === role &&
+        typeof last.content === 'string' &&
+        last.content.trim() === triggerContent;
+    if (alreadyLast)
+        return messages;
+    return [...messages, { role, content: triggerContent }];
+}
+function computePercent(used, limit) {
+    const budget = Math.max(limit - CONTEXT_METER_OUTPUT_RESERVE, 1);
+    return Math.min(100, Math.round((used / budget) * 100));
+}
+export async function computeContextMeter(options) {
+    const { state, storage, modelString, contextEngine, toolDefinitions = {}, trigger, lastUsage, } = options;
+    const limit = getModelContextLimit(modelString);
+    const instructions = buildInstructions(state);
+    const contextBlock = await contextEngine.buildContext(state, storage);
+    const systemTokens = estimateTokens([instructions, contextBlock].filter(Boolean).join('\n\n'));
+    const events = await storage.getEvents({
+        channelId: state.channelId,
+        threadId: state.threadId,
+    });
+    const messages = applyTrigger(reconstructHistory(events), trigger);
+    const historyTokens = estimateMessagesTokens(messages);
+    const toolsTokens = estimateToolsTokens(toolDefinitions);
+    let used = systemTokens + historyTokens + toolsTokens;
+    let estimated = true;
+    if (lastUsage?.input && lastUsage.input > 0) {
+        used = lastUsage.input;
+        estimated = false;
+    }
+    return {
+        model: modelString,
+        limit,
+        used,
+        percent: computePercent(used, limit),
+        estimated,
+        breakdown: {
+            system: systemTokens,
+            history: historyTokens,
+            tools: toolsTokens,
+        },
+        messageCount: messages.length,
+        ...(lastUsage ? { lastUsage } : {}),
+    };
+}
+export function contextMeterEvent(snapshot, meta) {
+    return { type: 'client:ui:context-meter', data: snapshot, meta };
+}

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