openbot 0.4.4 → 0.4.6

package/src/app/types.ts

@@ -141,6 +141,10 @@ export type GetEventsResultEvent = BaseEvent & {
   };
 };
 
+export type GetActiveRunsEvent = BaseEvent & {
+  type: 'action:storage:get-active-runs';
+};
+
 export type GetAgentDetailsEvent = BaseEvent & {
   type: 'action:storage:get-agent-details';
   data: {
@@ -297,8 +301,6 @@ export type PatchChannelDetailsEvent = BaseEvent & {
     state?: Record<string, unknown>;
     spec?: string;
     cwd?: string;
-    /** When set, replaces `state.json` `participants` (merged after `state` if both are sent). */
-    participants?: string[];
   };
 };
 
@@ -306,7 +308,7 @@ export type PatchChannelDetailsResultEvent = BaseEvent & {
   type: 'action:patch_channel_details:result';
   data: {
     success: boolean;
-    updatedFields: ('state' | 'spec' | 'cwd' | 'participants')[];
+    updatedFields: ('state' | 'spec' | 'cwd')[];
   };
 };
 
@@ -565,8 +567,6 @@ export type CreateChannelEvent = BaseEvent & {
     spec?: string;
     initialState?: Record<string, unknown>;
     cwd?: string;
-    /** Initial channel agent ids; written into `state.json` (overrides `initialState.participants` if both are set). */
-    participants?: string[];
   };
   meta?: {
     toolCallId?: string;
@@ -590,8 +590,6 @@ export type UpdateChannelEvent = BaseEvent & {
     channelId?: string;
     name?: string;
     cwd?: string;
-    /** Replaces the channel participant list when provided. */
-    participants?: string[];
   };
 };
 
@@ -651,7 +649,7 @@ export type UIWidgetAction = {
 export type UIWidgetField = {
   id: string;
   label: string;
-  type: 'text' | 'textarea' | 'number' | 'boolean' | 'select' | 'multiselect' | 'date';
+  type: 'text' | 'textarea' | 'number' | 'boolean' | 'select' | 'multiselect' | 'date' | 'password';
   description?: string;
   placeholder?: string;
   required?: boolean;
@@ -847,7 +845,6 @@ export type ListMarketplaceRegistryResultEvent = BaseEvent & {
       image?: string;
       spec?: string;
       initialState?: Record<string, unknown>;
-      participants: string[];
       starterPrompts?: Array<{ label: string; prompt: string }>;
     }>;
     error?: string;
@@ -859,7 +856,6 @@ export type InstallChannelEvent = BaseEvent & {
   data: {
     channelId: string;
     name?: string;
-    participants?: string[];
     initialState?: Record<string, unknown>;
   };
 };
@@ -1059,6 +1055,7 @@ export type OpenBotEvent =
   | DeleteAgentResultEvent
   | GetEventsEvent
   | GetEventsResultEvent
+  | GetActiveRunsEvent
   | StreamThreadEvent
   | GetVariablesEvent
   | GetVariablesResultEvent

package/src/plugins/openbot/context.ts

@@ -27,20 +27,11 @@ export const getContextBudgetForModel = (modelString: string): number => {
 /** Built-in orchestrator agent id. */
 export const ORCHESTRATOR_AGENT_ID = 'system';
 
-/**
- * Check if a channel is a solo DM (only the agent is present).
- */
-export function isDmSoloChannel(participants: string[], agentId: string): boolean {
-  return participants.length === 0 || (participants.length === 1 && participants[0] === agentId);
-}
-
 /**
  * Simplified context builder for MVP.
  */
 export async function buildContext(state: OpenBotState, storage?: Storage): Promise<string> {
   const { channelId, threadId, channelDetails, agentId, threadDetails, agentDetails } = state;
-  const participants = channelDetails?.participants || [];
-  const isDm = isDmSoloChannel(participants, agentId);
 
   const sections: string[] = [];
 
@@ -54,23 +45,13 @@ export async function buildContext(state: OpenBotState, storage?: Storage): Prom
 
   // 2. Environment
   let env = '## ENVIRONMENT\n';
-  if (isDm) {
-    env += '- Mode: Direct Message (Solo)\n';
-  } else {
-    const channelName = channelDetails?.name || channelId;
-    env += `- Mode: Channel (#${channelName})\n`;
-    if (channelDetails?.cwd) {
-      env += `- Workspace: ${channelDetails.cwd}\n`;
-    }
-    if (threadId) {
-      env += `- Thread: ${threadDetails?.name || threadId}\n`;
-    }
-    const peerIds = participants.filter((id: string) => id !== agentId);
-    const participantLabels = peerIds.map((id) => {
-      const agent = allAgents.find((a) => a.id === id);
-      return agent ? `${agent.name} (${id})` : id;
-    });
-    env += `- Participants: ${participantLabels.length > 0 ? participantLabels.join(', ') : 'None'}\n`;
+  const channelName = channelDetails?.name || channelId;
+  env += `- Mode: Channel (#${channelName})\n`;
+  if (channelDetails?.cwd) {
+    env += `- Workspace: ${channelDetails.cwd}\n`;
+  }
+  if (threadId) {
+    env += `- Thread: ${threadDetails?.name || threadId}\n`;
   }
   sections.push(env);
 

package/src/plugins/openbot/runtime.ts

@@ -2,6 +2,7 @@ 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';
@@ -10,8 +11,33 @@ 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';
+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`). */
@@ -34,6 +60,8 @@ function resolveModel(modelString: string): LanguageModel {
       return openai(modelId);
     case 'anthropic':
       return anthropic(modelId);
+    case 'google':
+      return google(modelId);
     default:
       throw new Error(`Unsupported AI provider: "${provider}"`);
   }
@@ -246,49 +274,20 @@ export const openbotRuntime =
             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,
-                  },
+                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' },
                 ],
-                submitLabel: 'Save & Continue',
                 metadata: {
-                  type: 'api_key_request',
+                  type: 'api_provider_selection',
                 },
               },
               meta: { agentId: context.state.agentId, threadId },
@@ -315,49 +314,6 @@ export const openbotRuntime =
 
         const threadId = event.meta?.threadId || context.state.threadId;
 
-        // Auto-add participants if tagged in the prompt
-        const content = (event as AgentInvokeEvent).data?.content;
-        if (content && storage) {
-          try {
-            const allAgents = await storage.getAgents();
-            const tags = content.match(/@([\w-]+)/g);
-            if (tags) {
-              const taggedAgentIds = tags.map((t) => t.slice(1));
-              const validAgentIds = taggedAgentIds.filter((id) =>
-                allAgents.some((a) => a.id === id),
-              );
-
-              const currentParticipants = context.state.channelDetails?.participants || [];
-              const newParticipants = [...new Set([...currentParticipants, ...validAgentIds])];
-
-              if (newParticipants.length > currentParticipants.length) {
-                // Update storage
-                await storage.patchChannelState({
-                  channelId: context.state.channelId,
-                  state: { participants: newParticipants },
-                });
-
-                // Refresh local state
-                context.state.channelDetails = await storage.getChannelDetails({
-                  channelId: context.state.channelId,
-                });
-
-                // Notify UI/others about the change
-                yield {
-                  type: 'action:patch_channel_details:result',
-                  data: { success: true, updatedFields: ['participants'] },
-                  meta: {
-                    agentId: context.state.agentId,
-                    threadId,
-                  },
-                } as OpenBotEvent;
-              }
-            }
-          } catch (error) {
-            console.warn('[openbot] Failed to auto-add participants from tags:', error);
-          }
-        }
-
         // 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(
@@ -394,15 +350,98 @@ export const openbotRuntime =
       });
 
       builder.on('client:ui:widget:response', async function* (event, context) {
-        const { metadata, values } = event.data;
+        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?.provider || !values?.model) return;
+        if (!values?.apiKey || !values?.model) return;
 
-        const provider = String(values.provider);
+        const provider = String(values.provider || metadata.provider);
         const modelId = String(values.model).trim();
         const apiKey = String(values.apiKey);
 
-        if (provider !== 'openai' && provider !== 'anthropic') {
+        if (provider !== 'openai' && provider !== 'anthropic' && provider !== 'google') {
           yield {
             type: 'agent:output',
             data: { content: `Unsupported provider: ${provider}` },
@@ -411,7 +450,12 @@ export const openbotRuntime =
           return;
         }
 
-        const envVar = provider === 'openai' ? 'OPENAI_API_KEY' : 'ANTHROPIC_API_KEY';
+        const envVar =
+          provider === 'openai'
+            ? 'OPENAI_API_KEY'
+            : provider === 'anthropic'
+              ? 'ANTHROPIC_API_KEY'
+              : 'GOOGLE_GENERATIVE_AI_API_KEY';
         const newModelString = `${provider}/${modelId}`;
 
         if (!storage) return;
@@ -460,10 +504,14 @@ export const openbotRuntime =
               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' }],
+              display: 'collapsed',
+              disabled: true,
+              actions: [],
             },
             meta: { agentId: context.state.agentId },
           };
+
+          yield* runLLM(context, threadId);
         } catch (error) {
           yield {
             type: 'agent:output',

package/src/plugins/openbot/system-prompt.ts

@@ -7,13 +7,12 @@ export const OPENBOT_SYSTEM_PROMPT = [
   '- **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 (channel participants). You act as a high-level manager, ensuring the right agent is working on the right task.',
+  '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.',
-  '- **Agent Participation**: ONLY add an agent via `patch_channel_details` if the user manually tags them (e.g., `@name`) AND they are missing from the `Participants` list in `ENVIRONMENT`.',
-  '- **Delegation**: NEVER delegate to an agent who is not a participant. Only if existing participants clearly cannot handle a task should you suggest relevant agents from 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 participant can handle.',
+  '- **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.',
   '- **Structured Interaction**: Use the `render_widget` tool to collect information via forms, offer choices, or display lists. This is preferred over asking multiple separate questions in plain text.',
@@ -21,7 +20,3 @@ export const OPENBOT_SYSTEM_PROMPT = [
   '# COMMUNICATION STYLE',
   '- Be always concise, professional, and proactive.',
 ].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/src/plugins/plugin-manager/index.ts

@@ -67,10 +67,9 @@ export const pluginManagerPlugin: Plugin = {
           const {
             channelId: instanceId,
             name: templateName,
-            participants: customParticipants,
             initialState: customInitialState,
           } = event.data;
-          const { agents: marketplaceAgents, channels } = await resolveMarketplaceRegistry();
+          const { channels } = await resolveMarketplaceRegistry();
 
           // Try to find the template by ID or Name
           const channelListing =
@@ -78,64 +77,17 @@ export const pluginManagerPlugin: Plugin = {
             channels.find((c) => c.name === templateName);
 
           const channelId = instanceId;
-          const participants = customParticipants || channelListing?.participants || [];
           const initialState = {
             ...(channelListing?.initialState || {}),
             ...(customInitialState || {}),
           };
           const spec = channelListing?.spec || '';
 
-          // 1. Auto-install participant agents if missing
-          for (const agentId of participants) {
-            const existingAgents = await storage.getAgents();
-            if (existingAgents.some((a) => a.id === agentId)) {
-              continue;
-            }
-
-            // Not found locally, look in marketplace
-            const agentListing = marketplaceAgents.find((a) => a.id === agentId);
-            if (agentListing) {
-              console.log(`[plugin-manager] Auto-installing agent ${agentId} for channel ${channelId}`);
-
-              // Install plugins for this agent
-              for (const ref of agentListing.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);
-                  }
-                }
-              }
-
-              // Create the agent
-              await storage.createAgent({
-                agentId: agentListing.id,
-                name: agentListing.name,
-                description: agentListing.description,
-                image: agentListing.image,
-                instructions: agentListing.instructions,
-                plugins: agentListing.plugins,
-              });
-            }
-          }
-
           // 2. Create the channel
           await storage.createChannel({
             channelId,
             spec,
-            initialState: {
-              ...initialState,
-              participants,
-            },
+            initialState,
           });
 
           const channelUrl = `/channels/${channelId}`;

package/src/plugins/storage/index.ts

@@ -48,20 +48,13 @@ const storageToolDefinitions = {
             'Markdown content for the channel specification (SPEC.md). Use for goals and rules.',
           ),
         cwd: z.string().optional().describe('Current working directory for the channel.'),
-        participants: z
-          .array(z.string())
-          .optional()
-          .describe(
-            'List of agent IDs that are participants in this channel. When a user tags an agent (e.g. @agent-id), you should ensure they are added to this list if they are not already there.',
-          ),
       })
       .refine(
         (value) =>
           value.state !== undefined ||
           value.spec !== undefined ||
-          value.cwd !== undefined ||
-          value.participants !== undefined,
-        { message: 'Provide at least one of state, spec, cwd, or participants.' },
+          value.cwd !== undefined,
+        { message: 'Provide at least one of state, spec, or cwd.' },
       ),
   },
   patch_thread_details: {
@@ -155,7 +148,7 @@ export const storagePlugin: Plugin = {
     });
 
     builder.on('action:create_channel', async function* (event, context) {
-      const { channelId, spec, initialState, cwd, participants } = (event as any).data;
+      const { channelId, spec, initialState, cwd } = (event as any).data;
       const rawChannelId = (channelId || '').trim();
       const channelSpec = typeof spec === 'string' ? spec : '';
 
@@ -173,15 +166,6 @@ export const storagePlugin: Plugin = {
       const channelUrl = `/channels/${rawChannelId}`;
 
       const mergedInitial: Record<string, unknown> = { ...(initialState || {}) };
-      if (participants !== undefined) {
-        const normalized = Array.isArray(participants)
-          ? participants
-            .filter((x: unknown): x is string => typeof x === 'string')
-            .map((s: string) => s.trim())
-            .filter(Boolean)
-          : [];
-        mergedInitial.participants = normalized;
-      }
 
       try {
         await storage.createChannel({
@@ -254,7 +238,6 @@ export const storagePlugin: Plugin = {
         channelId?: string;
         name?: string;
         cwd?: string;
-        participants?: string[];
       };
       const targetChannelId = (data.channelId || context.state.channelId || '').trim();
       const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
@@ -279,17 +262,6 @@ export const storagePlugin: Plugin = {
         patch.cwd = data.cwd.trim();
         updatedFields.push('cwd');
       }
-      if (data.participants !== undefined) {
-        if (Array.isArray(data.participants)) {
-          patch.participants = data.participants
-            .filter((x): x is string => typeof x === 'string')
-            .map((s) => s.trim())
-            .filter(Boolean);
-        } else {
-          patch.participants = [];
-        }
-        updatedFields.push('participants');
-      }
 
       try {
         if (updatedFields.length > 0) {
@@ -317,13 +289,12 @@ export const storagePlugin: Plugin = {
     });
 
     builder.on('action:patch_channel_details', async function* (event, context) {
-      const updatedFields: ('state' | 'spec' | 'cwd' | 'participants')[] = [];
+      const updatedFields: ('state' | 'spec' | 'cwd')[] = [];
       const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
       const data = (event.data || {}) as {
         state?: Record<string, unknown>;
         spec?: string;
         cwd?: string;
-        participants?: string[];
       };
       try {
         if (data.state !== undefined) {
@@ -347,19 +318,6 @@ export const storagePlugin: Plugin = {
           });
           updatedFields.push('cwd');
         }
-        if (data.participants !== undefined) {
-          const normalized = Array.isArray(data.participants)
-            ? data.participants
-              .filter((x): x is string => typeof x === 'string')
-              .map((s) => s.trim())
-              .filter(Boolean)
-            : [];
-          await storage.patchChannelState({
-            channelId: context.state.channelId,
-            state: { participants: normalized },
-          });
-          updatedFields.push('participants');
-        }
 
         context.state.channelDetails = await storage.getChannelDetails({
           channelId: context.state.channelId,