openbot 0.2.14 → 0.3.0

package/src/agents/system.ts

@@ -1,112 +0,0 @@
-import { AgentDetails } from '../plugins/storage.js';
-import { delegationToolDefinitions } from '../plugins/delegation.js';
-import { storageToolDefinitions } from '../plugins/storage.js';
-import { mcpToolDefinitions } from '../plugins/mcp.js';
-import { uiToolDefinitions } from '../plugins/ui.js';
-import { storageService } from '../services/storage.js';
-import { readFileSync } from 'node:fs';
-
-const SYSTEM_ICON_DATA_URL = (() => {
-  try {
-    const svg = readFileSync(new URL('../assets/icon.svg', import.meta.url), 'utf-8').trim();
-    if (!svg.startsWith('<svg')) return undefined;
-    return `data:image/svg+xml;base64,${Buffer.from(svg, 'utf-8').toString('base64')}`;
-  } catch {
-    return undefined;
-  }
-})();
-
-export const getSystemAgentDetails = (overrides?: Partial<AgentDetails>): AgentDetails => {
-  const defaults: AgentDetails = {
-    id: 'system',
-    name: 'Lolly',
-    image: SYSTEM_ICON_DATA_URL,
-    instructions:
-      'You are OpenBot, the primary AI assistant and orchestrator of this workspace. Your goal is to help users onboard, answer questions about the system, and suggest specialized agents for specific tasks.\n\n' +
-      '### How to use OpenBot:\n' +
-      '1. **General Chat**: Just type your message here, and I will help you.\n' +
-      '2. **Specialized Agents**: You can delegate tasks to specialized agents for specific tasks. For example, use the `delegate` tool to invoke the `os` agent for terminal commands and file operations.\n' +
-      '3. **Channels**: Channels are shared spaces where multiple agents can participate. You can create new channels for different topics.\n' +
-      '4. **Local-First**: OpenBot runs entirely on your machine. Your data stays private and local.\n\n' +
-      '### Workflow Guidelines:\n' +
-      '- **Todo Schema**: Keep todo items simple. Each item should have a short `id`, a clear `task` description, and a `status` (e.g., "pending", "in_progress", "done").\n' +
-      '- **Interactive Widgets**: Use `render_ui_widget` to give the user a visual progress bar (`kind: "todo_list"`), request permissions (`kind: "approval"`), or gather structured data (`kind: "form"`).\n' +
-      '- **Delegation**: When delegating to another agent, reference the relevant Task ID from the thread state. Update the task status (e.g., using `patch_thread_details`) as progress is made.\n\n' +
-      'If you need to know what agents or plugins are installed, I can help you find that information.',
-    runtime: {
-      name: 'ai-sdk',
-      config: {
-        model: 'openai/gpt-4o-mini',
-        toolDefinitions: {
-          ...delegationToolDefinitions,
-          ...storageToolDefinitions,
-          ...mcpToolDefinitions,
-          ...uiToolDefinitions,
-        },
-      },
-    },
-    plugins: [
-      { name: 'storage', config: { storage: storageService } },
-      { name: 'delegation', config: {} },
-      { name: 'mcp', config: {} },
-      { name: 'ui', config: {} },
-    ],
-    description: 'System coordinator agent',
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  };
-
-  if (!overrides) return defaults;
-
-  // Merge logic:
-  // - Simple fields: override if present
-  // - Runtime: merge config/model, but preserve toolDefinitions unless explicitly overridden
-  // - Plugins: merge by name (user plugins override defaults)
-
-  const mergedRuntime = {
-    ...(typeof defaults.runtime === 'object' ? defaults.runtime : {}),
-    ...(typeof overrides.runtime === 'object' ? overrides.runtime : {}),
-    name:
-      (typeof overrides.runtime === 'object' ? overrides.runtime.name : overrides.runtime) ||
-      (typeof defaults.runtime === 'object' ? defaults.runtime.name : defaults.runtime) ||
-      'ai-sdk',
-    config: {
-      ...(defaults.runtime && typeof defaults.runtime !== 'string' ? defaults.runtime.config : {}),
-      ...(overrides.runtime && typeof overrides.runtime !== 'string' ? overrides.runtime.config : {}),
-      toolDefinitions: {
-        ...(defaults.runtime && typeof defaults.runtime !== 'string'
-          ? (defaults.runtime.config as any)?.toolDefinitions
-          : {}),
-        ...(overrides.runtime && typeof overrides.runtime !== 'string'
-          ? (overrides.runtime.config as any)?.toolDefinitions
-          : {}),
-      },
-    },
-  };
-
-  const mergedPlugins = [...(defaults.plugins || [])];
-  if (overrides.plugins) {
-    for (const p of overrides.plugins) {
-      const name = typeof p === 'string' ? p : p.name;
-      const index = mergedPlugins.findIndex((existing) => {
-        const existingName = typeof existing === 'string' ? existing : existing.name;
-        return existingName === name;
-      });
-      if (index !== -1) {
-        mergedPlugins[index] = p;
-      } else {
-        mergedPlugins.push(p);
-      }
-    }
-  }
-
-  return {
-    ...defaults,
-    ...overrides,
-    id: 'system', // Always enforce 'system' ID
-    image: overrides.image || defaults.image, // Ensure image is preserved if not explicitly overridden
-    runtime: mergedRuntime as any,
-    plugins: mergedPlugins,
-    updatedAt: new Date(),
-  };
-};

package/src/plugins/ai-sdk.ts

@@ -1,197 +0,0 @@
-import { MelonyPlugin, RuntimeContext } from 'melony';
-import { generateText, ModelMessage, type LanguageModel } from 'ai';
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { z } from 'zod';
-import { OpenBotEvent, OpenBotState, ShortTermMessage } from '../app/types.js';
-import { Storage } from './storage.js';
-
-export interface AISDKPluginOptions {
-  /**
-   * Provider model as a standardized string (e.g. `openai/gpt-4o-mini`, `anthropic/claude-3-5-sonnet-20240620`).
-   * Default: `openai/gpt-4o-mini`
-   */
-  model?: string;
-  system?: string | ((context: RuntimeContext) => string | Promise<string>);
-  storage?: Storage;
-  toolDefinitions?: Record<
-    string,
-    {
-      description: string;
-      inputSchema: z.ZodType<any>;
-    }
-  >;
-}
-
-/**
- * Resolves a standardized model string to an AI SDK LanguageModel.
- */
-function resolveModel(modelString: string): LanguageModel {
-  const [provider, ...rest] = modelString.split('/');
-  const modelId = rest.join('/');
-
-  if (!modelId) {
-    throw new Error(`Invalid model string: "${modelString}". Expected format: "provider/model-id"`);
-  }
-
-  switch (provider) {
-    case 'openai':
-      return openai(modelId);
-    case 'anthropic':
-      return anthropic(modelId);
-    default:
-      throw new Error(`Unsupported AI provider: "${provider}"`);
-  }
-}
-
-async function buildSystemPrompt(
-  state: OpenBotState,
-  system?: string | ((context: RuntimeContext) => string | Promise<string>),
-  context?: RuntimeContext,
-  storage?: Storage,
-): Promise<string> {
-  const sections: string[] = [];
-
-  if (state.agentDetails) {
-    sections.push(`## AGENT NAME\n${state.agentDetails.name}`);
-    sections.push(`## AGENT SPECIFICATION\n${state.agentDetails.instructions}`);
-  }
-
-  if (state.channelDetails) {
-    sections.push(`## CHANNEL NAME\n${state.channelDetails.name}`);
-    sections.push(`## CHANNEL SPECIFICATION\n${state.channelDetails.spec}`);
-    // sections.push(`## CHANNEL STATE\n${JSON.stringify(state.channelDetails.state, null, 2)}`);
-
-    if (storage) {
-      try {
-        const channelEvents = await storage.getEvents({ channelId: state.channelId });
-        if (channelEvents.length > 0) {
-          const formattedEvents = channelEvents
-            .slice(-20)
-            .map((e) => `- ${e.type}: ${JSON.stringify((e as any).data || {})}`)
-            .join('\n');
-          sections.push(`## CHANNEL RECENT ACTIVITIES (events)\n${formattedEvents}`);
-        }
-      } catch (error) {
-        console.warn(`[ai-sdk] Failed to fetch channel events for ${state.channelId}`, error);
-      }
-    }
-  }
-
-  if (state.threadDetails) {
-    sections.push(`## THREAD NAME\n${state.threadDetails.name}`);
-    sections.push(`## THREAD SPECIFICATION\n${state.threadDetails.spec}`);
-    // sections.push(`## THREAD STATE\n${JSON.stringify(state.threadDetails.state, null, 2)}`);
-
-    if (storage && state.threadId) {
-      try {
-        const threadEvents = await storage.getEvents({
-          channelId: state.channelId,
-          threadId: state.threadId,
-        });
-        if (threadEvents.length > 0) {
-          const formattedEvents = threadEvents
-            .slice(-20)
-            .map((e) => `- ${e.type}: ${JSON.stringify((e as any).data || {})}`)
-            .join('\n');
-          sections.push(`## THREAD RECENT ACTIVITIES (events)\n${formattedEvents}`);
-        }
-      } catch (error) {
-        console.warn(
-          `[ai-sdk] Failed to fetch thread events for channel ${state.channelId} thread ${state.threadId}`,
-          error,
-        );
-      }
-    }
-  }
-
-  if (system && typeof system === 'string') {
-    sections.push(`## SYSTEM INSTRUCTIONS\n${system}`);
-  }
-
-  if (system && typeof system === 'function' && context) {
-    sections.push(await system(context));
-  }
-
-  return sections.join('\n\n');
-}
-
-/**
- * AI SDK Plugin for Melony.
- * Automatically handles text events and routes them through an AI SDK using Vercel AI SDK.
- * It can also automatically trigger events based on tool calls.
- */
-export const aiSdkPlugin =
-  (options: AISDKPluginOptions): MelonyPlugin<OpenBotState, OpenBotEvent> =>
-  (builder) => {
-    const {
-      model: modelString = 'openai/gpt-4o-mini',
-      system,
-      storage,
-      toolDefinitions = {},
-    } = options;
-
-    const model = resolveModel(modelString);
-
-    builder.on('agent:invoke', async function* (event, context) {
-      // extract threadId if model decides to reply in a thread
-      const threadId = event.meta?.threadId || context.state.threadId;
-      const systemPrompt = await buildSystemPrompt(context.state, system, context, storage);
-
-      context.state.shortTermMessages = [
-        ...(context.state.shortTermMessages ?? []),
-        {
-          role: event.data?.role || 'user',
-          content: (event as any)?.data?.content || '',
-        },
-      ];
-
-      const result = await generateText({
-        model,
-        system: systemPrompt,
-        messages: context.state.shortTermMessages,
-        tools: toolDefinitions,
-      });
-
-      const toolCalls = result.toolCalls ?? [];
-
-      if (toolCalls.length > 0) {
-        for (const toolCall of toolCalls) {
-          const toolEvent = {
-            type: `action:${toolCall.toolName}` as OpenBotEvent['type'],
-            data: toolCall.input,
-            meta: {
-              toolCallId: toolCall.toolCallId,
-              agentId: context.state.agentId,
-              threadId,
-            },
-          } as unknown as OpenBotEvent;
-          yield toolEvent;
-        }
-      }
-
-      if (result.text) {
-        context.state.shortTermMessages = [
-          ...(context.state.shortTermMessages ?? []),
-          { role: 'assistant', content: result.text },
-        ];
-
-        yield {
-          type: 'agent:output',
-          data: {
-            content: result.text,
-          },
-          meta: {
-            agentId: context.state.agentId,
-          },
-        };
-      }
-    });
-  };
-
-export const plugin = {
-  name: 'ai-sdk',
-  description: 'Built-in AI SDK plugin',
-  kind: 'runtime' as const,
-  factory: aiSdkPlugin,
-};

package/src/plugins/delegation.ts

@@ -1,60 +0,0 @@
-import { MelonyPlugin } from 'melony';
-import { OpenBotEvent, OpenBotState } from '../app/types.js';
-import z from 'zod';
-
-/**
- * Delegation Plugin for Melony.
- * Automatically handles delegation events and routes them through the storage service.
- */
-export const delegationPlugin = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
-  builder.on('action:delegate', async function* (event, context) {
-    const { agentId, content } = event.data;
-
-    // 1. Show the delegation in the UI
-    yield {
-      type: 'agent:output',
-      data: {
-        content: `Delegating to **${agentId}**: ${content}`,
-      },
-      meta: {
-        ...(event.meta || {}),
-        agentId: context.state.agentId,
-      },
-    };
-
-    // 2. Trigger the linear execution loop in orchestratorService
-    yield {
-      type: 'agent:invoke',
-      data: {
-        agentId,
-        content,
-      },
-      meta: {
-        ...(event.meta || {}),
-        agentId: context.state.agentId,
-      },
-    };
-  });
-};
-
-export const delegationToolDefinitions = {
-  delegate: {
-    description:
-      'Delegate a task to another agent. The agent will run independently and feed results back to you. Call at most once per step.',
-    inputSchema: z.object({
-      agentId: z.string().describe('The ID of the agent (e.g. "os", "browser", "tavily").'),
-      content: z.string().describe('The message or task for the agent.'),
-    }),
-  },
-};
-
-export const plugin = {
-  name: 'delegation',
-  description: 'Delegation plugin',
-  version: '1.0.0',
-  author: 'OpenBot',
-  license: 'MIT',
-  website: 'https://openbot.one',
-  factory: delegationPlugin,
-  toolDefinitions: delegationToolDefinitions,
-};

package/src/plugins/mcp.ts

@@ -1,154 +0,0 @@
-import { MelonyPlugin } from 'melony';
-import z from 'zod';
-import { OpenBotEvent, OpenBotState } from '../app/types.js';
-import { mcpService } from '../harness/mcp.js';
-
-function stringifyResult(value: unknown): string {
-  if (typeof value === 'string') {
-    return value;
-  }
-
-  try {
-    return JSON.stringify(value, null, 2);
-  } catch {
-    return String(value);
-  }
-}
-
-export const mcpToolDefinitions = {
-  mcp_list_tools: {
-    description:
-      'List available tools from a configured MCP server. Use this first before calling tools on an unknown server.',
-    inputSchema: z.object({
-      serverId: z.string().describe('Configured MCP server id (for example: github, notion, linear).'),
-    }),
-  },
-  mcp_call: {
-    description:
-      'Call a tool on a configured MCP server. Provide tool arguments as a JSON object. Use mcp_list_tools first when uncertain.',
-    inputSchema: z.object({
-      serverId: z.string().describe('Configured MCP server id.'),
-      toolName: z.string().describe('Exact MCP tool name from mcp_list_tools.'),
-      args: z.record(z.string(), z.unknown()).default({}).describe('Tool arguments as a JSON object.'),
-    }),
-  },
-};
-
-export const mcpPlugin = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
-  builder.on('action:mcp_list_tools', async function* (event, context) {
-    const serverId = (event.data as any)?.serverId as string;
-
-    try {
-      const tools = await mcpService.listTools(serverId);
-      const toolNames = tools.map((tool) => `- ${tool.name}${tool.description ? `: ${tool.description}` : ''}`);
-
-      yield {
-        type: 'action:mcp_list_tools:result',
-        data: {
-          success: true,
-          serverId,
-          tools,
-        },
-        meta: event.meta,
-      } as any;
-
-      yield {
-        type: 'agent:output',
-        data: {
-          content:
-            toolNames.length > 0
-              ? `MCP tools available on \`${serverId}\`:\n${toolNames.join('\n')}`
-              : `MCP server \`${serverId}\` has no tools.`,
-        },
-        meta: {
-          ...(event.meta || {}),
-          agentId: context.state.agentId,
-        },
-      } as any;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown MCP error';
-      yield {
-        type: 'action:mcp_list_tools:result',
-        data: {
-          success: false,
-          serverId,
-          tools: [],
-          error: message,
-        },
-        meta: event.meta,
-      } as any;
-      yield {
-        type: 'agent:output',
-        data: {
-          content: `Failed to list MCP tools for \`${serverId}\`: ${message}`,
-        },
-        meta: {
-          ...(event.meta || {}),
-          agentId: context.state.agentId,
-        },
-      } as any;
-    }
-  });
-
-  builder.on('action:mcp_call', async function* (event, context) {
-    const serverId = (event.data as any)?.serverId as string;
-    const toolName = (event.data as any)?.toolName as string;
-    const args = ((event.data as any)?.args || {}) as Record<string, unknown>;
-
-    try {
-      const result = await mcpService.callTool(serverId, toolName, args);
-      const rendered = stringifyResult(result);
-
-      yield {
-        type: 'action:mcp_call:result',
-        data: {
-          success: true,
-          serverId,
-          toolName,
-          result,
-        },
-        meta: event.meta,
-      } as any;
-
-      yield {
-        type: 'agent:output',
-        data: {
-          content: `MCP \`${serverId}.${toolName}\` result:\n\n${rendered}`,
-        },
-        meta: {
-          ...(event.meta || {}),
-          agentId: context.state.agentId,
-        },
-      } as any;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown MCP error';
-      yield {
-        type: 'action:mcp_call:result',
-        data: {
-          success: false,
-          serverId,
-          toolName,
-          error: message,
-        },
-        meta: event.meta,
-      } as any;
-      yield {
-        type: 'agent:output',
-        data: {
-          content: `MCP call failed for \`${serverId}.${toolName}\`: ${message}`,
-        },
-        meta: {
-          ...(event.meta || {}),
-          agentId: context.state.agentId,
-        },
-      } as any;
-    }
-  });
-};
-
-export const plugin = {
-  name: 'mcp',
-  description: 'Basic MCP integration for configured servers',
-  factory: mcpPlugin,
-  toolDefinitions: mcpToolDefinitions,
-};