openbot 0.3.6 → 0.4.2

package/src/plugins/openbot/context.ts

@@ -0,0 +1,140 @@
+import { OpenBotState } from '../../app/types.js';
+import { Storage } from '../../services/plugins/domain.js';
+import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
+
+export const DEFAULT_CONTEXT_BUDGET = 8000;
+export const MAX_CONTEXT_FILES = 50;
+
+/**
+ * Returns the known context window budget (in tokens) for a given model string.
+ */
+export const getContextBudgetForModel = (modelString: string): number => {
+  const budgets: Record<string, number> = {
+    'openai/gpt-4o': 128000,
+    'openai/gpt-4o-mini': 128000,
+    'openai/o1-preview': 128000,
+    'openai/o1-mini': 128000,
+    'anthropic/claude-3-5-sonnet-20240620': 200000,
+    'anthropic/claude-3-5-sonnet-latest': 200000,
+    'anthropic/claude-3-opus-20240229': 200000,
+    'anthropic/claude-3-sonnet-20240229': 200000,
+    'anthropic/claude-3-haiku-20240307': 200000,
+  };
+
+  return budgets[modelString] || DEFAULT_CONTEXT_BUDGET;
+};
+
+/** Built-in orchestrator agent id. */
+export const ORCHESTRATOR_AGENT_ID = 'system';
+
+/**
+ * Check if a channel is a solo DM (only the agent is present).
+ */
+export function isDmSoloChannel(participants: string[], agentId: string): boolean {
+  return participants.length === 0 || (participants.length === 1 && participants[0] === agentId);
+}
+
+/**
+ * Simplified context builder for MVP.
+ */
+export async function buildContext(state: OpenBotState, storage?: Storage): Promise<string> {
+  const { channelId, threadId, channelDetails, agentId, threadDetails, agentDetails } = state;
+  const participants = channelDetails?.participants || [];
+  const isDm = isDmSoloChannel(participants, agentId);
+
+  const sections: string[] = [];
+
+  // Fetch agents once if storage is available
+  const allAgents = storage?.getAgents ? await storage.getAgents().catch(() => []) : [];
+
+  // 1. User
+  if (state.currentUser?.userName) {
+    sections.push(`## HUMAN\n- Name: ${state.currentUser.userName}`);
+  }
+
+  // 2. Environment
+  let env = '## ENVIRONMENT\n';
+  if (isDm) {
+    env += '- Mode: Direct Message (Solo)\n';
+  } else {
+    const channelName = channelDetails?.name || channelId;
+    env += `- Mode: Channel (#${channelName})\n`;
+    if (channelDetails?.cwd) {
+      env += `- Workspace: ${channelDetails.cwd}\n`;
+    }
+    if (threadId) {
+      env += `- Thread: ${threadDetails?.name || threadId}\n`;
+    }
+    const peerIds = participants.filter((id: string) => id !== agentId);
+    const participantLabels = peerIds.map((id) => {
+      const agent = allAgents.find((a) => a.id === id);
+      return agent ? `${agent.name} (${id})` : id;
+    });
+    env += `- Participants: ${participantLabels.length > 0 ? participantLabels.join(', ') : 'None'}\n`;
+  }
+  sections.push(env);
+
+  // 2.5 Installed Agents
+  if (allAgents.length > 0) {
+    const formatted = allAgents
+      .map((a) => `- ${a.id}: ${a.name}${a.description ? ` - ${a.description}` : ''}`)
+      .join('\n');
+    sections.push(`## INSTALLED AGENTS\n${formatted}`);
+  }
+
+  // 3. Channel Spec
+  const spec = channelDetails?.spec?.trim();
+  if (spec) {
+    sections.push(`## CHANNEL SPECIFICATION\n${spec}`);
+  }
+
+  // 4. Files
+  if (storage?.listFiles && channelId && channelDetails?.cwd) {
+    try {
+      const files = await storage.listFiles({ channelId });
+      if (files.length > 0) {
+        const limited = files.slice(0, MAX_CONTEXT_FILES);
+        const formatted = limited
+          .map((f) => `- ${f.name}${f.isDirectory ? '/' : ''}`)
+          .join('\n');
+        let fileSection = `## FILES\n${formatted}`;
+        if (files.length > MAX_CONTEXT_FILES) {
+          fileSection += `\n- ... and ${files.length - MAX_CONTEXT_FILES} more files`;
+        }
+        sections.push(fileSection);
+      } else {
+        sections.push('## FILES\n- (No files in workspace)');
+      }
+    } catch (error) {
+      console.warn('[context] Failed to fetch files:', error);
+    }
+  }
+
+  // 5. Agent Instructions
+  const rawInstructions = agentDetails?.instructions?.trim();
+  if (
+    rawInstructions &&
+    rawInstructions !== OPENBOT_SYSTEM_PROMPT.trim()
+  ) {
+    sections.push(`## Instructions\n${rawInstructions}`);
+  }
+
+  // 6. Memories
+  if (storage?.listMemories) {
+    try {
+      const scopes = ['global', `agent:${agentId}`];
+      if (channelId) scopes.push(`channel:${channelId}`);
+      const records = await storage.listMemories({ scopes, limit: 20 });
+      if (records.length > 0) {
+        const formatted = records
+          .map((r: any) => `- (${r.scope}) ${r.content}`)
+          .join('\n');
+        sections.push(`## MEMORIES\n${formatted}`);
+      }
+    } catch (error) {
+      console.warn('[context] Failed to fetch memories:', error);
+    }
+  }
+
+  return sections.join('\n\n');
+}

package/src/plugins/openbot/history.ts

@@ -0,0 +1,158 @@
+import { OpenBotEvent } from '../../app/types.js';
+import { ToolResultPart, type ModelMessage } from 'ai';
+
+/**
+ * Ensures every tool-call has a matching tool-result before calling the LLM.
+ * Orphaned calls (interrupted run, missing :result event, etc.) get an empty
+ * result so the conversation can resume instead of failing validation.
+ */
+function fillMissingToolResults(messages: ModelMessage[]): ModelMessage[] {
+  const filled: ModelMessage[] = [];
+  const pending = new Map<string, string>();
+
+  const flushPending = () => {
+    if (pending.size === 0) return;
+    filled.push({
+      role: 'tool',
+      content: [...pending.entries()].map(([toolCallId, toolName]) => ({
+        type: 'tool-result' as const,
+        toolCallId,
+        toolName,
+        output: { type: 'text' as const, value: '' },
+      })),
+    });
+    pending.clear();
+  };
+
+  for (const message of messages) {
+    if (message.role === 'tool' && Array.isArray(message.content)) {
+      filled.push(message);
+      for (const part of message.content) {
+        if ((part as ToolResultPart).type === 'tool-result') {
+          pending.delete((part as ToolResultPart).toolCallId);
+        }
+      }
+      continue;
+    }
+
+    flushPending();
+    filled.push(message);
+
+    if (message.role === 'assistant' && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if ((part as { type?: string; toolCallId?: string; toolName?: string }).type === 'tool-call') {
+          const toolCall = part as { toolCallId: string; toolName: string };
+          pending.set(toolCall.toolCallId, toolCall.toolName);
+        }
+      }
+    }
+  }
+
+  flushPending();
+  return filled;
+}
+
+/**
+ * Converts a raw event log into a valid chain of ModelMessages for the AI SDK.
+ * 
+ * This is a basic implementation that maps events to messages and filters out
+ * events from sub-processes (delegation) to avoid duplication in history.
+ */
+export function eventsToModelMessages(events: OpenBotEvent[]): ModelMessage[] {
+  const messages: ModelMessage[] = [];
+
+  for (const event of events) {
+    // Skip events that belong to a sub-process (like delegation)
+    // so they don't pollute the main conversation history.
+    if (event.meta?.parentToolCallId) {
+      continue;
+    }
+
+    switch (event.type) {
+      case 'agent:output': {
+        const last = messages[messages.length - 1];
+        if (last && last.role === 'assistant' && typeof last.content === 'string') {
+          last.content += event.data.content;
+        } else {
+          messages.push({ role: 'assistant', content: event.data.content });
+        }
+        break;
+      }
+
+      case 'agent:invoke': {
+        const invokeEvent = event as any;
+        if (invokeEvent.data?.content && invokeEvent.data?.role) {
+          messages.push({
+            role: invokeEvent.data.role,
+            content: invokeEvent.data.content
+          } as ModelMessage);
+        }
+        break;
+      }
+
+      default:
+        // Handle tool calls (action:*)
+        if (event.type.startsWith('action:') && !event.type.endsWith(':result')) {
+
+
+          const toolName = event.type.slice(7);
+          const toolCallId = event.meta?.toolCallId;
+          if (!toolCallId) break;
+
+          const toolCall = {
+            type: 'tool-call' as const,
+            toolCallId,
+            toolName,
+            input: (event as any).data,
+          };
+
+          const last = messages[messages.length - 1];
+
+          if (last && last.role === 'assistant') {
+            if (typeof last.content === 'string') {
+              last.content = [
+                { type: 'text', text: last.content },
+                toolCall,
+              ];
+            } else if (Array.isArray(last.content)) {
+              (last.content as any[]).push(toolCall);
+            }
+          } else {
+            messages.push({
+              role: 'assistant',
+              content: [toolCall],
+            });
+          }
+        }
+        // Handle tool results (action:*:result)
+        else if (event.type.startsWith('action:') && event.type.endsWith(':result')) {
+          const toolName = event.type.slice(7, -7);
+          const toolCallId = event.meta?.toolCallId;
+          if (!toolCallId) break;
+
+          const toolResult: ToolResultPart = {
+            type: 'tool-result' as const,
+            toolCallId,
+            toolName,
+            output: {
+              type: 'text',
+              value: (event as any)?.data?.output || "No output", // ?.output is from delegation result
+            },
+          };
+
+          const last = messages[messages.length - 1];
+          if (last && last.role === 'tool' && Array.isArray(last.content)) {
+            (last.content as any[]).push(toolResult);
+          } else {
+            messages.push({
+              role: 'tool',
+              content: [toolResult],
+            });
+          }
+        }
+        break;
+    }
+  }
+
+  return fillMissingToolResults(messages);
+}

package/src/plugins/openbot/index.ts

@@ -0,0 +1,79 @@
+import type { Plugin } from '../../services/plugins/types.js';
+import { openbotRuntime } from './runtime.js';
+import { bashPlugin } from '../bash/index.js';
+import { memoryPlugin } from '../memory/index.js';
+import { approvalPlugin } from '../approval/index.js';
+import { storagePlugin } from '../storage/index.js';
+import { delegationPlugin } from '../delegation/index.js';
+import { uiPlugin } from '../ui/index.js';
+
+/**
+ * `openbot` — the standard, opinionated OpenBot agent runtime.
+ *
+ * This is the canonical execution loop for OpenBot agents. It handles
+ * `agent:invoke`, manages short-term memory, assembles context, and
+ * orchestrates tool calls.
+ * 
+ * It comes with a "batteries-included" set of inbuilt tools: bash, memory,
+ * storage, delegation, and approval.
+ */
+export const openbotPlugin: Plugin = {
+  id: 'openbot',
+  name: 'OpenBot Agent',
+  description:
+    'The standard OpenBot agent runtime with inbuilt tools (bash, memory, storage, delegation, and approval).',
+  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',
+      },
+      approval: {
+        type: 'object',
+        description: 'Configuration for the inbuilt approval plugin.',
+        properties: {
+          actions: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'List of actions that require manual approval.',
+          },
+        },
+      },
+    },
+  },
+  toolDefinitions: {
+    ...bashPlugin.toolDefinitions,
+    ...memoryPlugin.toolDefinitions,
+    ...storagePlugin.toolDefinitions,
+    ...delegationPlugin.toolDefinitions,
+    ...uiPlugin.toolDefinitions,
+  },
+  factory: (context) => (builder) => {
+    const { config, storage, tools, abortSignal } = context;
+
+    // Register inbuilt plugins
+    bashPlugin.factory(context)(builder);
+    memoryPlugin.factory(context)(builder);
+    storagePlugin.factory(context)(builder);
+    delegationPlugin.factory(context)(builder);
+    uiPlugin.factory(context)(builder);
+
+    // Approval plugin configuration
+    const approvalConfig = (config?.approval as any) || {
+      actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
+    };
+    approvalPlugin.factory({ ...context, config: approvalConfig })(builder);
+
+    return openbotRuntime({
+      model: config?.model as string,
+      storage,
+      toolDefinitions: tools,
+      abortSignal,
+    })(builder);
+  },
+};
+
+export default openbotPlugin;