openbot 0.3.3 → 0.3.4

package/src/harness/event-normalizer.ts

@@ -1,82 +0,0 @@
-import { AgentInvokeEvent, OpenBotEvent, OpenBotState } from '../app/types.js';
-import { ensureEventId } from '../app/utils.js';
-import { storageService } from '../services/storage.js';
-
-export interface NormalizedEventResult {
-  finalEvent: OpenBotEvent;
-  finalAgentId: string;
-}
-
-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: OpenBotEvent,
-    options: {
-      runId: string;
-      agentId?: string;
-      channelId: string;
-      threadId?: string;
-      onEvent: (chunk: OpenBotEvent, state: OpenBotState) => Promise<boolean | void>;
-    }
-  ): Promise<NormalizedEventResult> => {
-    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 as any).data?.content || '';
-    if (event.type === 'user:input' || event.type === 'agent:invoke') {
-      const normalizedInvokeEvent: 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,
-        },
-      };
-      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 as any).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/src/harness/orchestrator.ts

@@ -1,104 +0,0 @@
-import { OpenBotEvent, OpenBotState } from '../app/types.js';
-import { storageService } from '../services/storage.js';
-import { createAgentRuntime } from './runtime-factory.js';
-import { EventNormalizer } from './event-normalizer.js';
-import { QueueProcessor } from './queue-processor.js';
-
-export interface ExecuteAgentOptions {
-  runId: string;
-  agentId: string;
-  event: OpenBotEvent;
-  channelId: string;
-  threadId?: string;
-  onEvent: (chunk: OpenBotEvent, state: OpenBotState) => Promise<boolean | void>;
-}
-
-export interface DispatchOptions {
-  runId: string;
-  agentId?: string;
-  event: OpenBotEvent;
-  channelId: string;
-  threadId?: string;
-  onEvent: (chunk: OpenBotEvent, state: OpenBotState) => Promise<boolean | void>;
-}
-
-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: DispatchOptions): Promise<void> => {
-    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.
-   */
-  executeAgent: async (options: ExecuteAgentOptions): Promise<void> => {
-    const { runId, agentId, event, channelId, threadId, onEvent } = options;
-
-    let agentState: OpenBotState;
-    try {
-      agentState = await storageService.getOpenBotState(options);
-    } catch (error) {
-      if ((error as Error & { code?: string }).code === 'AGENT_NOT_FOUND') {
-        const fallbackState = await storageService.getOpenBotState({
-          runId,
-          agentId: 'system',
-          channelId,
-          threadId,
-          event,
-        });
-        const warning = `⚠️ Agent **${agentId}** does not exist. Please check the agent ID and try again.`;
-
-        await onEvent(
-          {
-            type: 'agent:output',
-            data: { content: warning },
-            meta: { agentId: 'system', threadId },
-          },
-          fallbackState,
-        );
-
-        return;
-      }
-      throw error;
-    }
-
-    const agentRuntime = await createAgentRuntime(agentState);
-
-    try {
-      // RUN the agent runtime
-      for await (const chunk of agentRuntime.run(event, { state: agentState, runId })) {
-        chunk.meta = { ...chunk.meta, agentId };
-        await onEvent(chunk, agentState);
-      }
-    } catch (error) {
-      console.error(`[orchestrator] Agent run failed: ${agentId}`, error);
-    }
-  },
-};

package/src/harness/queue-processor.ts

@@ -1,220 +0,0 @@
-import {
-  AgentInvokeEvent,
-  HandoffRequestEvent,
-  OpenBotEvent,
-  OpenBotState,
-} from '../app/types.js';
-import { ensureEventId } from '../app/utils.js';
-import { storageService } from '../services/storage.js';
-import { advanceAfterRun } from './todo-advance.js';
-
-export interface QueueItem {
-  agentId: string;
-  event: OpenBotEvent;
-}
-
-export interface QueueProcessorOptions {
-  runId: string;
-  channelId: string;
-  threadId?: string;
-  onEvent: (chunk: OpenBotEvent, state: OpenBotState) => Promise<boolean | void>;
-  executeAgent: (options: {
-    runId: string;
-    agentId: string;
-    event: OpenBotEvent;
-    channelId: string;
-    threadId?: string;
-    onEvent: (chunk: OpenBotEvent, state: OpenBotState) => Promise<boolean | void>;
-  }) => Promise<void>;
-}
-
-export class QueueProcessor {
-  private currentQueue: QueueItem[] = [];
-  private currentThreadId?: string;
-  private readonly MAX_ITERATIONS = 20;
-
-  constructor(private options: QueueProcessorOptions) {
-    this.currentThreadId = options.threadId;
-  }
-
-  enqueue(item: QueueItem) {
-    this.currentQueue.push(item);
-  }
-
-  async run() {
-    let iterations = 0;
-
-    while (this.currentQueue.length > 0 && iterations < this.MAX_ITERATIONS) {
-      iterations++;
-
-      // Group by agentId to avoid parallel state corruption for the same agent.
-      const groups = new Map<string, QueueItem[]>();
-      for (const item of this.currentQueue) {
-        const list = groups.get(item.agentId) || [];
-        list.push(item);
-        groups.set(item.agentId, list);
-      }
-
-      const nextQueue: QueueItem[] = [];
-
-      // Run each agent group in parallel
-      await Promise.all(
-        Array.from(groups.entries()).map(async ([agentId, items]) => {
-          // Run items for the SAME agent sequentially to preserve event order and state consistency.
-          for (const item of items) {
-            const { event: currentEvent } = item;
-
-            // Track handoff requests queued in this step to avoid accidental duplicates.
-            const queuedRequestKeys = new Set<string>();
-            const queuedItems: QueueItem[] = [];
-            let lastAgentOutput: string | undefined;
-
-            const runOnEvent = async (chunk: OpenBotEvent, state: OpenBotState) => {
-              // 0. Filter out echoed input events to prevent duplication in the UI/storage
-              if (chunk.type === currentEvent.type && chunk.id === currentEvent.id) {
-                return false;
-              }
-
-              if (chunk.type === 'agent:output') {
-                const outMeta = chunk.meta as { agentId?: string } | undefined;
-                if (outMeta?.agentId === agentId) {
-                  const content = chunk.data?.content;
-                  if (typeof content === 'string' && content.trim()) {
-                    lastAgentOutput = content.trim();
-                  }
-                }
-              }
-
-              // 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) {
-                this.currentThreadId = chunk.data.threadId || this.currentThreadId;
-              }
-
-              // 2. Internal routing (handoff requests are internal — not forwarded)
-              if (chunk.type === 'handoff:request') {
-                const request = chunk as HandoffRequestEvent;
-                const targetAgentId = request.data?.agentId;
-                const requestKey = `handoff:${targetAgentId}`;
-
-                if (
-                  targetAgentId &&
-                  targetAgentId !== agentId &&
-                  !queuedRequestKeys.has(requestKey)
-                ) {
-                  queuedRequestKeys.add(requestKey);
-                  const targetEvent = ensureEventId({
-                    type: 'agent:invoke',
-                    data: {
-                      role: 'user',
-                      content: request.data.content,
-                    },
-                    meta: {
-                      ...(request.meta || {}),
-                      threadId: this.currentThreadId,
-                    },
-                  } satisfies AgentInvokeEvent) as AgentInvokeEvent;
-
-                  queuedItems.push({ agentId: targetAgentId, event: targetEvent });
-                }
-                return false;
-              }
-
-              // If we get here, the event is accepted and should be emitted.
-              await this.options.onEvent(chunk, state);
-              return true;
-            };
-
-            const startState = await storageService.getOpenBotState({
-              runId: this.options.runId,
-              agentId,
-              channelId: this.options.channelId,
-              threadId: this.currentThreadId,
-              event: currentEvent,
-            });
-
-            await this.options.onEvent(
-              {
-                type: 'agent:run:start',
-                data: {
-                  runId: this.options.runId,
-                  agentId,
-                  channelId: this.options.channelId,
-                  threadId: this.currentThreadId,
-                },
-              },
-              startState,
-            );
-
-            try {
-              await this.options.executeAgent({
-                runId: this.options.runId,
-                agentId,
-                event: currentEvent,
-                channelId: this.options.channelId,
-                threadId: this.currentThreadId,
-                onEvent: runOnEvent,
-              });
-            } finally {
-              const endState = await storageService.getOpenBotState({
-                runId: this.options.runId,
-                agentId,
-                channelId: this.options.channelId,
-                threadId: this.currentThreadId,
-                event: currentEvent,
-              });
-              await this.options.onEvent(
-                {
-                  type: 'agent:run:end',
-                  data: {
-                    runId: this.options.runId,
-                    agentId,
-                    channelId: this.options.channelId,
-                    threadId: this.currentThreadId,
-                  },
-                },
-                endState,
-              );
-
-              // Autonomous todo advance: mark this agent's in_progress todo done
-              // and dispatch the next assignee, if any. Single trigger point,
-              // no reliance on the LLM remembering to call `todo_update`.
-              try {
-                const handoff = await advanceAfterRun({
-                  storage: storageService,
-                  channelId: this.options.channelId,
-                  threadId: this.currentThreadId,
-                  endedAgentId: agentId,
-                  lastAgentOutput,
-                });
-                if (handoff) {
-                  const requestKey = `handoff:${handoff.agentId}`;
-                  if (!queuedRequestKeys.has(requestKey)) {
-                    queuedRequestKeys.add(requestKey);
-                    const targetEvent = ensureEventId({
-                      type: 'agent:invoke',
-                      data: { role: 'user', content: handoff.content },
-                      meta: { threadId: this.currentThreadId },
-                    } satisfies AgentInvokeEvent) as AgentInvokeEvent;
-                    queuedItems.push({ agentId: handoff.agentId, event: targetEvent });
-                  }
-                }
-              } catch (error) {
-                console.warn('[queue] todo advance failed', error);
-              }
-            }
-
-            nextQueue.push(...queuedItems);
-          }
-        }),
-      );
-
-      this.currentQueue = nextQueue;
-    }
-
-    if (iterations >= this.MAX_ITERATIONS) {
-      console.warn(
-        `[orchestrator] Reached MAX_ITERATIONS (${this.MAX_ITERATIONS}). Stopping execution.`,
-      );
-    }
-  }
-}

package/src/harness/types.ts

@@ -1,34 +0,0 @@
-import { OpenBotEvent, OpenBotState } from '../app/types.js';
-
-/**
- * The Harness is the environment in which an agent operates.
- * it provides the necessary "plumbing" (storage, communication, tools) 
- * so the agent can focus on reasoning.
- */
-export interface Harness {
-  readonly runId: string;
-  readonly channelId: string;
-  readonly threadId?: string;
-  
-  /**
-   * Dispatches an event into the harness.
-   * This is the primary way to interact with the agent.
-   */
-  dispatch(event: OpenBotEvent): Promise<void>;
-
-  /**
-   * Observes events emitted by the harness.
-   */
-  onEvent(callback: (event: OpenBotEvent, state: OpenBotState) => Promise<void>): void;
-}
-
-/**
- * Options for creating a new Agent Harness instance.
- */
-export interface HarnessOptions {
-  runId: string;
-  agentId: string;
-  channelId: string;
-  threadId?: string;
-  onEvent: (event: OpenBotEvent, state: OpenBotState) => Promise<void>;
-}