openbot 0.4.0 → 0.4.2

package/src/plugins/openbot/runtime.ts

@@ -8,7 +8,6 @@ import { Storage } from '../../services/plugins/domain.js';
 import type { ToolDefinition } from '../../services/plugins/types.js';
 import {
   ORCHESTRATOR_AGENT_ID,
-  getContextBudgetForModel,
   buildContext,
 } from './context.js';
 import { saveConfig } from '../../app/config.js';
@@ -20,6 +19,8 @@ export interface OpenBotRuntimeOptions {
   storage?: Storage;
   /** Tool definitions merged from all tool plugins attached to this agent. */
   toolDefinitions?: Record<string, ToolDefinition>;
+  /** Fires when the run is stopped; cancels the in-flight LLM call. */
+  abortSignal?: AbortSignal;
 }
 
 function resolveModel(modelString: string): LanguageModel {
@@ -44,12 +45,7 @@ async function buildSystemPrompt(
 ): Promise<string> {
   const context = await buildContext(state, storage);
 
-  const instructions =
-    state.agentId === ORCHESTRATOR_AGENT_ID
-      ? (state.agentDetails?.instructions?.trim() || OPENBOT_SYSTEM_PROMPT)
-      : OPENBOT_SYSTEM_PROMPT;
-
-  const sections = [instructions, '', context];
+  const sections = [OPENBOT_SYSTEM_PROMPT, '', context];
 
   // Hardcoded naming hint logic
   const threadState = state.threadDetails?.state as any;
@@ -71,23 +67,44 @@ async function buildSystemPrompt(
  * a single `generateText` response execute one-by-one. We must wait for every ID
  * in the batch before calling the LLM again — not after the first result.
  */
-function createToolBatchTracker() {
-  let pending: Set<string> | null = null;
+function createToolBatchTracker(
+  state: OpenBotState,
+  storage?: Storage,
+  channelId?: string,
+  threadId?: string,
+) {
+  const save = async (ids?: string[]) => {
+    if (!storage || !channelId || !threadId) return;
+    try {
+      await storage.patchThreadState({
+        channelId,
+        threadId,
+        state: { pendingToolCallIds: ids },
+      });
+    } catch (error) {
+      console.error('[openbot] Failed to persist pendingToolCallIds:', error);
+    }
+  };
 
   return {
-    startBatch(toolCallIds: string[]) {
-      pending = new Set(toolCallIds);
+    async startBatch(toolCallIds: string[]) {
+      state.pendingToolCallIds = [...toolCallIds];
+      await save(state.pendingToolCallIds);
     },
-    clear() {
-      pending = null;
+    async clear() {
+      state.pendingToolCallIds = undefined;
+      await save(undefined);
     },
     /** Returns true when this result completes the batch (time to call the LLM again). */
-    recordResult(toolCallId: string): boolean {
-      if (!pending?.has(toolCallId)) return false;
-      pending.delete(toolCallId);
-      if (pending.size > 0) return false;
-      pending = null;
-      return true;
+    async recordResult(toolCallId: string): Promise<boolean> {
+      if (!state.pendingToolCallIds?.includes(toolCallId)) return false;
+      state.pendingToolCallIds = state.pendingToolCallIds.filter((id) => id !== toolCallId);
+      const done = state.pendingToolCallIds.length === 0;
+      if (done) {
+        state.pendingToolCallIds = undefined;
+      }
+      await save(state.pendingToolCallIds);
+      return done;
     },
   };
 }
@@ -106,11 +123,11 @@ export const openbotRuntime =
         model: modelString = 'openai/gpt-4o-mini',
         storage,
         toolDefinitions = {},
+        abortSignal,
       } = options;
 
       let currentModelString = modelString;
       let model = resolveModel(currentModelString);
-      const toolBatch = createToolBatchTracker();
 
       const runLLM = async function* (
         context: RuntimeContext<OpenBotState, OpenBotEvent>,
@@ -118,6 +135,14 @@ export const openbotRuntime =
         trigger?: AgentInvokeEvent,
       ): AsyncGenerator<OpenBotEvent> {
         if (!storage) return;
+        if (abortSignal?.aborted) return;
+
+        const toolBatch = createToolBatchTracker(
+          context.state,
+          storage,
+          context.state.channelId,
+          threadId || context.state.threadId,
+        );
 
         // Capture parent metadata for event enrichment
         const triggerEvent = trigger || context.state.triggerEvent;
@@ -136,8 +161,8 @@ export const openbotRuntime =
         const messages = eventsToModelMessages(events);
 
         // console.log('systemPrompt:::::::\n', systemPrompt);
-        // console.log('messages:::::::\n', JSON.stringify(messages, null, 2));
-        // console.log('toolDefinitions:::::::\n', JSON.stringify(toolDefinitions, null, 2));
+        // console.log('messages:::::::\n', JSON.stringify(messages));
+        // console.log('toolDefinitions:::::::\n', JSON.stringify(toolDefinitions));
 
         try {
           // Single LLM request — tool execution happens externally via action:* handlers.
@@ -148,6 +173,7 @@ export const openbotRuntime =
             tools: toolDefinitions as Record<string, { description: string; inputSchema: any }>,
             stopWhen: ({ steps }) => steps.length === 1,
             allowSystemInMessages: true,
+            abortSignal,
           });
 
           const toolCalls = result.toolCalls ?? [];
@@ -192,7 +218,7 @@ export const openbotRuntime =
 
           if (toolCalls.length > 0) {
             // when multiple tool calls are made, Melony runtime handles them one by one, thats why we need to start a new batch
-            toolBatch.startBatch(toolCalls.map((tc) => tc.toolCallId));
+            await toolBatch.startBatch(toolCalls.map((tc) => tc.toolCallId));
 
             for (const toolCall of toolCalls) {
               yield {
@@ -206,9 +232,12 @@ export const openbotRuntime =
             }
           } else {
             // clear the tool batch if there are no tool calls
-            toolBatch.clear();
+            await toolBatch.clear();
           }
         } catch (error: unknown) {
+          // Run was stopped — unwind quietly without surfacing an error.
+          if (abortSignal?.aborted) return;
+
           const errorMessage = error instanceof Error ? error.message : String(error);
           const isApiKeyError =
             errorMessage.includes('API key') ||
@@ -277,11 +306,67 @@ export const openbotRuntime =
           return;
         }
 
+        // Capture user info from meta if available
+        if (event.meta?.userName) {
+          context.state.currentUser = {
+            userName: event.meta.userName,
+          };
+        }
+
+        const threadId = event.meta?.threadId || context.state.threadId;
+
+        // Auto-add participants if tagged in the prompt
+        const content = (event as AgentInvokeEvent).data?.content;
+        if (content && storage) {
+          try {
+            const allAgents = await storage.getAgents();
+            const tags = content.match(/@([\w-]+)/g);
+            if (tags) {
+              const taggedAgentIds = tags.map((t) => t.slice(1));
+              const validAgentIds = taggedAgentIds.filter((id) =>
+                allAgents.some((a) => a.id === id),
+              );
+
+              const currentParticipants = context.state.channelDetails?.participants || [];
+              const newParticipants = [...new Set([...currentParticipants, ...validAgentIds])];
+
+              if (newParticipants.length > currentParticipants.length) {
+                // Update storage
+                await storage.patchChannelState({
+                  channelId: context.state.channelId,
+                  state: { participants: newParticipants },
+                });
+
+                // Refresh local state
+                context.state.channelDetails = await storage.getChannelDetails({
+                  channelId: context.state.channelId,
+                });
+
+                // Notify UI/others about the change
+                yield {
+                  type: 'action:patch_channel_details:result',
+                  data: { success: true, updatedFields: ['participants'] },
+                  meta: {
+                    agentId: context.state.agentId,
+                    threadId,
+                  },
+                } as OpenBotEvent;
+              }
+            }
+          } catch (error) {
+            console.warn('[openbot] Failed to auto-add participants from tags:', error);
+          }
+        }
+
         // clear the tool batch if the agent is invoked
         // this is to prevent the tool batch from being used for a new agent invocation
-        toolBatch.clear();
+        await createToolBatchTracker(
+          context.state,
+          storage,
+          context.state.channelId,
+          threadId,
+        ).clear();
 
-        const threadId = event.meta?.threadId || context.state.threadId;
         yield* runLLM(context, threadId, event as AgentInvokeEvent);
       });
 
@@ -293,7 +378,16 @@ export const openbotRuntime =
 
         const toolCallId = event.meta?.toolCallId;
         // record the result of the tool call
-        if (!toolCallId || !toolBatch.recordResult(toolCallId)) return;
+        if (
+          !toolCallId ||
+          !(await createToolBatchTracker(
+            context.state,
+            storage,
+            context.state.channelId,
+            event.meta?.threadId || context.state.threadId,
+          ).recordResult(toolCallId))
+        )
+          return;
 
         const threadId = event.meta?.threadId || context.state.threadId;
         yield* runLLM(context, threadId);

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

@@ -1,5 +1,25 @@
 export const OPENBOT_SYSTEM_PROMPT = [
-  'You are a helpful AI assistant for your human. Your job is to help the user with their questions and tasks.',
+  '# 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.',
+  '',
+  '# 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 (channel participants). You act as a high-level manager, ensuring the right agent is working on the right task.',
+  '',
+  '# 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.',
+  '- **Agent Participation**: ONLY add an agent via `patch_channel_details` if the user manually tags them (e.g., `@name`) AND they are missing from the `Participants` list in `ENVIRONMENT`.',
+  '- **Delegation**: NEVER delegate to an agent who is not a participant. Only if existing participants clearly cannot handle a task should you suggest relevant agents from 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 participant 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.',
+  '- **Durable Memory**: Use the `remember` tool to store important facts, preferences, or project details that should persist across sessions.',
+  '- **Structured Interaction**: Use the `render_widget` tool to collect information via forms, offer choices, or display lists. This is preferred over asking multiple separate questions in plain text.',
+  '',
+  '# COMMUNICATION STYLE',
+  '- Be always concise, professional, and proactive.',
 ].join('\n');
 
 /** Shown in the API key setup form when no provider credentials are configured. */

package/src/plugins/plugin-manager/index.ts

@@ -3,7 +3,7 @@ import { STATE_AGENT_ID } from '../../app/agent-ids.js';
 import { OpenBotEvent } from '../../app/types.js';
 import {
   pluginService,
-  resolveMarketplaceAgentList,
+  resolveMarketplaceRegistry,
 } from '../../services/plugins/service.js';
 
 /**
@@ -55,13 +55,115 @@ export const pluginManagerPlugin: Plugin = {
       });
 
       builder.on('action:marketplace:list', async function* () {
-        const agents = await resolveMarketplaceAgentList();
+        const { agents, channels } = await resolveMarketplaceRegistry();
         yield {
           type: 'action:marketplace:list:result',
-          data: { success: true, agents },
+          data: { success: true, agents, channels },
         } as OpenBotEvent;
       });
 
+      builder.on('action:channel:install', async function* (event) {
+        try {
+          const {
+            channelId: instanceId,
+            name: templateName,
+            participants: customParticipants,
+            initialState: customInitialState,
+          } = event.data;
+          const { agents: marketplaceAgents, channels } = await resolveMarketplaceRegistry();
+
+          // Try to find the template by ID or Name
+          const channelListing =
+            channels.find((c) => c.id === instanceId) ||
+            channels.find((c) => c.name === templateName);
+
+          const channelId = instanceId;
+          const participants = customParticipants || channelListing?.participants || [];
+          const initialState = {
+            ...(channelListing?.initialState || {}),
+            ...(customInitialState || {}),
+          };
+          const spec = channelListing?.spec || '';
+
+          // 1. Auto-install participant agents if missing
+          for (const agentId of participants) {
+            const existingAgents = await storage.getAgents();
+            if (existingAgents.some((a) => a.id === agentId)) {
+              continue;
+            }
+
+            // Not found locally, look in marketplace
+            const agentListing = marketplaceAgents.find((a) => a.id === agentId);
+            if (agentListing) {
+              console.log(`[plugin-manager] Auto-installing agent ${agentId} for channel ${channelId}`);
+
+              // Install plugins for this agent
+              for (const ref of agentListing.plugins) {
+                const installed = await pluginService.isInstalled(ref.id);
+                if (
+                  !installed &&
+                  ref.id.includes('/') === false &&
+                  ref.id.includes('-plugin-') === false
+                ) {
+                  continue;
+                }
+                if (!installed) {
+                  try {
+                    await pluginService.install({ packageName: ref.id });
+                  } catch (err) {
+                    console.warn(`[plugins] Failed to pre-install plugin ${ref.id}`, err);
+                  }
+                }
+              }
+
+              // Create the agent
+              await storage.createAgent({
+                agentId: agentListing.id,
+                name: agentListing.name,
+                description: agentListing.description,
+                image: agentListing.image,
+                instructions: agentListing.instructions,
+                plugins: agentListing.plugins,
+              });
+            }
+          }
+
+          // 2. Create the channel
+          await storage.createChannel({
+            channelId,
+            spec,
+            initialState: {
+              ...initialState,
+              participants,
+            },
+          });
+
+          const channelUrl = `/channels/${channelId}`;
+          yield {
+            type: 'action:channel:install:result',
+            data: { success: true, channelId, channelUrl },
+          } as OpenBotEvent;
+
+          yield {
+            type: 'agent:output',
+            data: {
+              content: `Successfully installed channel **${
+                channelListing?.name || templateName || channelId
+              }** and created channel \`${channelId}\`.`,
+            },
+            meta: { agentId: 'system' },
+          } as OpenBotEvent;
+        } catch (error) {
+          yield {
+            type: 'action:channel:install:result',
+            data: {
+              success: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          } as OpenBotEvent;
+        }
+      });
+
       builder.on('action:agent:install', async function* (event) {
         try {
           const {

package/src/plugins/storage/files.ts

@@ -0,0 +1,81 @@
+import { createReadStream } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { resolvePath } from '../../app/config.js';
+
+const MIME_BY_EXT: Record<string, string> = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mov': 'video/quicktime',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.pdf': 'application/pdf',
+  '.json': 'application/json',
+  '.txt': 'text/plain',
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.js': 'text/javascript',
+  '.zip': 'application/zip',
+};
+
+export function guessMimeType(filePath: string): string {
+  return MIME_BY_EXT[path.extname(filePath).toLowerCase()] ?? 'application/octet-stream';
+}
+
+/** Resolve a relative path under a channel cwd; rejects directory escape. */
+export function resolveChannelFile(baseCwd: string, relativePath: string): string {
+  const resolvedBase = resolvePath(baseCwd);
+  const normalized = relativePath.replace(/\\/g, '/').replace(/^\/+/, '');
+  const target = path.resolve(resolvedBase, normalized);
+  if (target !== resolvedBase && !target.startsWith(resolvedBase + path.sep)) {
+    throw new Error('Access denied: directory escape');
+  }
+  return target;
+}
+
+export async function statChannelFile(
+  baseCwd: string,
+  relativePath: string,
+): Promise<{ abs: string; size: number }> {
+  const abs = resolveChannelFile(baseCwd, relativePath);
+  const stat = await fs.stat(abs);
+  if (!stat.isFile()) {
+    throw new Error('Not a file');
+  }
+  return { abs, size: stat.size };
+}
+
+export function openChannelFileStream(abs: string) {
+  return createReadStream(abs);
+}
+
+export function buildWorkspaceFileUrl(args: {
+  baseUrl: string;
+  channelId: string;
+  filePath: string;
+}): string {
+  const base = args.baseUrl.replace(/\/$/, '');
+  const data = encodeURIComponent(JSON.stringify({ path: args.filePath }));
+  const channelId = encodeURIComponent(args.channelId);
+  return `${base}/api/state?channelId=${channelId}&type=${encodeURIComponent('action:storage:serve-file')}&data=${data}`;
+}
+
+export function getPublicBaseUrl(port: number, configPublicUrl?: string): string {
+  const fromConfig = configPublicUrl?.trim();
+  if (fromConfig) {
+    return fromConfig.replace(/\/$/, '');
+  }
+  const fromEnv = process.env.OPENBOT_PUBLIC_URL?.trim();
+  if (fromEnv) {
+    return fromEnv.replace(/\/$/, '');
+  }
+  return `http://localhost:${port}`;
+}