openbot 0.2.14 → 0.3.1

package/dist/plugins/ui.js

@@ -1,39 +1,203 @@
 import z from 'zod';
+const actionSchema = z.object({
+    id: z.string().describe('Stable action ID returned by client:ui:widget:response.'),
+    label: z.string().describe('Human-readable button label.'),
+    value: z.unknown().optional().describe('Optional machine-readable value for this action.'),
+    variant: z.enum(['primary', 'secondary', 'danger']).optional(),
+    disabled: z.boolean().optional(),
+});
+const optionSchema = z.object({
+    label: z.string(),
+    value: z.string(),
+});
+const fieldSchema = z.object({
+    id: z.string().describe('Stable field ID used as the submitted value key.'),
+    label: z.string(),
+    type: z.enum(['text', 'textarea', 'number', 'boolean', 'select', 'multiselect', 'date']),
+    description: z.string().optional(),
+    placeholder: z.string().optional(),
+    required: z.boolean().optional(),
+    options: z.array(optionSchema).optional(),
+    defaultValue: z.unknown().optional(),
+});
+const listItemSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+const widgetBaseSchema = {
+    widgetId: z.string().optional().describe('Optional stable widget ID. Defaults from toolCallId.'),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    body: z.string().optional(),
+    state: z.enum(['open', 'submitted', 'cancelled', 'error']).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+};
+const renderWidgetSchema = z.union([
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('message'),
+        actions: z.array(actionSchema).optional(),
+    }),
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('choice'),
+        actions: z.array(actionSchema).min(1),
+    }),
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('form'),
+        fields: z.array(fieldSchema).optional(),
+        submitLabel: z.string().optional(),
+        actions: z.array(actionSchema).optional(),
+        props: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Legacy form props. Prefer fields and submitLabel.'),
+    }),
+    z.object({
+        ...widgetBaseSchema,
+        kind: z.literal('list'),
+        items: z.array(listItemSchema).optional(),
+        actions: z.array(actionSchema).optional(),
+    }),
+    z.object({
+        kind: z.enum(['approval', 'todo_list']).describe('Legacy preset. Prefer choice or list.'),
+        widgetId: z.string().optional(),
+        title: z.string().optional(),
+        props: z.record(z.string(), z.unknown()).optional(),
+        metadata: z.record(z.string(), z.unknown()).optional(),
+    }),
+]);
+const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const readString = (value) => typeof value === 'string' && value.trim() ? value : undefined;
+const asFields = (value) => Array.isArray(value) ? value : undefined;
+const asListItems = (value) => Array.isArray(value) ? value : undefined;
+const todoToListItem = (todo, index) => {
+    if (!isRecord(todo)) {
+        return {
+            id: `todo_${index + 1}`,
+            label: String(todo),
+        };
+    }
+    return {
+        id: readString(todo.id) || `todo_${index + 1}`,
+        label: readString(todo.label) ||
+            readString(todo.task) ||
+            readString(todo.title) ||
+            `Todo ${index + 1}`,
+        description: readString(todo.description),
+        status: readString(todo.status),
+        metadata: todo,
+    };
+};
+const createWidgetId = (data, toolCallId) => {
+    if ('widgetId' in data && data.widgetId)
+        return data.widgetId;
+    if (toolCallId)
+        return `widget_${toolCallId}`;
+    return `widget_${Date.now()}`;
+};
+const normalizeWidget = (data, state, toolCallId) => {
+    const widgetId = createWidgetId(data, toolCallId);
+    if (data.kind === 'approval') {
+        const props = data.props || {};
+        return {
+            widgetId,
+            kind: 'choice',
+            title: data.title || 'Approval Required',
+            body: readString(props.message) ||
+                readString(props.summary) ||
+                'Please approve or deny this action.',
+            metadata: {
+                ...(data.metadata || {}),
+                legacyKind: 'approval',
+                actionId: props.actionId,
+            },
+            actions: [
+                { id: 'approve', label: 'Approve', value: props.actionId || 'approve', variant: 'primary' },
+                { id: 'deny', label: 'Deny', value: props.actionId || 'deny', variant: 'danger' },
+            ],
+        };
+    }
+    if (data.kind === 'todo_list') {
+        const props = data.props || {};
+        const stateTodos = isRecord(state.threadDetails?.state)
+            ? state.threadDetails.state.todos
+            : undefined;
+        const todos = asListItems(props.todos) || asListItems(stateTodos) || [];
+        return {
+            widgetId,
+            kind: 'list',
+            title: data.title || readString(props.title) || 'Task List',
+            description: readString(props.description),
+            metadata: {
+                ...(data.metadata || {}),
+                legacyKind: 'todo_list',
+            },
+            items: todos.map(todoToListItem),
+        };
+    }
+    if (data.kind === 'form') {
+        const propsSource = data.props;
+        const props = isRecord(propsSource) ? propsSource : {};
+        return {
+            widgetId,
+            kind: 'form',
+            title: data.title || 'Details Required',
+            description: data.description,
+            body: data.body,
+            state: data.state,
+            metadata: data.metadata,
+            fields: data.fields || asFields(props.schema) || [],
+            submitLabel: data.submitLabel || readString(props.submitLabel),
+            actions: data.actions,
+        };
+    }
+    if (data.kind === 'list') {
+        return {
+            ...data,
+            widgetId,
+            title: data.title || 'Task List',
+            items: data.items || [],
+        };
+    }
+    if (data.kind === 'choice') {
+        return {
+            ...data,
+            widgetId,
+            title: data.title || 'Choose an Option',
+        };
+    }
+    if (data.kind === 'message') {
+        return {
+            ...data,
+            widgetId,
+            title: data.title || 'Message',
+        };
+    }
+    throw new Error(`Unsupported UI widget kind: ${data.kind || 'unknown'}`);
+};
 /**
  * UI Plugin for Melony.
  * Provides tools for agents to trigger interactive UI widgets.
  */
 export const uiPlugin = () => (builder) => {
     builder.on('action:render_ui_widget', async function* (event, context) {
-        const { kind, title, props } = event.data;
-        const finalProps = { ...props };
-        // Auto-inject todos if it's a todo_list and they aren't provided
-        if (kind === 'todo_list' && !finalProps.todos) {
-            finalProps.todos = context.state.threadDetails?.state?.todos || [];
-        }
+        const widget = normalizeWidget(event.data, context.state, event.meta?.toolCallId);
         yield {
             type: 'client:ui:widget',
-            data: {
-                widgetId: `${kind}_${Date.now()}`,
-                kind,
-                title: title || (kind === 'approval' ? 'Approval Required' : kind === 'todo_list' ? 'Task List' : 'Details Required'),
-                props: finalProps,
-            },
+            data: widget,
             meta: event.meta,
         };
     });
 };
 export const uiToolDefinitions = {
     render_ui_widget: {
-        description: 'Render an interactive UI widget (approval, todo_list, or form) in the conversation.',
-        inputSchema: z.object({
-            kind: z.enum(['approval', 'todo_list', 'form']).describe('The type of widget to render.'),
-            title: z.string().optional().describe('Optional title for the widget.'),
-            props: z.record(z.string(), z.unknown()).describe('Properties for the widget. \n' +
-                '- For "approval": { message: string, actionId: string }\n' +
-                '- For "todo_list": { title?: string } (Note: current thread todos are auto-injected if not provided)\n' +
-                '- For "form": { schema: Array<{ id, label, type, options?, required? }>, submitLabel?: string }'),
-        }),
+        description: 'Render a small server-driven UI widget in the conversation. Prefer primitive kinds: message, choice, form, or list. Legacy presets approval and todo_list are still accepted.',
+        inputSchema: renderWidgetSchema,
     },
 };
 export const plugin = {

package/dist/registry/agents.js

@@ -0,0 +1,138 @@
+import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { openBotAgentPackage } from '../agents/openbot/index.js';
+import { DEFAULT_AGENT_PACKAGES_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
+let agentPackagesDir = null;
+const loadedPackages = new Set();
+const cache = new Map();
+const BUILT_IN = {
+    [openBotAgentPackage.id]: openBotAgentPackage,
+};
+/**
+ * Normalize a dynamically imported agent package module. Supports:
+ * - `agentPackage`, `default` (current AgentPackage layout)
+ * - `plugin`: legacy/community bundles that used `{ kind: "runtime", factory: (opts) => ... }`
+ *   where opts should come from agent config (merged at runtime via AgentPackageContext).
+ */
+export function parseAgentPackageModule(module) {
+    const raw = module.agentPackage ??
+        module.default ??
+        module.plugin;
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const id = raw.id;
+    const name = raw.name;
+    const factory = raw.factory;
+    if (typeof id !== 'string' || typeof name !== 'string' || typeof factory !== 'function') {
+        return null;
+    }
+    const description = typeof raw.description === 'string' ? raw.description : '';
+    if (raw.kind === 'runtime') {
+        const legacyFactory = factory;
+        return {
+            id,
+            name,
+            description,
+            image: typeof raw.image === 'string' ? raw.image : undefined,
+            defaultInstructions: typeof raw.defaultInstructions === 'string' ? raw.defaultInstructions : undefined,
+            configSchema: raw.configSchema,
+            factory: (ctx) => {
+                const opts = ctx.config && typeof ctx.config === 'object' && !Array.isArray(ctx.config)
+                    ? { ...ctx.config }
+                    : {};
+                return legacyFactory(opts);
+            },
+        };
+    }
+    return raw;
+}
+async function resolveCommunityDistPath(agentPackagesDir, id) {
+    const direct = path.join(agentPackagesDir, id, 'dist', 'index.js');
+    if (fs.existsSync(direct))
+        return direct;
+    try {
+        const entries = await fsPromises.readdir(agentPackagesDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const distPath = path.join(agentPackagesDir, entry.name, 'dist', 'index.js');
+            if (!fs.existsSync(distPath))
+                continue;
+            try {
+                const mod = await import(pathToFileURL(distPath).href);
+                const pkg = parseAgentPackageModule(mod);
+                if (pkg?.id === id)
+                    return distPath;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+/** Initialize the on-disk agent packages directory (defaults to ~/.openbot/agent-packages). */
+export function initAgentPackages(dir) {
+    if (dir) {
+        agentPackagesDir = dir;
+    }
+    else {
+        const config = loadConfig();
+        const baseDir = config.baseDir || DEFAULT_BASE_DIR;
+        agentPackagesDir = path.join(resolvePath(baseDir), DEFAULT_AGENT_PACKAGES_DIR);
+    }
+}
+/**
+ * Resolve an AgentPackage by id. Looks up built-in packages first, then any
+ * community packages installed under the agent-packages directory.
+ */
+export async function resolveAgentPackage(id) {
+    if (cache.has(id))
+        return cache.get(id);
+    if (BUILT_IN[id]) {
+        cache.set(id, BUILT_IN[id]);
+        return BUILT_IN[id];
+    }
+    if (!agentPackagesDir) {
+        initAgentPackages();
+    }
+    if (!agentPackagesDir)
+        return null;
+    const distPath = await resolveCommunityDistPath(agentPackagesDir, id);
+    if (!distPath) {
+        console.warn(`[agents] AgentPackage "${id}" not found in registry or under ${agentPackagesDir}.`);
+        return null;
+    }
+    try {
+        const module = await import(pathToFileURL(distPath).href);
+        const pkg = parseAgentPackageModule(module);
+        if (!pkg) {
+            console.warn(`[agents] AgentPackage "${id}" at ${distPath} has no recognizable export.`);
+            return null;
+        }
+        cache.set(id, pkg);
+        if (!loadedPackages.has(id)) {
+            console.log(`[agents] Loaded community agent package "${id}" from ${distPath}`);
+            loadedPackages.add(id);
+        }
+        return pkg;
+    }
+    catch (e) {
+        console.warn(`[agents] Failed to load agent package "${id}" from ${distPath}:`, e);
+        return null;
+    }
+}
+/** List built-in agent package descriptors (for marketplace/registry views). */
+export function listBuiltInAgentPackages() {
+    return Object.values(BUILT_IN);
+}
+export function getAgentPackagesDir() {
+    return agentPackagesDir;
+}

package/dist/registry/plugins.js

@@ -1,18 +1,54 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { aiSdkPlugin } from '../plugins/ai-sdk.js';
-import { storagePlugin } from '../plugins/storage.js';
-import { storageService } from '../services/storage.js';
-import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
-import { delegationPlugin } from '../plugins/delegation.js';
-import { mcpPlugin } from '../plugins/mcp.js';
-import { uiPlugin } from '../plugins/ui.js';
+import { aiSdkPlugin } from '../plugins/ai-sdk/index.js';
+import { shellPlugin } from '../plugins/shell/index.js';
+import { mcpPlugin } from '../plugins/mcp/index.js';
+import { delegationPlugin } from '../plugins/delegation/index.js';
+import { storageToolsPlugin } from '../plugins/storage-tools/index.js';
+import { uiPlugin } from '../plugins/ui/index.js';
+import { approvalPlugin } from '../plugins/approval/index.js';
+import { memoryPlugin } from '../plugins/memory/index.js';
+import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
 let pluginsDir = null;
 const loadedPlugins = new Set();
-/**
- * Initializes the plugins directory.
- */
+const cache = new Map();
+const BUILT_IN = {
+    [aiSdkPlugin.id]: aiSdkPlugin,
+    [shellPlugin.id]: shellPlugin,
+    [mcpPlugin.id]: mcpPlugin,
+    [delegationPlugin.id]: delegationPlugin,
+    [storageToolsPlugin.id]: storageToolsPlugin,
+    [uiPlugin.id]: uiPlugin,
+    [approvalPlugin.id]: approvalPlugin,
+    [memoryPlugin.id]: memoryPlugin,
+};
+/** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
+export function parsePluginModule(module) {
+    const raw = module.plugin ??
+        module.default;
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const factory = raw.factory;
+    if (typeof factory !== 'function')
+        return null;
+    const name = typeof raw.name === 'string' ? raw.name : '';
+    const description = typeof raw.description === 'string' ? raw.description : '';
+    const image = typeof raw.image === 'string' ? raw.image : undefined;
+    const defaultInstructions = typeof raw.defaultInstructions === 'string' ? raw.defaultInstructions : undefined;
+    const configSchema = raw.configSchema;
+    const toolDefinitions = raw.toolDefinitions;
+    return {
+        name,
+        description,
+        image,
+        defaultInstructions,
+        configSchema,
+        toolDefinitions,
+        factory: factory,
+    };
+}
+/** Initialize the on-disk plugins directory (defaults to ~/.openbot/plugins). */
 export function initPlugins(dir) {
     if (dir) {
         pluginsDir = dir;
@@ -20,54 +56,61 @@ export function initPlugins(dir) {
     else {
         const config = loadConfig();
         const baseDir = config.baseDir || DEFAULT_BASE_DIR;
-        pluginsDir = path.join(resolvePath(baseDir), 'plugins');
+        pluginsDir = path.join(resolvePath(baseDir), DEFAULT_PLUGINS_DIR);
     }
 }
 /**
- * Resolves a plugin from its name and config.
+ * Resolve a Plugin by id. The id is either:
+ *   - a built-in id (e.g. "ai-sdk", "shell"), or
+ *   - an npm package name (e.g. "openbot-plugin-foo" or "@scope/foo"),
+ *     in which case the folder layout is `plugins/<id>/dist/index.js`.
  */
-export async function resolvePlugin(pluginName, config = {}) {
-    // 1. Built-in plugins
-    switch (pluginName) {
-        case 'storage':
-            return storagePlugin({ storage: storageService, ...config });
-        case 'ai-sdk':
-            return aiSdkPlugin({
-                storage: storageService,
-                ...config,
-            });
-        case 'delegation':
-            return delegationPlugin();
-        case 'mcp':
-            return mcpPlugin();
-        case 'ui':
-            return uiPlugin();
+export async function resolvePlugin(id) {
+    if (cache.has(id))
+        return cache.get(id);
+    if (BUILT_IN[id]) {
+        cache.set(id, BUILT_IN[id]);
+        return BUILT_IN[id];
     }
-    // 2. Search for external plugins in the initialized plugins directory
     if (!pluginsDir) {
         initPlugins();
     }
-    if (pluginsDir) {
-        const pluginDir = path.resolve(pluginsDir, pluginName);
-        const distPath = path.join(pluginDir, 'dist', 'index.js');
-        if (fs.existsSync(distPath)) {
-            try {
-                // Dynamic import needs file:// URL for absolute paths
-                const module = await import(pathToFileURL(distPath).href);
-                const factory = module.plugin.factory;
-                if (typeof factory === 'function') {
-                    if (!loadedPlugins.has(pluginName)) {
-                        console.log(`[plugins] Loaded community plugin "${pluginName}" from ${distPath}`);
-                        loadedPlugins.add(pluginName);
-                    }
-                    return factory(config);
-                }
-            }
-            catch (e) {
-                console.warn(`[plugins] Failed to load plugin "${pluginName}" from ${distPath}:`, e);
-            }
+    if (!pluginsDir)
+        return null;
+    const distPath = path.join(pluginsDir, id, 'dist', 'index.js');
+    if (!fs.existsSync(distPath)) {
+        console.warn(`[plugins] Plugin "${id}" not found at ${distPath}.`);
+        return null;
+    }
+    try {
+        const module = await import(pathToFileURL(distPath).href);
+        const parsed = parsePluginModule(module);
+        if (!parsed) {
+            console.warn(`[plugins] Plugin "${id}" at ${distPath} has no recognizable export.`);
+            return null;
+        }
+        const plugin = { id, ...parsed, name: parsed.name || id };
+        cache.set(id, plugin);
+        if (!loadedPlugins.has(id)) {
+            console.log(`[plugins] Loaded community plugin "${id}" from ${distPath}`);
+            loadedPlugins.add(id);
         }
+        return plugin;
     }
-    console.warn(`[plugins] Plugin "${pluginName}" not found in registry or external directory.`);
-    return null;
+    catch (e) {
+        console.warn(`[plugins] Failed to load plugin "${id}" from ${distPath}:`, e);
+        return null;
+    }
+}
+/** Drop a single id from the in-memory cache (e.g. after fresh install). */
+export function invalidatePlugin(id) {
+    cache.delete(id);
+    loadedPlugins.delete(id);
+}
+/** List built-in plugins (for marketplace/registry views). */
+export function listBuiltInPlugins() {
+    return Object.values(BUILT_IN);
+}
+export function getPluginsDir() {
+    return pluginsDir;
 }

package/dist/services/agent-packages.js

@@ -0,0 +1,103 @@
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import { DEFAULT_AGENT_PACKAGES_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath, } from '../app/config.js';
+import { parseAgentPackageModule } from '../registry/agents.js';
+const execAsync = promisify(exec);
+/**
+ * Lifecycle for community-built agent packages distributed via npm.
+ * The package format mirrors a normal npm package whose `dist/index.js`
+ * exports `agentPackage` (or `default`) that satisfies the `AgentPackage`
+ * interface.
+ */
+export const agentPackageService = {
+    install: async ({ packageName, version }) => {
+        const config = loadConfig();
+        const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
+        const packagesDir = path.join(baseDir, DEFAULT_AGENT_PACKAGES_DIR);
+        await fs.mkdir(packagesDir, { recursive: true });
+        const target = version ? `${packageName}@${version}` : packageName;
+        const entries = await fs.readdir(packagesDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() || entry.isSymbolicLink()) {
+                const pkgPath = path.join(packagesDir, entry.name, 'package.json');
+                if (existsSync(pkgPath)) {
+                    try {
+                        const pkgJson = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+                        if (pkgJson.name === packageName && (!version || pkgJson.version === version)) {
+                            console.log(`[agent-packages] ${packageName}${version ? `@${version}` : ''} is already installed at ${entry.name}.`);
+                            return {
+                                name: pkgJson.name,
+                                id: entry.name,
+                                version: pkgJson.version,
+                            };
+                        }
+                    }
+                    catch {
+                        // ignore corrupted package.json
+                    }
+                }
+            }
+        }
+        console.log(`[agent-packages] Installing ${target} to ${packagesDir}...`);
+        try {
+            const tempDir = path.join(packagesDir, '.tmp_' + Date.now());
+            await fs.mkdir(tempDir, { recursive: true });
+            await execAsync(`npm install ${target} --no-save --prefix "${tempDir}"`);
+            const pkgNameOnly = packageName.includes('/') ? packageName.split('/').pop() : packageName;
+            const installedPath = path.join(tempDir, 'node_modules', packageName);
+            let finalId = pkgNameOnly;
+            try {
+                const distPath = path.join(installedPath, 'dist', 'index.js');
+                if (existsSync(distPath)) {
+                    const module = await import(pathToFileURL(distPath).href);
+                    const exported = parseAgentPackageModule(module);
+                    if (exported?.id)
+                        finalId = exported.id;
+                }
+            }
+            catch (e) {
+                console.warn(`[agent-packages] Could not read package metadata for ${packageName}; using folder name as id.`, e);
+            }
+            const finalPath = path.join(packagesDir, finalId);
+            await fs.rm(finalPath, { recursive: true, force: true });
+            await fs.rename(installedPath, finalPath);
+            await fs.rm(tempDir, { recursive: true, force: true });
+            console.log(`[agent-packages] Running npm install in ${finalPath}...`);
+            try {
+                await execAsync(`npm install`, { cwd: finalPath });
+                console.log(`[agent-packages] npm install completed in ${finalPath}`);
+            }
+            catch (e) {
+                console.warn(`[agent-packages] Failed to run npm install in ${finalPath}:`, e);
+            }
+            const pkgJson = JSON.parse(await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'));
+            return {
+                name: pkgJson.name,
+                id: finalId,
+                version: pkgJson.version,
+            };
+        }
+        catch (error) {
+            console.error(`[agent-packages] Failed to install ${packageName}:`, error);
+            throw new Error(`Failed to install agent package ${packageName}: ${error.message}`);
+        }
+    },
+    uninstall: async (id) => {
+        const config = loadConfig();
+        const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
+        const packagesDir = path.join(baseDir, DEFAULT_AGENT_PACKAGES_DIR);
+        const packagePath = path.join(packagesDir, id);
+        try {
+            await fs.rm(packagePath, { recursive: true, force: true });
+            console.log(`[agent-packages] Uninstalled agent package ${id}`);
+        }
+        catch (error) {
+            console.error(`[agent-packages] Failed to uninstall ${id}:`, error);
+            throw new Error(`Failed to uninstall agent package ${id}: ${error.message}`);
+        }
+    },
+};