openbot 0.3.6 → 0.4.0

package/dist/plugins/openbot/runtime.js

@@ -0,0 +1,317 @@
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { eventsToModelMessages } from './history.js';
+import { ORCHESTRATOR_AGENT_ID, buildContext, } from './context.js';
+import { saveConfig } from '../../app/config.js';
+import { API_KEY_SETUP_MESSAGE, OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
+function resolveModel(modelString) {
+    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 'openai':
+            return openai(modelId);
+        case 'anthropic':
+            return anthropic(modelId);
+        default:
+            throw new Error(`Unsupported AI provider: "${provider}"`);
+    }
+}
+async function buildSystemPrompt(state, storage) {
+    const context = await buildContext(state, storage);
+    const instructions = state.agentId === ORCHESTRATOR_AGENT_ID
+        ? (state.agentDetails?.instructions?.trim() || OPENBOT_SYSTEM_PROMPT)
+        : OPENBOT_SYSTEM_PROMPT;
+    const sections = [instructions, '', context];
+    // Hardcoded naming hint logic
+    const threadState = state.threadDetails?.state;
+    if (!threadState?.isSmartNamed) {
+        sections.push('', '## SYSTEM HINT', 'This thread is unnamed. Please use the `patch_thread_details` tool to set a concise, descriptive, and regular `name` (e.g., "Project Brainstorming" instead of "project-brainstorm") in the thread state and set `isSmartNamed: true` in the same patch. Only do this once.');
+    }
+    return sections.join('\n');
+}
+/**
+ * Tracks tool-call IDs from one LLM turn until matching `:result` events arrive.
+ *
+ * Melony runs yielded `action:*` events depth-first, so parallel tool calls from
+ * a single `generateText` response execute one-by-one. We must wait for every ID
+ * in the batch before calling the LLM again — not after the first result.
+ */
+function createToolBatchTracker() {
+    let pending = null;
+    return {
+        startBatch(toolCallIds) {
+            pending = new Set(toolCallIds);
+        },
+        clear() {
+            pending = null;
+        },
+        /** Returns true when this result completes the batch (time to call the LLM again). */
+        recordResult(toolCallId) {
+            if (!pending?.has(toolCallId))
+                return false;
+            pending.delete(toolCallId);
+            if (pending.size > 0)
+                return false;
+            pending = null;
+            return true;
+        },
+    };
+}
+/**
+ * OpenBot agent runtime.
+ *
+ * - One `generateText` call per `runLLM` (tools have no `execute`; SDK stops at 1 step).
+ * - Tool calls become `action:*` events; plugins emit `:result` when done.
+ * - When a full batch of results is in, `runLLM` runs again with updated history.
+ */
+export const openbotRuntime = (options) => (builder) => {
+    const { model: modelString = 'openai/gpt-4o-mini', storage, toolDefinitions = {}, } = options;
+    let currentModelString = modelString;
+    let model = resolveModel(currentModelString);
+    const toolBatch = createToolBatchTracker();
+    const runLLM = async function* (context, threadId, trigger) {
+        if (!storage)
+            return;
+        // Capture parent metadata for event enrichment
+        const triggerEvent = trigger || context.state.triggerEvent;
+        const parentAgentId = triggerEvent?.meta?.parentAgentId;
+        const parentToolCallId = triggerEvent?.meta?.parentToolCallId;
+        context.state.model = currentModelString;
+        const systemPrompt = await buildSystemPrompt(context.state, storage);
+        const events = await storage.getEvents({
+            channelId: context.state.channelId,
+            threadId: context.state.threadId,
+        });
+        const messages = eventsToModelMessages(events);
+        // console.log('systemPrompt:::::::\n', systemPrompt);
+        // console.log('messages:::::::\n', JSON.stringify(messages, null, 2));
+        // console.log('toolDefinitions:::::::\n', JSON.stringify(toolDefinitions, null, 2));
+        try {
+            // Single LLM request — tool execution happens externally via action:* handlers.
+            const result = await generateText({
+                model,
+                system: systemPrompt,
+                messages,
+                tools: toolDefinitions,
+                stopWhen: ({ steps }) => steps.length === 1,
+                allowSystemInMessages: true,
+            });
+            const toolCalls = result.toolCalls ?? [];
+            // if (result.usage) {
+            //   const usage = result.usage;
+            //   yield {
+            //     type: 'agent:usage',
+            //     data: {
+            //       usage: {
+            //         promptTokens: usage.inputTokens,
+            //         completionTokens: usage.outputTokens,
+            //         totalTokens: usage.totalTokens,
+            //         currentContextTokens: usage.inputTokens,
+            //         contextBudget: getContextBudgetForModel(currentModelString),
+            //       },
+            //       model: currentModelString,
+            //     },
+            //     meta: {
+            //       agentId: context.state.agentId,
+            //       threadId,
+            //       runId: context.state.runId,
+            //     },
+            //   } as OpenBotEvent;
+            // }
+            const outputMeta = {
+                agentId: context.state.agentId,
+                threadId,
+                parentAgentId,
+                parentToolCallId,
+            };
+            // Text before actions so history/UI show the model's intent first.
+            if (result.text) {
+                yield {
+                    type: 'agent:output',
+                    data: { content: result.text },
+                    meta: outputMeta,
+                };
+            }
+            if (toolCalls.length > 0) {
+                // when multiple tool calls are made, Melony runtime handles them one by one, thats why we need to start a new batch
+                toolBatch.startBatch(toolCalls.map((tc) => tc.toolCallId));
+                for (const toolCall of toolCalls) {
+                    yield {
+                        type: `action:${toolCall.toolName}`,
+                        data: toolCall.input,
+                        meta: {
+                            toolCallId: toolCall.toolCallId,
+                            ...outputMeta,
+                        },
+                    };
+                }
+            }
+            else {
+                // clear the tool batch if there are no tool calls
+                toolBatch.clear();
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isApiKeyError = errorMessage.includes('API key') ||
+                errorMessage.includes('401') ||
+                errorMessage.includes('Unauthorized') ||
+                errorMessage.includes('authentication');
+            if (isApiKeyError) {
+                const [currentProvider, ...rest] = currentModelString.split('/');
+                const currentModelId = rest.join('/');
+                yield {
+                    type: 'client:ui:widget',
+                    data: {
+                        kind: 'form',
+                        widgetId: `api_key_request_${Date.now()}`,
+                        title: `AI Provider API Key Required`,
+                        description: API_KEY_SETUP_MESSAGE,
+                        fields: [
+                            {
+                                id: 'provider',
+                                label: 'Provider',
+                                type: 'select',
+                                required: true,
+                                options: [
+                                    { label: 'OpenAI', value: 'openai' },
+                                    { label: 'Anthropic', value: 'anthropic' },
+                                ],
+                                defaultValue: currentProvider === 'anthropic' ? 'anthropic' : 'openai',
+                            },
+                            {
+                                id: 'model',
+                                label: 'Model',
+                                type: 'text',
+                                description: 'Model name without the provider prefix (e.g. `gpt-4o-mini` or `claude-3-5-sonnet-20240620`).',
+                                placeholder: 'gpt-4o-mini',
+                                required: true,
+                                defaultValue: currentModelId,
+                            },
+                            {
+                                id: 'apiKey',
+                                label: 'API Key',
+                                type: 'text',
+                                placeholder: `sk-...`,
+                                required: true,
+                            },
+                        ],
+                        submitLabel: 'Save & Continue',
+                        metadata: {
+                            type: 'api_key_request',
+                        },
+                    },
+                    meta: { agentId: context.state.agentId, threadId },
+                };
+                return;
+            }
+            throw error;
+        }
+    };
+    builder.on('agent:invoke', async function* (event, context) {
+        const routedTo = event.data?.agentId;
+        if (typeof routedTo === 'string' && routedTo && routedTo !== context.state.agentId) {
+            return;
+        }
+        // clear the tool batch if the agent is invoked
+        // this is to prevent the tool batch from being used for a new agent invocation
+        toolBatch.clear();
+        const threadId = event.meta?.threadId || context.state.threadId;
+        yield* runLLM(context, threadId, event);
+    });
+    // this is to handle the tool results from the tool calls
+    // because Melony runtime handles them one by one, thats why we need to record the result
+    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;
+        // record the result of the tool call
+        if (!toolCallId || !toolBatch.recordResult(toolCallId))
+            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')
+            return;
+        if (!values?.apiKey || !values?.provider || !values?.model)
+            return;
+        const provider = String(values.provider);
+        const modelId = String(values.model).trim();
+        const apiKey = String(values.apiKey);
+        if (provider !== 'openai' && provider !== 'anthropic') {
+            yield {
+                type: 'agent:output',
+                data: { content: `Unsupported provider: ${provider}` },
+                meta: { agentId: context.state.agentId },
+            };
+            return;
+        }
+        const envVar = provider === 'openai' ? 'OPENAI_API_KEY' : 'ANTHROPIC_API_KEY';
+        const newModelString = `${provider}/${modelId}`;
+        if (!storage)
+            return;
+        try {
+            await storage.createVariable({ key: envVar, value: apiKey, secret: true });
+            process.env[envVar] = apiKey;
+            currentModelString = newModelString;
+            model = resolveModel(currentModelString);
+            try {
+                saveConfig({ model: currentModelString });
+                // Also update the agent's AGENT.md if it has an openbot plugin config
+                const details = await storage.getAgentDetails({ agentId: context.state.agentId });
+                const updatedPlugins = details.pluginRefs.map((ref) => {
+                    if (ref.id === 'openbot') {
+                        return {
+                            ...ref,
+                            config: { ...ref.config, model: currentModelString },
+                        };
+                    }
+                    return ref;
+                });
+                await storage.updateAgent({
+                    agentId: context.state.agentId,
+                    plugins: updatedPlugins,
+                });
+            }
+            catch {
+                // best-effort: config persistence failure shouldn't block the conversation
+            }
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: `Saved ${provider} API key and set model to \`${newModelString}\`.`,
+                },
+                meta: { agentId: context.state.agentId },
+            };
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    widgetId: event.data.widgetId,
+                    kind: 'message',
+                    title: 'API Key Saved',
+                    body: `Successfully saved ${provider} API key and selected model \`${newModelString}\`. 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 },
+            };
+        }
+    });
+};

package/dist/plugins/openbot/system-prompt.js

@@ -0,0 +1,5 @@
+export const OPENBOT_SYSTEM_PROMPT = [
+    'You are a helpful AI assistant for your human. Your job is to help the user with their questions and tasks.',
+].join('\n');
+/** Shown in the API key setup form when no provider credentials are configured. */
+export const API_KEY_SETUP_MESSAGE = 'OpenBot runs AI agents locally with tools, memory, and delegation. Bring your own OpenAI or Anthropic key — it stays on your machine. Use the form below to get started.';

package/dist/plugins/plugin-manager/index.js

@@ -0,0 +1,105 @@
+import { STATE_AGENT_ID } from '../../app/agent-ids.js';
+import { pluginService, resolveMarketplaceAgentList, } from '../../services/plugins/service.js';
+/**
+ * `plugin-manager` — marketplace listing, npm plugin install/uninstall, and
+ * installing agents from the registry. Wired on the **`state`** built-in agent
+ * via its default `pluginRefs`.
+ *
+ * Handlers register only when `agentId === state` so attaching this plugin to
+ * other agents via AGENT.md does not widen infra privileges.
+ */
+export const pluginManagerPlugin = {
+    id: 'plugin-manager',
+    name: 'Plugin manager',
+    description: 'Marketplace listings, npm-based plugin lifecycle, and agent installs from marketplace metadata.',
+    factory: ({ agentId, storage }) => {
+        if (agentId !== STATE_AGENT_ID) {
+            return () => { };
+        }
+        return (builder) => {
+            builder.on('action:plugin:install', async function* (event) {
+                try {
+                    const { name, version } = event.data;
+                    const result = await pluginService.install({ packageName: name, version });
+                    yield {
+                        type: 'action:plugin:install:result',
+                        data: { success: true, plugin: result },
+                    };
+                }
+                catch (error) {
+                    yield {
+                        type: 'action:plugin:install:result',
+                        data: { success: false, error: error.message },
+                    };
+                }
+            });
+            builder.on('action:plugin:uninstall', async function* (event) {
+                try {
+                    await pluginService.uninstall(event.data.id);
+                    yield { type: 'action:plugin:uninstall:result', data: { success: true } };
+                }
+                catch (error) {
+                    yield {
+                        type: 'action:plugin:uninstall:result',
+                        data: { success: false, error: error.message },
+                    };
+                }
+            });
+            builder.on('action:marketplace:list', async function* () {
+                const agents = await resolveMarketplaceAgentList();
+                yield {
+                    type: 'action:marketplace:list:result',
+                    data: { success: true, agents },
+                };
+            });
+            builder.on('action:agent:install', async function* (event) {
+                try {
+                    const { agentId: newAgentId, name, description, image, instructions, plugins, } = event.data;
+                    for (const ref of plugins) {
+                        const installed = await pluginService.isInstalled(ref.id);
+                        if (!installed && ref.id.includes('/') === false && ref.id.includes('-plugin-') === false) {
+                            continue;
+                        }
+                        if (!installed) {
+                            try {
+                                await pluginService.install({ packageName: ref.id });
+                            }
+                            catch (err) {
+                                console.warn(`[plugins] Failed to pre-install plugin ${ref.id}`, err);
+                            }
+                        }
+                    }
+                    await storage.createAgent({
+                        agentId: newAgentId,
+                        name,
+                        description,
+                        image,
+                        instructions,
+                        plugins,
+                    });
+                    yield {
+                        type: 'action:agent:install:result',
+                        data: { success: true, agentId: newAgentId },
+                    };
+                    yield {
+                        type: 'agent:output',
+                        data: {
+                            content: `Successfully installed agent **${name}** (${newAgentId}) from marketplace.`,
+                        },
+                        meta: { agentId: 'system' },
+                    };
+                }
+                catch (error) {
+                    yield {
+                        type: 'action:agent:install:result',
+                        data: {
+                            success: false,
+                            agentId: event.data.agentId,
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                        },
+                    };
+                }
+            });
+        };
+    },
+};