openbot 0.3.6 → 0.4.0

package/src/app/types.ts

@@ -6,9 +6,9 @@ import {
   PluginDescriptor,
   Thread,
   ThreadDetails,
-} from '../bus/types.js';
-import type { PluginRef } from '../bus/plugin.js';
-import type { MemoryRecord } from '../services/memory.js';
+} from '../services/plugins/domain.js';
+import type { PluginRef } from '../services/plugins/types.js';
+import type { MemoryRecord } from '../plugins/memory/service.js';
 
 export interface OpenBotState {
   agentId: string;
@@ -19,15 +19,10 @@ export interface OpenBotState {
   channelDetails?: ChannelDetails;
   threadDetails?: ThreadDetails;
   triggerEvent?: OpenBotEvent;
-  shortTermMessages?: ShortTermMessage[];
+  /** Active model string (e.g. `openai/gpt-4o-mini`). */
+  model?: string;
 }
 
-export type ShortTermMessage =
-  | { role: 'system'; content: string }
-  | { role: 'user'; content: string }
-  | { role: 'assistant'; content: string; toolCalls?: any[] }
-  | { role: 'tool'; content: string; toolCallId: string; toolName: string };
-
 export type BaseEvent = {
   id?: string;
   type: string;
@@ -144,6 +139,7 @@ export type CreateAgentEvent = BaseEvent & {
     name: string;
     description?: string;
     image?: string;
+    hidden?: boolean;
     instructions: string;
     plugins: PluginRef[];
   };
@@ -164,6 +160,7 @@ export type UpdateAgentEvent = BaseEvent & {
     name?: string;
     description?: string;
     image?: string;
+    hidden?: boolean;
     instructions?: string;
     plugins?: PluginRef[];
   };
@@ -509,12 +506,26 @@ export type UIWidgetListItem = {
   metadata?: Record<string, unknown>;
 };
 
+export type UIMediaItem = {
+  type: 'image' | 'video' | 'audio' | 'file';
+  url: string;
+  title?: string;
+  alt?: string;
+  thumbnailUrl?: string;
+  metadata?: Record<string, unknown>;
+};
+
 export type UIWidgetBase = {
   widgetId: string;
   title?: string;
   description?: string;
-  body?: string;
+  /** Optional hero media for the widget */
+  media?: UIMediaItem;
+  /** Optional actions for the widget */
+  actions?: UIWidgetAction[];
   state?: 'open' | 'submitted' | 'cancelled' | 'error';
+  display?: 'expanded' | 'collapsed';
+  size?: 'small' | 'medium' | 'large' | 'full';
   metadata?: Record<string, unknown>;
 };
 
@@ -543,19 +554,6 @@ export type UIListWidget = UIWidgetBase & {
 
 export type UIWidgetSpec = UIMessageWidget | UIChoiceWidget | UIFormWidget | UIListWidget;
 
-export type RenderUIWidgetData =
-  | (Omit<UIMessageWidget, 'widgetId'> & { widgetId?: string })
-  | (Omit<UIChoiceWidget, 'widgetId'> & { widgetId?: string })
-  | (Omit<UIFormWidget, 'widgetId'> & { widgetId?: string })
-  | (Omit<UIListWidget, 'widgetId'> & { widgetId?: string })
-  | {
-      kind: 'approval' | 'todo_list';
-      widgetId?: string;
-      title?: string;
-      props?: Record<string, unknown>;
-      metadata?: Record<string, unknown>;
-    };
-
 export type UIWidgetEvent = BaseEvent & {
   type: 'client:ui:widget';
   data: UIWidgetSpec;
@@ -565,11 +563,6 @@ export type UIWidgetEvent = BaseEvent & {
   };
 };
 
-export type RenderUIWidgetEvent = BaseEvent & {
-  type: 'action:render_ui_widget';
-  data: RenderUIWidgetData;
-};
-
 export type UIWidgetResponseEvent = BaseEvent & {
   type: 'client:ui:widget:response';
   data: {
@@ -580,80 +573,6 @@ export type UIWidgetResponseEvent = BaseEvent & {
   };
 };
 
-export type HandoffEvent = BaseEvent & {
-  type: 'action:handoff';
-  data: {
-    agentId: string;
-    content: string;
-  };
-  meta?: {
-    toolCallId?: string;
-    [key: string]: any;
-  };
-};
-
-export type HandoffResultEvent = BaseEvent & {
-  type: 'action:handoff:result';
-  data: {
-    success: boolean;
-    agentId: string;
-    accepted: boolean;
-  };
-  meta: {
-    toolCallId: string;
-    agentId: string;
-    threadId?: string;
-    [key: string]: any;
-  };
-};
-
-/** Internal routing: handoff plugin → orchestrator only (not stored or broadcast). */
-export type HandoffRequestEvent = BaseEvent & {
-  type: 'handoff:request';
-  data: {
-    agentId: string;
-    content: string;
-  };
-  meta?: Record<string, unknown>;
-};
-
-export type MCPListToolsEvent = BaseEvent & {
-  type: 'action:mcp_list_tools';
-  data: {
-    serverId: string;
-  };
-};
-
-export type MCPListToolsResultEvent = BaseEvent & {
-  type: 'action:mcp_list_tools:result';
-  data: {
-    success: boolean;
-    serverId: string;
-    tools: Array<{ name: string; description?: string; inputSchema?: unknown }>;
-    error?: string;
-  };
-};
-
-export type MCPCallEvent = BaseEvent & {
-  type: 'action:mcp_call';
-  data: {
-    serverId: string;
-    toolName: string;
-    args?: Record<string, unknown>;
-  };
-};
-
-export type MCPCallResultEvent = BaseEvent & {
-  type: 'action:mcp_call:result';
-  data: {
-    success: boolean;
-    serverId: string;
-    toolName: string;
-    result?: unknown;
-    error?: string;
-  };
-};
-
 export type ShellExecEvent = BaseEvent & {
   type: 'action:shell_exec';
   data: {
@@ -683,18 +602,6 @@ export type ShellExecResultEvent = BaseEvent & {
   };
 };
 
-export type UserInputEvent = BaseEvent & {
-  type: 'user:input';
-  data: {
-    content: string;
-  };
-  meta?: {
-    userId?: string;
-    userName?: string;
-    userAvatarUrl?: string;
-  };
-};
-
 export type InstallPluginEvent = BaseEvent & {
   type: 'action:plugin:install';
   data: {
@@ -770,6 +677,25 @@ export type InstallAgentResultEvent = BaseEvent & {
 
 export type MemoryScopeAlias = 'global' | 'agent' | 'channel';
 
+export interface Usage {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+}
+
+export type AgentUsageEvent = BaseEvent & {
+  type: 'agent:usage';
+  data: {
+    usage: Usage;
+    model?: string;
+  };
+  meta: {
+    agentId: string;
+    threadId?: string;
+    runId?: string;
+  };
+};
+
 export type RememberEvent = BaseEvent & {
   type: 'action:remember';
   data: {
@@ -821,83 +747,41 @@ export type ForgetResultEvent = BaseEvent & {
   };
 };
 
-export type TodoStatus = 'pending' | 'in_progress' | 'done' | 'cancelled';
-
-/**
- * A single unit of work tracked in thread state. Todos are owned by the
- * system (bus services); agents can only mutate them by calling the
- * `todo_write` / `todo_update` tools so every change is observable on the
- * event stream and audit-friendly.
- */
-export interface TodoItem {
-  id: string;
-  content: string;
-  status: TodoStatus;
-  /** Optional agent id responsible for this item — drives autonomous handoffs. */
-  assignee?: string;
-  /** Agent id that created the todo (or "system"). */
-  createdBy: string;
-  createdAt: number;
-  updatedAt: number;
-  /**
-   * Captured final reply when this item reaches `done` (last `agent:output`
-   * from the assignee for that run). Lets downstream agents rely on thread
-   * state instead of merged short-term messages.
-   */
-  result?: string;
-}
-
-export type TodoWriteInput = {
-  id?: string;
-  content: string;
-  status?: TodoStatus;
-  assignee?: string;
-};
-
-export type TodoWriteEvent = BaseEvent & {
-  type: 'action:todo_write';
+export type DelegateTaskEvent = BaseEvent & {
+  type: 'action:delegate_task';
   data: {
-    todos: TodoWriteInput[];
+    agentId: string;
+    prompt: string;
   };
-  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
 };
 
-export type TodoWriteResultEvent = BaseEvent & {
-  type: 'action:todo_write:result';
+export type DelegateTaskResultEvent = BaseEvent & {
+  type: 'action:delegate_task:result';
   data: {
     success: boolean;
-    todos: TodoItem[];
+    output?: string;
     error?: string;
   };
-  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
 };
 
-export type TodoUpdateEvent = BaseEvent & {
-  type: 'action:todo_update';
-  data: {
-    id: string;
-    status?: TodoStatus;
-    content?: string;
-    assignee?: string;
-  };
-  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
-};
+/**
+ * Internal message representation to decouple harness history from specific AI SDKs.
+ */
+export type OpenBotMessage =
+  | { role: 'user'; content: string | OpenBotMessagePart[] }
+  | { role: 'assistant'; content: string | OpenBotMessagePart[] }
+  | { role: 'system'; content: string }
+  | { role: 'tool'; content: OpenBotMessagePart[] };
 
-export type TodoUpdateResultEvent = BaseEvent & {
-  type: 'action:todo_update:result';
-  data: {
-    success: boolean;
-    todo?: TodoItem;
-    todos: TodoItem[];
-    error?: string;
-  };
-  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
-};
+export type OpenBotMessagePart =
+  | { type: 'text'; text: string }
+  | { type: 'tool-call'; toolCallId: string; toolName: string; input: any }
+  | { type: 'tool-result'; toolCallId: string; toolName: string; output: any };
 
 export type OpenBotEvent =
-  | UserInputEvent
   | AgentInvokeEvent
   | AgentOutputEvent
+  | AgentUsageEvent
   | AgentRunStartEvent
   | AgentRunEndEvent
   | AgentRunStoppedEvent
@@ -952,15 +836,7 @@ export type OpenBotEvent =
   | UpdateChannelEvent
   | UpdateChannelResultEvent
   | UIWidgetEvent
-  | RenderUIWidgetEvent
   | UIWidgetResponseEvent
-  | HandoffEvent
-  | HandoffResultEvent
-  | HandoffRequestEvent
-  | MCPListToolsEvent
-  | MCPListToolsResultEvent
-  | MCPCallEvent
-  | MCPCallResultEvent
   | ShellExecEvent
   | ShellExecResultEvent
   | InstallPluginEvent
@@ -977,7 +853,5 @@ export type OpenBotEvent =
   | RecallResultEvent
   | ForgetEvent
   | ForgetResultEvent
-  | TodoWriteEvent
-  | TodoWriteResultEvent
-  | TodoUpdateEvent
-  | TodoUpdateResultEvent;
+  | DelegateTaskEvent
+  | DelegateTaskResultEvent;

package/src/harness/index.ts

@@ -0,0 +1,145 @@
+import { melony } from 'melony';
+import { OpenBotEvent, OpenBotState } from '../app/types.js';
+import { ensureEventId } from '../app/utils.js';
+import { storageService } from '../plugins/storage/service.js';
+import { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../app/agent-ids.js';
+import { resolvePlugin } from '../services/plugins/registry.js';
+import { ToolDefinition } from '../services/plugins/types.js';
+
+export { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID };
+
+export interface RunAgentOptions {
+  runId: string;
+  agentId: string;
+  event: OpenBotEvent;
+  channelId: string;
+  threadId?: string;
+  persistEvents?: boolean;
+  onEvent: (event: OpenBotEvent, state?: OpenBotState) => Promise<void>;
+}
+
+async function emitEvent(
+  chunk: OpenBotEvent,
+  state: OpenBotState | undefined,
+  {
+    persistEvents,
+    channelId,
+    threadId,
+    onEvent,
+    parentAgentId,
+    parentToolCallId,
+  }: {
+    persistEvents: boolean;
+    channelId: string;
+    threadId?: string;
+    onEvent: RunAgentOptions['onEvent'];
+    parentAgentId?: string;
+    parentToolCallId?: string;
+  },
+): Promise<void> {
+  ensureEventId(chunk);
+
+  // Enrich event with parent metadata if not already present
+  if (parentAgentId || parentToolCallId) {
+    chunk.meta = {
+      ...chunk.meta,
+      parentAgentId: chunk.meta?.parentAgentId || parentAgentId,
+      parentToolCallId: chunk.meta?.parentToolCallId || parentToolCallId,
+    };
+  }
+
+  if (persistEvents) {
+    await storageService.storeEvent({
+      channelId: state?.channelId || channelId,
+      threadId: state?.threadId || threadId,
+      event: chunk,
+    });
+  }
+
+  await onEvent(chunk, state);
+}
+
+/**
+ * Runs a single agent turn.
+ * Fire and forget.
+ */
+export async function runAgent(options: RunAgentOptions): Promise<void> {
+  const { runId, agentId, event, channelId, threadId, onEvent } = options;
+  const persistEvents = options.persistEvents !== false;
+
+  const parentAgentId = event.meta?.parentAgentId;
+  const parentToolCallId = event.meta?.parentToolCallId;
+
+  const agentDetails = await storageService.getAgentDetails({ agentId });
+
+  const state = await storageService.getOpenBotState({
+    runId,
+    agentId,
+    channelId,
+    threadId,
+    event,
+  });
+
+  await emitEvent(
+    {
+      type: 'agent:run:start',
+      data: { runId, agentId, channelId, threadId },
+    } as OpenBotEvent,
+    state,
+    { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId },
+  );
+
+  try {
+    const pluginRefs = agentDetails.pluginRefs ?? [];
+    const tools: Record<string, ToolDefinition> = {};
+
+    for (const ref of pluginRefs) {
+      const plugin = await resolvePlugin(ref.id);
+      if (plugin?.toolDefinitions) {
+        Object.assign(tools, plugin.toolDefinitions);
+      }
+    }
+
+    const builder = melony<OpenBotState, OpenBotEvent>().initialState(state);
+
+    for (const ref of pluginRefs) {
+      const plugin = await resolvePlugin(ref.id);
+      if (!plugin) continue;
+
+      builder.use(
+        plugin.factory({
+          agentId,
+          agentDetails,
+          config: ref.config ?? {},
+          storage: storageService,
+          tools,
+        }),
+      );
+    }
+
+    const runtime = builder.build();
+    const generator = runtime.run(event, { runId, state });
+
+    for await (const outputEvent of generator) {
+      await emitEvent(outputEvent, state, {
+        persistEvents,
+        channelId,
+        threadId,
+        onEvent,
+        parentAgentId,
+        parentToolCallId,
+      });
+    }
+  } catch (error) {
+    console.error(`[harness] Error running agent ${agentId}:`, error);
+  } finally {
+    await emitEvent(
+      {
+        type: 'agent:run:end',
+        data: { runId, agentId, channelId, threadId },
+      } as OpenBotEvent,
+      state,
+      { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId },
+    );
+  }
+}