openbot 0.5.4 → 0.5.5

package/src/plugins/memory/index.ts

@@ -1,182 +0,0 @@
-import z from 'zod';
-import type { Plugin } from '../../services/plugins/types.js';
-import { OpenBotEvent, MemoryScopeAlias } from '../../app/types.js';
-
-/**
- * Resolve a scope alias to a concrete scope string. Aliases let tools accept
- * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
- * them using `context.state`.
- */
-function resolveMemoryScope(
-  alias: MemoryScopeAlias | undefined,
-  state: any,
-): string {
-  switch (alias) {
-    case 'agent':
-      return `agent:${state.agentId}`;
-    case 'channel':
-      return `channel:${state.channelId}`;
-    case 'global':
-    case undefined:
-      return 'global';
-    default:
-      return 'global';
-  }
-}
-
-function resolveMemoryScopeFilter(
-  alias: MemoryScopeAlias | 'all' | undefined,
-  state: any,
-): string[] | undefined {
-  if (alias === 'all' || alias === undefined) {
-    return ['global', `agent:${state.agentId}`, `channel:${state.channelId}`];
-  }
-  return [resolveMemoryScope(alias, state)];
-}
-
-/**
- * `memory` — exposes the global memory store as agent tools and provides
- * platform-level memory handlers.
- */
-const memoryToolDefinitions = {
-  remember: {
-    description:
-      'Persist a durable fact, preference, or note to long-term memory so it can be recalled in future turns and runs. Use for stable information (user preferences, project conventions, contact details, decisions); avoid using it for transient chatter or per-step scratch state — that belongs in thread state. Keep entries short and self-contained.',
-    inputSchema: z.object({
-      content: z
-        .string()
-        .min(1)
-        .describe(
-          'The fact to remember, written so it makes sense out of context (e.g. "User prefers TypeScript over JavaScript.").',
-        ),
-      scope: z
-        .enum(['global', 'agent', 'channel'])
-        .optional()
-        .describe(
-          'Visibility: `global` (default, all agents everywhere), `agent` (only this agent), `channel` (only this channel).',
-        ),
-      tags: z
-        .array(z.string())
-        .optional()
-        .describe('Optional tags for filtering with `recall`.'),
-    }),
-  },
-  recall: {
-    description:
-      'Search long-term memory for facts you previously stored with `remember`. Returns up to `limit` matching records with their ids so you can `forget` stale ones.',
-    inputSchema: z.object({
-      query: z
-        .string()
-        .optional()
-        .describe('Case-insensitive substring filter against memory content.'),
-      tag: z.string().optional().describe('Only return memories that include this tag.'),
-      scope: z
-        .enum(['global', 'agent', 'channel', 'all'])
-        .optional()
-        .describe(
-          'Restrict the search to a single scope. Default `all` returns global + this agent + this channel.',
-        ),
-      limit: z
-        .number()
-        .int()
-        .positive()
-        .max(50)
-        .optional()
-        .describe('Maximum records to return (default 20, max 50).'),
-    }),
-  },
-  forget: {
-    description:
-      'Delete a memory by id. Use after the user asks to forget something or when a previously remembered fact is now wrong. Get ids from `recall`.',
-    inputSchema: z.object({
-      id: z.string().describe('The memory record id (returned by `recall`/`remember`).'),
-    }),
-  },
-};
-
-export const memoryPlugin: Plugin = {
-  id: 'memory',
-  name: 'Memory',
-  description:
-    'Global long-term memory: remember/recall/forget facts across runs and agents.',
-  toolDefinitions: memoryToolDefinitions,
-  factory: ({ storage }) => (builder) => {
-    builder.on('action:remember', async function* (event, context) {
-      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-      try {
-        const { content, scope, tags } = event.data;
-        const record = await storage.appendMemory({
-          scope: resolveMemoryScope(scope, context.state),
-          content,
-          tags,
-        });
-        yield {
-          type: 'action:remember:result',
-          data: { success: true, record },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      } catch (error) {
-        yield {
-          type: 'action:remember:result',
-          data: {
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      }
-    });
-
-    builder.on('action:recall', async function* (event, context) {
-      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-      try {
-        const { query, tag, scope, limit } = event.data;
-        const records = await storage.listMemories({
-          scopes: resolveMemoryScopeFilter(scope, context.state),
-          query,
-          tag,
-          limit,
-        });
-        yield {
-          type: 'action:recall:result',
-          data: { success: true, records },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      } catch (error) {
-        yield {
-          type: 'action:recall:result',
-          data: {
-            success: false,
-            records: [],
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      }
-    });
-
-    builder.on('action:forget', async function* (event, context) {
-      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-      try {
-        const deleted = await storage.deleteMemory({ id: event.data.id });
-        yield {
-          type: 'action:forget:result',
-          data: { success: true, deleted },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      } catch (error) {
-        yield {
-          type: 'action:forget:result',
-          data: {
-            success: false,
-            deleted: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      }
-    });
-  },
-};
-
-export default memoryPlugin;

package/src/plugins/openbot/context.ts

@@ -1,137 +0,0 @@
-import { OpenBotState } from '../../app/types.js';
-import { Storage } from '../../services/plugins/domain.js';
-import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
-import { todoService } from '../todo/service.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';
-
-/**
- * Simplified context builder for MVP.
- */
-export async function buildContext(state: OpenBotState, storage?: Storage): Promise<string> {
-  const { channelId, threadId, channelDetails, agentId, threadDetails, agentDetails } = state;
-
-  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';
-  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`;
-  }
-  sections.push(env);
-
-  // 2.5 Thread todos
-  if (channelId && threadId) {
-    try {
-      const list = await todoService.getTodos({ channelId, threadId });
-      if (list.items.length > 0) {
-        const formatted = list.items
-          .map((t) => `- [${t.status}] (${t.id}) ${t.content}`)
-          .join('\n');
-        sections.push(`## TODOS\n${formatted}`);
-      }
-    } catch (error) {
-      console.warn('[context] Failed to fetch todos:', error);
-    }
-  }
-
-  // 2.6 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

@@ -1,158 +0,0 @@
-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

@@ -1,95 +0,0 @@
-import type { Plugin } from '../../services/plugins/types.js';
-import { isCloudSystemAgent, resolveCloudSystemModel } from '../../app/cloud-mode.js';
-import { openbotRuntime } from './runtime.js';
-import { bashPlugin } from '../bash/index.js';
-import { memoryPlugin } from '../memory/index.js';
-import { todoPlugin } from '../todo/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';
-import { previewPlugin } from '../preview/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: shell, memory,
- * todo, storage, delegation, and approval.
- */
-export const openbotPlugin: Plugin = {
-  id: 'openbot',
-  name: 'OpenBot Agent',
-  description:
-    'The standard OpenBot agent runtime with inbuilt tools (shell, memory, todo, storage, delegation, and approval).',
-  configSchema: {
-    type: 'object',
-    properties: {
-      model: {
-        type: 'string',
-        description: 'Model from the hosted marketplace registry.',
-      },
-      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,
-    ...todoPlugin.toolDefinitions,
-    ...storagePlugin.toolDefinitions,
-    ...delegationPlugin.toolDefinitions,
-    ...previewPlugin.toolDefinitions,
-    // this is the capability to render UI widgets to the user. We dont need it for now.
-    // ...uiPlugin.toolDefinitions,
-  },
-  factory: (context) => (builder) => {
-    const { agentId, config, storage, tools, abortSignal } = context;
-
-    // Register inbuilt plugins
-    bashPlugin.factory(context)(builder);
-    memoryPlugin.factory(context)(builder);
-    todoPlugin.factory(context)(builder);
-    storagePlugin.factory(context)(builder);
-    delegationPlugin.factory(context)(builder);
-    uiPlugin.factory(context)(builder);
-    previewPlugin.factory(context)(builder);
-
-    // Approval plugin configuration
-    const approvalConfig = (config?.approval as any) || {
-      actions: [
-        'action:shell_exec',
-        'action:expose_port',
-        'action:create_channel',
-        'action:delete_channel',
-      ],
-    };
-    approvalPlugin.factory({ ...context, config: approvalConfig })(builder);
-
-    const model = isCloudSystemAgent(agentId)
-      ? resolveCloudSystemModel(config?.model as string | undefined)
-      : (config?.model as string);
-
-    return openbotRuntime({
-      model,
-      agentId,
-      storage,
-      toolDefinitions: tools,
-      abortSignal,
-    })(builder);
-  },
-};
-
-export default openbotPlugin;

package/src/plugins/openbot/model.ts

@@ -1,76 +0,0 @@
-import { createOpenAI, openai as defaultOpenai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { google } from '@ai-sdk/google';
-import type { LanguageModel } from 'ai';
-import {
-  getCloudIntegrationsConfig,
-  isCloudSystemAgent,
-} from '../../app/cloud-mode.js';
-
-let cloudOpenAIProvider: ReturnType<typeof createOpenAI> | null | undefined;
-
-/** Strip credentials — the integrations gateway injects the provider master key. */
-const integrationsFetch: typeof fetch = async (input, init) => {
-  const headers = new Headers(init?.headers);
-  headers.delete('Authorization');
-  headers.delete('x-api-key');
-  return globalThis.fetch(input, { ...init, headers });
-};
-
-function getCloudOpenAIProvider(): ReturnType<typeof createOpenAI> | null {
-  if (cloudOpenAIProvider !== undefined) return cloudOpenAIProvider;
-
-  const config = getCloudIntegrationsConfig();
-  if (!config) {
-    cloudOpenAIProvider = null;
-    return null;
-  }
-
-  cloudOpenAIProvider = createOpenAI({
-    baseURL: `${config.baseUrl}/openai/v1`,
-    apiKey: 'unused',
-    headers: {
-      'x-openbot-integrations-token': config.token,
-    },
-    fetch: integrationsFetch,
-  });
-  return cloudOpenAIProvider;
-}
-
-function resolveOpenbotModel(modelId: string, agentId?: string): LanguageModel {
-  if (!agentId || !isCloudSystemAgent(agentId)) {
-    throw new Error(
-      `OpenBot models are only available for the cloud system agent. Use openai/..., anthropic/..., etc.`,
-    );
-  }
-
-  const cloudOpenai = getCloudOpenAIProvider();
-  if (!cloudOpenai) {
-    throw new Error(
-      'OpenBot cloud model requires OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN.',
-    );
-  }
-
-  return cloudOpenai.chat(modelId);
-}
-
-export function resolveModel(modelString: string, agentId?: 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 'openbot':
-      return resolveOpenbotModel(modelId, agentId);
-    case 'openai':
-      return defaultOpenai(modelId);
-    case 'anthropic':
-      return anthropic(modelId);
-    case 'google':
-      return google(modelId);
-    default:
-      throw new Error(`Unsupported AI provider: "${provider}"`);
-  }
-}