openbot 0.2.14 → 0.3.1

package/dist/plugins/ai-sdk.js

@@ -1,6 +1,7 @@
 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.
  */
@@ -19,61 +20,41 @@ function resolveModel(modelString) {
             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);
-            }
-        }
+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 INSTRUCTIONS\n${system}`);
+        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');
 }
 /**
@@ -82,60 +63,269 @@ async function buildSystemPrompt(state, system, context, storage) {
  * 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: 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;
-        const systemPrompt = await buildSystemPrompt(context.state, system, context, storage);
+        ensureShortTermMessages(context.state);
         context.state.shortTermMessages = [
             ...(context.state.shortTermMessages ?? []),
             {
                 role: event.data?.role || 'user',
-                content: event?.data?.content || '',
+                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;
+        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);
             }
         }
-        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,
-                },
-            };
+    });
+    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 = {
-    name: 'ai-sdk',
+    id: 'ai-sdk',
+    name: 'AI SDK',
     description: 'Built-in AI SDK plugin',
     kind: 'runtime',
-    factory: aiSdkPlugin,
+    factory: () => aiSdkPlugin({}),
 };

package/dist/plugins/approval/index.js

@@ -0,0 +1,159 @@
+import { storageService } from '../../services/storage.js';
+export const DEFAULT_APPROVAL_RULES = [
+    {
+        action: 'action:shell_exec',
+        denyEvent: 'action:shell_exec:result',
+        message: 'The agent wants to run a terminal command.',
+        detailKeys: ['command', 'cwd', 'shell', 'timeoutMs'],
+        hiddenKeys: ['env'],
+        denyData: {
+            exitCode: null,
+            stdout: '',
+            stderr: 'Command execution was denied by the user.',
+            timedOut: false,
+        },
+    },
+];
+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 },
+    });
+};
+const buildApprovalPlugin = (rules) => (builder) => {
+    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 },
+        };
+    });
+};
+const readRules = (config) => {
+    const raw = config.rules;
+    if (!Array.isArray(raw))
+        return DEFAULT_APPROVAL_RULES;
+    return raw.filter((entry) => !!entry && typeof entry === 'object' && typeof entry.action === 'string');
+};
+export const approvalPlugin = {
+    id: 'approval',
+    name: 'Approval',
+    description: 'Gate protected tool calls (e.g. shell_exec) behind a UI confirmation prompt.',
+    factory: ({ config }) => buildApprovalPlugin(readRules(config)),
+};
+export default approvalPlugin;