@meetopenbot/openbot 0.1.6 → 0.1.8

package/dist/index.d.ts

@@ -12,11 +12,7 @@ export declare const openbotPlugin: {
     configSchema: {
         type: "object";
         properties: {
-            model: {
-                type: "string";
-                override: true;
-                description: string;
-            };
+            model: import("./model-registry.js").ModelConfigField;
             authMode?: {
                 type: "string";
                 description: string;

package/dist/index.js

@@ -1,5 +1,6 @@
 import { defineOpenbotPlugin } from './types.js';
 import { isCloudMode } from './cloud-mode.js';
+import { resolveModelConfigField } from './model-registry.js';
 import { openbotRuntime } from './runtime.js';
 import { bashPlugin } from './tools/bash.js';
 import { memoryPlugin } from './tools/memory.js';
@@ -10,6 +11,7 @@ import { uiPlugin } from './tools/ui.js';
 import { previewPlugin } from './tools/preview.js';
 import { storageToolPlugin } from './tools/storage.js';
 export const OPENBOT_PLUGIN_ID = '@meetopenbot/openbot';
+const modelField = await resolveModelConfigField();
 /**
  * `@meetopenbot/openbot` — the standard, opinionated OpenBot agent runtime.
  *
@@ -33,11 +35,7 @@ export const openbotPlugin = defineOpenbotPlugin({
                     },
                 }
                 : {}),
-            model: {
-                type: 'string',
-                override: true,
-                description: 'Model from the hosted marketplace registry.',
-            },
+            model: modelField,
         },
     },
     toolDefinitions: {

package/dist/model-registry.d.ts

@@ -0,0 +1,35 @@
+export type ModelRegistryProvider = {
+    label: string;
+    models: Array<{
+        id: string;
+        label: string;
+        description: string;
+    }>;
+};
+export type ModelRegistry = {
+    providers?: Record<string, ModelRegistryProvider>;
+};
+export type ModelConfigField = {
+    type: 'string';
+    description: string;
+    default?: string;
+    override?: boolean;
+    enum?: string[];
+    options?: Array<{
+        label: string;
+        value: string;
+        description?: string;
+    }>;
+};
+export declare const PROVIDER_API_KEY_LINKS: Record<string, string>;
+export declare function fetchModelRegistry(): Promise<ModelRegistry | null>;
+export declare function listApiKeyProviders(registry: ModelRegistry | null): Array<{
+    id: string;
+    label: string;
+}>;
+export declare function getProviderModelOptions(registry: ModelRegistry | null, provider: string): Array<{
+    label: string;
+    value: string;
+}> | undefined;
+/** Registry-backed model field for plugin configSchema (`enum` + labeled `options`). */
+export declare function resolveModelConfigField(): Promise<ModelConfigField>;

package/dist/model-registry.js

@@ -0,0 +1,91 @@
+const DEFAULT_REGISTRY_URL = 'https://raw.githubusercontent.com/meetopenbot/openbot-registry/main/registry.json';
+const API_KEY_PROVIDER_IDS = ['openai', 'anthropic', 'google'];
+export const PROVIDER_API_KEY_LINKS = {
+    openai: 'https://platform.openai.com/api-keys',
+    anthropic: 'https://console.anthropic.com/settings/keys',
+    google: 'https://aistudio.google.com/app/apikey',
+};
+const FALLBACK_PROVIDERS = [
+    { id: 'openai', label: 'OpenAI' },
+    { id: 'anthropic', label: 'Anthropic' },
+    { id: 'google', label: 'Google' },
+];
+let cachedRegistry;
+export async function fetchModelRegistry() {
+    if (cachedRegistry !== undefined)
+        return cachedRegistry;
+    const url = process.env.OPENBOT_MODEL_REGISTRY_URL?.trim() || DEFAULT_REGISTRY_URL;
+    try {
+        const response = await fetch(url, {
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!response.ok) {
+            cachedRegistry = null;
+            return null;
+        }
+        cachedRegistry = (await response.json());
+        return cachedRegistry;
+    }
+    catch {
+        cachedRegistry = null;
+        return null;
+    }
+}
+export function listApiKeyProviders(registry) {
+    if (!registry?.providers)
+        return FALLBACK_PROVIDERS;
+    const providers = API_KEY_PROVIDER_IDS.flatMap((id) => {
+        const provider = registry.providers?.[id];
+        return provider ? [{ id, label: provider.label }] : [];
+    });
+    return providers.length > 0 ? providers : FALLBACK_PROVIDERS;
+}
+export function getProviderModelOptions(registry, provider) {
+    const models = registry?.providers?.[provider]?.models;
+    if (!models?.length)
+        return undefined;
+    return models.map((m) => ({ label: m.label, value: m.id }));
+}
+function listAllModelOptions(registry) {
+    if (!registry?.providers)
+        return [];
+    const options = [];
+    for (const providerId of API_KEY_PROVIDER_IDS) {
+        const provider = registry.providers[providerId];
+        if (!provider)
+            continue;
+        for (const model of provider.models ?? []) {
+            options.push({
+                value: `${providerId}/${model.id}`,
+                label: `${provider.label} — ${model.label}`,
+                description: model.description,
+            });
+        }
+    }
+    return options;
+}
+const freeInputModelField = () => ({
+    type: 'string',
+    override: true,
+    description: 'Provider model in provider/model-id format (e.g. openai/gpt-4o-mini).',
+    default: 'openai/gpt-4o-mini',
+});
+/** Registry-backed model field for plugin configSchema (`enum` + labeled `options`). */
+export async function resolveModelConfigField() {
+    const registry = await fetchModelRegistry();
+    const options = listAllModelOptions(registry);
+    if (options.length === 0)
+        return freeInputModelField();
+    const defaultModel = options.find((option) => option.value === 'openai/gpt-4o-mini')?.value ??
+        options.find((option) => option.value.startsWith('openai/'))?.value ??
+        options[0].value;
+    return {
+        type: 'string',
+        override: true,
+        description: 'Model from the OpenBot registry.',
+        default: defaultModel,
+        enum: options.map((option) => option.value),
+        options,
+    };
+}

package/dist/runtime.js

@@ -4,6 +4,7 @@ import { buildContext } from './context.js';
 import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
 import { isAuthErrorMessage, isCreditsErrorMessage } from './credits-auth.js';
 import { resolveModel } from './model.js';
+import { fetchModelRegistry, getProviderModelOptions, listApiKeyProviders, PROVIDER_API_KEY_LINKS, } from './model-registry.js';
 async function buildSystemPrompt(state, storage) {
     const context = await buildContext(state, storage);
     const sections = [OPENBOT_SYSTEM_PROMPT, '', context];
@@ -187,8 +188,8 @@ export const openbotRuntime = (options) => (builder) => {
                 }
             }
             if (isAuthErrorMessage(errorMessage) && !isCreditsCloudAgent(context.state.agentId)) {
-                const registry = await host.resolveModelRegistry();
-                const providerActions = host.listApiKeyProvidersFromRegistry(registry).map((provider) => ({
+                const registry = await fetchModelRegistry();
+                const providerActions = listApiKeyProviders(registry).map((provider) => ({
                     id: provider.id,
                     label: provider.label,
                     variant: 'primary',
@@ -200,13 +201,7 @@ export const openbotRuntime = (options) => (builder) => {
                         widgetId: `api_provider_selection_${Date.now()}`,
                         title: `Setup AI Provider`,
                         description: `Select a provider to continue.`,
-                        actions: providerActions.length > 0
-                            ? providerActions
-                            : [
-                                { id: 'openai', label: 'OpenAI', variant: 'primary' },
-                                { id: 'anthropic', label: 'Anthropic', variant: 'primary' },
-                                { id: 'google', label: 'Google', variant: 'primary' },
-                            ],
+                        actions: providerActions,
                         metadata: {
                             type: 'api_provider_selection',
                         },
@@ -259,31 +254,11 @@ export const openbotRuntime = (options) => (builder) => {
             const provider = actionId;
             const [_, ...rest] = currentModelString.split('/');
             const currentModelId = rest.join('/');
-            const registry = await host.resolveModelRegistry();
-            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 registry = await fetchModelRegistry();
+            const providerData = registry?.providers?.[provider];
             const label = providerData?.label || provider;
-            const link = providerLinks[provider] || '';
-            const modelOptions = providerData?.models.map((m) => ({
-                label: m.label,
-                value: m.id,
-            }));
-            if (!modelOptions || modelOptions.length === 0) {
-                yield {
-                    type: 'agent:output',
-                    data: {
-                        content: `No models are listed for **${label}** in the marketplace registry.`,
-                    },
-                    meta: { agentId: context.state.agentId },
-                };
-                return;
-            }
-            const defaultModel = modelOptions[0].value;
-            const defaultValue = modelOptions.find((m) => m.value === currentModelId)?.value || defaultModel;
+            const link = PROVIDER_API_KEY_LINKS[provider] || '';
+            const modelOptions = getProviderModelOptions(registry, provider);
             yield {
                 type: 'client:ui:widget',
                 data: {
@@ -298,21 +273,49 @@ export const openbotRuntime = (options) => (builder) => {
                 },
                 meta: { agentId: context.state.agentId, threadId },
             };
+            if (modelOptions && modelOptions.length > 0) {
+                const defaultModelId = modelOptions.find((m) => m.value === currentModelId)?.value || modelOptions[0].value;
+                yield {
+                    type: 'client:ui:widget',
+                    data: {
+                        kind: 'choice',
+                        widgetId: `api_model_selection_${Date.now()}`,
+                        title: 'Select Model',
+                        description: `Choose a ${label} model.`,
+                        actions: modelOptions.map((option) => ({
+                            id: option.value,
+                            label: option.label,
+                            variant: option.value === defaultModelId ? 'primary' : 'secondary',
+                        })),
+                        metadata: {
+                            type: 'api_model_selection',
+                            provider,
+                        },
+                    },
+                    meta: { agentId: context.state.agentId, threadId },
+                };
+                return;
+            }
             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.`,
+                    description: `Enter your API key and model ID.`,
                     fields: [
                         {
                             id: 'model',
                             label: 'Model',
-                            type: 'select',
-                            options: modelOptions,
+                            type: 'text',
+                            description: 'Enter the model ID for this provider.',
+                            placeholder: provider === 'openai'
+                                ? 'gpt-4o-mini'
+                                : provider === 'anthropic'
+                                    ? 'claude-3-5-sonnet-20241022'
+                                    : 'gemini-2.0-flash',
                             required: true,
-                            defaultValue,
+                            defaultValue: currentModelId || '',
                         },
                         {
                             id: 'apiKey',
@@ -333,12 +336,64 @@ export const openbotRuntime = (options) => (builder) => {
             };
             return;
         }
+        if (metadata?.type === 'api_model_selection') {
+            const provider = String(metadata.provider);
+            const modelId = String(actionId).trim();
+            const registry = await fetchModelRegistry();
+            const providerData = registry?.providers?.[provider];
+            const label = providerData?.label || provider;
+            const modelLabel = providerData?.models.find((model) => model.id === modelId)?.label || modelId;
+            const link = PROVIDER_API_KEY_LINKS[provider] || '';
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    widgetId: event.data.widgetId,
+                    kind: 'message',
+                    title: 'Model Selected',
+                    body: `${modelLabel} 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 to continue.`,
+                    fields: [
+                        {
+                            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,
+                        model: modelId,
+                    },
+                },
+                meta: { agentId: context.state.agentId, threadId },
+            };
+            return;
+        }
         if (metadata?.type !== 'api_key_request')
             return;
-        if (!values?.apiKey || !values?.model)
+        if (!values?.apiKey)
             return;
         const provider = String(values.provider || metadata.provider);
-        const modelId = String(values.model).trim();
+        const modelId = String(values.model || metadata.model || '').trim();
+        if (!modelId)
+            return;
         const apiKey = String(values.apiKey);
         if (provider !== 'openai' && provider !== 'anthropic' && provider !== 'google') {
             yield {

package/dist/tools/delegation.d.ts

@@ -1,3 +1,3 @@
-import type { Plugin } from '../types.js';
+import type { Plugin } from "../types.js";
 export declare const delegationPlugin: Plugin;
 export default delegationPlugin;

package/dist/tools/delegation.js

@@ -1,5 +1,5 @@
-import { randomUUID } from 'node:crypto';
-import { z } from 'zod';
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
 /**
  * `delegation` — allows agents to delegate tasks to other agents.
  *
@@ -9,29 +9,33 @@ import { z } from 'zod';
  */
 const delegationToolDefinitions = {
     delegate_task: {
-        description: 'Delegate a specific task or question to another specialized agent.',
+        description: "Delegate a specific task or question to another specialized agent.",
         inputSchema: z.object({
-            agentId: z.string().describe('The ID of the agent to delegate to (e.g., "researcher", "coder").'),
-            prompt: z.string().describe('The instructions or question for the delegated agent.'),
+            agentId: z
+                .string()
+                .describe('The ID of the agent to delegate to (e.g., "researcher", "coder").'),
+            prompt: z
+                .string()
+                .describe("The instructions or question for the delegated agent."),
         }),
     },
 };
 export const delegationPlugin = {
-    id: 'delegation',
-    name: 'Delegation',
-    description: 'Allows agents to call upon other agents to solve sub-tasks.',
+    id: "delegation",
+    name: "Delegation",
+    description: "Allows agents to call upon other agents to solve sub-tasks.",
     toolDefinitions: delegationToolDefinitions,
     factory: (pluginContext) => (builder) => {
         // Handle the tool execution
-        builder.on('action:delegate_task', async function* (event, context) {
+        builder.on("action:delegate_task", async function* (event, context) {
             const delegateEvent = event;
             // POLICY: Only the 'system' agent can delegate
             if (context.state.agentId !== pluginContext.host.orchestratorAgentId) {
                 yield {
-                    type: 'action:delegate_task:result',
+                    type: "action:delegate_task:result",
                     data: {
                         success: false,
-                        error: 'Only the system agent can delegate.'
+                        error: "Only the system agent can delegate.",
                     },
                     meta: delegateEvent.meta,
                 };
@@ -43,7 +47,7 @@ export const delegationPlugin = {
                 return;
             const runAgent = pluginContext.host.runAgent;
             const runId = `dg_${randomUUID()}`;
-            let lastAgentOutput = '';
+            let lastAgentOutput = "";
             // Queue to bridge the async onEvent callback to this generator
             const eventQueue = [];
             let resolveNext = null;
@@ -54,20 +58,19 @@ export const delegationPlugin = {
                 runId,
                 agentId,
                 event: {
-                    type: 'agent:invoke',
+                    type: "agent:invoke",
                     data: {
-                        role: 'user',
+                        role: "user",
                         content: prompt,
                         agentId: agentId,
                     },
                     meta: {
+                        channelId: context.state.channelId,
                         threadId: context.state.threadId,
                         parentAgentId: context.state.agentId,
                         parentToolCallId: toolCallId,
                     },
                 },
-                channelId: context.state.channelId,
-                threadId: context.state.threadId,
                 publicBaseUrl: pluginContext.publicBaseUrl,
                 // Child events are re-yielded to the parent harness, which persists them once.
                 persistEvents: false,
@@ -79,10 +82,10 @@ export const delegationPlugin = {
                             ...outEvent.meta,
                             parentAgentId: context.state.agentId,
                             parentToolCallId: toolCallId,
-                        }
+                        },
                     };
                     eventQueue.push(enrichedEvent);
-                    if (outEvent.type === 'agent:output') {
+                    if (outEvent.type === "agent:output") {
                         lastAgentOutput = outEvent.data.content;
                     }
                     // Wake up the generator loop if it's waiting
@@ -90,10 +93,12 @@ export const delegationPlugin = {
                         resolveNext();
                         resolveNext = null;
                     }
-                }
-            }).catch(error => {
+                },
+            })
+                .catch((error) => {
                 console.error(`[delegation] Error in delegated run ${runId}:`, error);
-            }).finally(() => {
+            })
+                .finally(() => {
                 isFinished = true;
                 if (resolveNext) {
                     resolveNext();
@@ -103,7 +108,9 @@ export const delegationPlugin = {
             // Yield events from the delegated agent as they arrive
             while (!isFinished || eventQueue.length > 0) {
                 if (eventQueue.length === 0) {
-                    await new Promise(r => { resolveNext = r; });
+                    await new Promise((r) => {
+                        resolveNext = r;
+                    });
                 }
                 while (eventQueue.length > 0) {
                     yield eventQueue.shift();
@@ -113,7 +120,7 @@ export const delegationPlugin = {
             await runPromise;
             // Yield the result back to our own LLM runtime.
             yield {
-                type: 'action:delegate_task:result',
+                type: "action:delegate_task:result",
                 data: {
                     success: true,
                     output: lastAgentOutput,

package/dist/types.d.ts

@@ -1,15 +1,15 @@
-import type { Plugin as SdkPlugin, PluginContext as SdkPluginContext, OpenBotState as SdkOpenBotState, ToolActionEvent, PluginFactory as SdkPluginFactory, PluginBuilder, PluginHandlerContext, OpenBotEvent } from '@meetopenbot/plugin-sdk';
-export { definePlugin } from '@meetopenbot/plugin-sdk';
-export type { AgentInvokeEvent, AgentOutputEvent, ConfigSchema, OpenBotEvent, PluginBuilder, PluginFactory, PluginHandlerContext, Storage, ToolDefinition, ToolActionEvent, UIWidgetListItem, UIWidgetResponseEvent, } from '@meetopenbot/plugin-sdk';
-export type MemoryScopeAlias = 'global' | 'agent' | 'channel';
+import type { Plugin as SdkPlugin, PluginContext as SdkPluginContext, OpenBotState as SdkOpenBotState, ToolActionEvent, PluginFactory as SdkPluginFactory, PluginBuilder, PluginHandlerContext, OpenBotEvent } from "@meetopenbot/plugin-sdk";
+export { definePlugin } from "@meetopenbot/plugin-sdk";
+export type { AgentInvokeEvent, AgentOutputEvent, ConfigSchema, OpenBotEvent, PluginBuilder, PluginFactory, PluginHandlerContext, Storage, ToolDefinition, ToolActionEvent, UIWidgetListItem, UIWidgetResponseEvent, } from "@meetopenbot/plugin-sdk";
+export type MemoryScopeAlias = "global" | "agent" | "channel";
 export type DelegateTaskEvent = ToolActionEvent<{
     agentId: string;
     prompt: string;
 }> & {
-    type: 'action:delegate_task';
+    type: "action:delegate_task";
 };
 export type RenderWidgetEvent = ToolActionEvent<Record<string, unknown>> & {
-    type: 'action:render_widget';
+    type: "action:render_widget";
 };
 /** Runtime state extends the SDK with fields used by the OpenBot agent plugin. */
 export type OpenBotState = SdkOpenBotState & {
@@ -18,7 +18,7 @@ export type OpenBotState = SdkOpenBotState & {
         userName?: string;
     };
     pendingToolCallIds?: string[];
-    threadDetails?: SdkOpenBotState['threadDetails'] & {
+    threadDetails?: SdkOpenBotState["threadDetails"] & {
         name?: string;
     };
 };
@@ -32,39 +32,24 @@ export type ActionBuilder = {
 };
 export declare function asActionBuilder(builder: PluginBuilder): ActionBuilder;
 export interface PluginHost {
+    /** Run context (channelId, threadId) is passed on `event.meta`, not as top-level options. */
     runAgent: (options: {
         runId: string;
         agentId: string;
         event: OpenBotEvent;
-        channelId: string;
-        threadId?: string;
         persistEvents?: boolean;
         publicBaseUrl?: string;
         onEvent: (event: OpenBotEvent, state?: OpenBotState) => Promise<void>;
     }) => Promise<void>;
     isCloudSystemAgent: (agentId: string) => boolean;
     isCloudMode: () => boolean;
-    parseOpenbotAuthMode: (value: unknown) => 'credits' | 'byok';
-    resolveModelRegistry: () => Promise<{
-        providers?: Record<string, {
-            label: string;
-            models: Array<{
-                id: string;
-                label: string;
-                description: string;
-            }>;
-        }>;
-    }>;
-    listApiKeyProvidersFromRegistry: (registry: Awaited<ReturnType<PluginHost['resolveModelRegistry']>>) => Array<{
-        id: string;
-        label: string;
-    }>;
+    parseOpenbotAuthMode: (value: unknown) => "credits" | "byok";
     saveConfig: (patch: Record<string, unknown>) => void;
     getBaseDir: () => string;
     resolvePath: (p: string) => string;
     orchestratorAgentId: string;
     openbotPluginId: string;
-    defaultCloudAuthMode: 'credits' | 'byok';
+    defaultCloudAuthMode: "credits" | "byok";
 }
 /** Host context extends the SDK with OpenBot runtime wiring. */
 export interface PluginContext extends SdkPluginContext {
@@ -72,8 +57,8 @@ export interface PluginContext extends SdkPluginContext {
     abortSignal?: AbortSignal;
     host: PluginHost;
 }
-export interface Plugin extends Omit<SdkPlugin, 'factory' | 'configSchema'> {
-    configSchema?: SdkPlugin['configSchema'] | Record<string, unknown>;
+export interface Plugin extends Omit<SdkPlugin, "factory" | "configSchema"> {
+    configSchema?: SdkPlugin["configSchema"] | Record<string, unknown>;
     factory: (context: PluginContext) => SdkPluginFactory;
 }
 /** Type-safe plugin definition for the extended OpenBot host context. */

package/dist/types.js

@@ -1,4 +1,4 @@
-export { definePlugin } from '@meetopenbot/plugin-sdk';
+export { definePlugin } from "@meetopenbot/plugin-sdk";
 export function asActionBuilder(builder) {
     return {
         on(action, handler) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Monolithic OpenBot agent runtime with batteries-included tools.",
   "type": "module",
   "main": "dist/index.js",