openbot 0.3.2 → 0.3.4

package/src/app/server.ts

@@ -12,10 +12,12 @@ import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
 import { ActiveRunsSnapshotEvent, OpenBotEvent, OpenBotState } from './types.js';
 import { processService } from '../harness/process.js';
 import { storageService } from '../services/storage.js';
-import { AgentHarness } from '../harness/agent-harness.js';
+import { dispatch } from '../harness/dispatcher.js';
 import { initPlugins } from '../registry/plugins.js';
 import { ensureEventId, openBotEventFromQuery } from './utils.js';
 
+type Bucket = { channelId: string; threadId?: string; activeCount: number; agentIds: Set<string> };
+
 export interface ServerOptions {
   port?: number;
 }
@@ -94,25 +96,38 @@ export async function startServer(options: ServerOptions = {}) {
   };
 
   const buildActiveRunsSnapshot = (): ActiveRunsSnapshotEvent => {
-    const byChannel = new Map<string, { activeCount: number; agentIds: Set<string> }>();
+    const byBucket = new Map<string, Bucket>();
     for (const run of activeRuns.values()) {
-      const existing = byChannel.get(run.channelId) ?? {
-        activeCount: 0,
-        agentIds: new Set<string>(),
-      };
-      existing.activeCount += 1;
-      existing.agentIds.add(run.agentId);
-      byChannel.set(run.channelId, existing);
+      const threadId = run.threadId || undefined;
+      const key = JSON.stringify([run.channelId, threadId ?? null]);
+      let bucket = byBucket.get(key);
+      if (!bucket) {
+        bucket = { channelId: run.channelId, threadId, activeCount: 0, agentIds: new Set<string>() };
+        byBucket.set(key, bucket);
+      }
+      bucket.activeCount += 1;
+      bucket.agentIds.add(run.agentId);
     }
+    const channels = Array.from(byBucket.values())
+      .sort((a, b) => {
+        const c = a.channelId.localeCompare(b.channelId);
+        if (c !== 0) return c;
+        return (a.threadId ?? '').localeCompare(b.threadId ?? '');
+      })
+      .map(({ channelId, threadId, activeCount, agentIds }) => {
+        const row: ActiveRunsSnapshotEvent['data']['channels'][number] = {
+          channelId,
+          activeCount,
+          agentIds: Array.from(agentIds),
+        };
+        if (threadId !== undefined) {
+          row.threadId = threadId;
+        }
+        return row;
+      });
     return {
       type: 'agent:active-runs:snapshot',
-      data: {
-        channels: Array.from(byChannel.entries()).map(([channelId, value]) => ({
-          channelId,
-          activeCount: value.activeCount,
-          agentIds: Array.from(value.agentIds),
-        })),
-      },
+      data: { channels },
     };
   };
 
@@ -149,6 +164,7 @@ export async function startServer(options: ServerOptions = {}) {
 
     if (channelId === GLOBAL_CHANNEL_ID) {
       const snapshot = buildActiveRunsSnapshot();
+
       ensureEventId(snapshot);
       res.write(`data: ${JSON.stringify(snapshot)}\n\n`);
     }
@@ -206,10 +222,10 @@ export async function startServer(options: ServerOptions = {}) {
         activeRuns.set(
           getRunKey(chunk.data.runId, chunk.data.agentId, chunk.data.channelId, chunk.data.threadId),
           {
-          runId: chunk.data.runId,
-          channelId: chunk.data.channelId,
-          threadId: chunk.data.threadId,
-          agentId: chunk.data.agentId,
+            runId: chunk.data.runId,
+            channelId: chunk.data.channelId,
+            threadId: chunk.data.threadId,
+            agentId: chunk.data.agentId,
           },
         );
       } else if (chunk.type === 'agent:run:end') {
@@ -226,21 +242,26 @@ export async function startServer(options: ServerOptions = {}) {
 
       sendToClientKey(targetClientKey, chunk);
 
-      if (chunk.type === 'agent:run:start' || chunk.type === 'agent:run:end') {
+      if (
+        chunk.type === 'agent:run:start' ||
+        chunk.type === 'agent:run:end' ||
+        chunk.type === 'agent:run:stopped'
+      ) {
         sendToClientKey(GLOBAL_CHANNEL_ID, chunk);
       }
     };
 
     try {
-      const harness = new AgentHarness({
+      ensureEventId(event);
+
+      await dispatch({
         runId,
         agentId: agentId || 'system',
+        event,
         channelId,
         threadId,
         onEvent,
       });
-
-      await harness.dispatch(event);
       res.sendStatus(200);
     } catch (error) {
       console.error('[publish] Failed to dispatch event', {
@@ -272,15 +293,16 @@ export async function startServer(options: ServerOptions = {}) {
     };
 
     try {
-      const harness = new AgentHarness({
+      ensureEventId(event);
+
+      await dispatch({
         runId,
         agentId: agentId || 'system',
+        event,
         channelId,
         threadId,
         onEvent,
       });
-
-      await harness.dispatch(event);
       res.json({ events });
     } catch (error) {
       res.status(500).json({ error: 'Failed to process state request' });

package/src/app/types.ts

@@ -365,17 +365,48 @@ export type AgentRunEndEvent = BaseEvent & {
   };
 };
 
+export type AgentRunStoppedEvent = BaseEvent & {
+  type: 'agent:run:stopped';
+  data: {
+    runId: string;
+    agentId: string;
+    channelId: string;
+    threadId?: string;
+    reason?: string;
+  };
+};
+
 export type ActiveRunsSnapshotEvent = BaseEvent & {
   type: 'agent:active-runs:snapshot';
   data: {
     channels: Array<{
       channelId: string;
+      threadId?: string;
       activeCount: number;
       agentIds: string[];
     }>;
   };
 };
 
+export type StopAgentRunEvent = BaseEvent & {
+  type: 'action:agent_run_stop';
+  data: {
+    runId: string;
+    agentId?: string;
+    channelId?: string;
+    threadId?: string;
+    reason?: string;
+  };
+};
+
+export type StopAgentRunResultEvent = BaseEvent & {
+  type: 'action:agent_run_stop:result';
+  data: {
+    success: boolean;
+    message?: string;
+  };
+};
+
 export type CreateThreadEvent = BaseEvent & {
   type: 'action:create_thread';
   data: {
@@ -860,7 +891,10 @@ export type OpenBotEvent =
   | AgentOutputEvent
   | AgentRunStartEvent
   | AgentRunEndEvent
+  | AgentRunStoppedEvent
   | ActiveRunsSnapshotEvent
+  | StopAgentRunEvent
+  | StopAgentRunResultEvent
   | GetChannelsEvent
   | GetChannelsResultEvent
   | GetThreadsEvent

package/src/harness/dispatcher.ts

@@ -0,0 +1,379 @@
+import {
+  AgentInvokeEvent,
+  HandoffRequestEvent,
+  OpenBotEvent,
+  OpenBotState,
+  StopAgentRunEvent,
+} from '../app/types.js';
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../services/storage.js';
+import { createAgentRuntime } from './runtime-factory.js';
+import { advanceAfterRun } from './todo-advance.js';
+
+/**
+ * Single entry point for every event arriving at the bus.
+ *
+ * Three flavors of dispatch:
+ *
+ *   1. `action:agent_run_stop` — record a stop signal, ack, done.
+ *   2. `user:input` / `agent:invoke` — *agent step*: normalize, emit user-facing
+ *      copy, then run the target agent with `run:start`/`run:end` bracketing,
+ *      handoff routing, and a single `advanceAfterRun` pass that can chain the
+ *      next assignee. Recursive, depth-bounded.
+ *   3. Everything else — *bus pass-through*: run the event through the targeted
+ *      agent's runtime once and forward emitted chunks. No `run:start`/`run:end`,
+ *      no todo advance, no handoff. This is what backs `/api/state` queries and
+ *      out-of-band action events posted to `/api/publish`.
+ */
+
+export interface DispatchOptions {
+  runId: string;
+  agentId?: string;
+  event: OpenBotEvent;
+  channelId: string;
+  threadId?: string;
+  onEvent: (chunk: OpenBotEvent, state: OpenBotState) => Promise<boolean | void>;
+}
+
+interface StepContext {
+  runId: string;
+  channelId: string;
+  /** Mutable: a `create_thread:result` mid-chain rebinds the rest of the chain. */
+  threadId?: string;
+  onEvent: DispatchOptions['onEvent'];
+}
+
+interface FollowUp {
+  agentId: string;
+  event: AgentInvokeEvent;
+}
+
+const MAX_CHAIN_DEPTH = 20;
+
+// ---------------------------------------------------------------------------
+// Stop requests
+// ---------------------------------------------------------------------------
+
+type StopRequest = {
+  runId: string;
+  agentId?: string;
+  channelId?: string;
+  threadId?: string;
+  reason?: string;
+  requestedAt: number;
+};
+
+const stopRequests: StopRequest[] = [];
+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: {
+  runId: string;
+  agentId: string;
+  channelId: string;
+  threadId?: string;
+}): StopRequest | undefined => {
+  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;
+  });
+};
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export async function dispatch(options: DispatchOptions): Promise<void> {
+  const { event } = options;
+  ensureEventId(event);
+
+  if (event.type === 'action:agent_run_stop') {
+    await handleStop(event as StopAgentRunEvent, options);
+    return;
+  }
+
+  const ctx: StepContext = {
+    runId: options.runId,
+    channelId: options.channelId,
+    threadId: options.threadId,
+    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);
+    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);
+}
+
+// ---------------------------------------------------------------------------
+// Agent step: run:start -> runtime -> run:end -> advance -> chain
+// ---------------------------------------------------------------------------
+
+async function runStep(step: FollowUp, ctx: StepContext, depth: number): Promise<void> {
+  if (depth >= MAX_CHAIN_DEPTH) {
+    console.warn(`[dispatcher] Reached MAX_CHAIN_DEPTH (${MAX_CHAIN_DEPTH}); stopping chain.`);
+    return;
+  }
+
+  const target = {
+    runId: ctx.runId,
+    agentId: step.agentId,
+    channelId: ctx.channelId,
+    threadId: ctx.threadId,
+  };
+
+  const preStop = findStopRequest(target);
+  if (preStop) {
+    const state = await storageService.getOpenBotState({ ...target, event: step.event });
+    await ctx.onEvent(
+      { type: 'agent:run:stopped', data: { ...target, reason: preStop.reason } },
+      state,
+    );
+    return;
+  }
+
+  let state: OpenBotState;
+  try {
+    state = await storageService.getOpenBotState({ ...target, event: step.event });
+  } catch (error) {
+    if ((error as Error & { code?: string }).code === 'AGENT_NOT_FOUND') {
+      const fallback = await storageService.getOpenBotState({
+        ...target,
+        agentId: 'system',
+        event: step.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 },
+        },
+        fallback,
+      );
+      return;
+    }
+    throw error;
+  }
+
+  await ctx.onEvent({ type: 'agent:run:start', data: { ...target } }, state);
+
+  const followUps: FollowUp[] = [];
+  const queuedAgentIds = new Set<string>();
+  let lastAgentOutput: string | undefined;
+
+  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 as { agentId?: string } | undefined)?.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 as HandoffRequestEvent;
+        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: OpenBotEvent,
+  agentId: string,
+  ctx: StepContext,
+): Promise<void> {
+  let state: OpenBotState;
+  try {
+    state = await storageService.getOpenBotState({
+      runId: ctx.runId,
+      agentId,
+      channelId: ctx.channelId,
+      threadId: ctx.threadId,
+      event,
+    });
+  } catch (error) {
+    if ((error as Error & { code?: string }).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);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+async function normalizeUserInput(
+  event: OpenBotEvent,
+  ctx: StepContext,
+): Promise<AgentInvokeEvent> {
+  const rawContent = (event as { data?: { content?: string } }).data?.content || '';
+
+  // The user-facing copy stored/streamed for the UI.
+  const userFacing: AgentInvokeEvent = {
+    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,
+    },
+  };
+
+  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 {
+    ...(event as AgentInvokeEvent),
+    type: 'agent:invoke',
+    data: { ...((event as AgentInvokeEvent).data || {}), content: rawContent, role: 'user' },
+    meta: {
+      ...(event.meta || {}),
+      threadId: ctx.threadId || event.id,
+    },
+  };
+}
+
+function makeInvoke(
+  content: string,
+  threadId?: string,
+  baseMeta?: Record<string, unknown>,
+): AgentInvokeEvent {
+  return ensureEventId({
+    type: 'agent:invoke',
+    data: { role: 'user', content },
+    meta: { ...(baseMeta || {}), threadId },
+  } satisfies AgentInvokeEvent) as AgentInvokeEvent;
+}
+
+async function handleStop(stopEvent: StopAgentRunEvent, options: DispatchOptions): Promise<void> {
+  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 || 'system',
+    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/src/services/storage.ts

@@ -440,7 +440,7 @@ export const storageService = {
     await fs.writeFile(
       specPath,
       spec?.trim() ||
-        `# ${normalizedChannelId}\n\nDefine the goals and rules for this channel here.\n`,
+      `# ${normalizedChannelId}\n\nDefine the goals and rules for this channel here.\n`,
     );
     await fs.writeFile(statePath, JSON.stringify(finalState, null, 2));
   },

package/src/harness/agent-harness.ts

@@ -1,58 +0,0 @@
-import { Runtime } from 'melony';
-import { OpenBotEvent, OpenBotState } from '../app/types.js';
-import { Harness, HarnessOptions } from './types.js';
-import { orchestratorService } from './orchestrator.js';
-import { ensureEventId } from '../app/utils.js';
-
-/**
- * Standard implementation of the Agent Harness.
- * It wraps the orchestrator logic into a clean, stateful container.
- */
-export class AgentHarness implements Harness {
-  public readonly runId: string;
-  public readonly agentId: string;
-  public readonly channelId: string;
-  public threadId?: string;
-  private eventCallbacks: ((event: OpenBotEvent, state: OpenBotState) => Promise<void>)[] = [];
-
-  constructor(options: HarnessOptions) {
-    this.runId = options.runId;
-    this.agentId = options.agentId;
-    this.channelId = options.channelId;
-    this.threadId = options.threadId;
-    if (options.onEvent) {
-      this.eventCallbacks.push(options.onEvent);
-    }
-  }
-
-  /**
-   * Dispatches an event to the agent within this harness.
-   */
-  async dispatch(event: OpenBotEvent): Promise<void> {
-    ensureEventId(event);
-
-    await orchestratorService.dispatch({
-      runId: this.runId,
-      agentId: this.agentId,
-      event,
-      channelId: this.channelId,
-      threadId: this.threadId,
-      onEvent: async (chunk, state) => {
-        // Update internal thread state if it changes (e.g. thread creation)
-        if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
-          this.threadId = chunk.data.threadId || this.threadId;
-        }
-
-        // Notify all observers
-        await Promise.all(this.eventCallbacks.map(cb => cb(chunk, state)));
-      }
-    });
-  }
-
-  /**
-   * Adds an event listener to the harness.
-   */
-  onEvent(callback: (event: OpenBotEvent, state: OpenBotState) => Promise<void>): void {
-    this.eventCallbacks.push(callback);
-  }
-}