openbot 0.4.5 → 0.4.6

package/dist/plugins/storage/service.js

@@ -340,18 +340,16 @@ const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArr
 /** Display-oriented fields persisted in a channel's `state.json`. */
 const readChannelStateFileFields = (parsed) => {
     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 = [];
-    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) => {
+    const statePath = `${getConversationDir(channelId)}/state.json`;
+    const state = await readJsonFile(statePath, {});
+    return !!readChannelStateFileFields(state).cwd;
 };
 /**
  * Parse the `plugins:` array from AGENT.md frontmatter. Each entry must have an
@@ -412,23 +410,23 @@ export const storageService = {
             const statePath = path.join(channelDir, 'state.json');
             let cwd;
             let displayName = name;
-            let participants = [];
             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 = {
                 id: name,
                 name: displayName,
                 description: '',
                 cwd,
-                participants,
                 createdAt: stats.birthtime,
                 updatedAt: stats.mtime,
             };
@@ -452,7 +450,9 @@ export const storageService = {
             }
             return channel;
         }));
-        return channels.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return channels
+            .filter((channel) => channel !== null)
+            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     },
     createChannel: async ({ channelId, spec, initialState, cwd, }) => {
         const normalizedChannelId = channelId.trim();
@@ -486,6 +486,44 @@ export const storageService = {
             `# ${normalizedChannelId}\n\n`);
         await writeJsonFileAtomically(statePath, finalState);
     },
+    ensureChannel: async ({ channelId, spec, initialState, cwd, }) => {
+        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(statePath, {});
+        const existingFields = readChannelStateFileFields(existingState);
+        if (existingFields.cwd) {
+            await fs.mkdir(resolvePath(existingFields.cwd), { recursive: true });
+            return;
+        }
+        const finalState = {
+            ...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) {
+            if (error?.code === 'ENOENT') {
+                await fs.writeFile(specPath, spec?.trim() || `# ${normalizedChannelId}\n\n`);
+            }
+            else {
+                throw error;
+            }
+        }
+        await writeJsonFileAtomically(statePath, finalState);
+    },
     deleteChannel: async ({ channelId }) => {
         const normalizedChannelId = channelId.trim();
         if (!normalizedChannelId) {
@@ -648,7 +686,6 @@ export const storageService = {
             spec,
             state,
             cwd,
-            participants: diskFields.participants,
         };
         details.threads = await storageService.getThreads({ channelId });
         return details;
@@ -1030,6 +1067,9 @@ export const storageService = {
     },
     storeEvent: async ({ channelId, threadId, event, }) => {
         try {
+            if (!(await isChannelProvisioned(channelId))) {
+                return;
+            }
             const threadDir = getConversationDir(channelId, threadId);
             if (threadId) {
                 let exists = false;

package/dist/services/plugins/service.js

@@ -74,20 +74,16 @@ export function parseMarketplaceRegistryJson(data) {
         const id = item.id;
         const name = item.name;
         const description = item.description;
-        const participants = item.participants;
         if (typeof id !== 'string' || !id)
             throw new Error(`channels[${i}].id must be a non-empty string`);
         if (typeof name !== 'string')
             throw new Error(`channels[${i}].name must be a string`);
         if (typeof description !== 'string')
             throw new Error(`channels[${i}].description must be a string`);
-        if (!Array.isArray(participants))
-            throw new Error(`channels[${i}].participants must be an array`);
         const listing = {
             id,
             name,
             description,
-            participants: participants.filter((p) => typeof p === 'string'),
         };
         if (typeof item.image === 'string')
             listing.image = item.image;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "private": false,
   "type": "module",
   "engines": {
@@ -16,6 +16,7 @@
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.33",
+    "@ai-sdk/google": "^3.0.82",
     "@ai-sdk/openai": "^3.0.13",
     "@anthropic-ai/claude-agent-sdk": "^0.2.138",
     "@types/cors": "^2.8.19",

package/src/app/channel-ids.ts

@@ -0,0 +1,5 @@
+/** Default channel when requests omit channelId (general-purpose conversation). */
+export const UNCATEGORIZED_CHANNEL_ID = 'uncategorized';
+
+export const DEFAULT_UNCATEGORIZED_SPEC =
+  '# Uncategorized\n\nGeneral-purpose channel for conversations without a dedicated channel.';

package/src/app/cli.ts

@@ -25,7 +25,7 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.4.5');
+program.name('openbot').description('OpenBot CLI').version('0.4.6');
 
 program
   .command('start')

package/src/app/server.ts

@@ -22,6 +22,10 @@ import {
 import { ensureEventId, openBotEventFromQuery } from './utils.js';
 import { abortRegistry, abortKey } from '../services/abort.js';
 import { resolveRespondingAgentId } from './responding-agent.js';
+import {
+  DEFAULT_UNCATEGORIZED_SPEC,
+  UNCATEGORIZED_CHANNEL_ID,
+} from './channel-ids.js';
 
 type Bucket = { channelId: string; threadId?: string; activeCount: number; agentIds: Set<string> };
 
@@ -65,9 +69,18 @@ export async function startServer(options: ServerOptions = {}) {
   storageService.getAgents().catch((err) => console.warn('[server] Failed to pre-warm agents cache', err));
   storageService.getPlugins().catch((err) => console.warn('[server] Failed to pre-warm plugins cache', err));
 
+  const getRawChannelId = (req: express.Request): string | undefined => {
+    const raw =
+      req.get('x-openbot-channel-id') ||
+      req.query.channelId ||
+      (req.body && req.body.channelId);
+    if (typeof raw !== 'string') return undefined;
+    const trimmed = raw.trim();
+    return trimmed || undefined;
+  };
+
   const getContext = (req: express.Request) => {
-    const channelId =
-      req.get('x-openbot-channel-id') || req.query.channelId || (req.body && req.body.channelId);
+    const rawChannelId = getRawChannelId(req);
     const threadId =
       req.get('x-openbot-thread-id') || req.query.threadId || (req.body && req.body.threadId);
     const agentId =
@@ -83,7 +96,8 @@ export async function startServer(options: ServerOptions = {}) {
       (req.body && req.body.responseType);
 
     return {
-      channelId: (channelId || (threadId ? 'uncategorized' : 'uncategorized')) as string, // Default to uncategorized if none
+      channelId: (rawChannelId || UNCATEGORIZED_CHANNEL_ID) as string,
+      rawChannelId,
       threadId: threadId as string | undefined,
       agentId: agentId as string | undefined,
       runId: runId as string,
@@ -532,6 +546,20 @@ export async function startServer(options: ServerOptions = {}) {
     try {
       ensureEventId(event);
 
+      const isUserConversationStart =
+        event.type === 'agent:invoke' &&
+        event.data?.role === 'user' &&
+        typeof event.data.content === 'string' &&
+        event.data.content.trim().length > 0;
+
+      if (isUserConversationStart && channelId === UNCATEGORIZED_CHANNEL_ID) {
+        await storageService.ensureChannel({
+          channelId: UNCATEGORIZED_CHANNEL_ID,
+          spec: DEFAULT_UNCATEGORIZED_SPEC,
+          initialState: { name: 'Uncategorized' },
+        });
+      }
+
       const bindIfUnbound = event.type === 'agent:invoke';
       const resolved = await resolveRespondingAgentId({
         channelId,

package/src/app/types.ts

@@ -301,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[];
   };
 };
 
@@ -310,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')[];
   };
 };
 
@@ -569,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;
@@ -594,8 +590,6 @@ export type UpdateChannelEvent = BaseEvent & {
     channelId?: string;
     name?: string;
     cwd?: string;
-    /** Replaces the channel participant list when provided. */
-    participants?: string[];
   };
 };
 
@@ -655,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;
@@ -851,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;
@@ -863,7 +856,6 @@ export type InstallChannelEvent = BaseEvent & {
   data: {
     channelId: string;
     name?: string;
-    participants?: string[];
     initialState?: Record<string, unknown>;
   };
 };

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.';