openbot 0.4.7 → 0.5.4

package/dist/plugins/ai-sdk.js

@@ -1,331 +0,0 @@
-import { generateText } from 'ai';
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { createDefaultContextEngine } from '../harness/context.js';
-/**
- * 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}"`);
-    }
-}
-const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-const readPersistedShortTermMessages = (state) => {
-    const source = state.threadDetails?.state ?? state.channelDetails?.state;
-    const record = asRecord(source);
-    const raw = record.shortTermMessages;
-    return Array.isArray(raw) ? raw : [];
-};
-const persistShortTermMessages = async (state, storage) => {
-    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, system, context, storage, contextEngine) {
-    const sections = [];
-    if (system && typeof system === 'string') {
-        sections.push(system);
-    }
-    if (system && typeof system === 'function' && context) {
-        sections.push(await system(context));
-    }
-    if (contextEngine) {
-        sections.push(await contextEngine.buildContext(state, storage));
-    }
-    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, contextEngine = createDefaultContextEngine(), toolDefinitions = {}, } = options;
-    const model = resolveModel(modelString);
-    const ensureShortTermMessages = (state) => {
-        if (!state.shortTermMessages || state.shortTermMessages.length === 0) {
-            state.shortTermMessages = readPersistedShortTermMessages(state);
-        }
-    };
-    const mapToCoreMessages = (messages) => {
-        return messages.map((m) => {
-            if (m.role === 'assistant' && m.toolCalls) {
-                const assistantContent = [
-                    {
-                        role: 'assistant',
-                        content: [
-                            { type: 'text', text: m.content || '' },
-                            ...m.toolCalls.map((tc) => ({
-                                type: 'tool-call',
-                                toolCallId: tc.id,
-                                toolName: tc.function.name,
-                                input: JSON.parse(tc.function.arguments),
-                            })),
-                        ],
-                    },
-                ];
-                return assistantContent[0];
-            }
-            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, threadId) {
-        ensureShortTermMessages(context.state);
-        const systemPrompt = await buildSystemPrompt(context.state, system, context, storage, contextEngine);
-        const coreMessages = mapToCoreMessages(context.state.shortTermMessages || []);
-        try {
-            const result = await generateText({
-                model,
-                system: systemPrompt,
-                messages: coreMessages,
-                tools: toolDefinitions,
-            });
-            const toolCalls = result.toolCalls ?? [];
-            if (toolCalls.length > 0) {
-                // Add assistant message with tool calls to state
-                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}`,
-                        data: toolCall.input,
-                        meta: {
-                            toolCallId: toolCall.toolCallId,
-                            agentId: context.state.agentId,
-                            threadId,
-                        },
-                    };
-                }
-            }
-            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) {
-            const errorMessage = error?.message || String(error);
-            const isApiKeyError = errorMessage.includes('API key') ||
-                errorMessage.includes('401') ||
-                errorMessage.includes('Unauthorized') ||
-                errorMessage.includes('authentication');
-            if (isApiKeyError) {
-                const provider = modelString.split('/')[0];
-                const envVar = provider === 'openai' ? 'OPENAI_API_KEY' : 'ANTHROPIC_API_KEY';
-                yield {
-                    type: 'client:ui:widget',
-                    data: {
-                        kind: 'form',
-                        widgetId: `api_key_request_${Date.now()}`,
-                        title: `${provider.toUpperCase()} API Key Required`,
-                        description: `The ${provider} API returned an authentication error. Please provide a valid API key to continue. The key provided here never leaves your runtime Computer.`,
-                        fields: [
-                            {
-                                id: 'apiKey',
-                                label: 'API Key',
-                                type: 'text',
-                                placeholder: `sk-...`,
-                                required: true,
-                            },
-                        ],
-                        submitLabel: 'Save API Key',
-                        metadata: {
-                            type: 'api_key_request',
-                            provider,
-                            envVar,
-                        },
-                    },
-                    meta: {
-                        agentId: context.state.agentId,
-                        threadId,
-                    },
-                };
-                return;
-            }
-            // Re-throw other errors
-            throw error;
-        }
-    };
-    builder.on('agent:invoke', async function* (event, context) {
-        // if the agent:invoke is routed to a different agent, don't process it, it prevents infinite loops
-        const routedTo = event.data?.agentId;
-        if (typeof routedTo === 'string' && routedTo && routedTo !== context.state.agentId) {
-            return;
-        }
-        // extract threadId if model decides to reply in a thread
-        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);
-        // Extract tool name from event type (e.g., action:shell_exec:result -> shell_exec)
-        const toolName = event.type.replace(/^action:/, '').replace(/:result$/, '');
-        // Add tool result to state
-        const resultData = event.data;
-        const content = typeof resultData === 'string' ? resultData : JSON.stringify(resultData);
-        context.state.shortTermMessages = [
-            ...(context.state.shortTermMessages ?? []),
-            { role: 'tool', content, toolCallId, toolName },
-        ];
-        await persistShortTermMessages(context.state, storage);
-        // Check if we should re-trigger LLM
-        // We re-trigger if the last assistant message's tool calls are all fulfilled
-        const lastAssistant = [...(context.state.shortTermMessages ?? [])]
-            .reverse()
-            .find((m) => m.role === 'assistant' && 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) {
-                // Some tools intentionally terminate the current agent path (e.g., handoff).
-                // We still persist their tool result for provider consistency, but do not continue this agent.
-                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' && values?.apiKey) {
-            const key = metadata.envVar;
-            const value = values.apiKey;
-            if (storage) {
-                try {
-                    await storage.createVariable({ key, value, secret: true });
-                    yield {
-                        type: 'agent:output',
-                        data: {
-                            content: `Successfully saved ${metadata.provider} API key to workspace variables.`,
-                        },
-                        meta: {
-                            agentId: context.state.agentId,
-                        },
-                    };
-                    // Update the widget to show success
-                    yield {
-                        type: 'client:ui:widget',
-                        data: {
-                            widgetId: event.data.widgetId,
-                            kind: 'message',
-                            title: 'API Key Saved',
-                            body: `Successfully saved ${metadata.provider} API key. 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,
-                        },
-                    };
-                }
-            }
-        }
-    });
-};
-export const plugin = {
-    id: 'ai-sdk',
-    name: 'AI SDK',
-    description: 'Built-in AI SDK plugin',
-    kind: 'runtime',
-    factory: () => aiSdkPlugin({}),
-};

package/dist/plugins/approval.js

@@ -1,163 +0,0 @@
-import { storageService } from '../services/storage.js';
-const DEFAULT_RULES = [];
-const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-const getApprovalsFromState = (state) => {
-    const source = state.threadDetails?.state ?? state.channelDetails?.state;
-    const stateRecord = asRecord(source);
-    return asRecord(stateRecord.approvals);
-};
-const persistApprovals = async (state, approvals) => {
-    if (state.threadId) {
-        await storageService.patchThreadState({
-            channelId: state.channelId,
-            threadId: state.threadId,
-            state: { approvals },
-        });
-        return;
-    }
-    await storageService.patchChannelState({
-        channelId: state.channelId,
-        state: { approvals },
-    });
-};
-export const approvalPlugin = (options = {}) => (builder) => {
-    const rules = options.rules && options.rules.length > 0 ? options.rules : DEFAULT_RULES;
-    for (const rule of rules) {
-        builder.on(rule.action, async function* (event, context) {
-            const meta = asRecord(event.meta);
-            if (meta.approvalStatus === 'approved') {
-                return;
-            }
-            const eventData = asRecord(event.data);
-            const eventMeta = meta;
-            const approvalId = `approval_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-            const widgetId = `widget_${approvalId}`;
-            const executeEvent = rule.executeEvent || rule.action;
-            const denyEvent = rule.denyEvent || `${rule.action}:result`;
-            const denyData = rule.denyData || {};
-            const hiddenKeys = new Set(rule.hiddenKeys || []);
-            const detailKeys = rule.detailKeys || Object.keys(eventData);
-            const details = detailKeys
-                .filter((key) => !hiddenKeys.has(key))
-                .map((key) => `- ${key}: ${String(eventData[key] ?? '')}`)
-                .join('\n');
-            const pendingApprovals = getApprovalsFromState(context.state);
-            pendingApprovals[approvalId] = {
-                id: approvalId,
-                action: rule.action,
-                executeEvent,
-                denyEvent,
-                denyData,
-                payload: eventData,
-                meta: eventMeta,
-                message: rule.message || `Approval required for ${rule.action}.`,
-                createdAt: new Date().toISOString(),
-                status: 'pending',
-            };
-            await persistApprovals(context.state, pendingApprovals);
-            yield {
-                type: 'client:ui:widget',
-                data: {
-                    kind: 'choice',
-                    widgetId,
-                    title: 'Approval Required',
-                    body: `${rule.message || 'A protected action requires approval.'}${details ? `\n\n${details}` : ''}`,
-                    metadata: {
-                        type: 'approval:request',
-                        approvalId,
-                        action: rule.action,
-                    },
-                    actions: [
-                        { id: 'approve', label: 'Approve', variant: 'primary' },
-                        { id: 'deny', label: 'Deny', variant: 'danger' },
-                    ],
-                },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
-            };
-            yield {
-                type: 'agent:output',
-                data: {
-                    content: `Waiting for approval before running \`${rule.action}\`.`,
-                },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
-            };
-            context.suspend();
-        });
-    }
-    builder.on('client:ui:widget:response', async function* (event, context) {
-        const metadata = asRecord(event.data?.metadata);
-        if (metadata.type !== 'approval:request') {
-            return;
-        }
-        const approvalId = String(metadata.approvalId || '');
-        if (!approvalId) {
-            return;
-        }
-        const approvals = getApprovalsFromState(context.state);
-        const approval = approvals[approvalId];
-        if (!approval || approval.status !== 'pending') {
-            yield {
-                type: 'agent:output',
-                data: { content: 'Approval request not found or already resolved.' },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
-            };
-            return;
-        }
-        const approved = event.data.actionId === 'approve';
-        approvals[approvalId] = {
-            ...approval,
-            status: approved ? 'approved' : 'denied',
-        };
-        await persistApprovals(context.state, approvals);
-        if (approved) {
-            yield {
-                type: approval.executeEvent,
-                data: approval.payload,
-                meta: {
-                    ...(approval.meta || {}),
-                    approvalId,
-                    approvalStatus: 'approved',
-                },
-            };
-            return;
-        }
-        yield {
-            type: approval.denyEvent,
-            data: {
-                success: false,
-                approved: false,
-                error: 'Action denied by user approval.',
-                ...approval.denyData,
-            },
-            meta: {
-                ...(approval.meta || {}),
-                approvalId,
-            },
-        };
-        yield {
-            type: 'agent:output',
-            data: { content: 'Action denied by user approval.' },
-            meta: {
-                ...(event.meta || {}),
-                agentId: context.state.agentId,
-            },
-        };
-    });
-};
-export const plugin = {
-    name: 'approval',
-    description: 'Approval workflow for protected actions',
-    version: '1.0.0',
-    author: 'OpenBot',
-    license: 'MIT',
-    factory: approvalPlugin,
-};

package/dist/plugins/delegation.js

@@ -1,108 +0,0 @@
-import z from 'zod';
-/**
- * Delegation Plugin for Melony.
- * Handles handoff/delegation events and routes internal control events to the orchestrator.
- */
-export const delegationPlugin = () => (builder) => {
-    builder.on('action:handoff', async function* (event, context) {
-        const { agentId, content } = event.data;
-        // 1. Show the handoff in the UI
-        yield {
-            type: 'agent:output',
-            data: {
-                content: `Handing off to **${agentId}**: ${content}`,
-            },
-            meta: {
-                ...(event.meta || {}),
-                agentId: context.state.agentId,
-            },
-        };
-        // 2. Orchestrator turns this into a real agent:invoke for the target.
-        yield {
-            type: 'handoff:request',
-            data: { agentId, content },
-            meta: {
-                ...(event.meta || {}),
-                agentId: context.state.agentId,
-            },
-        };
-        // 3. Acknowledge tool completion so providers requiring tool-result pairing stay consistent.
-        if (event.meta?.toolCallId) {
-            yield {
-                type: 'action:handoff:result',
-                data: {
-                    success: true,
-                    agentId,
-                    accepted: true,
-                },
-                meta: {
-                    ...(event.meta || {}),
-                    agentId: context.state.agentId,
-                },
-            };
-        }
-    });
-    builder.on('action:delegate', async function* (event, context) {
-        const { agentId, content } = event.data;
-        const widgetId = event.meta?.toolCallId
-            ? `delegate_${event.meta.toolCallId}`
-            : `delegate_${Date.now()}`;
-        // 1. Show delegation progress in UI (child output stays hidden for delegate mode).
-        yield {
-            type: 'client:ui:widget',
-            data: {
-                kind: 'message',
-                widgetId,
-                title: `Delegation started: ${agentId}`,
-                body: `Running delegated task in background.\n\n${content}`,
-                state: 'open',
-                metadata: {
-                    type: 'delegation:status',
-                    phase: 'started',
-                    delegatedAgentId: agentId,
-                },
-            },
-            meta: {
-                ...(event.meta || {}),
-                agentId: context.state.agentId,
-            },
-        };
-        // 2. Orchestrator executes target agent and feeds result back as action:delegate:result.
-        yield {
-            type: 'delegation:request',
-            data: { agentId, content },
-            meta: {
-                ...(event.meta || {}),
-                parentAgentId: context.state.agentId,
-                delegationWidgetId: widgetId,
-                agentId: context.state.agentId,
-            },
-        };
-    });
-};
-export const delegationToolDefinitions = {
-    handoff: {
-        description: 'Transfer control to another agent. The target agent continues the task and you do not wait for a tool result.',
-        inputSchema: z.object({
-            agentId: z.string().describe('The ID of the target agent (e.g. "os", "browser", "tavily").'),
-            content: z.string().describe('The message or task to hand off.'),
-        }),
-    },
-    delegate: {
-        description: 'Delegate a subtask to another agent and wait for its result so you can continue.',
-        inputSchema: z.object({
-            agentId: z.string().describe('The ID of the target agent (e.g. "os", "browser", "tavily").'),
-            content: z.string().describe('The subtask you want the target agent to execute.'),
-        }),
-    },
-};
-export const plugin = {
-    name: 'delegation',
-    description: 'Delegation plugin',
-    version: '1.0.0',
-    author: 'OpenBot',
-    license: 'MIT',
-    website: 'https://openbot.one',
-    factory: delegationPlugin,
-    toolDefinitions: delegationToolDefinitions,
-};