openbot 0.3.1 → 0.3.3

package/src/harness/queue-processor.ts

@@ -1,22 +1,16 @@
 import {
   AgentInvokeEvent,
-  DelegateResultEvent,
-  DelegationRequestEvent,
   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;
-  delegationContext?: {
-    parentAgentId: string;
-    toolCallId: string;
-    delegationWidgetId?: string;
-  };
 }
 
 export interface QueueProcessorOptions {
@@ -68,12 +62,12 @@ export class QueueProcessor {
         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, delegationContext } = item;
+            const { event: currentEvent } = item;
 
-            // Track delegation/handoff requests queued in this step to avoid accidental duplicates.
+            // Track handoff requests queued in this step to avoid accidental duplicates.
             const queuedRequestKeys = new Set<string>();
             const queuedItems: QueueItem[] = [];
-            const runOutputs: string[] = [];
+            let lastAgentOutput: string | undefined;
 
             const runOnEvent = async (chunk: OpenBotEvent, state: OpenBotState) => {
               // 0. Filter out echoed input events to prevent duplication in the UI/storage
@@ -81,26 +75,27 @@ export class QueueProcessor {
                 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/delegation requests are internal — not forwarded)
-              if (chunk.type === 'handoff:request' || chunk.type === 'delegation:request') {
-                const isHandoff = chunk.type === 'handoff:request';
-                const request = isHandoff
-                  ? (chunk as HandoffRequestEvent)
-                  : (chunk as DelegationRequestEvent);
+              // 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 toolCallId =
-                  typeof request.meta?.toolCallId === 'string'
-                    ? request.meta.toolCallId
-                    : undefined;
-                const requestKey = isHandoff
-                  ? `handoff:${targetAgentId}:${request.data?.content ?? ''}`
-                  : `delegate:${toolCallId ?? 'missing'}:${targetAgentId}:${request.data?.content ?? ''}`;
-                
+                const requestKey = `handoff:${targetAgentId}`;
+
                 if (
                   targetAgentId &&
                   targetAgentId !== agentId &&
@@ -119,62 +114,11 @@ export class QueueProcessor {
                     },
                   } satisfies AgentInvokeEvent) as AgentInvokeEvent;
 
-                  if (isHandoff) {
-                    queuedItems.push({ agentId: targetAgentId, event: targetEvent });
-                  } else {
-                    if (!toolCallId) {
-                      // Emit error output (this triggers run start if not already started)
-                      await runOnEvent(
-                        ensureEventId({
-                          type: 'agent:output',
-                          data: {
-                            content:
-                              'Delegation request ignored: missing toolCallId. Please retry delegation.',
-                          },
-                          meta: {
-                            agentId,
-                            threadId: this.currentThreadId,
-                          },
-                        } as OpenBotEvent),
-                        state,
-                      );
-                      return true;
-                    }
-                    const parentAgentId =
-                      typeof request.meta?.parentAgentId === 'string'
-                        ? request.meta.parentAgentId
-                        : agentId;
-                    const delegationWidgetId =
-                      typeof request.meta?.delegationWidgetId === 'string'
-                        ? request.meta.delegationWidgetId
-                        : undefined;
-                    queuedItems.push({
-                      agentId: targetAgentId,
-                      event: targetEvent,
-                      delegationContext: {
-                        parentAgentId,
-                        toolCallId,
-                        delegationWidgetId,
-                      },
-                    });
-                  }
+                  queuedItems.push({ agentId: targetAgentId, event: targetEvent });
                 }
                 return false;
               }
 
-              if (chunk.type === 'agent:output') {
-                const content = chunk.data?.content;
-                if (typeof content === 'string' && content.trim().length > 0) {
-                  runOutputs.push(content.trim());
-                }
-              }
-
-              // For delegate mode, child agent execution is internal:
-              // capture outputs for parent tool result, but don't stream child events to clients/storage.
-              if (delegationContext) {
-                return false;
-              }
-
               // If we get here, the event is accepted and should be emitted.
               await this.options.onEvent(chunk, state);
               return true;
@@ -191,11 +135,11 @@ export class QueueProcessor {
             await this.options.onEvent(
               {
                 type: 'agent:run:start',
-                data: { 
-                  runId: this.options.runId, 
-                  agentId, 
-                  channelId: this.options.channelId, 
-                  threadId: this.currentThreadId 
+                data: {
+                  runId: this.options.runId,
+                  agentId,
+                  channelId: this.options.channelId,
+                  threadId: this.currentThreadId,
                 },
               },
               startState,
@@ -221,75 +165,42 @@ export class QueueProcessor {
               await this.options.onEvent(
                 {
                   type: 'agent:run:end',
-                  data: { 
-                    runId: this.options.runId, 
-                    agentId, 
-                    channelId: this.options.channelId, 
-                    threadId: this.currentThreadId 
+                  data: {
+                    runId: this.options.runId,
+                    agentId,
+                    channelId: this.options.channelId,
+                    threadId: this.currentThreadId,
                   },
                 },
                 endState,
               );
-            }
 
-            if (delegationContext) {
-              const summary =
-                runOutputs.length > 0
-                  ? runOutputs.join('\n\n').slice(0, 4000)
-                  : `Delegated agent "${agentId}" completed with no textual output.`;
-              
-              const delegateResultEvent: DelegateResultEvent = ensureEventId({
-                type: 'action:delegate:result',
-                data: {
-                  success: true,
-                  agentId,
-                  summary,
-                },
-                meta: {
-                  toolCallId: delegationContext.toolCallId,
-                  agentId: delegationContext.parentAgentId,
+              // 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,
-                },
-              } satisfies DelegateResultEvent) as DelegateResultEvent;
-
-              if (delegationContext.delegationWidgetId) {
-                await this.options.onEvent(
-                  ensureEventId({
-                    type: 'client:ui:widget',
-                    data: {
-                      kind: 'message',
-                      widgetId: delegationContext.delegationWidgetId,
-                      title: `Delegation complete: ${agentId}`,
-                      body:
-                        runOutputs.length > 0
-                          ? 'Delegated task finished. Parent agent is preparing final response.'
-                          : 'Delegated task finished with no textual output. Parent agent will continue.',
-                      state: 'submitted',
-                      metadata: {
-                        type: 'delegation:status',
-                        phase: 'completed',
-                        delegatedAgentId: agentId,
-                      },
-                    },
-                    meta: {
-                      agentId: delegationContext.parentAgentId,
-                      threadId: this.currentThreadId,
-                    },
-                  } as OpenBotEvent),
-                  await storageService.getOpenBotState({
-                    runId: this.options.runId,
-                    agentId: delegationContext.parentAgentId,
-                    channelId: this.options.channelId,
-                    threadId: this.currentThreadId,
-                    event: delegateResultEvent,
-                  }),
-                );
+                  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({
-                agentId: delegationContext.parentAgentId,
-                event: delegateResultEvent,
-              });
             }
 
             nextQueue.push(...queuedItems);

package/src/harness/runtime-factory.ts

@@ -7,8 +7,8 @@ import { busServicesPlugin } from '../bus/services.js';
 
 /**
  * Enhances the agent's instructions with a list of other available agents the
- * orchestrator can hand off / delegate to. Agents that include the
- * `delegation` plugin will surface peers; agents without it can ignore this.
+ * orchestrator can hand off to. Agents that include the `delegation` plugin
+ * will surface peers; agents without it can ignore this.
  */
 export async function enhanceInstructions(state: OpenBotState) {
   const { agentId, agentDetails } = state;
@@ -23,12 +23,16 @@ export async function enhanceInstructions(state: OpenBotState) {
       .map((a) => `- **${a.id}**${a.description ? `: ${a.description}` : ''}`)
       .join('\n');
 
-    const header = '### Available Agents for Handoff/Delegation:';
+    const header = '### Available Agents:';
     if (!agentDetails.instructions.includes(header)) {
-      agentDetails.instructions +=
-        `\n\n${header}\n${agentsList}\n\n` +
-        'Use `handoff` to transfer control to another agent. ' +
-        'Use `delegate` when you need a sub-result from another agent and want to continue after it returns.';
+      const hasHandoff = (agentDetails.pluginRefs || []).some((r) => r.id === 'delegation');
+      const hasTodo = (agentDetails.pluginRefs || []).some((r) => r.id === 'todo');
+      const usage = hasTodo
+        ? 'Use these ids as `assignee` when calling `todo_write` to plan multi-agent work.'
+        : hasHandoff
+          ? 'Use `handoff` to transfer control to another agent in this thread.'
+          : '';
+      agentDetails.instructions += `\n\n${header}\n${agentsList}${usage ? `\n\n${usage}` : ''}`;
     }
   } catch (error) {
     console.warn('[agent] Failed to enhance instructions', error);

package/src/harness/todo-advance.ts

@@ -0,0 +1,128 @@
+import { TodoItem, TodoStatus } from '../app/types.js';
+import type { Storage } from '../bus/types.js';
+
+/** Stored on each todo and inlined into the next assignee's invoke payload. */
+const RESULT_MAX_CHARS = 12000;
+
+/**
+ * Shared helpers that drive the autonomous todo loop. The queue processor
+ * calls `advanceAfterRun` once per `agent:run:end`; that is the only place
+ * todos are completed and dispatched, which keeps the autonomous flow
+ * single-threaded and easy to reason about.
+ */
+
+export const readTodosFromState = (state: unknown): TodoItem[] => {
+  const raw = (state as Record<string, unknown> | undefined)?.todos;
+  return Array.isArray(raw) ? (raw as TodoItem[]) : [];
+};
+
+export function truncateTodoResult(text: string, maxChars = RESULT_MAX_CHARS): string | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.length <= maxChars) return trimmed;
+  return `${trimmed.slice(0, maxChars)}\n…[truncated]`;
+}
+
+export interface AdvanceResult {
+  /** Updated todo list (after marking finished + flipping next to in_progress). */
+  todos: TodoItem[];
+  /** Next agent to invoke, if any. */
+  handoff: { agentId: string; content: string; todoId: string } | null;
+}
+
+/**
+ * Apply a single advance step:
+ *  1. If a todo is `in_progress` and `assignee` matches the agent whose run
+ *     just ended, mark it `done` and attach `result` from `lastOutput` when present.
+ *  2. Pick the next `pending` todo with an `assignee` and flip it to
+ *     `in_progress`. That assignee gets handed off to; `invoke content` includes
+ *     the previous step output when available so agents without short-term
+ *     history still see prior work.
+ *
+ * If a todo is already `in_progress` and the just-ended agent wasn't its
+ * assignee, leave it alone — someone else is working.
+ */
+export function advanceTodos(
+  todos: TodoItem[],
+  endedAgentId: string,
+  lastOutput?: string,
+): AdvanceResult {
+  const now = Date.now();
+  const truncated = truncateTodoResult(lastOutput ?? '');
+
+  let completedOutput: string | undefined;
+
+  let working = todos.map((t) => {
+    if (t.status === 'in_progress' && t.assignee === endedAgentId) {
+      completedOutput = truncated;
+      return {
+        ...t,
+        status: 'done' as TodoStatus,
+        updatedAt: now,
+        ...(truncated !== undefined ? { result: truncated } : {}),
+      };
+    }
+    return t;
+  });
+
+  if (working.some((t) => t.status === 'in_progress')) {
+    return { todos: working, handoff: null };
+  }
+
+  const idx = working.findIndex((t) => t.status === 'pending' && t.assignee);
+  if (idx === -1) return { todos: working, handoff: null };
+
+  const picked = working[idx];
+  working = working.map((t, i) =>
+    i === idx ? { ...t, status: 'in_progress' as TodoStatus, updatedAt: now } : t,
+  );
+
+  const invokeContent =
+    completedOutput !== undefined && completedOutput !== ''
+      ? `${picked.content}\n\n--- Output from previous step ---\n${completedOutput}`
+      : picked.content;
+
+  return {
+    todos: working,
+    handoff: {
+      agentId: picked.assignee!,
+      content: invokeContent,
+      todoId: picked.id,
+    },
+  };
+}
+
+export async function advanceAfterRun(options: {
+  storage: Storage;
+  channelId: string;
+  threadId?: string;
+  endedAgentId: string;
+  lastAgentOutput?: string;
+}): Promise<AdvanceResult['handoff']> {
+  const { storage, channelId, threadId, endedAgentId, lastAgentOutput } = options;
+  if (!threadId) return null;
+
+  const details = await storage.getThreadDetails({ channelId, threadId });
+  const todos = readTodosFromState(details?.state);
+  if (todos.length === 0) return null;
+
+  const { todos: nextList, handoff } = advanceTodos(todos, endedAgentId, lastAgentOutput);
+
+  const changed =
+    nextList.length !== todos.length ||
+    nextList.some((t, i) => {
+      const u = todos[i];
+      if (!u) return true;
+      return (
+        t.status !== u.status ||
+        t.updatedAt !== u.updatedAt ||
+        t.result !== u.result ||
+        t.assignee !== u.assignee ||
+        t.content !== u.content
+      );
+    });
+  if (changed) {
+    await storage.patchThreadState({ channelId, threadId, state: { todos: nextList } });
+  }
+  return handoff;
+}

package/src/plugins/ai-sdk/index.ts

@@ -1,6 +1,5 @@
 import type { Plugin } from '../../bus/plugin.js';
 import { aiSdkRuntime } from './runtime.js';
-import { AI_SDK_SYSTEM_PROMPT } from './system-prompt.js';
 
 /**
  * `ai-sdk` — generic LLM runtime plugin built on the Vercel AI SDK.
@@ -14,7 +13,6 @@ export const aiSdkPlugin: Plugin = {
   name: 'AI SDK Runtime',
   description:
     'Generic LLM runtime built on the Vercel AI SDK. Consumes tools contributed by other plugins.',
-  defaultInstructions: AI_SDK_SYSTEM_PROMPT,
   configSchema: {
     type: 'object',
     properties: {
@@ -34,7 +32,6 @@ export const aiSdkPlugin: Plugin = {
 
     return aiSdkRuntime({
       model,
-      system: agentDetails.instructions || AI_SDK_SYSTEM_PROMPT,
       storage,
       toolDefinitions: tools,
     });