openbot 0.4.7 → 0.5.5

package/src/plugins/openbot/runtime.ts

@@ -1,526 +0,0 @@
-import { MelonyPlugin, RuntimeContext } from 'melony';
-import { generateText, type LanguageModel } from 'ai';
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { google } from '@ai-sdk/google';
-import { OpenBotEvent, OpenBotState, AgentInvokeEvent } from '../../app/types.js';
-import { eventsToModelMessages } from './history.js';
-import { Storage } from '../../services/plugins/domain.js';
-import type { ToolDefinition } from '../../services/plugins/types.js';
-import {
-  ORCHESTRATOR_AGENT_ID,
-  buildContext,
-} from './context.js';
-import { saveConfig, DEFAULT_MARKETPLACE_REGISTRY_URL } from '../../app/config.js';
-import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
-
-interface ModelRegistry {
-  providers: Record<
-    string,
-    {
-      label: string;
-      models: Array<{ id: string; label: string; description: string }>;
-    }
-  >;
-}
-
-let cachedRegistry: ModelRegistry | null = null;
-
-async function fetchRegistry(): Promise<ModelRegistry | null> {
-  if (cachedRegistry) return cachedRegistry;
-  try {
-    const response = await fetch(DEFAULT_MARKETPLACE_REGISTRY_URL);
-    if (!response.ok) throw new Error(`Failed to fetch registry: ${response.statusText}`);
-    cachedRegistry = (await response.json()) as ModelRegistry;
-    return cachedRegistry;
-  } catch (error) {
-    console.error('[openbot] Failed to fetch model registry:', error);
-    return null;
-  }
-}
-
-export interface OpenBotRuntimeOptions {
-  /** Provider model string (e.g. `openai/gpt-4o-mini`, `anthropic/claude-3-5-sonnet-20240620`). */
-  model?: string;
-  storage?: Storage;
-  /** Tool definitions merged from all tool plugins attached to this agent. */
-  toolDefinitions?: Record<string, ToolDefinition>;
-  /** Fires when the run is stopped; cancels the in-flight LLM call. */
-  abortSignal?: AbortSignal;
-}
-
-function resolveModel(modelString: string): LanguageModel {
-  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);
-    case 'google':
-      return google(modelId);
-    default:
-      throw new Error(`Unsupported AI provider: "${provider}"`);
-  }
-}
-
-async function buildSystemPrompt(
-  state: OpenBotState,
-  storage: Storage | undefined,
-): Promise<string> {
-  const context = await buildContext(state, storage);
-
-  const sections = [OPENBOT_SYSTEM_PROMPT, '', context];
-
-  // Hardcoded naming hint logic
-  const threadState = state.threadDetails?.state as any;
-  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(
-  state: OpenBotState,
-  storage?: Storage,
-  channelId?: string,
-  threadId?: string,
-) {
-  const save = async (ids?: string[]) => {
-    if (!storage || !channelId || !threadId) return;
-    try {
-      await storage.patchThreadState({
-        channelId,
-        threadId,
-        state: { pendingToolCallIds: ids },
-      });
-    } catch (error) {
-      console.error('[openbot] Failed to persist pendingToolCallIds:', error);
-    }
-  };
-
-  return {
-    async startBatch(toolCallIds: string[]) {
-      state.pendingToolCallIds = [...toolCallIds];
-      await save(state.pendingToolCallIds);
-    },
-    async clear() {
-      state.pendingToolCallIds = undefined;
-      await save(undefined);
-    },
-    /** Returns true when this result completes the batch (time to call the LLM again). */
-    async recordResult(toolCallId: string): Promise<boolean> {
-      if (!state.pendingToolCallIds?.includes(toolCallId)) return false;
-      state.pendingToolCallIds = state.pendingToolCallIds.filter((id) => id !== toolCallId);
-      const done = state.pendingToolCallIds.length === 0;
-      if (done) {
-        state.pendingToolCallIds = undefined;
-      }
-      await save(state.pendingToolCallIds);
-      return done;
-    },
-  };
-}
-
-/**
- * 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: OpenBotRuntimeOptions): MelonyPlugin<OpenBotState, OpenBotEvent> =>
-    (builder) => {
-      const {
-        model: modelString = 'openai/gpt-4o-mini',
-        storage,
-        toolDefinitions = {},
-        abortSignal,
-      } = options;
-
-      let currentModelString = modelString;
-      let model = resolveModel(currentModelString);
-
-      const runLLM = async function* (
-        context: RuntimeContext<OpenBotState, OpenBotEvent>,
-        threadId?: string,
-        trigger?: AgentInvokeEvent,
-      ): AsyncGenerator<OpenBotEvent> {
-        if (!storage) return;
-        if (abortSignal?.aborted) return;
-
-        const toolBatch = createToolBatchTracker(
-          context.state,
-          storage,
-          context.state.channelId,
-          threadId || context.state.threadId,
-        );
-
-        // 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));
-        // console.log('toolDefinitions:::::::\n', JSON.stringify(toolDefinitions));
-
-        try {
-          // Single LLM request — tool execution happens externally via action:* handlers.
-          const result = await generateText({
-            model,
-            system: systemPrompt,
-            messages,
-            tools: toolDefinitions as Record<string, { description: string; inputSchema: any }>,
-            stopWhen: ({ steps }) => steps.length === 1,
-            allowSystemInMessages: true,
-            abortSignal,
-          });
-
-          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
-            await toolBatch.startBatch(toolCalls.map((tc) => tc.toolCallId));
-
-            for (const toolCall of toolCalls) {
-              yield {
-                type: `action:${toolCall.toolName}` as OpenBotEvent['type'],
-                data: toolCall.input,
-                meta: {
-                  toolCallId: toolCall.toolCallId,
-                  ...outputMeta,
-                },
-              } as unknown as OpenBotEvent;
-            }
-          } else {
-            // clear the tool batch if there are no tool calls
-            await toolBatch.clear();
-          }
-        } catch (error: unknown) {
-          // Run was stopped — unwind quietly without surfacing an error.
-          if (abortSignal?.aborted) return;
-
-          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) {
-            yield {
-              type: 'client:ui:widget',
-              data: {
-                kind: 'choice',
-                widgetId: `api_provider_selection_${Date.now()}`,
-                title: `Setup AI Provider`,
-                description: `Select a provider to continue.`,
-                actions: [
-                  { id: 'openai', label: 'OpenAI', variant: 'primary' },
-                  { id: 'anthropic', label: 'Anthropic', variant: 'primary' },
-                  { id: 'google', label: 'Google', variant: 'primary' },
-                ],
-                metadata: {
-                  type: 'api_provider_selection',
-                },
-              },
-              meta: { agentId: context.state.agentId, threadId },
-            } as OpenBotEvent;
-            return;
-          }
-
-          throw error;
-        }
-      };
-
-      builder.on('agent:invoke', async function* (event, context) {
-        const routedTo = (event as { data?: { agentId?: string } }).data?.agentId;
-        if (typeof routedTo === 'string' && routedTo && routedTo !== context.state.agentId) {
-          return;
-        }
-
-        // Capture user info from meta if available
-        if (event.meta?.userName) {
-          context.state.currentUser = {
-            userName: event.meta.userName,
-          };
-        }
-
-        const threadId = event.meta?.threadId || context.state.threadId;
-
-        // clear the tool batch if the agent is invoked
-        // this is to prevent the tool batch from being used for a new agent invocation
-        await createToolBatchTracker(
-          context.state,
-          storage,
-          context.state.channelId,
-          threadId,
-        ).clear();
-
-        yield* runLLM(context, threadId, event as AgentInvokeEvent);
-      });
-
-      // 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 ||
-          !(await createToolBatchTracker(
-            context.state,
-            storage,
-            context.state.channelId,
-            event.meta?.threadId || context.state.threadId,
-          ).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, actionId } = event.data;
-        const threadId = event.meta?.threadId || context.state.threadId;
-
-        if (metadata?.type === 'api_provider_selection') {
-          const provider = actionId;
-          const [_, ...rest] = currentModelString.split('/');
-          const currentModelId = rest.join('/');
-
-          const registry = await fetchRegistry();
-          const providerData = registry?.providers[provider as string];
-
-          const providerLinks: Record<string, string> = {
-            openai: 'https://platform.openai.com/api-keys',
-            anthropic: 'https://console.anthropic.com/settings/keys',
-            google: 'https://aistudio.google.com/app/apikey',
-          };
-
-          const label = providerData?.label || (provider as string);
-          const link = providerLinks[provider as string] || '';
-
-          const modelOptions = providerData?.models.map((m) => ({
-            label: m.label,
-            value: m.id,
-          }));
-
-          const defaultModel = modelOptions?.[0]?.value || 'gpt-4o-mini';
-          const defaultValue =
-            modelOptions?.find((m) => m.value === currentModelId)?.value ||
-            currentModelId ||
-            defaultModel;
-
-          yield {
-            type: 'client:ui:widget',
-            data: {
-              widgetId: event.data.widgetId,
-              kind: 'message',
-              title: 'Provider Selected',
-              body: `${label} provider was selected.`,
-              state: 'submitted',
-              display: 'collapsed',
-              disabled: true,
-              actions: [],
-            },
-            meta: { agentId: context.state.agentId, threadId },
-          } as OpenBotEvent;
-
-          yield {
-            type: 'client:ui:widget',
-            data: {
-              kind: 'form',
-              widgetId: `api_key_request_${Date.now()}`,
-              title: `${label} Setup`,
-              description: `Enter your API key and select a model.`,
-              fields: [
-                {
-                  id: 'model',
-                  label: 'Model',
-                  type: modelOptions ? 'select' : 'text',
-                  description: modelOptions ? undefined : `Model name (e.g. \`${defaultModel}\`).`,
-                  options: modelOptions,
-                  placeholder: defaultModel,
-                  required: true,
-                  defaultValue,
-                },
-                {
-                  id: 'apiKey',
-                  label: 'API Key',
-                  type: 'password',
-                  description: `Get your key here: [${link}](${link})`,
-                  placeholder: `sk-...`,
-                  required: true,
-                },
-              ],
-              submitLabel: 'Save & Continue',
-              metadata: {
-                type: 'api_key_request',
-                provider,
-              },
-            },
-            meta: { agentId: context.state.agentId, threadId },
-          } as OpenBotEvent;
-          return;
-        }
-
-        if (metadata?.type !== 'api_key_request') return;
-        if (!values?.apiKey || !values?.model) return;
-
-        const provider = String(values.provider || metadata.provider);
-        const modelId = String(values.model).trim();
-        const apiKey = String(values.apiKey);
-
-        if (provider !== 'openai' && provider !== 'anthropic' && provider !== 'google') {
-          yield {
-            type: 'agent:output',
-            data: { content: `Unsupported provider: ${provider}` },
-            meta: { agentId: context.state.agentId },
-          };
-          return;
-        }
-
-        const envVar =
-          provider === 'openai'
-            ? 'OPENAI_API_KEY'
-            : provider === 'anthropic'
-              ? 'ANTHROPIC_API_KEY'
-              : 'GOOGLE_GENERATIVE_AI_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',
-              display: 'collapsed',
-              disabled: true,
-              actions: [],
-            },
-            meta: { agentId: context.state.agentId },
-          };
-
-          yield* runLLM(context, threadId);
-        } 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/src/plugins/openbot/system-prompt.ts

@@ -1,22 +0,0 @@
-export const OPENBOT_SYSTEM_PROMPT = [
-  '# ROLE',
-  'You are an OpenBot, the main coordinator and router agent. Your primary role is to orchestrate specialized agents to help the human achieve their goals.',
-  '',
-  '# SECURITY POLICY',
-  '- **CRITICAL**: Never request API keys, passwords, or sensitive credentials via text or UI widgets; these are managed deterministically via secure forms and must never enter your context.',
-  '- **Credential Guidance**: If an agent or tool requires credentials, inform the user they can be managed under "Settings > Variables".',
-  '',
-  '# CORE MISSION',
-  'You almost never execute tasks yourself. Instead, you delegate tasks to specialized agents. You act as a high-level manager, ensuring the right agent is working on the right task.',
-  '',
-  '# OPERATIONAL GUIDELINES',
-  '- **Channel and Threads**: The main and only way to communicate and act is through channels and threads. There might be a channel called "uncategorized" for general purpose communication.',
-  '- **Delegation**: You can delegate tasks to any specialized agent in the `INSTALLED AGENTS` list.',
-  '- **Bash Tool Usage**: You should use the `bash` tool very rarely. Only use it when the user explicitly requests a command to be run or when it is absolutely necessary for a task that no other agent can handle.',
-  '- **Context Awareness**: Use the provided ENVIRONMENT, CHANNEL SPECIFICATION, and MEMORIES to maintain continuity. Do not ask for information already present in these sections.',
-  '- **Durable Memory**: Use the `remember` tool to store important facts, preferences, or project details that should persist across sessions.',
-  '- **Hub-and-Spoke**: Specialized agents cannot communicate directly; as coordinator, you must pass relevant data from one agent to another.',
-  '',
-  '# COMMUNICATION STYLE',
-  '- Be always concise, professional, and proactive.',
-].join('\n');

package/src/plugins/ui/index.ts

@@ -1,123 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { z } from 'zod';
-import type { Plugin } from '../../services/plugins/types.js';
-import { OpenBotEvent, RenderWidgetEvent, UIWidgetResponseEvent } from '../../app/types.js';
-
-/**
- * `ui` — provides a tool for the agent to render interactive UI widgets.
- * 
- * The model can choose which widget to render (form, choice, list, message)
- * depending on the situation.
- */
-
-export const uiPlugin: Plugin = {
-  id: 'ui',
-  name: 'UI',
-  description: 'Render interactive UI widgets to interact with the user.',
-  toolDefinitions: {
-    render_widget: {
-      description: 'Render a UI widget to the user. Use "form" for data collection, "choice" for simple selection, "list" for displaying items, and "message" for simple notifications with actions. When using form widge to unquire user, do not provide complex forms with many fields, always try to make it simple to keep the experience smooth and straightforward.',
-      inputSchema: z.object({
-        kind: z.enum(['message', 'choice', 'form', 'list']).describe('The type of widget to render.'),
-        title: z.string().describe('The title of the widget.'),
-        description: z.string().optional().describe('A description or body text.'),
-        fields: z.array(z.object({
-          id: z.string().describe('Unique ID for the field.'),
-          label: z.string().describe('Label shown to the user.'),
-          type: z.enum(['text', 'textarea', 'number', 'boolean', 'select', 'multiselect', 'date']),
-          description: z.string().optional(),
-          placeholder: z.string().optional(),
-          required: z.boolean().optional(),
-          options: z.array(z.object({ label: z.string(), value: z.string() })).optional(),
-          defaultValue: z.any().optional()
-        })).optional().describe('Required for kind="form". List of form fields.'),
-        actions: z.array(z.object({
-          id: z.string(),
-          label: z.string(),
-          variant: z.enum(['primary', 'secondary', 'danger']).optional(),
-        })).optional().describe('Buttons or actions available on the widget.'),
-        items: z.array(z.object({
-          id: z.string(),
-          label: z.string(),
-          description: z.string().optional(),
-          status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
-          metadata: z.record(z.string(), z.any()).optional()
-        })).optional().describe('Required for kind="list". List of items to display.'),
-        submitLabel: z.string().optional().describe('Label for the primary action button (e.g. "Submit", "Save").')
-      })
-    }
-  },
-  factory: () => (builder) => {
-    // Handle the tool call from the agent
-    builder.on('action:render_widget', async function* (event, context) {
-      const widgetEvent = event as RenderWidgetEvent;
-      const toolCallId = widgetEvent.meta?.toolCallId;
-      const threadId = widgetEvent.meta?.threadId || context.state.threadId;
-
-      if (!toolCallId) return;
-
-      const widgetId = randomUUID();
-
-      // Emit the UI widget event to the client
-      yield {
-        type: 'client:ui:widget',
-        data: {
-          ...widgetEvent.data,
-          widgetId,
-          metadata: {
-            type: 'ui:request',
-            originalEvent: widgetEvent
-          }
-        },
-        meta: { agentId: context.state.agentId, threadId }
-      } as OpenBotEvent;
-    });
-
-    // Handle the user's response from the UI widget
-    builder.on('client:ui:widget:response', async function* (event, context) {
-      const responseEvent = event as UIWidgetResponseEvent;
-      const { widgetId, actionId, values, metadata } = responseEvent.data;
-      if (metadata?.type !== 'ui:request') return;
-
-      const originalEvent = metadata.originalEvent as RenderWidgetEvent;
-      const toolCallId = originalEvent?.meta?.toolCallId;
-      const threadId = originalEvent?.meta?.threadId || context.state.threadId;
-
-      if (!toolCallId) return;
-
-      // Yield a "submitted" widget update to the UI to collapse/disable it
-      yield {
-        type: 'client:ui:widget',
-        data: {
-          widgetId,
-          title: originalEvent.data.title,
-          kind: originalEvent.data.kind as any,
-          state: 'submitted',
-          body: "Thank you for your response. We will process it and get back to you soon.",
-          display: 'collapsed',
-          disabled: true,
-          actions: [], // Clear actions to disable buttons in UI
-        },
-        meta: { agentId: context.state.agentId, threadId },
-      } as OpenBotEvent;
-
-      // Emit the tool result event so the agent runtime can resume
-      yield {
-        type: 'action:render_widget:result',
-        data: {
-          success: true,
-          actionId,
-          values,
-          output: JSON.stringify(values)
-        },
-        meta: {
-          agentId: context.state.agentId,
-          threadId,
-          toolCallId
-        }
-      } as any as OpenBotEvent;
-    });
-  },
-};
-
-export default uiPlugin;