openbot 0.4.0 → 0.4.2

package/dist/plugins/delegation/index.js

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 import { generateId } from 'melony';
-import { runAgent } from '../../harness/index.js';
 /**
  * `delegation` — allows agents to delegate tasks to other agents.
  *
@@ -22,7 +21,7 @@ export const delegationPlugin = {
     name: 'Delegation',
     description: 'Allows agents to call upon other agents to solve sub-tasks.',
     toolDefinitions: delegationToolDefinitions,
-    factory: () => (builder) => {
+    factory: (pluginContext) => (builder) => {
         // Handle the tool execution
         builder.on('action:delegate_task', async function* (event, context) {
             const delegateEvent = event;
@@ -42,6 +41,8 @@ export const delegationPlugin = {
             const toolCallId = delegateEvent.meta?.toolCallId;
             if (!toolCallId)
                 return;
+            // Break circular dependency by dynamic import
+            const { runAgent } = await import('../../harness/index.js');
             const runId = `dg_${generateId()}`;
             let lastAgentOutput = '';
             // Queue to bridge the async onEvent callback to this generator
@@ -68,6 +69,7 @@ export const delegationPlugin = {
                 },
                 channelId: context.state.channelId,
                 threadId: context.state.threadId,
+                publicBaseUrl: pluginContext.publicBaseUrl,
                 onEvent: async (outEvent) => {
                     // Enrich events with parent metadata so the UI can track the hierarchy
                     const enrichedEvent = {

package/dist/plugins/openbot/context.js

@@ -1,4 +1,6 @@
+import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
 export const DEFAULT_CONTEXT_BUDGET = 8000;
+export const MAX_CONTEXT_FILES = 50;
 /**
  * Returns the known context window budget (in tokens) for a given model string.
  */
@@ -32,7 +34,13 @@ export async function buildContext(state, storage) {
     const participants = channelDetails?.participants || [];
     const isDm = isDmSoloChannel(participants, agentId);
     const sections = [];
-    // 1. Environment
+    // Fetch agents once if storage is available
+    const allAgents = storage?.getAgents ? await storage.getAgents().catch(() => []) : [];
+    // 1. User
+    if (state.currentUser?.userName) {
+        sections.push(`## HUMAN\n- Name: ${state.currentUser.userName}`);
+    }
+    // 2. Environment
     let env = '## ENVIRONMENT\n';
     if (isDm) {
         env += '- Mode: Direct Message (Solo)\n';
@@ -40,25 +48,62 @@ export async function buildContext(state, storage) {
     else {
         const channelName = channelDetails?.name || channelId;
         env += `- Mode: Channel (#${channelName})\n`;
+        if (channelDetails?.cwd) {
+            env += `- Workspace: ${channelDetails.cwd}\n`;
+        }
         if (threadId) {
             env += `- Thread: ${threadDetails?.name || threadId}\n`;
         }
         const peerIds = participants.filter((id) => id !== agentId);
-        if (peerIds.length > 0) {
-            env += `- Participants: ${peerIds.join(', ')}\n`;
-        }
+        const participantLabels = peerIds.map((id) => {
+            const agent = allAgents.find((a) => a.id === id);
+            return agent ? `${agent.name} (${id})` : id;
+        });
+        env += `- Participants: ${participantLabels.length > 0 ? participantLabels.join(', ') : 'None'}\n`;
     }
     sections.push(env);
-    // 2. Channel Spec
+    // 2.5 Installed Agents
+    if (allAgents.length > 0) {
+        const formatted = allAgents
+            .map((a) => `- ${a.id}: ${a.name}${a.description ? ` - ${a.description}` : ''}`)
+            .join('\n');
+        sections.push(`## INSTALLED AGENTS\n${formatted}`);
+    }
+    // 3. Channel Spec
     const spec = channelDetails?.spec?.trim();
     if (spec) {
         sections.push(`## CHANNEL SPECIFICATION\n${spec}`);
     }
-    // 3. Agent Instructions
-    if (agentDetails?.instructions) {
-        sections.push(`## AGENT: ${agentDetails?.name}\n${agentDetails.instructions}`);
+    // 4. Files
+    if (storage?.listFiles && channelId && channelDetails?.cwd) {
+        try {
+            const files = await storage.listFiles({ channelId });
+            if (files.length > 0) {
+                const limited = files.slice(0, MAX_CONTEXT_FILES);
+                const formatted = limited
+                    .map((f) => `- ${f.name}${f.isDirectory ? '/' : ''}`)
+                    .join('\n');
+                let fileSection = `## FILES\n${formatted}`;
+                if (files.length > MAX_CONTEXT_FILES) {
+                    fileSection += `\n- ... and ${files.length - MAX_CONTEXT_FILES} more files`;
+                }
+                sections.push(fileSection);
+            }
+            else {
+                sections.push('## FILES\n- (No files in workspace)');
+            }
+        }
+        catch (error) {
+            console.warn('[context] Failed to fetch files:', error);
+        }
+    }
+    // 5. Agent Instructions
+    const rawInstructions = agentDetails?.instructions?.trim();
+    if (rawInstructions &&
+        rawInstructions !== OPENBOT_SYSTEM_PROMPT.trim()) {
+        sections.push(`## Instructions\n${rawInstructions}`);
     }
-    // 4. Memories
+    // 6. Memories
     if (storage?.listMemories) {
         try {
             const scopes = ['global', `agent:${agentId}`];

package/dist/plugins/openbot/history.js

@@ -1,3 +1,49 @@
+/**
+ * Ensures every tool-call has a matching tool-result before calling the LLM.
+ * Orphaned calls (interrupted run, missing :result event, etc.) get an empty
+ * result so the conversation can resume instead of failing validation.
+ */
+function fillMissingToolResults(messages) {
+    const filled = [];
+    const pending = new Map();
+    const flushPending = () => {
+        if (pending.size === 0)
+            return;
+        filled.push({
+            role: 'tool',
+            content: [...pending.entries()].map(([toolCallId, toolName]) => ({
+                type: 'tool-result',
+                toolCallId,
+                toolName,
+                output: { type: 'text', value: '' },
+            })),
+        });
+        pending.clear();
+    };
+    for (const message of messages) {
+        if (message.role === 'tool' && Array.isArray(message.content)) {
+            filled.push(message);
+            for (const part of message.content) {
+                if (part.type === 'tool-result') {
+                    pending.delete(part.toolCallId);
+                }
+            }
+            continue;
+        }
+        flushPending();
+        filled.push(message);
+        if (message.role === 'assistant' && Array.isArray(message.content)) {
+            for (const part of message.content) {
+                if (part.type === 'tool-call') {
+                    const toolCall = part;
+                    pending.set(toolCall.toolCallId, toolCall.toolName);
+                }
+            }
+        }
+    }
+    flushPending();
+    return filled;
+}
 /**
  * Converts a raw event log into a valid chain of ModelMessages for the AI SDK.
  *
@@ -94,5 +140,5 @@ export function eventsToModelMessages(events) {
                 break;
         }
     }
-    return messages;
+    return fillMissingToolResults(messages);
 }

package/dist/plugins/openbot/index.js

@@ -1,15 +1,24 @@
 import { openbotRuntime } from './runtime.js';
+import { bashPlugin } from '../bash/index.js';
+import { memoryPlugin } from '../memory/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';
 /**
  * `openbot` — the standard, opinionated OpenBot agent runtime.
  *
  * 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.
  */
 export const openbotPlugin = {
     id: 'openbot',
     name: 'OpenBot Agent',
-    description: 'The standard, opinionated OpenBot agent runtime. Handles the core execution loop and tool orchestration.',
+    description: 'The standard OpenBot agent runtime with inbuilt tools (bash, memory, storage, delegation, and approval).',
     configSchema: {
         type: 'object',
         properties: {
@@ -18,14 +27,45 @@ export const openbotPlugin = {
                 description: 'Provider model string, e.g. openai/gpt-4o-mini, anthropic/claude-3-5-sonnet-20240620',
                 default: 'openai/gpt-4o-mini',
             },
+            approval: {
+                type: 'object',
+                description: 'Configuration for the inbuilt approval plugin.',
+                properties: {
+                    actions: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'List of actions that require manual approval.',
+                    },
+                },
+            },
         },
     },
-    factory: ({ config, storage, tools }) => {
+    toolDefinitions: {
+        ...bashPlugin.toolDefinitions,
+        ...memoryPlugin.toolDefinitions,
+        ...storagePlugin.toolDefinitions,
+        ...delegationPlugin.toolDefinitions,
+        ...uiPlugin.toolDefinitions,
+    },
+    factory: (context) => (builder) => {
+        const { config, storage, tools, abortSignal } = context;
+        // Register inbuilt plugins
+        bashPlugin.factory(context)(builder);
+        memoryPlugin.factory(context)(builder);
+        storagePlugin.factory(context)(builder);
+        delegationPlugin.factory(context)(builder);
+        uiPlugin.factory(context)(builder);
+        // Approval plugin configuration
+        const approvalConfig = config?.approval || {
+            actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
+        };
+        approvalPlugin.factory({ ...context, config: approvalConfig })(builder);
         return openbotRuntime({
             model: config?.model,
             storage,
             toolDefinitions: tools,
-        });
+            abortSignal,
+        })(builder);
     },
 };
 export default openbotPlugin;

package/dist/plugins/openbot/runtime.js

@@ -2,7 +2,7 @@ import { generateText } from 'ai';
 import { openai } from '@ai-sdk/openai';
 import { anthropic } from '@ai-sdk/anthropic';
 import { eventsToModelMessages } from './history.js';
-import { ORCHESTRATOR_AGENT_ID, buildContext, } from './context.js';
+import { buildContext, } from './context.js';
 import { saveConfig } from '../../app/config.js';
 import { API_KEY_SETUP_MESSAGE, OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
 function resolveModel(modelString) {
@@ -22,10 +22,7 @@ function resolveModel(modelString) {
 }
 async function buildSystemPrompt(state, storage) {
     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;
     if (!threadState?.isSmartNamed) {
@@ -40,24 +37,41 @@ async function buildSystemPrompt(state, storage) {
  * 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 = null;
+function createToolBatchTracker(state, storage, channelId, threadId) {
+    const save = async (ids) => {
+        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) {
-            pending = new Set(toolCallIds);
+        async startBatch(toolCallIds) {
+            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) {
-            if (!pending?.has(toolCallId))
-                return false;
-            pending.delete(toolCallId);
-            if (pending.size > 0)
+        async recordResult(toolCallId) {
+            if (!state.pendingToolCallIds?.includes(toolCallId))
                 return false;
-            pending = null;
-            return true;
+            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;
         },
     };
 }
@@ -69,13 +83,15 @@ function createToolBatchTracker() {
  * - When a full batch of results is in, `runLLM` runs again with updated history.
  */
 export const openbotRuntime = (options) => (builder) => {
-    const { model: modelString = 'openai/gpt-4o-mini', storage, toolDefinitions = {}, } = options;
+    const { 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, threadId, trigger) {
         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;
         const parentAgentId = triggerEvent?.meta?.parentAgentId;
@@ -88,8 +104,8 @@ export const openbotRuntime = (options) => (builder) => {
         });
         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.
             const result = await generateText({
@@ -99,6 +115,7 @@ export const openbotRuntime = (options) => (builder) => {
                 tools: toolDefinitions,
                 stopWhen: ({ steps }) => steps.length === 1,
                 allowSystemInMessages: true,
+                abortSignal,
             });
             const toolCalls = result.toolCalls ?? [];
             // if (result.usage) {
@@ -138,7 +155,7 @@ export const openbotRuntime = (options) => (builder) => {
             }
             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 {
                         type: `action:${toolCall.toolName}`,
@@ -152,10 +169,13 @@ export const openbotRuntime = (options) => (builder) => {
             }
             else {
                 // clear the tool batch if there are no tool calls
-                toolBatch.clear();
+                await toolBatch.clear();
             }
         }
         catch (error) {
+            // 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') ||
                 errorMessage.includes('401') ||
@@ -217,10 +237,53 @@ export const openbotRuntime = (options) => (builder) => {
         if (typeof routedTo === 'string' && routedTo && routedTo !== context.state.agentId) {
             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.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,
+                            },
+                        };
+                    }
+                }
+            }
+            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();
-        const threadId = event.meta?.threadId || context.state.threadId;
+        await createToolBatchTracker(context.state, storage, context.state.channelId, threadId).clear();
         yield* runLLM(context, threadId, event);
     });
     // this is to handle the tool results from the tool calls
@@ -232,7 +295,8 @@ export const openbotRuntime = (options) => (builder) => {
             return;
         const toolCallId = event.meta?.toolCallId;
         // record the result of the tool call
-        if (!toolCallId || !toolBatch.recordResult(toolCallId))
+        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/dist/plugins/openbot/system-prompt.js

@@ -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. */
 export const API_KEY_SETUP_MESSAGE = 'OpenBot runs AI agents locally with tools, memory, and delegation. Bring your own OpenAI or Anthropic key — it stays on your machine. Use the form below to get started.';

package/dist/plugins/plugin-manager/index.js

@@ -1,5 +1,5 @@
 import { STATE_AGENT_ID } from '../../app/agent-ids.js';
-import { pluginService, resolveMarketplaceAgentList, } from '../../services/plugins/service.js';
+import { pluginService, resolveMarketplaceRegistry, } from '../../services/plugins/service.js';
 /**
  * `plugin-manager` — marketplace listing, npm plugin install/uninstall, and
  * installing agents from the registry. Wired on the **`state`** built-in agent
@@ -46,12 +46,96 @@ export const pluginManagerPlugin = {
                 }
             });
             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 },
                 };
             });
+            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 },
+                    };
+                    yield {
+                        type: 'agent:output',
+                        data: {
+                            content: `Successfully installed channel **${channelListing?.name || templateName || channelId}** and created channel \`${channelId}\`.`,
+                        },
+                        meta: { agentId: 'system' },
+                    };
+                }
+                catch (error) {
+                    yield {
+                        type: 'action:channel:install:result',
+                        data: {
+                            success: false,
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                        },
+                    };
+                }
+            });
             builder.on('action:agent:install', async function* (event) {
                 try {
                     const { agentId: newAgentId, name, description, image, instructions, plugins, } = event.data;

package/dist/plugins/shell/index.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { spawn } from 'node:child_process';
+import { resolvePath } from '../../app/config.js';
 const shellToolDefinitions = {
     shell_exec: {
         description: 'Execute a shell command in the terminal. Use this for file operations, running scripts, or system tasks.',
@@ -22,7 +23,7 @@ const shellPluginRuntime = () => (builder) => {
     builder.on('action:shell_exec', async function* (event, context) {
         const { command, cwd, shell = 'bash', timeoutMs = 30000 } = event.data;
         const actualTimeout = Math.max(1000, Math.min(timeoutMs, 60000));
-        const actualCwd = cwd || context.state.channelDetails?.cwd || process.cwd();
+        const actualCwd = resolvePath(cwd || context.state.channelDetails?.cwd || process.cwd());
         try {
             const result = await new Promise((resolve) => {
                 const child = spawn(command, {