openbot 0.4.4 → 0.4.6

package/dist/app/channel-ids.js

@@ -0,0 +1,3 @@
+/** 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/dist/app/cli.js

@@ -16,7 +16,7 @@ function checkNodeVersion() {
     }
 }
 checkNodeVersion();
-program.name('openbot').description('OpenBot CLI').version('0.4.4');
+program.name('openbot').description('OpenBot CLI').version('0.4.6');
 program
     .command('start')
     .description('Start the OpenBot harness')

package/dist/app/responding-agent.js

@@ -0,0 +1,48 @@
+import { ORCHESTRATOR_AGENT_ID } from './agent-ids.js';
+import { storageService } from '../plugins/storage/service.js';
+/** Thread `state.json` key for the sticky responding agent id. */
+export const THREAD_RESPONDING_AGENT_ID_KEY = 'respondingAgentId';
+const readBoundAgentId = (state) => {
+    if (!state || typeof state !== 'object')
+        return undefined;
+    const value = state[THREAD_RESPONDING_AGENT_ID_KEY];
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+};
+/**
+ * Resolves which agent should handle a thread-scoped publish.
+ * Once `respondingAgentId` is stored on the thread, that value wins over request overrides.
+ */
+export async function resolveRespondingAgentId(options) {
+    const { channelId, threadId, requestedAgentId, bindIfUnbound = false } = options;
+    const requested = requestedAgentId?.trim() || undefined;
+    const fallback = requested || ORCHESTRATOR_AGENT_ID;
+    if (!threadId) {
+        return { agentId: fallback, bound: false, overridden: false };
+    }
+    const details = await storageService.getThreadDetails({ channelId, threadId });
+    const bound = readBoundAgentId(details.state);
+    if (bound) {
+        const overridden = !!requested && requested !== bound;
+        if (overridden) {
+            console.warn('[publish] Ignoring agentId override; thread is bound to responding agent', {
+                threadId,
+                bound,
+                requested,
+            });
+        }
+        return { agentId: bound, bound: true, overridden };
+    }
+    if (!bindIfUnbound) {
+        return { agentId: fallback, bound: false, overridden: false };
+    }
+    await storageService.getAgentDetails({ agentId: fallback });
+    await storageService.patchThreadState({
+        channelId,
+        threadId,
+        state: { [THREAD_RESPONDING_AGENT_ID_KEY]: fallback },
+    });
+    return { agentId: fallback, bound: true, overridden: false };
+}

package/dist/app/server.js

@@ -16,6 +16,8 @@ import { storageService } from '../plugins/storage/service.js';
 import { buildWorkspaceFileUrl, getPublicBaseUrl, openChannelFileStream, } from '../plugins/storage/files.js';
 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';
 export async function startServer(options = {}) {
     const publishEventSchema = z
         .object({
@@ -42,8 +44,17 @@ export async function startServer(options = {}) {
     // Pre-warm caches for agents and plugins to speed up first UI load
     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) => {
+        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) => {
-        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 = req.get('x-openbot-agent-id') || req.query.agentId || (req.body && req.body.agentId);
         const runId = req.get('x-openbot-run-id') ||
@@ -54,7 +65,8 @@ export async function startServer(options = {}) {
             req.query.responseType ||
             (req.body && req.body.responseType);
         return {
-            channelId: (channelId || (threadId ? 'uncategorized' : 'uncategorized')), // Default to uncategorized if none
+            channelId: (rawChannelId || UNCATEGORIZED_CHANNEL_ID),
+            rawChannelId,
             threadId: threadId,
             agentId: agentId,
             runId: runId,
@@ -116,18 +128,58 @@ export async function startServer(options = {}) {
             data: { channels },
         };
     };
+    const broadcastActiveRunsSnapshot = () => {
+        const snapshot = buildActiveRunsSnapshot();
+        ensureEventId(snapshot);
+        sendToClientKey(GLOBAL_CHANNEL_ID, snapshot);
+    };
+    const persistLifecycleEvent = (event, targetChannelId, targetThreadId) => {
+        ensureEventId(event);
+        storageService
+            .storeEvent({
+            channelId: targetChannelId,
+            threadId: targetThreadId,
+            event,
+        })
+            .catch((error) => {
+            console.error('[server] Failed to persist lifecycle event', {
+                type: event.type,
+                channelId: targetChannelId,
+                threadId: targetThreadId,
+                error,
+            });
+        });
+    };
     // Drop every tracked run for a channel/thread. A stop aborts the whole
     // chain (parent + delegated sub-agents), but the sub-agents' `agent:run:end`
     // events can be swallowed when the parent run loop breaks on abort, leaving
-    // orphaned entries that keep a channel falsely "active". Purging by
-    // channel/thread guarantees the snapshot self-heals after a stop.
+    // orphaned entries that keep a channel falsely "active". Emit explicit
+    // `agent:run:end` for each purged run and refresh the global snapshot so
+    // clients stay in sync even when the parent harness stops yielding.
     const purgeActiveRunsForThread = (channelId, threadId) => {
         const target = threadId || undefined;
+        const removed = [];
         for (const [key, run] of activeRuns) {
             if (run.channelId === channelId && (run.threadId || undefined) === target) {
+                removed.push(run);
                 activeRuns.delete(key);
             }
         }
+        for (const run of removed) {
+            const endEvent = {
+                type: 'agent:run:end',
+                data: {
+                    runId: run.runId,
+                    agentId: run.agentId,
+                    channelId: run.channelId,
+                    threadId: run.threadId,
+                },
+            };
+            ensureEventId(endEvent);
+            persistLifecycleEvent(endEvent, run.channelId, run.threadId);
+            sendToClientKey(getClientKey(run.channelId, run.threadId), endEvent);
+            sendToClientKey(GLOBAL_CHANNEL_ID, endEvent);
+        }
     };
     // Support for Chrome's Private Network Access (PNA)
     // https://developer.chrome.com/blog/private-network-access-preflight/
@@ -328,19 +380,38 @@ export async function startServer(options = {}) {
             const data = (event.data ?? {});
             const targetChannelId = data.channelId || channelId;
             const targetThreadId = data.threadId || threadId;
+            let resolvedStopAgentId = data.agentId || agentId || ORCHESTRATOR_AGENT_ID;
+            try {
+                const resolved = await resolveRespondingAgentId({
+                    channelId: targetChannelId,
+                    threadId: targetThreadId,
+                    requestedAgentId: data.agentId || agentId,
+                });
+                resolvedStopAgentId = resolved.agentId;
+            }
+            catch (error) {
+                console.warn('[publish] Failed to resolve responding agent for stop request', {
+                    channelId: targetChannelId,
+                    threadId: targetThreadId,
+                    error,
+                });
+            }
             const stopped = abortRegistry.abort(abortKey(targetChannelId, targetThreadId));
             purgeActiveRunsForThread(targetChannelId, targetThreadId);
+            // Resync global clients even when nothing was tracked server-side.
+            broadcastActiveRunsSnapshot();
             const stoppedEvent = {
                 type: 'agent:run:stopped',
                 data: {
                     runId: data.runId || runId,
-                    agentId: data.agentId || agentId || ORCHESTRATOR_AGENT_ID,
+                    agentId: resolvedStopAgentId,
                     channelId: targetChannelId,
                     threadId: targetThreadId,
                     reason: data.reason,
                 },
             };
             ensureEventId(stoppedEvent);
+            persistLifecycleEvent(stoppedEvent, targetChannelId, targetThreadId);
             sendToClientKey(getClientKey(targetChannelId, targetThreadId), stoppedEvent);
             sendToClientKey(GLOBAL_CHANNEL_ID, stoppedEvent);
             res.json({ success: stopped });
@@ -363,6 +434,7 @@ export async function startServer(options = {}) {
             }
             else if (chunk.type === 'agent:run:stopped') {
                 purgeActiveRunsForThread(chunk.data.channelId, chunk.data.threadId);
+                broadcastActiveRunsSnapshot();
             }
             sendToClientKey(targetClientKey, chunk);
             if (chunk.type === 'agent:run:start' ||
@@ -373,9 +445,27 @@ export async function startServer(options = {}) {
         };
         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,
+                threadId,
+                requestedAgentId: agentId,
+                bindIfUnbound,
+            });
             await runAgent({
                 runId,
-                agentId: agentId || ORCHESTRATOR_AGENT_ID,
+                agentId: resolved.agentId,
                 event,
                 channelId,
                 threadId,
@@ -385,6 +475,11 @@ export async function startServer(options = {}) {
             res.sendStatus(200);
         }
         catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const isUnknownAgent = (error instanceof Error &&
+                (error.code === 'AGENT_NOT_FOUND' ||
+                    error.message.includes('does not exist'))) ||
+                message.includes('does not exist');
             console.error('[publish] Failed to dispatch event', {
                 runId,
                 channelId,
@@ -392,6 +487,10 @@ export async function startServer(options = {}) {
                 eventType: event.type,
                 error,
             });
+            if (isUnknownAgent) {
+                res.status(400).json({ error: message });
+                return;
+            }
             res.status(500).json({ error: 'Failed to process publish event' });
         }
     });
@@ -406,6 +505,13 @@ export async function startServer(options = {}) {
             return;
         }
         const { channelId, threadId, agentId, runId } = getContext(req);
+        // In-memory active runs (not persisted). Mirrors the initial SSE frame on __global__.
+        if (channelId === GLOBAL_CHANNEL_ID && event.type === 'action:storage:get-active-runs') {
+            const snapshot = buildActiveRunsSnapshot();
+            ensureEventId(snapshot);
+            res.json({ events: [snapshot] });
+            return;
+        }
         if (event.type === 'action:storage:serve-file') {
             const filePath = event.data?.path;
             if (!channelId?.trim()) {

package/dist/plugins/openbot/context.js

@@ -20,19 +20,11 @@ export const getContextBudgetForModel = (modelString) => {
 };
 /** 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, agentId) {
-    return participants.length === 0 || (participants.length === 1 && participants[0] === agentId);
-}
 /**
  * Simplified context builder for MVP.
  */
 export async function buildContext(state, storage) {
     const { channelId, threadId, channelDetails, agentId, threadDetails, agentDetails } = state;
-    const participants = channelDetails?.participants || [];
-    const isDm = isDmSoloChannel(participants, agentId);
     const sections = [];
     // Fetch agents once if storage is available
     const allAgents = storage?.getAgents ? await storage.getAgents().catch(() => []) : [];
@@ -42,24 +34,13 @@ export async function buildContext(state, storage) {
     }
     // 2. Environment
     let env = '## ENVIRONMENT\n';
-    if (isDm) {
-        env += '- Mode: Direct Message (Solo)\n';
+    const channelName = channelDetails?.name || channelId;
+    env += `- Mode: Channel (#${channelName})\n`;
+    if (channelDetails?.cwd) {
+        env += `- Workspace: ${channelDetails.cwd}\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) => 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`;
+    if (threadId) {
+        env += `- Thread: ${threadDetails?.name || threadId}\n`;
     }
     sections.push(env);
     // 2.5 Installed Agents

package/dist/plugins/openbot/runtime.js

@@ -1,10 +1,27 @@
 import { generateText } from 'ai';
 import { openai } from '@ai-sdk/openai';
 import { anthropic } from '@ai-sdk/anthropic';
+import { google } from '@ai-sdk/google';
 import { eventsToModelMessages } from './history.js';
 import { 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';
+let cachedRegistry = null;
+async function fetchRegistry() {
+    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());
+        return cachedRegistry;
+    }
+    catch (error) {
+        console.error('[openbot] Failed to fetch model registry:', error);
+        return null;
+    }
+}
 function resolveModel(modelString) {
     const [provider, ...rest] = modelString.split('/');
     const modelId = rest.join('/');
@@ -16,6 +33,8 @@ function resolveModel(modelString) {
             return openai(modelId);
         case 'anthropic':
             return anthropic(modelId);
+        case 'google':
+            return google(modelId);
         default:
             throw new Error(`Unsupported AI provider: "${provider}"`);
     }
@@ -182,47 +201,20 @@ export const openbotRuntime = (options) => (builder) => {
                 errorMessage.includes('Unauthorized') ||
                 errorMessage.includes('authentication');
             if (isApiKeyError) {
-                const [currentProvider, ...rest] = currentModelString.split('/');
-                const currentModelId = rest.join('/');
                 yield {
                     type: 'client:ui:widget',
                     data: {
-                        kind: 'form',
-                        widgetId: `api_key_request_${Date.now()}`,
-                        title: `AI Provider API Key Required`,
-                        description: API_KEY_SETUP_MESSAGE,
-                        fields: [
-                            {
-                                id: 'provider',
-                                label: 'Provider',
-                                type: 'select',
-                                required: true,
-                                options: [
-                                    { label: 'OpenAI', value: 'openai' },
-                                    { label: 'Anthropic', value: 'anthropic' },
-                                ],
-                                defaultValue: currentProvider === 'anthropic' ? 'anthropic' : 'openai',
-                            },
-                            {
-                                id: 'model',
-                                label: 'Model',
-                                type: 'text',
-                                description: 'Model name without the provider prefix (e.g. `gpt-4o-mini` or `claude-3-5-sonnet-20240620`).',
-                                placeholder: 'gpt-4o-mini',
-                                required: true,
-                                defaultValue: currentModelId,
-                            },
-                            {
-                                id: 'apiKey',
-                                label: 'API Key',
-                                type: 'text',
-                                placeholder: `sk-...`,
-                                required: true,
-                            },
+                        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 },
@@ -244,43 +236,6 @@ export const openbotRuntime = (options) => (builder) => {
             };
         }
         const threadId = event.meta?.threadId || context.state.threadId;
-        // Auto-add participants if tagged in the prompt
-        const content = event.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,
-                            },
-                        };
-                    }
-                }
-            }
-            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(context.state, storage, context.state.channelId, threadId).clear();
@@ -302,15 +257,88 @@ export const openbotRuntime = (options) => (builder) => {
         yield* runLLM(context, threadId);
     });
     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];
+            const providerLinks = {
+                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;
+            const link = providerLinks[provider] || '';
+            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 },
+            };
+            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 },
+            };
+            return;
+        }
         if (metadata?.type !== 'api_key_request')
             return;
-        if (!values?.apiKey || !values?.provider || !values?.model)
+        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}` },
@@ -318,7 +346,11 @@ export const openbotRuntime = (options) => (builder) => {
             };
             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;
@@ -363,10 +395,13 @@ export const openbotRuntime = (options) => (builder) => {
                     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 {

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

@@ -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,5 +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.';