openbot 0.4.5 → 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.5');
+program.name('openbot').description('OpenBot CLI').version('0.4.6');
 program
     .command('start')
     .description('Start the OpenBot harness')

package/dist/app/server.js

@@ -17,6 +17,7 @@ import { buildWorkspaceFileUrl, getPublicBaseUrl, openChannelFileStream, } from
 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({
@@ -43,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') ||
@@ -55,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,
@@ -434,6 +445,17 @@ 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,

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

package/dist/plugins/plugin-manager/index.js

@@ -54,64 +54,22 @@ export const pluginManagerPlugin = {
             });
             builder.on('action:channel:install', async function* (event) {
                 try {
-                    const { channelId: instanceId, name: templateName, participants: customParticipants, initialState: customInitialState, } = event.data;
-                    const { agents: marketplaceAgents, channels } = await resolveMarketplaceRegistry();
+                    const { channelId: instanceId, name: templateName, initialState: customInitialState, } = event.data;
+                    const { channels } = await resolveMarketplaceRegistry();
                     // Try to find the template by ID or Name
                     const channelListing = channels.find((c) => c.id === instanceId) ||
                         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}`;
                     yield {

package/dist/plugins/storage/index.js

@@ -38,15 +38,10 @@ const storageToolDefinitions = {
                 .optional()
                 .describe('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: {
         description: 'Patch current thread details (state).',
@@ -125,7 +120,7 @@ export const storagePlugin = {
             };
         });
         builder.on('action:create_channel', async function* (event, context) {
-            const { channelId, spec, initialState, cwd, participants } = event.data;
+            const { channelId, spec, initialState, cwd } = event.data;
             const rawChannelId = (channelId || '').trim();
             const channelSpec = typeof spec === 'string' ? spec : '';
             const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
@@ -139,15 +134,6 @@ export const storagePlugin = {
             }
             const channelUrl = `/channels/${rawChannelId}`;
             const mergedInitial = { ...(initialState || {}) };
-            if (participants !== undefined) {
-                const normalized = Array.isArray(participants)
-                    ? participants
-                        .filter((x) => typeof x === 'string')
-                        .map((s) => s.trim())
-                        .filter(Boolean)
-                    : [];
-                mergedInitial.participants = normalized;
-            }
             try {
                 await storage.createChannel({
                     channelId: rawChannelId,
@@ -232,18 +218,6 @@ export const storagePlugin = {
                 patch.cwd = data.cwd.trim();
                 updatedFields.push('cwd');
             }
-            if (data.participants !== undefined) {
-                if (Array.isArray(data.participants)) {
-                    patch.participants = data.participants
-                        .filter((x) => typeof x === 'string')
-                        .map((s) => s.trim())
-                        .filter(Boolean);
-                }
-                else {
-                    patch.participants = [];
-                }
-                updatedFields.push('participants');
-            }
             try {
                 if (updatedFields.length > 0) {
                     await storage.patchChannelState({ channelId: targetChannelId, state: patch });
@@ -293,19 +267,6 @@ export const storagePlugin = {
                     });
                     updatedFields.push('cwd');
                 }
-                if (data.participants !== undefined) {
-                    const normalized = Array.isArray(data.participants)
-                        ? data.participants
-                            .filter((x) => 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,
                 });