openbot 0.3.5 → 0.4.0

package/src/harness/todo-advance.ts

@@ -1,128 +0,0 @@
-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,41 +0,0 @@
-import type { Plugin } from '../../bus/plugin.js';
-import { aiSdkRuntime } from './runtime.js';
-
-/**
- * `ai-sdk` — generic LLM runtime plugin built on the Vercel AI SDK.
- *
- * Owns `agent:invoke` and consumes the merged `tools` map provided by the
- * agent loader (collected from every tool plugin attached to the same agent).
- * Pair with tool plugins like `shell`, `mcp`, `delegation`, etc.
- */
-export const aiSdkPlugin: Plugin = {
-  id: 'ai-sdk',
-  name: 'AI SDK Runtime',
-  description:
-    'Generic LLM runtime built on the Vercel AI SDK. Consumes tools contributed by other plugins.',
-  configSchema: {
-    type: 'object',
-    properties: {
-      model: {
-        type: 'string',
-        description:
-          'Provider model string, e.g. openai/gpt-4o-mini, anthropic/claude-3-5-sonnet-20240620',
-        default: 'openai/gpt-4o-mini',
-      },
-    },
-  },
-  factory: ({ agentDetails, config, storage, tools }) => {
-    const model =
-      typeof config.model === 'string' && config.model
-        ? config.model
-        : 'openai/gpt-4o-mini';
-
-    return aiSdkRuntime({
-      model,
-      storage,
-      toolDefinitions: tools,
-    });
-  },
-};
-
-export default aiSdkPlugin;

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

@@ -1,468 +0,0 @@
-import { MelonyPlugin, RuntimeContext } from 'melony';
-import { generateText, type LanguageModel, type ModelMessage } from 'ai';
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { OpenBotEvent, OpenBotState, ShortTermMessage } from '../../app/types.js';
-import { Storage } from '../../bus/types.js';
-import type { ToolDefinition } from '../../bus/plugin.js';
-import { createDefaultContextEngine } from '../../harness/context.js';
-import { saveConfig } from '../../app/config.js';
-
-export interface AiSdkRuntimeOptions {
-  /** Provider model string (e.g. `openai/gpt-4o-mini`, `anthropic/claude-3-5-sonnet-20240620`). */
-  model?: string;
-  storage?: Storage;
-  contextEngine?: {
-    buildContext: (state: OpenBotState, storage?: Storage) => Promise<string>;
-  };
-  /** Tool definitions merged from all tool plugins attached to this agent. */
-  toolDefinitions?: Record<string, ToolDefinition>;
-}
-
-function resolveModel(modelString: string): LanguageModel {
-  const [provider, ...rest] = modelString.split('/');
-  const modelId = rest.join('/');
-  if (!modelId) {
-    throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
-  }
-  switch (provider) {
-    case 'openai':
-      return openai(modelId);
-    case 'anthropic':
-      return anthropic(modelId);
-    default:
-      throw new Error(`Unsupported AI provider: "${provider}"`);
-  }
-}
-
-const asRecord = (value: unknown): Record<string, unknown> =>
-  value && typeof value === 'object' && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : {};
-
-/** Per-message hard cap (in characters) on tool-result payloads we feed back
- *  to the model. Prevents one huge tool output from eating the context window;
- *  the original event remains intact in storage. */
-const TOOL_RESULT_MAX_CHARS = 8000;
-
-/** Sliding window: max number of messages we replay to the model on each
- *  invocation. Older turns stay on disk but are not sent. Keeps both the
- *  recent prompts and the prompt token budget bounded. */
-const MAX_WINDOW_MESSAGES = 80;
-
-const truncateToolPayload = (raw: unknown): string => {
-  const serialized = typeof raw === 'string' ? raw : JSON.stringify(raw);
-  if (serialized.length <= TOOL_RESULT_MAX_CHARS) return serialized;
-  const dropped = serialized.length - TOOL_RESULT_MAX_CHARS;
-  return `${serialized.slice(0, TOOL_RESULT_MAX_CHARS)}\n…[truncated ${dropped} chars]`;
-};
-
-/**
- * Trim the message history to a sliding window while preserving tool-call
- * integrity. Drops any leading orphan `tool` messages whose matching
- * assistant call was sliced off, since most providers reject that.
- */
-const buildMessageWindow = (messages: ShortTermMessage[]): ShortTermMessage[] => {
-  if (messages.length <= MAX_WINDOW_MESSAGES) return messages;
-  const tail = messages.slice(-MAX_WINDOW_MESSAGES);
-  const knownAssistantCallIds = new Set<string>();
-  for (const m of tail) {
-    if (m.role === 'assistant' && m.toolCalls) {
-      for (const tc of m.toolCalls) knownAssistantCallIds.add(tc.id);
-    }
-  }
-  return tail.filter((m) => m.role !== 'tool' || knownAssistantCallIds.has(m.toolCallId));
-};
-
-/**
- * Self-healing pass: every assistant tool_call must have a matching tool
- * result before the next user/assistant turn, or providers (OpenAI in
- * particular) reject the request with "Tool result is missing for tool call".
- *
- * This can happen when a handler emits a `:result` event without `meta`
- * (orphaning the call), the process restarts mid-run, or a tool handler
- * crashes. Rather than refuse to continue, we inject synthetic tool messages
- * with a clear error payload — the LLM can then explain the failure to the
- * user and proceed.
- */
-const repairOpenToolCalls = (messages: ShortTermMessage[]): ShortTermMessage[] => {
-  const fulfilled = new Set<string>();
-  for (const m of messages) {
-    if (m.role === 'tool') fulfilled.add(m.toolCallId);
-  }
-
-  const repaired: ShortTermMessage[] = [];
-  for (const m of messages) {
-    repaired.push(m);
-    if (m.role !== 'assistant' || !m.toolCalls) continue;
-    for (const tc of m.toolCalls) {
-      if (fulfilled.has(tc.id)) continue;
-      repaired.push({
-        role: 'tool',
-        toolCallId: tc.id,
-        toolName: tc.function.name,
-        content: JSON.stringify({
-          success: false,
-          error: 'Tool result was lost (handler did not emit a matching :result event).',
-        }),
-      });
-      fulfilled.add(tc.id);
-    }
-  }
-  return repaired;
-};
-
-const readPersistedShortTermMessages = (state: OpenBotState): ShortTermMessage[] => {
-  const source = state.threadDetails?.state ?? state.channelDetails?.state;
-  const record = asRecord(source);
-  const raw = record.shortTermMessages;
-  return Array.isArray(raw) ? (raw as ShortTermMessage[]) : [];
-};
-
-const persistShortTermMessages = async (
-  state: OpenBotState,
-  storage: Storage | undefined,
-): Promise<void> => {
-  if (!storage) return;
-  const shortTermMessages = state.shortTermMessages ?? [];
-  if (state.threadId) {
-    await storage.patchThreadState({
-      channelId: state.channelId,
-      threadId: state.threadId,
-      state: { shortTermMessages },
-    });
-    return;
-  }
-  await storage.patchChannelState({
-    channelId: state.channelId,
-    state: { shortTermMessages },
-  });
-};
-
-async function buildSystemPrompt(
-  state: OpenBotState,
-  storage: Storage | undefined,
-  contextEngine: {
-    buildContext: (state: OpenBotState, storage?: Storage) => Promise<string>;
-  },
-): Promise<string> {
-  return contextEngine.buildContext(state, storage);
-}
-
-/**
- * Generic ai-sdk runtime plugin.
- *
- * Owns `agent:invoke`, runs the LLM, emits tool-call events, and stitches tool
- * results back into the conversation. Tools are supplied externally by the
- * loader (merged from every tool plugin attached to the same agent).
- */
-export const aiSdkRuntime =
-  (options: AiSdkRuntimeOptions): MelonyPlugin<OpenBotState, OpenBotEvent> =>
-    (builder) => {
-      const {
-        model: modelString = 'openai/gpt-4o-mini',
-        storage,
-        contextEngine = createDefaultContextEngine(),
-        toolDefinitions = {},
-      } = options;
-
-      let currentModelString = modelString;
-      let model = resolveModel(currentModelString);
-
-      const ensureShortTermMessages = (state: OpenBotState) => {
-        if (!state.shortTermMessages || state.shortTermMessages.length === 0) {
-          state.shortTermMessages = readPersistedShortTermMessages(state);
-        }
-      };
-
-      const mapToCoreMessages = (messages: ShortTermMessage[]): ModelMessage[] => {
-        return messages.map((m): ModelMessage => {
-          if (m.role === 'assistant' && m.toolCalls) {
-            return {
-              role: 'assistant',
-              content: [
-                { type: 'text', text: m.content || '' },
-                ...m.toolCalls.map((tc) => ({
-                  type: 'tool-call' as const,
-                  toolCallId: tc.id,
-                  toolName: tc.function.name,
-                  input: JSON.parse(tc.function.arguments),
-                })),
-              ],
-            };
-          }
-          if (m.role === 'assistant') {
-            return { role: 'assistant', content: m.content || '' };
-          }
-          if (m.role === 'tool') {
-            return {
-              role: 'tool',
-              content: [
-                {
-                  type: 'tool-result',
-                  toolCallId: m.toolCallId,
-                  toolName: m.toolName,
-                  output: { type: 'text', value: JSON.stringify(m.content) },
-                },
-              ],
-            };
-          }
-          return m;
-        });
-      };
-
-      const runLLM = async function* (
-        context: RuntimeContext<OpenBotState, OpenBotEvent>,
-        threadId?: string,
-      ): AsyncGenerator<OpenBotEvent> {
-        ensureShortTermMessages(context.state);
-        const systemPrompt = await buildSystemPrompt(context.state, storage, contextEngine);
-
-        const coreMessages = mapToCoreMessages(
-          buildMessageWindow(repairOpenToolCalls(context.state.shortTermMessages || [])),
-        );
-
-        try {
-          const result = await generateText({
-            model,
-            system: systemPrompt,
-            messages: coreMessages,
-            tools: toolDefinitions as Record<string, { description: string; inputSchema: any }>,
-          });
-
-          const toolCalls = result.toolCalls ?? [];
-
-          if (toolCalls.length > 0) {
-            context.state.shortTermMessages = [
-              ...(context.state.shortTermMessages ?? []),
-              {
-                role: 'assistant',
-                content: result.text || '',
-                toolCalls: toolCalls.map((tc) => ({
-                  id: tc.toolCallId,
-                  type: 'function',
-                  function: {
-                    name: tc.toolName,
-                    arguments: JSON.stringify(tc.input),
-                  },
-                })),
-              },
-            ];
-            await persistShortTermMessages(context.state, storage);
-
-            for (const toolCall of toolCalls) {
-              yield {
-                type: `action:${toolCall.toolName}` as OpenBotEvent['type'],
-                data: toolCall.input,
-                meta: {
-                  toolCallId: toolCall.toolCallId,
-                  agentId: context.state.agentId,
-                  threadId,
-                },
-              } as unknown as OpenBotEvent;
-            }
-          }
-
-          if (result.text) {
-            if (toolCalls.length === 0) {
-              context.state.shortTermMessages = [
-                ...(context.state.shortTermMessages ?? []),
-                { role: 'assistant', content: result.text },
-              ];
-              await persistShortTermMessages(context.state, storage);
-            }
-
-            yield {
-              type: 'agent:output',
-              data: { content: result.text },
-              meta: { agentId: context.state.agentId, threadId },
-            };
-          }
-        } catch (error: unknown) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          const isApiKeyError =
-            errorMessage.includes('API key') ||
-            errorMessage.includes('401') ||
-            errorMessage.includes('Unauthorized') ||
-            errorMessage.includes('authentication');
-
-          if (isApiKeyError) {
-            const [currentProvider, ...rest] = currentModelString.split('/');
-            const currentModelId = rest.join('/');
-            yield {
-              type: 'client:ui:widget',
-              data: {
-                kind: 'form',
-                widgetId: `api_key_request_${Date.now()}`,
-                title: `AI Provider API Key Required`,
-                description: `The AI provider returned an authentication error. Select your provider, model, and provide a valid API key to continue. The key never leaves your local runtime.`,
-                fields: [
-                  {
-                    id: 'provider',
-                    label: 'Provider',
-                    type: 'select',
-                    required: true,
-                    options: [
-                      { label: 'OpenAI', value: 'openai' },
-                      { label: 'Anthropic', value: 'anthropic' },
-                    ],
-                    defaultValue: currentProvider === 'anthropic' ? 'anthropic' : 'openai',
-                  },
-                  {
-                    id: 'model',
-                    label: 'Model',
-                    type: 'text',
-                    description:
-                      'Model name without the provider prefix (e.g. `gpt-4o-mini` or `claude-3-5-sonnet-20240620`).',
-                    placeholder: 'gpt-4o-mini',
-                    required: true,
-                    defaultValue: currentModelId,
-                  },
-                  {
-                    id: 'apiKey',
-                    label: 'API Key',
-                    type: 'text',
-                    placeholder: `sk-...`,
-                    required: true,
-                  },
-                ],
-                submitLabel: 'Save & Continue',
-                metadata: {
-                  type: 'api_key_request',
-                },
-              },
-              meta: { agentId: context.state.agentId, threadId },
-            } as OpenBotEvent;
-            return;
-          }
-
-          throw error;
-        }
-      };
-
-      builder.on('agent:invoke', async function* (event, context) {
-        const routedTo = (event as { data?: { agentId?: string } }).data?.agentId;
-        if (typeof routedTo === 'string' && routedTo && routedTo !== context.state.agentId) {
-          return;
-        }
-
-        const threadId = event.meta?.threadId || context.state.threadId;
-
-        ensureShortTermMessages(context.state);
-        context.state.shortTermMessages = [
-          ...(context.state.shortTermMessages ?? []),
-          {
-            role: event.data?.role || 'user',
-            content: event?.data?.content || '',
-          },
-        ];
-        await persistShortTermMessages(context.state, storage);
-
-        yield* runLLM(context, threadId);
-      });
-
-      builder.on('*', async function* (event, context) {
-        if (!event.type.endsWith(':result')) return;
-        if (event.meta?.agentId !== context.state.agentId) return;
-        const toolCallId = event.meta?.toolCallId;
-        if (!toolCallId) return;
-        ensureShortTermMessages(context.state);
-
-        const toolName = event.type.replace(/^action:/, '').replace(/:result$/, '');
-        const resultData = (event as { data?: unknown }).data;
-        const content = truncateToolPayload(resultData);
-
-        context.state.shortTermMessages = [
-          ...(context.state.shortTermMessages ?? []),
-          { role: 'tool', content, toolCallId, toolName },
-        ];
-        await persistShortTermMessages(context.state, storage);
-
-        const lastAssistant = [...(context.state.shortTermMessages ?? [])]
-          .reverse()
-          .find(
-            (m): m is Extract<ShortTermMessage, { role: 'assistant' }> =>
-              m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length > 0,
-          );
-
-        if (lastAssistant && lastAssistant.toolCalls) {
-          const allFulfilled = lastAssistant.toolCalls.every((tc) =>
-            context.state.shortTermMessages?.some(
-              (m) => m.role === 'tool' && m.toolCallId === tc.id,
-            ),
-          );
-
-          if (allFulfilled) {
-            if (toolName === 'handoff') return;
-            const threadId = event.meta?.threadId || context.state.threadId;
-            yield* runLLM(context, threadId);
-          }
-        }
-      });
-
-      builder.on('client:ui:widget:response', async function* (event, context) {
-        const { metadata, values } = event.data;
-        if (metadata?.type !== 'api_key_request') return;
-        if (!values?.apiKey || !values?.provider || !values?.model) return;
-
-        const provider = String(values.provider);
-        const modelId = String(values.model).trim();
-        const apiKey = String(values.apiKey);
-
-        if (provider !== 'openai' && provider !== 'anthropic') {
-          yield {
-            type: 'agent:output',
-            data: { content: `Unsupported provider: ${provider}` },
-            meta: { agentId: context.state.agentId },
-          };
-          return;
-        }
-
-        const envVar = provider === 'openai' ? 'OPENAI_API_KEY' : 'ANTHROPIC_API_KEY';
-        const newModelString = `${provider}/${modelId}`;
-
-        if (!storage) return;
-        try {
-          await storage.createVariable({ key: envVar, value: apiKey, secret: true });
-          process.env[envVar] = apiKey;
-
-          currentModelString = newModelString;
-          model = resolveModel(currentModelString);
-          try {
-            saveConfig({ model: currentModelString });
-          } catch {
-            // best-effort: config persistence failure shouldn't block the conversation
-          }
-
-          yield {
-            type: 'agent:output',
-            data: {
-              content: `Saved ${provider} API key and set model to \`${newModelString}\`.`,
-            },
-            meta: { agentId: context.state.agentId },
-          };
-
-          yield {
-            type: 'client:ui:widget',
-            data: {
-              widgetId: event.data.widgetId,
-              kind: 'message',
-              title: 'API Key Saved',
-              body: `Successfully saved ${provider} API key and selected model \`${newModelString}\`. You can now continue your conversation.`,
-              state: 'submitted',
-              actions: [{ id: 'ok', label: 'Got it', variant: 'primary' }],
-            },
-            meta: { agentId: context.state.agentId },
-          };
-        } catch (error) {
-          yield {
-            type: 'agent:output',
-            data: {
-              content: `Failed to save API key: ${error instanceof Error ? error.message : 'Unknown error'
-                }`,
-            },
-            meta: { agentId: context.state.agentId },
-          };
-        }
-      });
-    };

package/src/plugins/ai-sdk/system-prompt.ts

@@ -1,18 +0,0 @@
-export const AI_SDK_SYSTEM_PROMPT = [
-  'You are a helpful AI assistant on the OpenBot platform.',
-  'Use the tools available to you to help the user.',
-  'Be concise unless the user asks for depth.',
-  '',
-  '## Planning with todos',
-  'The current thread has a shared todo list (visible under "Shared todo plan" in context).',
-  'It is the single source of truth for multi-step work and is shared across every agent in the thread.',
-  '',
-  'When planning:',
-  '- For any task that needs more than one step, call `todo_write` ONCE with the full ordered plan, then stop. Do not call any other tool in the same turn.',
-  '- The platform dispatches assignees automatically and completes their todo when their run ends. You do NOT need to call `handoff` to start the plan or `todo_update` to finish items.',
-  '- Each item must be concrete and atomic (one verb, one outcome). Skip the list entirely for trivial single-step requests.',
-  '',
-  'When you are an assignee (you have an `in_progress` todo addressed to you):',
-  '- Just do the work and reply. The platform will mark your todo done and dispatch the next one.',
-  '- If you genuinely cannot complete it, call `todo_update(id, status: "cancelled")` with a brief reason in your reply.',
-].join('\n');