openbot 0.4.7 → 0.5.5

package/src/plugins/storage/index.ts

@@ -1,109 +1,15 @@
-import z from 'zod';
 import type { Plugin } from '../../services/plugins/types.js';
 import { OpenBotEvent } from '../../app/types.js';
 import { buildWorkspaceFileUrl } from './files.js';
 
 /**
- * `storage` — exposes channel/thread/variable mutation tools and provides
- * platform-level storage handlers.
+ * `storage` — platform infra handlers for `/api/state` and deterministic reads.
+ * Agent-facing storage tools live in `@meetopenbot/openbot`.
  */
-const storageToolDefinitions = {
-  create_channel: {
-    description:
-      'Create a new channel. Use when the user intent is clearly different from the current channel and should be split. Always confirm before creating. Skip for simple Q&A.',
-    inputSchema: z.object({
-      channelId: z
-        .string()
-        .describe('Unique channel ID (e.g. product-launch, backend-platform, channel_roadmap).'),
-      spec: z
-        .string()
-        .optional()
-        .describe('Optional initial markdown content for the channel spec.'),
-      initialState: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe('Optional initial state object for the channel.'),
-      cwd: z
-        .string()
-        .optional()
-        .describe(
-          'Optional initial current working directory for the channel. Defaults to an absolute path under ~/openbot/{channelId}.',
-        ),
-    }),
-  },
-  patch_channel_details: {
-    description: 'Patch current channel details (state, spec, cwd).',
-    inputSchema: z
-      .object({
-        state: z
-          .record(z.string(), z.unknown())
-          .optional()
-          .describe(
-            'JSON state object for the channel. Use for structured metadata.',
-          ),
-        spec: z
-          .string()
-          .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.'),
-      })
-      .refine(
-        (value) =>
-          value.state !== undefined ||
-          value.spec !== undefined ||
-          value.cwd !== undefined,
-        { message: 'Provide at least one of state, spec, or cwd.' },
-      ),
-  },
-  patch_thread_details: {
-    description: 'Patch current thread details (state).',
-    inputSchema: z.object({
-      state: z
-        .record(z.string(), z.unknown())
-        .describe(
-          'JSON state object for the thread. Use for structured progress or metadata.',
-        ),
-    }),
-  },
-  create_variable: {
-    description: 'Create or update a variable in the workspace storage.',
-    inputSchema: z.object({
-      key: z.string().describe('The key of the variable.'),
-      value: z.string().describe('The value of the variable.'),
-      secret: z.boolean().optional().describe('Whether the variable is a secret.'),
-    }),
-  },
-  delete_variable: {
-    description: 'Delete a variable from the workspace storage.',
-    inputSchema: z.object({
-      key: z.string().describe('The key of the variable to delete.'),
-    }),
-  },
-  delete_channel: {
-    description:
-      'Permanently delete a channel and all its threads and events. Always confirm with the user before deleting.',
-    inputSchema: z.object({
-      channelId: z.string().describe('The channel ID to delete.'),
-    }),
-  },
-  get_workspace_file_url: {
-    description:
-      'Get a fetchable HTTP URL for a file in the current channel workspace (images, video, audio, documents).',
-    inputSchema: z.object({
-      path: z
-        .string()
-        .describe('Path relative to the channel working directory, e.g. "uploads/clip.mp4".'),
-    }),
-  },
-};
-
 export const storagePlugin: Plugin = {
   id: 'storage',
   name: 'Storage',
-  description: 'Tools for creating channels, patching state, and managing workspace variables.',
-  toolDefinitions: storageToolDefinitions,
+  description: 'Infrastructure storage handlers for channels, threads, agents, and files.',
   factory: ({ storage, publicBaseUrl }) => (builder) => {
     const resolvePublicBaseUrl = () => publicBaseUrl;
 
@@ -147,243 +53,6 @@ export const storagePlugin: Plugin = {
       } as OpenBotEvent;
     });
 
-    builder.on('action:create_channel', async function* (event, context) {
-      const { channelId, spec, initialState, cwd } = (event as any).data;
-      const rawChannelId = (channelId || '').trim();
-      const channelSpec = typeof spec === 'string' ? spec : '';
-
-      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-
-      if (!rawChannelId) {
-        yield {
-          type: 'action:create_channel:result',
-          data: { success: false, channelId: '', channelUrl: '' },
-          meta: resultMeta,
-        } as OpenBotEvent;
-        return;
-      }
-
-      const channelUrl = `/channels/${rawChannelId}`;
-
-      const mergedInitial: Record<string, unknown> = { ...(initialState || {}) };
-
-      try {
-        await storage.createChannel({
-          channelId: rawChannelId,
-          spec: channelSpec,
-          initialState: mergedInitial,
-          cwd,
-        });
-
-        yield {
-          type: 'action:create_channel:result',
-          data: { success: true, channelId: rawChannelId, channelUrl },
-          meta: resultMeta,
-        } as OpenBotEvent;
-
-        yield {
-          type: 'agent:output',
-          data: { content: `Created channel \`${rawChannelId}\`.` },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      } catch {
-        yield {
-          type: 'action:create_channel:result',
-          data: { success: false, channelId: rawChannelId, channelUrl },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      }
-    });
-
-    builder.on('action:delete_channel', async function* (event, context) {
-      const rawChannelId = ((event.data as { channelId?: string })?.channelId || '').trim();
-      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-
-      if (!rawChannelId) {
-        yield {
-          type: 'action:delete_channel:result',
-          data: { success: false, channelId: '', error: 'channelId is required' },
-          meta: resultMeta,
-        } as OpenBotEvent;
-        return;
-      }
-
-      try {
-        await storage.deleteChannel({ channelId: rawChannelId });
-        yield {
-          type: 'action:delete_channel:result',
-          data: { success: true, channelId: rawChannelId },
-          meta: resultMeta,
-        } as OpenBotEvent;
-        yield {
-          type: 'agent:output',
-          data: { content: `Deleted channel \`${rawChannelId}\`.` },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      } catch (error) {
-        yield {
-          type: 'action:delete_channel:result',
-          data: {
-            success: false,
-            channelId: rawChannelId,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      }
-    });
-
-    builder.on('action:update_channel', async function* (event, context) {
-      const data = (event.data || {}) as {
-        channelId?: string;
-        name?: string;
-        cwd?: string;
-      };
-      const targetChannelId = (data.channelId || context.state.channelId || '').trim();
-      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-
-      if (!targetChannelId) {
-        yield {
-          type: 'action:update_channel:result',
-          data: { success: false, channelId: '', updatedFields: [] as string[] },
-          meta: resultMeta,
-        } as OpenBotEvent;
-        return;
-      }
-
-      const patch: Record<string, unknown> = {};
-      const updatedFields: string[] = [];
-
-      if (typeof data.name === 'string' && data.name.trim()) {
-        patch.name = data.name.trim();
-        updatedFields.push('name');
-      }
-      if (typeof data.cwd === 'string' && data.cwd.trim()) {
-        patch.cwd = data.cwd.trim();
-        updatedFields.push('cwd');
-      }
-
-      try {
-        if (updatedFields.length > 0) {
-          await storage.patchChannelState({ channelId: targetChannelId, state: patch });
-        }
-
-        if (targetChannelId === context.state.channelId) {
-          context.state.channelDetails = await storage.getChannelDetails({
-            channelId: context.state.channelId,
-          });
-        }
-
-        yield {
-          type: 'action:update_channel:result',
-          data: { success: true, channelId: targetChannelId, updatedFields },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      } catch {
-        yield {
-          type: 'action:update_channel:result',
-          data: { success: false, channelId: targetChannelId, updatedFields },
-          meta: resultMeta,
-        } as OpenBotEvent;
-      }
-    });
-
-    builder.on('action:patch_channel_details', async function* (event, context) {
-      const updatedFields: ('state' | 'spec' | 'cwd')[] = [];
-      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-      const data = (event.data || {}) as {
-        state?: Record<string, unknown>;
-        spec?: string;
-        cwd?: string;
-      };
-      try {
-        if (data.state !== undefined) {
-          await storage.patchChannelState({
-            channelId: context.state.channelId,
-            state: data.state,
-          });
-          updatedFields.push('state');
-        }
-        if (typeof data.spec === 'string') {
-          await storage.patchChannelSpec({
-            channelId: context.state.channelId,
-            spec: data.spec,
-          });
-          updatedFields.push('spec');
-        }
-        if (typeof data.cwd === 'string') {
-          await storage.patchChannelState({
-            channelId: context.state.channelId,
-            state: { cwd: data.cwd },
-          });
-          updatedFields.push('cwd');
-        }
-
-        context.state.channelDetails = await storage.getChannelDetails({
-          channelId: context.state.channelId,
-        });
-
-        yield {
-          type: "client:ui:widget",
-          data: {
-            widgetId: "patch-channel-details-result" + Date.now(),
-            kind: "message",
-            title: "Channel details updated.",
-            body: `The channel details have been updated. ${updatedFields.join(', ')}`,
-            display: "collapsed",
-          },
-          meta: resultMeta,
-        }
-
-        yield {
-          type: 'action:patch_channel_details:result',
-          data: { success: true, updatedFields },
-          meta: resultMeta,
-        };
-      } catch {
-        yield {
-          type: 'action:patch_channel_details:result',
-          data: { success: false, updatedFields },
-          meta: resultMeta,
-        };
-      }
-    });
-
-    builder.on('action:patch_thread_details', async function* (event, context) {
-      const updatedFields: ('state')[] = [];
-      const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-      try {
-        if (!context.state.threadId) {
-          throw new Error('Missing threadId in state for patch_thread_details');
-        }
-        if ((event.data as any).state !== undefined) {
-          await storage.patchThreadState({
-            channelId: context.state.channelId,
-            threadId: context.state.threadId,
-            state: (event.data as any).state,
-          });
-          updatedFields.push('state');
-        }
-
-        context.state.threadDetails = await storage.getThreadDetails({
-          channelId: context.state.channelId,
-          threadId: context.state.threadId,
-        });
-
-        yield {
-          type: 'action:patch_thread_details:result',
-          data: { success: true, updatedFields },
-          meta: resultMeta,
-        };
-      } catch {
-        yield {
-          type: 'action:patch_thread_details:result',
-          data: { success: false, updatedFields },
-          meta: resultMeta,
-        };
-      }
-    });
-
     builder.on('agent:usage', async function* (event, context) {
       const { usage } = event.data;
       if (!context.state.threadId) return;
@@ -738,43 +407,6 @@ export const storagePlugin: Plugin = {
         };
       }
     });
-
-    builder.on('action:get_workspace_file_url', async function* (event, context) {
-      const channelId = context.state.channelId;
-      const filePath = (event.data as { path?: string })?.path;
-      const toolCallId = event.meta?.toolCallId;
-
-      if (!filePath) {
-        yield {
-          type: 'action:get_workspace_file_url:result',
-          data: { success: false, path: '', error: 'Path is required', output: 'Path is required' },
-          meta: { ...(event.meta || {}), toolCallId },
-        };
-        return;
-      }
-
-      try {
-        const { size, mimeType } = await storage.getChannelFileStat({ channelId, path: filePath });
-        const url = buildWorkspaceFileUrl({
-          baseUrl: resolvePublicBaseUrl(),
-          channelId,
-          filePath,
-        });
-        const output = JSON.stringify({ path: filePath, url, mimeType, size });
-        yield {
-          type: 'action:get_workspace_file_url:result',
-          data: { success: true, path: filePath, url, mimeType, size, output },
-          meta: { ...(event.meta || {}), toolCallId },
-        };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        yield {
-          type: 'action:get_workspace_file_url:result',
-          data: { success: false, path: filePath, error: message, output: message },
-          meta: { ...(event.meta || {}), toolCallId },
-        };
-      }
-    });
   },
 };
 

package/src/plugins/storage/service.ts

@@ -1,11 +1,15 @@
 import { ORCHESTRATOR_AGENT_ID, STATE_AGENT_ID } from '../../app/agent-ids.js';
+import {
+  assertCloudSystemAgentPluginsMutable,
+  DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
+  isCloudMode,
+} from '../../app/cloud-mode.js';
 import {
   DEFAULT_PLUGINS_DIR,
   DEFAULT_AGENTS_DIR,
-  DEFAULT_BASE_DIR,
   DEFAULT_CHANNELS_DIR,
+  getBaseDir,
   getDefaultChannelCwd,
-  loadConfig,
   resolvePath,
   StoredVariable,
   VARIABLES_FILE,
@@ -27,8 +31,12 @@ import {
   ThreadState,
 } from '../../services/plugins/domain.js';
 import type { PluginRef } from '../../services/plugins/types.js';
-import { openbotPlugin } from '../openbot/index.js';
+import { OPENBOT_PLUGIN_ID } from '../../app/openbot-plugin.js';
 import { listBuiltInPlugins, parsePluginModule } from '../../services/plugins/registry.js';
+import {
+  enrichOpenbotPluginDescriptor,
+  listRegistryModelOptions,
+} from '../../services/plugins/model-registry.js';
 import { OpenBotEvent, OpenBotState } from '../../app/types.js';
 import { processService } from '../../services/process.js';
 import { memoryService } from '../memory/service.js';
@@ -38,10 +46,7 @@ import {
   statChannelFile,
 } from './files.js';
 
-const resolveBaseDir = () => {
-  const config = loadConfig();
-  return resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-};
+const resolveBaseDir = () => getBaseDir();
 
 const ENTITY_SVG_CANDIDATE_NAMES = ['avatar.svg', 'icon.svg', 'image.svg', 'logo.svg'] as const;
 
@@ -117,16 +122,46 @@ const SYSTEM_AGENT_ID = ORCHESTRATOR_AGENT_ID;
 
 const SYSTEM_DEFAULT_PLUGINS: PluginRef[] = [
   {
-    id: 'openbot',
+    id: OPENBOT_PLUGIN_ID,
     config: {
       model: 'openai/gpt-5.4-mini',
-      approval: {
-        actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
-      },
     },
   },
 ];
 
+function getCloudSystemDefaultPlugins(): PluginRef[] {
+  return SYSTEM_DEFAULT_PLUGINS.map((ref) => {
+    if (ref.id !== OPENBOT_PLUGIN_ID) return ref;
+    return {
+      ...ref,
+      config: {
+        ...ref.config,
+        authMode: DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
+      },
+    };
+  });
+}
+
+function mergeCloudSystemPluginRefs(
+  defaults: PluginRef[],
+  diskRefs: PluginRef[],
+): PluginRef[] {
+  const defaultOpenbot = defaults.find((ref) => ref.id === OPENBOT_PLUGIN_ID);
+  const diskOpenbot = diskRefs.find((ref) => ref.id === OPENBOT_PLUGIN_ID);
+
+  if (!defaultOpenbot) return defaults;
+
+  return [
+    {
+      ...defaultOpenbot,
+      config: {
+        ...defaultOpenbot.config,
+        ...diskOpenbot?.config,
+      },
+    },
+  ];
+}
+
 /** No `openbot` / `bash` — storage-side effects and infra plugins only. */
 const STATE_DEFAULT_PLUGINS: PluginRef[] = [
   { id: 'storage' },
@@ -137,6 +172,7 @@ const STATE_AGENT_INSTRUCTIONS =
   'Built-in infra agent for deterministic state reads. No conversational model is attached; handle storage, approvals, memory, and plugin marketplace events.';
 
 function getSystemAgentDetails(overrides?: Partial<AgentDetails>): AgentDetails {
+  const defaultPlugins = isCloudMode() ? getCloudSystemDefaultPlugins() : SYSTEM_DEFAULT_PLUGINS;
   const defaults: AgentDetails = {
     id: SYSTEM_AGENT_ID,
     name: 'OpenBot',
@@ -144,22 +180,41 @@ function getSystemAgentDetails(overrides?: Partial<AgentDetails>): AgentDetails
     description:
       'First-party orchestration agent for OpenBot.',
     instructions: '',
-    plugins: SYSTEM_DEFAULT_PLUGINS.map((ref) => ref.id),
-    pluginRefs: SYSTEM_DEFAULT_PLUGINS,
+    plugins: defaultPlugins.map((ref) => ref.id),
+    pluginRefs: defaultPlugins,
     createdAt: new Date(),
     updatedAt: new Date(),
   };
 
   if (!overrides) return defaults;
 
-  const refs = overrides.pluginRefs && overrides.pluginRefs.length > 0
-    ? overrides.pluginRefs
-    : defaults.pluginRefs;
-
   const diskInstructions = overrides.instructions?.trim();
   const instructions =
     diskInstructions && diskInstructions.length > 0 ? diskInstructions : defaults.instructions;
 
+  if (isCloudMode()) {
+    const diskRefs =
+      overrides.pluginRefs && overrides.pluginRefs.length > 0 ? overrides.pluginRefs : undefined;
+    const refs = diskRefs
+      ? mergeCloudSystemPluginRefs(defaults.pluginRefs, diskRefs)
+      : defaults.pluginRefs;
+
+    return {
+      ...defaults,
+      ...overrides,
+      id: SYSTEM_AGENT_ID,
+      instructions,
+      image: overrides.image || defaults.image,
+      plugins: refs.map((ref) => ref.id),
+      pluginRefs: refs,
+      updatedAt: new Date(),
+    };
+  }
+
+  const refs = overrides.pluginRefs && overrides.pluginRefs.length > 0
+    ? overrides.pluginRefs
+    : defaults.pluginRefs;
+
   return {
     ...defaults,
     ...overrides,
@@ -220,9 +275,6 @@ const agentSummaryFromDetails = (details: AgentDetails): Agent => ({
   updatedAt: details.updatedAt,
 });
 
-// Suppress unused warning until system agent customization re-uses openbotPlugin metadata.
-void openbotPlugin;
-
 /** Built-in agents may persist optional `agents/<id>/AGENT.md` overlays; read path merges them with defaults. */
 const isBuiltinOverlayAgentId = (agentId: string): boolean =>
   agentId === SYSTEM_AGENT_ID || agentId === STATE_AGENT_ID;
@@ -992,12 +1044,17 @@ export const storageService = {
     return Array.from(deduped.values()).filter((agent) => !agent.hidden);
   },
   getPlugins: async (): Promise<PluginDescriptor[]> => {
-    const [builtIn, fromDisk] = await Promise.all([
+    const [builtIn, fromDisk, modelOptions] = await Promise.all([
       listBuiltInPluginDescriptors(),
       listPluginsFromDisk(),
+      listRegistryModelOptions(),
     ]);
 
-    const merged = [...builtIn, ...fromDisk];
+    const enrichedBuiltIn = builtIn.map((plugin) =>
+      enrichOpenbotPluginDescriptor(plugin, modelOptions),
+    );
+
+    const merged = [...enrichedBuiltIn, ...fromDisk];
     const deduped = new Map<string, PluginDescriptor>();
     for (const plugin of merged) {
       if (!deduped.has(plugin.id)) {
@@ -1081,6 +1138,7 @@ export const storageService = {
     plugins: PluginRef[];
   }): Promise<void> => {
     assertAgentIdFormat(agentId);
+    assertCloudSystemAgentPluginsMutable(agentId, plugins);
     const agentDir = resolvePath(path.join(getAgentsRootDir(), agentId));
     const agentMdPath = path.join(agentDir, 'AGENT.md');
 
@@ -1133,6 +1191,7 @@ export const storageService = {
     plugins?: PluginRef[];
   }): Promise<void> => {
     assertAgentIdFormat(agentId);
+    assertCloudSystemAgentPluginsMutable(agentId, plugins);
     const agentDir = resolvePath(path.join(getAgentsRootDir(), agentId));
     const agentMdPath = path.join(agentDir, 'AGENT.md');
 

package/src/services/plugins/domain.ts

@@ -49,6 +49,8 @@ export type ConfigSchema = {
       description?: string;
       default?: unknown;
       enum?: unknown[];
+      /** Labeled select options (preferred over bare `enum` when present). */
+      options?: Array<{ label: string; value: string; description?: string }>;
       minimum?: number;
       maximum?: number;
       format?: 'password' | 'url' | 'email';

package/src/services/plugins/host.ts

@@ -0,0 +1,36 @@
+import {
+  DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
+  isCloudMode,
+  isCloudSystemAgent,
+  parseOpenbotAuthMode,
+  type OpenbotAuthMode,
+} from '../../app/cloud-mode.js';
+import { ORCHESTRATOR_AGENT_ID } from '../../app/agent-ids.js';
+import { OPENBOT_PLUGIN_ID } from '../../app/openbot-plugin.js';
+import { getBaseDir, resolvePath, saveConfig } from '../../app/config.js';
+import {
+  listApiKeyProvidersFromRegistry,
+  resolveModelRegistry,
+} from './model-registry.js';
+import type { PluginHost, RunAgentHostOptions } from './types.js';
+
+export function createPluginHost(
+  runAgent: (options: RunAgentHostOptions) => Promise<void>,
+): PluginHost {
+  return {
+    runAgent,
+    isCloudSystemAgent,
+    isCloudMode,
+    parseOpenbotAuthMode,
+    resolveModelRegistry,
+    listApiKeyProvidersFromRegistry,
+    saveConfig,
+    getBaseDir,
+    resolvePath,
+    orchestratorAgentId: ORCHESTRATOR_AGENT_ID,
+    openbotPluginId: OPENBOT_PLUGIN_ID,
+    defaultCloudAuthMode: DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
+  };
+}
+
+export type { OpenbotAuthMode };