openbot 0.2.12 → 0.2.14

package/dist/plugins/ai-sdk.js

@@ -0,0 +1,141 @@
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+/**
+ * Resolves a standardized model string to an AI SDK LanguageModel.
+ */
+function resolveModel(modelString) {
+    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, system, context, storage) {
+    const sections = [];
+    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.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.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) => (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?.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}`,
+                    data: toolCall.input,
+                    meta: {
+                        toolCallId: toolCall.toolCallId,
+                        agentId: context.state.agentId,
+                        threadId,
+                    },
+                };
+                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',
+    factory: aiSdkPlugin,
+};

package/dist/plugins/delegation.js

@@ -0,0 +1,52 @@
+import z from 'zod';
+/**
+ * Delegation Plugin for Melony.
+ * Automatically handles delegation events and routes them through the storage service.
+ */
+export const delegationPlugin = () => (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/dist/plugins/mcp.js

@@ -0,0 +1,140 @@
+import z from 'zod';
+import { mcpService } from '../harness/mcp.js';
+function stringifyResult(value) {
+    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 = () => (builder) => {
+    builder.on('action:mcp_list_tools', async function* (event, context) {
+        const serverId = event.data?.serverId;
+        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,
+            };
+            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,
+                },
+            };
+        }
+        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,
+            };
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: `Failed to list MCP tools for \`${serverId}\`: ${message}`,
+                },
+                meta: {
+                    ...(event.meta || {}),
+                    agentId: context.state.agentId,
+                },
+            };
+        }
+    });
+    builder.on('action:mcp_call', async function* (event, context) {
+        const serverId = event.data?.serverId;
+        const toolName = event.data?.toolName;
+        const args = (event.data?.args || {});
+        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,
+            };
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: `MCP \`${serverId}.${toolName}\` result:\n\n${rendered}`,
+                },
+                meta: {
+                    ...(event.meta || {}),
+                    agentId: context.state.agentId,
+                },
+            };
+        }
+        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,
+            };
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: `MCP call failed for \`${serverId}.${toolName}\`: ${message}`,
+                },
+                meta: {
+                    ...(event.meta || {}),
+                    agentId: context.state.agentId,
+                },
+            };
+        }
+    });
+};
+export const plugin = {
+    name: 'mcp',
+    description: 'Basic MCP integration for configured servers',
+    factory: mcpPlugin,
+    toolDefinitions: mcpToolDefinitions,
+};