openbot 0.4.5 → 0.4.7

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,21 +7,16 @@ 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.',
+  '- **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');
-
-/** 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,

package/src/plugins/storage/service.ts

@@ -418,20 +418,20 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
 /** Display-oriented fields persisted in a channel's `state.json`. */
 const readChannelStateFileFields = (
   parsed: unknown,
-): { name?: string; cwd?: string; participants: string[] } => {
+): { name?: string; cwd?: string } => {
   if (!isRecord(parsed)) {
-    return { participants: [] };
+    return {};
   }
   const name =
     typeof parsed.name === 'string' && parsed.name.trim() ? parsed.name.trim() : undefined;
   const cwd = typeof parsed.cwd === 'string' ? parsed.cwd : undefined;
-  const participants: string[] = [];
-  if (Array.isArray(parsed.participants)) {
-    for (const x of parsed.participants) {
-      if (typeof x === 'string' && x.trim()) participants.push(x.trim());
-    }
-  }
-  return { name, cwd, participants };
+  return { name, cwd };
+};
+
+const isChannelProvisioned = async (channelId: string): Promise<boolean> => {
+  const statePath = `${getConversationDir(channelId)}/state.json`;
+  const state = await readJsonFile(statePath, {});
+  return !!readChannelStateFileFields(state).cwd;
 };
 
 /**
@@ -507,24 +507,25 @@ export const storageService = {
         const statePath = path.join(channelDir, 'state.json');
         let cwd: string | undefined;
         let displayName = name;
-        let participants: string[] = [];
 
         try {
           const parsed = await readJsonFile(statePath, {});
           const fields = readChannelStateFileFields(parsed);
           cwd = fields.cwd;
           displayName = fields.name ?? name;
-          participants = fields.participants;
         } catch {
           // ignore
         }
 
+        if (!cwd) {
+          return null;
+        }
+
         const channel: Channel = {
           id: name,
           name: displayName,
           description: '',
           cwd,
-          participants,
           createdAt: stats.birthtime,
           updatedAt: stats.mtime,
         };
@@ -554,7 +555,9 @@ export const storageService = {
       }),
     );
 
-    return channels.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return channels
+      .filter((channel): channel is Channel => channel !== null)
+      .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
   },
   createChannel: async ({
     channelId,
@@ -606,6 +609,64 @@ export const storageService = {
     );
     await writeJsonFileAtomically(statePath, finalState);
   },
+  ensureChannel: async ({
+    channelId,
+    spec,
+    initialState,
+    cwd,
+  }: {
+    channelId: string;
+    spec?: string;
+    initialState?: Record<string, unknown>;
+    cwd?: string;
+  }): Promise<void> => {
+    const normalizedChannelId = channelId.trim();
+    if (!normalizedChannelId) {
+      throw new Error('channelId is required');
+    }
+
+    const channelDir = getConversationDir(normalizedChannelId);
+    const specPath = `${channelDir}/SPEC.md`;
+    const statePath = `${channelDir}/state.json`;
+
+    const existingState = await readJsonFile<Record<string, unknown>>(statePath, {});
+    const existingFields = readChannelStateFileFields(existingState);
+    if (existingFields.cwd) {
+      await fs.mkdir(resolvePath(existingFields.cwd), { recursive: true });
+      return;
+    }
+
+    const finalState: Record<string, unknown> = {
+      ...existingState,
+      ...(initialState || {}),
+    };
+
+    const rawCwd =
+      (typeof cwd === 'string' && cwd.trim()) ||
+      (typeof finalState.cwd === 'string' && finalState.cwd.trim()) ||
+      getDefaultChannelCwd(normalizedChannelId);
+
+    const resolvedCwd = resolvePath(rawCwd);
+    finalState.cwd = resolvedCwd;
+
+    await fs.mkdir(resolvedCwd, { recursive: true });
+    await fs.mkdir(channelDir, { recursive: true });
+
+    try {
+      await fs.access(specPath);
+    } catch (error: unknown) {
+      if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') {
+        await fs.writeFile(
+          specPath,
+          spec?.trim() || `# ${normalizedChannelId}\n\n`,
+        );
+      } else {
+        throw error;
+      }
+    }
+
+    await writeJsonFileAtomically(statePath, finalState);
+  },
   deleteChannel: async ({ channelId }: { channelId: string }): Promise<void> => {
     const normalizedChannelId = channelId.trim();
     if (!normalizedChannelId) {
@@ -808,7 +869,6 @@ export const storageService = {
       spec,
       state,
       cwd,
-      participants: diskFields.participants,
     };
 
     details.threads = await storageService.getThreads({ channelId });
@@ -1290,6 +1350,10 @@ export const storageService = {
     event: OpenBotEvent;
   }): Promise<void> => {
     try {
+      if (!(await isChannelProvisioned(channelId))) {
+        return;
+      }
+
       const threadDir = getConversationDir(channelId, threadId);
       if (threadId) {
         let exists = false;