openbot 0.4.7 → 0.5.4

package/src/plugins/memory/service.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
+import { getBaseDir } from '../../app/config.js';
 
 /**
  * Global memory service.
@@ -60,10 +60,7 @@ type LogEntry = AddEntry | DeleteEntry | UpdateEntry;
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 500;
 
-const getMemoryDir = (): string => {
-  const config = loadConfig();
-  return path.join(resolvePath(config.baseDir || DEFAULT_BASE_DIR), 'memory');
-};
+const getMemoryDir = (): string => path.join(getBaseDir(), 'memory');
 
 const getLogPath = (): string => path.join(getMemoryDir(), 'log.jsonl');
 

package/src/plugins/openbot/context.ts

@@ -1,6 +1,7 @@
 import { OpenBotState } from '../../app/types.js';
 import { Storage } from '../../services/plugins/domain.js';
 import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
+import { todoService } from '../todo/service.js';
 
 export const DEFAULT_CONTEXT_BUDGET = 8000;
 export const MAX_CONTEXT_FILES = 50;
@@ -55,7 +56,22 @@ export async function buildContext(state: OpenBotState, storage?: Storage): Prom
   }
   sections.push(env);
 
-  // 2.5 Installed Agents
+  // 2.5 Thread todos
+  if (channelId && threadId) {
+    try {
+      const list = await todoService.getTodos({ channelId, threadId });
+      if (list.items.length > 0) {
+        const formatted = list.items
+          .map((t) => `- [${t.status}] (${t.id}) ${t.content}`)
+          .join('\n');
+        sections.push(`## TODOS\n${formatted}`);
+      }
+    } catch (error) {
+      console.warn('[context] Failed to fetch todos:', error);
+    }
+  }
+
+  // 2.6 Installed Agents
   if (allAgents.length > 0) {
     const formatted = allAgents
       .map((a) => `- ${a.id}: ${a.name}${a.description ? ` - ${a.description}` : ''}`)

package/src/plugins/openbot/index.ts

@@ -1,11 +1,14 @@
 import type { Plugin } from '../../services/plugins/types.js';
+import { isCloudSystemAgent, resolveCloudSystemModel } from '../../app/cloud-mode.js';
 import { openbotRuntime } from './runtime.js';
 import { bashPlugin } from '../bash/index.js';
 import { memoryPlugin } from '../memory/index.js';
+import { todoPlugin } from '../todo/index.js';
 import { approvalPlugin } from '../approval/index.js';
 import { storagePlugin } from '../storage/index.js';
 import { delegationPlugin } from '../delegation/index.js';
 import { uiPlugin } from '../ui/index.js';
+import { previewPlugin } from '../preview/index.js';
 
 /**
  * `openbot` — the standard, opinionated OpenBot agent runtime.
@@ -13,23 +16,21 @@ import { uiPlugin } from '../ui/index.js';
  * This is the canonical execution loop for OpenBot agents. It handles
  * `agent:invoke`, manages short-term memory, assembles context, and
  * orchestrates tool calls.
- * 
- * It comes with a "batteries-included" set of inbuilt tools: bash, memory,
- * storage, delegation, and approval.
+ *
+ * It comes with a "batteries-included" set of inbuilt tools: shell, memory,
+ * todo, storage, delegation, and approval.
  */
 export const openbotPlugin: Plugin = {
   id: 'openbot',
   name: 'OpenBot Agent',
   description:
-    'The standard OpenBot agent runtime with inbuilt tools (bash, memory, storage, delegation, and approval).',
+    'The standard OpenBot agent runtime with inbuilt tools (shell, memory, todo, storage, delegation, and approval).',
   configSchema: {
     type: 'object',
     properties: {
       model: {
         type: 'string',
-        description:
-          'Provider model string, e.g. openai/gpt-4o-mini, anthropic/claude-3-5-sonnet-20240620',
-        default: 'openai/gpt-4o-mini',
+        description: 'Model from the hosted marketplace registry.',
       },
       approval: {
         type: 'object',
@@ -47,29 +48,43 @@ export const openbotPlugin: Plugin = {
   toolDefinitions: {
     ...bashPlugin.toolDefinitions,
     ...memoryPlugin.toolDefinitions,
+    ...todoPlugin.toolDefinitions,
     ...storagePlugin.toolDefinitions,
     ...delegationPlugin.toolDefinitions,
+    ...previewPlugin.toolDefinitions,
     // this is the capability to render UI widgets to the user. We dont need it for now.
     // ...uiPlugin.toolDefinitions,
   },
   factory: (context) => (builder) => {
-    const { config, storage, tools, abortSignal } = context;
+    const { agentId, config, storage, tools, abortSignal } = context;
 
     // Register inbuilt plugins
     bashPlugin.factory(context)(builder);
     memoryPlugin.factory(context)(builder);
+    todoPlugin.factory(context)(builder);
     storagePlugin.factory(context)(builder);
     delegationPlugin.factory(context)(builder);
     uiPlugin.factory(context)(builder);
+    previewPlugin.factory(context)(builder);
 
     // Approval plugin configuration
     const approvalConfig = (config?.approval as any) || {
-      actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
+      actions: [
+        'action:shell_exec',
+        'action:expose_port',
+        'action:create_channel',
+        'action:delete_channel',
+      ],
     };
     approvalPlugin.factory({ ...context, config: approvalConfig })(builder);
 
+    const model = isCloudSystemAgent(agentId)
+      ? resolveCloudSystemModel(config?.model as string | undefined)
+      : (config?.model as string);
+
     return openbotRuntime({
-      model: config?.model as string,
+      model,
+      agentId,
       storage,
       toolDefinitions: tools,
       abortSignal,

package/src/plugins/openbot/model.ts

@@ -0,0 +1,76 @@
+import { createOpenAI, openai as defaultOpenai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { google } from '@ai-sdk/google';
+import type { LanguageModel } from 'ai';
+import {
+  getCloudIntegrationsConfig,
+  isCloudSystemAgent,
+} from '../../app/cloud-mode.js';
+
+let cloudOpenAIProvider: ReturnType<typeof createOpenAI> | null | undefined;
+
+/** Strip credentials — the integrations gateway injects the provider master key. */
+const integrationsFetch: typeof fetch = async (input, init) => {
+  const headers = new Headers(init?.headers);
+  headers.delete('Authorization');
+  headers.delete('x-api-key');
+  return globalThis.fetch(input, { ...init, headers });
+};
+
+function getCloudOpenAIProvider(): ReturnType<typeof createOpenAI> | null {
+  if (cloudOpenAIProvider !== undefined) return cloudOpenAIProvider;
+
+  const config = getCloudIntegrationsConfig();
+  if (!config) {
+    cloudOpenAIProvider = null;
+    return null;
+  }
+
+  cloudOpenAIProvider = createOpenAI({
+    baseURL: `${config.baseUrl}/openai/v1`,
+    apiKey: 'unused',
+    headers: {
+      'x-openbot-integrations-token': config.token,
+    },
+    fetch: integrationsFetch,
+  });
+  return cloudOpenAIProvider;
+}
+
+function resolveOpenbotModel(modelId: string, agentId?: string): LanguageModel {
+  if (!agentId || !isCloudSystemAgent(agentId)) {
+    throw new Error(
+      `OpenBot models are only available for the cloud system agent. Use openai/..., anthropic/..., etc.`,
+    );
+  }
+
+  const cloudOpenai = getCloudOpenAIProvider();
+  if (!cloudOpenai) {
+    throw new Error(
+      'OpenBot cloud model requires OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN.',
+    );
+  }
+
+  return cloudOpenai.chat(modelId);
+}
+
+export function resolveModel(modelString: string, agentId?: string): LanguageModel {
+  const [provider, ...rest] = modelString.split('/');
+  const modelId = rest.join('/');
+  if (!modelId) {
+    throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
+  }
+
+  switch (provider) {
+    case 'openbot':
+      return resolveOpenbotModel(modelId, agentId);
+    case 'openai':
+      return defaultOpenai(modelId);
+    case 'anthropic':
+      return anthropic(modelId);
+    case 'google':
+      return google(modelId);
+    default:
+      throw new Error(`Unsupported AI provider: "${provider}"`);
+  }
+}

package/src/plugins/openbot/runtime.ts

@@ -1,47 +1,23 @@
 import { MelonyPlugin, RuntimeContext } from 'melony';
-import { generateText, type LanguageModel } from 'ai';
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { google } from '@ai-sdk/google';
+import { generateText } from 'ai';
 import { OpenBotEvent, OpenBotState, AgentInvokeEvent } from '../../app/types.js';
 import { eventsToModelMessages } from './history.js';
 import { Storage } from '../../services/plugins/domain.js';
 import type { ToolDefinition } from '../../services/plugins/types.js';
-import {
-  ORCHESTRATOR_AGENT_ID,
-  buildContext,
-} from './context.js';
-import { saveConfig, DEFAULT_MARKETPLACE_REGISTRY_URL } from '../../app/config.js';
+import { buildContext } from './context.js';
+import { saveConfig } from '../../app/config.js';
+import { isCloudSystemAgent } from '../../app/cloud-mode.js';
 import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
-
-interface ModelRegistry {
-  providers: Record<
-    string,
-    {
-      label: string;
-      models: Array<{ id: string; label: string; description: string }>;
-    }
-  >;
-}
-
-let cachedRegistry: ModelRegistry | null = null;
-
-async function fetchRegistry(): Promise<ModelRegistry | null> {
-  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()) as ModelRegistry;
-    return cachedRegistry;
-  } catch (error) {
-    console.error('[openbot] Failed to fetch model registry:', error);
-    return null;
-  }
-}
+import { resolveModel } from './model.js';
+import {
+  listApiKeyProvidersFromRegistry,
+  resolveModelRegistry,
+} from '../../services/plugins/model-registry.js';
 
 export interface OpenBotRuntimeOptions {
   /** Provider model string (e.g. `openai/gpt-4o-mini`, `anthropic/claude-3-5-sonnet-20240620`). */
   model?: string;
+  agentId?: string;
   storage?: Storage;
   /** Tool definitions merged from all tool plugins attached to this agent. */
   toolDefinitions?: Record<string, ToolDefinition>;
@@ -49,24 +25,6 @@ export interface OpenBotRuntimeOptions {
   abortSignal?: AbortSignal;
 }
 
-function resolveModel(modelString: string): LanguageModel {
-  const [provider, ...rest] = modelString.split('/');
-  const modelId = rest.join('/');
-  if (!modelId) {
-    throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
-  }
-  switch (provider) {
-    case 'openai':
-      return openai(modelId);
-    case 'anthropic':
-      return anthropic(modelId);
-    case 'google':
-      return google(modelId);
-    default:
-      throw new Error(`Unsupported AI provider: "${provider}"`);
-  }
-}
-
 async function buildSystemPrompt(
   state: OpenBotState,
   storage: Storage | undefined,
@@ -149,13 +107,14 @@ export const openbotRuntime =
     (builder) => {
       const {
         model: modelString = 'openai/gpt-4o-mini',
+        agentId,
         storage,
         toolDefinitions = {},
         abortSignal,
       } = options;
 
       let currentModelString = modelString;
-      let model = resolveModel(currentModelString);
+      let model = resolveModel(currentModelString, agentId);
 
       const runLLM = async function* (
         context: RuntimeContext<OpenBotState, OpenBotEvent>,
@@ -273,7 +232,14 @@ export const openbotRuntime =
             errorMessage.includes('Unauthorized') ||
             errorMessage.includes('authentication');
 
-          if (isApiKeyError) {
+          if (isApiKeyError && !isCloudSystemAgent(context.state.agentId)) {
+            const registry = await resolveModelRegistry();
+            const providerActions = listApiKeyProvidersFromRegistry(registry).map((provider) => ({
+              id: provider.id,
+              label: provider.label,
+              variant: 'primary' as const,
+            }));
+
             yield {
               type: 'client:ui:widget',
               data: {
@@ -281,11 +247,14 @@ export const openbotRuntime =
                 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' },
-                ],
+                actions:
+                  providerActions.length > 0
+                    ? providerActions
+                    : [
+                        { id: 'openai', label: 'OpenAI', variant: 'primary' as const },
+                        { id: 'anthropic', label: 'Anthropic', variant: 'primary' as const },
+                        { id: 'google', label: 'Google', variant: 'primary' as const },
+                      ],
                 metadata: {
                   type: 'api_provider_selection',
                 },
@@ -353,13 +322,15 @@ export const openbotRuntime =
         const { metadata, values, actionId } = event.data;
         const threadId = event.meta?.threadId || context.state.threadId;
 
+        if (isCloudSystemAgent(context.state.agentId)) return;
+
         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 as string];
+          const registry = await resolveModelRegistry();
+          const providerData = registry.providers?.[provider as string];
 
           const providerLinks: Record<string, string> = {
             openai: 'https://platform.openai.com/api-keys',
@@ -375,11 +346,20 @@ export const openbotRuntime =
             value: m.id,
           }));
 
-          const defaultModel = modelOptions?.[0]?.value || 'gpt-4o-mini';
+          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 ||
-            currentModelId ||
-            defaultModel;
+            modelOptions.find((m) => m.value === currentModelId)?.value || defaultModel;
 
           yield {
             type: 'client:ui:widget',
@@ -407,10 +387,8 @@ export const openbotRuntime =
                 {
                   id: 'model',
                   label: 'Model',
-                  type: modelOptions ? 'select' : 'text',
-                  description: modelOptions ? undefined : `Model name (e.g. \`${defaultModel}\`).`,
+                  type: 'select',
                   options: modelOptions,
-                  placeholder: defaultModel,
                   required: true,
                   defaultValue,
                 },
@@ -464,7 +442,7 @@ export const openbotRuntime =
           process.env[envVar] = apiKey;
 
           currentModelString = newModelString;
-          model = resolveModel(currentModelString);
+          model = resolveModel(currentModelString, agentId);
           try {
             saveConfig({ model: currentModelString });
 

package/src/plugins/openbot/system-prompt.ts

@@ -1,22 +1,57 @@
 export const OPENBOT_SYSTEM_PROMPT = [
   '# ROLE',
-  'You are an OpenBot, the main coordinator and router agent. Your primary role is to orchestrate specialized agents to help the human achieve their goals.',
+  'You are an OpenBot, the main coordinator and router agent. Your primary role is to orchestrate specialized agents and manage tasks methodically to help the human achieve their goals.',
   '',
   '# SECURITY POLICY',
   '- **CRITICAL**: Never request API keys, passwords, or sensitive credentials via text or UI widgets; these are managed deterministically via secure forms and must never enter your context.',
   '- **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. You act as a high-level manager, ensuring the right agent is working on the right task.',
+  'You act as a high-level manager, ensuring the right specialized agent is working on the right task. However, when orchestrating or when specialized agents are not available, you are capable of executing complex steps yourself using a highly structured, stateful, and disciplined approach.',
+  '',
+  '# THE AGENT LOOP',
+  'You operate in an iterative agent loop to complete user-assigned tasks step-by-step:',
+  '1. **Analyze Events**: Understand user needs and the current state through the chronological event stream (focusing on latest user messages and execution/observation results).',
+  '2. **Select Tools**: Choose the next tool call based on current state, todos, and environment constraints. To maximize precision, choose only one tool call per iteration for complex tasks, or parallel calls if they are independent.',
+  '3. **Wait for Execution**: Let the system execute the tool action and add observations/results back into the event stream.',
+  '4. **Iterate**: Patiently repeat the above steps, analyzing results at each turn, until all steps of the task are completed.',
+  '5. **Submit Results**: Message the human with clear, polished, and detailed outcomes, attaching any relevant files or deliverables.',
+  '6. **Enter Standby**: Enter an idle state and wait for new tasks.',
+  '',
+  '# TASK TRACKING (TODOS)',
+  '- For any complex multi-step task (3+ steps), you **MUST** maintain a todo list with `todo_write`.',
+  '- Write the full intended list at task start. Each call replaces the previous list (not a partial patch).',
+  '- Keep exactly one item `in_progress` while working. Mark items `completed` immediately after finishing them.',
+  '- Use `cancelled` for steps that are no longer needed. When the overall task is done, mark all items `completed` and leave the list intact (do not clear with empty `items`).',
+  '- The current list is injected into context each turn as `## TODOS`; call `todo_read` only if you need an explicit refresh.',
+  '- Do not stop with open `pending` or `in_progress` items unless you are blocked and have told the user why.',
   '',
   '# 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.',
-  '- **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.',
+  '- **Channel and Threads**: The main way to communicate and act is through channels and threads. There might be a channel called "uncategorized" for general purpose communication.',
+  '- **Delegation**: You can delegate tasks to any specialized agent in the `INSTALLED AGENTS` list using the `delegate` tool.',
   '- **Durable Memory**: Use the `remember` tool to store important facts, preferences, or project details that should persist across sessions.',
   '- **Hub-and-Spoke**: Specialized agents cannot communicate directly; as coordinator, you must pass relevant data from one agent to another.',
   '',
-  '# COMMUNICATION STYLE',
-  '- Be always concise, professional, and proactive.',
+  '# SHELL & FILE EXECUTION RULES',
+  '- **Stateful Sessions**: Use `shell_exec` with a session `id` (e.g. `default`, `server`). Reuse the same id to keep shell state (cwd, env) across commands.',
+  '- **Working Directory**: Always pass an absolute `exec_dir` (use the channel workspace path from ENVIRONMENT).',
+  '- **Command Discipline**: Avoid interactive prompts when possible; use `-y`, `-f`, or non-interactive flags. For prompts, use `shell_write_to_process`.',
+  '- **Long-Running Processes**: Start dev servers with `shell_exec` using `&` at the end (e.g. `pnpm dev &`). If you forget `&`, `shell_exec` returns after ~15s with partial logs — the server may still be running.',
+  '- **Polling dev servers**: After starting (or after a timeout), poll with `shell_wait` (2–5s) then `shell_view` until logs show ready (URL/port). Do not start a duplicate server; reuse the same session id.',
+  '- **Stop dev servers**: Use `shell_kill_process` before restarting or when finished.',
+  '- **Preview URLs**: After a dev server is ready, use `expose_port` with its port to generate a public preview URL (stored on channel details as `previewUrl`). Expose tunnels are temporary; close with `unexpose_port`.',
+  '- **Calculations**: Use `bc` or Python for math. Do not calculate complex math mentally.',
+  '- **Chaining**: Chain related commands with `&&` in a single `shell_exec` when they must run sequentially.',
+  '',
+  '# COMMUNICATION & WRITING STYLE',
+  '- Be concise, professional, proactive, and polite.',
+  '- Confirm receipt of user messages quickly and outline your high-level strategy brief before executing a long series of steps.',
+  '- Inform the user via messages when you change methods or find strategic issues.',
+  '- Write in clean, continuous prose. Avoid excessive bullet points or lists in final responses unless explicitly requested.',
+  '- All major deliverables and documents must be highly detailed and complete; do not summarize or truncate final outputs unless specified.',
+  '',
+  '# ERROR HANDLING',
+  '- Tool failures are provided as events. When an error occurs, do not panic or immediately ask the user for help.',
+  '- Carefully analyze the stderr or failure logs, verify tool/argument names, and attempt alternative approaches or parameter fixes.',
+  '- Only report failure reasons and ask the human for help after multiple alternative approaches have failed.',
 ].join('\n');