@meetopenbot/openbot 0.1.6 → 0.1.7

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/types.d.ts

@@ -45,20 +45,6 @@ export interface PluginHost {
     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;
-    }>;
     saveConfig: (patch: Record<string, unknown>) => void;
     getBaseDir: () => string;
     resolvePath: (p: string) => string;

package/package.json

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