openbot 0.5.4 → 0.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "private": false,
   "type": "module",
   "engines": {
@@ -11,7 +11,7 @@
     "build": "tsc && mkdir -p dist/assets && cp src/assets/icon.svg dist/assets/icon.svg",
     "start": "node dist/app/cli.js start",
     "format": "prettier --write .",
-    "push": "fly deploy --build-only --push --config deploy/fly.toml -a openbot-runtime --image-label v0.5.4"
+    "push": "fly deploy --build-only --push --config deploy/fly.toml -a openbot-runtime --image-label v0.5.5"
   },
   "bin": {
     "openbot": "./dist/app/cli.js"

package/src/app/cli.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { bootstrap } from './bootstrap.js';
+import { ensureDefaultStack } from './ensure-default-stack.js';
 import { startServer } from './server.js';
 
 const program = new Command();
@@ -26,7 +27,7 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.5.4');
+program.name('openbot').description('OpenBot CLI').version('0.5.5');
 
 program
   .command('start')
@@ -34,6 +35,7 @@ program
   .option('-p, --port <number>', 'Port to listen on')
   .action(async (options) => {
     await bootstrap();
+    await ensureDefaultStack();
     await startServer(options);
   });
 

package/src/app/cloud-mode.ts

@@ -1,35 +1,20 @@
 import { ORCHESTRATOR_AGENT_ID } from './agent-ids.js';
 
-/** Platform-managed OpenBot (Fly + integrations proxy). Self-hosted when unset. */
+/** Platform-managed OpenBot (Fly). Self-hosted when unset. */
 export const isCloudMode = (): boolean => process.env.OPENBOT_CLOUD_MODE === '1';
 
-/** Platform-managed coordinator model for cloud workspaces. */
-export const COORDINATOR_MODEL = 'openbot/coordinator-1';
+/** How the cloud system agent authenticates to LLM providers. */
+export type OpenbotAuthMode = 'credits' | 'byok';
 
-/** Default cloud system agent model. */
-export const CLOUD_SYSTEM_MODEL = COORDINATOR_MODEL;
-
-export interface CloudIntegrationsConfig {
-  baseUrl: string;
-  token: string;
-}
-
-export function getCloudIntegrationsConfig(): CloudIntegrationsConfig | null {
-  if (!isCloudMode()) return null;
-
-  const baseUrl = process.env.OPENBOT_INTEGRATIONS_BASE_URL?.trim();
-  const token = process.env.OPENBOT_INTEGRATIONS_TOKEN?.trim();
-  if (!baseUrl || !token) return null;
-
-  return { baseUrl: baseUrl.replace(/\/$/, ''), token };
-}
+/** Default cloud openbot plugin auth mode. */
+export const DEFAULT_CLOUD_OPENBOT_AUTH_MODE: OpenbotAuthMode = 'credits';
 
 export function isCloudSystemAgent(agentId: string): boolean {
   return isCloudMode() && agentId === ORCHESTRATOR_AGENT_ID;
 }
 
-export function resolveCloudSystemModel(configModel: string | undefined): string {
-  return configModel?.trim() || COORDINATOR_MODEL;
+export function parseOpenbotAuthMode(value: unknown): OpenbotAuthMode {
+  return value === 'byok' ? 'byok' : 'credits';
 }
 
 export function assertCloudSystemAgentPluginsMutable(

package/src/app/ensure-default-stack.ts

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import matter from 'gray-matter';
+import { ORCHESTRATOR_AGENT_ID } from './agent-ids.js';
+import { DEFAULT_SYSTEM_AGENT_MODEL, OPENBOT_PLUGIN_ID } from './openbot-plugin.js';
+import { DEFAULT_CLOUD_OPENBOT_AUTH_MODE, isCloudMode } from './cloud-mode.js';
+import { DEFAULT_AGENTS_DIR, getBaseDir } from './config.js';
+import { pluginService } from '../services/plugins/service.js';
+
+function systemAgentMdPath(): string {
+  return path.join(getBaseDir(), DEFAULT_AGENTS_DIR, ORCHESTRATOR_AGENT_ID, 'AGENT.md');
+}
+
+function defaultSystemPluginConfig(): Record<string, unknown> {
+  const config: Record<string, unknown> = {
+    model: DEFAULT_SYSTEM_AGENT_MODEL,
+  };
+  if (isCloudMode()) {
+    config.authMode = DEFAULT_CLOUD_OPENBOT_AUTH_MODE;
+  }
+  return config;
+}
+
+async function ensureOpenbotPluginInstalled(): Promise<void> {
+  if (await pluginService.isInstalled(OPENBOT_PLUGIN_ID)) {
+    return;
+  }
+
+  console.log(`[bootstrap] Installing ${OPENBOT_PLUGIN_ID} from npm`);
+  await pluginService.install({ packageName: OPENBOT_PLUGIN_ID });
+}
+
+async function ensureSystemAgentMaterialized(): Promise<void> {
+  const agentMdPath = systemAgentMdPath();
+  if (existsSync(agentMdPath)) {
+    return;
+  }
+
+  const agentDir = path.dirname(agentMdPath);
+  await fs.mkdir(agentDir, { recursive: true });
+
+  const frontmatter = {
+    name: 'OpenBot',
+    description: 'First-party orchestration agent for OpenBot.',
+    plugins: [
+      {
+        id: OPENBOT_PLUGIN_ID,
+        config: defaultSystemPluginConfig(),
+      },
+    ],
+  };
+
+  const content = matter.stringify('', frontmatter);
+  await fs.writeFile(agentMdPath, content, 'utf-8');
+  console.log(`[bootstrap] Materialized system agent at ${agentMdPath}`);
+}
+
+/** Install the default agent plugin from npm and materialize the system agent on first boot. */
+export async function ensureDefaultStack(): Promise<void> {
+  await ensureOpenbotPluginInstalled();
+  await ensureSystemAgentMaterialized();
+}

package/src/app/openbot-plugin.ts

@@ -0,0 +1,5 @@
+/** npm package id for the monolithic OpenBot agent runtime plugin. */
+export const OPENBOT_PLUGIN_ID = '@meetopenbot/openbot';
+
+/** Default model for the materialized system agent. */
+export const DEFAULT_SYSTEM_AGENT_MODEL = 'openai/gpt-5.4-mini';

package/src/app/server.ts

@@ -9,7 +9,7 @@ const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 import { generateId } from 'melony';
 import { getBaseDir, loadConfig } from '../app/config.js';
-import { isCloudMode, getCloudIntegrationsConfig } from './cloud-mode.js';
+import { isCloudMode } from './cloud-mode.js';
 import { ActiveRunsSnapshotEvent, OpenBotEvent, OpenBotState } from './types.js';
 import { processService } from '../services/process.js';
 import { runAgent, STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../harness/index.js';
@@ -48,10 +48,7 @@ export async function startServer(options: ServerOptions = {}) {
   processService.syncWorkspaceVariablesToProcessEnv();
 
   if (isCloudMode()) {
-    const integrations = getCloudIntegrationsConfig();
-    console.log(
-      `[server] Cloud mode enabled${integrations ? '' : ' (integrations proxy env not set)'}`,
-    );
+    console.log('[server] Cloud mode enabled');
   }
 
   const openBotDir = getBaseDir();

package/src/app/types.ts

@@ -9,7 +9,7 @@ import {
 } from '../services/plugins/domain.js';
 import type { PluginRef } from '../services/plugins/types.js';
 import type { MemoryRecord } from '../plugins/memory/service.js';
-import type { TodoList } from '../plugins/todo/service.js';
+import type { TodoList } from '../services/todo/types.js';
 
 export interface OpenBotState {
   agentId: string;
@@ -324,7 +324,7 @@ export type PatchThreadDetailsResultEvent = BaseEvent & {
   type: 'action:patch_thread_details:result';
   data: {
     success: boolean;
-    updatedFields: ('state')[];
+    updatedFields: 'state'[];
   };
 };
 
@@ -658,12 +658,7 @@ export type UIWidgetField = {
   defaultValue?: unknown;
 };
 
-export type UIWidgetListItemStatusVariant =
-  | 'default'
-  | 'success'
-  | 'warning'
-  | 'danger'
-  | 'info';
+export type UIWidgetListItemStatusVariant = 'default' | 'success' | 'warning' | 'danger' | 'info';
 
 export type UIWidgetListItem = {
   id: string;

package/src/harness/index.ts

@@ -8,6 +8,7 @@ import { ToolDefinition } from '../services/plugins/types.js';
 import { abortRegistry, abortKey } from '../services/abort.js';
 import { loadConfig } from '../app/config.js';
 import { getPublicBaseUrl } from '../plugins/storage/files.js';
+import { createPluginHost } from '../services/plugins/host.js';
 
 export { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID };
 
@@ -119,6 +120,8 @@ export async function runAgent(options: RunAgentOptions): Promise<void> {
 
     const builder = melony<OpenBotState, OpenBotEvent>().initialState(state);
 
+    const pluginHost = createPluginHost(runAgent);
+
     for (const ref of pluginRefs) {
       const plugin = await resolvePlugin(ref.id);
       if (!plugin) continue;
@@ -132,6 +135,7 @@ export async function runAgent(options: RunAgentOptions): Promise<void> {
           tools,
           publicBaseUrl,
           abortSignal,
+          host: pluginHost,
         }),
       );
     }

package/src/plugins/storage/index.ts

@@ -1,106 +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.'),
-        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). Use for thread metadata such as `name` or `isSmartNamed`. For multi-step task tracking, use `todo_write` instead.',
-    inputSchema: z.object({
-      state: z
-        .record(z.string(), z.unknown())
-        .describe('JSON state object for the thread. Merges with existing state.'),
-    }),
-  },
-  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;
 
@@ -144,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;
@@ -735,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 },
-        };
-      }
-    });
   },
 };