openbot 0.5.4 → 0.5.6

package/dist/plugins/storage/index.js

@@ -1,90 +1,12 @@
-import z from 'zod';
 import { buildWorkspaceFileUrl } from './files.js';
 /**
- * `storage` — exposes channel/thread/variable mutation tools and provides
- * platform-level storage handlers.
+ * `storage` — platform infra handlers for `/api/state` and deterministic reads.
+ * Agent-facing storage tools live in `@meetopenbot/openbot`.
  */
-const storageToolDefinitions = {
-    create_channel: {
-        description: 'Create a new channel. Use when the user intent is clearly different from the current channel and should be split. Always confirm before creating. Skip for simple Q&A.',
-        inputSchema: z.object({
-            channelId: z
-                .string()
-                .describe('Unique channel ID (e.g. product-launch, backend-platform, channel_roadmap).'),
-            spec: z
-                .string()
-                .optional()
-                .describe('Optional initial markdown content for the channel spec.'),
-            initialState: z
-                .record(z.string(), z.unknown())
-                .optional()
-                .describe('Optional initial state object for the channel.'),
-            cwd: z
-                .string()
-                .optional()
-                .describe('Optional initial current working directory for the channel. Defaults to an absolute path under ~/openbot/{channelId}.'),
-        }),
-    },
-    patch_channel_details: {
-        description: 'Patch current channel details (state, spec, cwd).',
-        inputSchema: z
-            .object({
-            state: z
-                .record(z.string(), z.unknown())
-                .optional()
-                .describe('JSON state object for the channel.'),
-            spec: z
-                .string()
-                .optional()
-                .describe('Markdown content for the channel specification (SPEC.md). Use for goals and rules.'),
-            cwd: z.string().optional().describe('Current working directory for the channel.'),
-        })
-            .refine((value) => value.state !== undefined ||
-            value.spec !== undefined ||
-            value.cwd !== undefined, { message: 'Provide at least one of state, spec, or cwd.' }),
-    },
-    patch_thread_details: {
-        description: 'Patch current thread details (state). Use for thread metadata such as `name` or `isSmartNamed`. For multi-step task tracking, use `todo_write` instead.',
-        inputSchema: z.object({
-            state: z
-                .record(z.string(), z.unknown())
-                .describe('JSON state object for the thread. Merges with existing state.'),
-        }),
-    },
-    create_variable: {
-        description: 'Create or update a variable in the workspace storage.',
-        inputSchema: z.object({
-            key: z.string().describe('The key of the variable.'),
-            value: z.string().describe('The value of the variable.'),
-            secret: z.boolean().optional().describe('Whether the variable is a secret.'),
-        }),
-    },
-    delete_variable: {
-        description: 'Delete a variable from the workspace storage.',
-        inputSchema: z.object({
-            key: z.string().describe('The key of the variable to delete.'),
-        }),
-    },
-    delete_channel: {
-        description: 'Permanently delete a channel and all its threads and events. Always confirm with the user before deleting.',
-        inputSchema: z.object({
-            channelId: z.string().describe('The channel ID to delete.'),
-        }),
-    },
-    get_workspace_file_url: {
-        description: 'Get a fetchable HTTP URL for a file in the current channel workspace (images, video, audio, documents).',
-        inputSchema: z.object({
-            path: z
-                .string()
-                .describe('Path relative to the channel working directory, e.g. "uploads/clip.mp4".'),
-        }),
-    },
-};
 export const storagePlugin = {
     id: 'storage',
     name: 'Storage',
-    description: 'Tools for creating channels, patching state, and managing workspace variables.',
-    toolDefinitions: storageToolDefinitions,
+    description: 'Infrastructure storage handlers for channels, threads, agents, and files.',
     factory: ({ storage, publicBaseUrl }) => (builder) => {
         const resolvePublicBaseUrl = () => publicBaseUrl;
         builder.on('action:create_thread', async function* (event, context) {
@@ -119,215 +41,6 @@ export const storagePlugin = {
                 meta: { ...(event.meta || {}), threadId, agentId: context.state.agentId },
             };
         });
-        builder.on('action:create_channel', async function* (event, context) {
-            const { channelId, spec, initialState, cwd } = event.data;
-            const rawChannelId = (channelId || '').trim();
-            const channelSpec = typeof spec === 'string' ? spec : '';
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-            if (!rawChannelId) {
-                yield {
-                    type: 'action:create_channel:result',
-                    data: { success: false, channelId: '', channelUrl: '' },
-                    meta: resultMeta,
-                };
-                return;
-            }
-            const channelUrl = `/channels/${rawChannelId}`;
-            const mergedInitial = { ...(initialState || {}) };
-            try {
-                await storage.createChannel({
-                    channelId: rawChannelId,
-                    spec: channelSpec,
-                    initialState: mergedInitial,
-                    cwd,
-                });
-                yield {
-                    type: 'action:create_channel:result',
-                    data: { success: true, channelId: rawChannelId, channelUrl },
-                    meta: resultMeta,
-                };
-                yield {
-                    type: 'agent:output',
-                    data: { content: `Created channel \`${rawChannelId}\`.` },
-                    meta: resultMeta,
-                };
-            }
-            catch {
-                yield {
-                    type: 'action:create_channel:result',
-                    data: { success: false, channelId: rawChannelId, channelUrl },
-                    meta: resultMeta,
-                };
-            }
-        });
-        builder.on('action:delete_channel', async function* (event, context) {
-            const rawChannelId = (event.data?.channelId || '').trim();
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-            if (!rawChannelId) {
-                yield {
-                    type: 'action:delete_channel:result',
-                    data: { success: false, channelId: '', error: 'channelId is required' },
-                    meta: resultMeta,
-                };
-                return;
-            }
-            try {
-                await storage.deleteChannel({ channelId: rawChannelId });
-                yield {
-                    type: 'action:delete_channel:result',
-                    data: { success: true, channelId: rawChannelId },
-                    meta: resultMeta,
-                };
-                yield {
-                    type: 'agent:output',
-                    data: { content: `Deleted channel \`${rawChannelId}\`.` },
-                    meta: resultMeta,
-                };
-            }
-            catch (error) {
-                yield {
-                    type: 'action:delete_channel:result',
-                    data: {
-                        success: false,
-                        channelId: rawChannelId,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    },
-                    meta: resultMeta,
-                };
-            }
-        });
-        builder.on('action:update_channel', async function* (event, context) {
-            const data = (event.data || {});
-            const targetChannelId = (data.channelId || context.state.channelId || '').trim();
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-            if (!targetChannelId) {
-                yield {
-                    type: 'action:update_channel:result',
-                    data: { success: false, channelId: '', updatedFields: [] },
-                    meta: resultMeta,
-                };
-                return;
-            }
-            const patch = {};
-            const updatedFields = [];
-            if (typeof data.name === 'string' && data.name.trim()) {
-                patch.name = data.name.trim();
-                updatedFields.push('name');
-            }
-            if (typeof data.cwd === 'string' && data.cwd.trim()) {
-                patch.cwd = data.cwd.trim();
-                updatedFields.push('cwd');
-            }
-            try {
-                if (updatedFields.length > 0) {
-                    await storage.patchChannelState({ channelId: targetChannelId, state: patch });
-                }
-                if (targetChannelId === context.state.channelId) {
-                    context.state.channelDetails = await storage.getChannelDetails({
-                        channelId: context.state.channelId,
-                    });
-                }
-                yield {
-                    type: 'action:update_channel:result',
-                    data: { success: true, channelId: targetChannelId, updatedFields },
-                    meta: resultMeta,
-                };
-            }
-            catch {
-                yield {
-                    type: 'action:update_channel:result',
-                    data: { success: false, channelId: targetChannelId, updatedFields },
-                    meta: resultMeta,
-                };
-            }
-        });
-        builder.on('action:patch_channel_details', async function* (event, context) {
-            const updatedFields = [];
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-            const data = (event.data || {});
-            try {
-                if (data.state !== undefined) {
-                    await storage.patchChannelState({
-                        channelId: context.state.channelId,
-                        state: data.state,
-                    });
-                    updatedFields.push('state');
-                }
-                if (typeof data.spec === 'string') {
-                    await storage.patchChannelSpec({
-                        channelId: context.state.channelId,
-                        spec: data.spec,
-                    });
-                    updatedFields.push('spec');
-                }
-                if (typeof data.cwd === 'string') {
-                    await storage.patchChannelState({
-                        channelId: context.state.channelId,
-                        state: { cwd: data.cwd },
-                    });
-                    updatedFields.push('cwd');
-                }
-                context.state.channelDetails = await storage.getChannelDetails({
-                    channelId: context.state.channelId,
-                });
-                yield {
-                    type: "client:ui:widget",
-                    data: {
-                        widgetId: "patch-channel-details-result" + Date.now(),
-                        kind: "message",
-                        title: "Channel details updated.",
-                        body: `The channel details have been updated. ${updatedFields.join(', ')}`,
-                        display: "collapsed",
-                    },
-                    meta: resultMeta,
-                };
-                yield {
-                    type: 'action:patch_channel_details:result',
-                    data: { success: true, updatedFields },
-                    meta: resultMeta,
-                };
-            }
-            catch {
-                yield {
-                    type: 'action:patch_channel_details:result',
-                    data: { success: false, updatedFields },
-                    meta: resultMeta,
-                };
-            }
-        });
-        builder.on('action:patch_thread_details', async function* (event, context) {
-            const updatedFields = [];
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-            try {
-                if (!context.state.threadId) {
-                    throw new Error('Missing threadId in state for patch_thread_details');
-                }
-                if (event.data.state !== undefined) {
-                    await storage.patchThreadState({
-                        channelId: context.state.channelId,
-                        threadId: context.state.threadId,
-                        state: event.data.state,
-                    });
-                    updatedFields.push('state');
-                }
-                context.state.threadDetails = await storage.getThreadDetails({
-                    channelId: context.state.channelId,
-                    threadId: context.state.threadId,
-                });
-                yield {
-                    type: 'action:patch_thread_details:result',
-                    data: { success: true, updatedFields },
-                    meta: resultMeta,
-                };
-            }
-            catch {
-                yield {
-                    type: 'action:patch_thread_details:result',
-                    data: { success: false, updatedFields },
-                    meta: resultMeta,
-                };
-            }
-        });
         builder.on('agent:usage', async function* (event, context) {
             const { usage } = event.data;
             if (!context.state.threadId)
@@ -671,41 +384,6 @@ export const storagePlugin = {
                 };
             }
         });
-        builder.on('action:get_workspace_file_url', async function* (event, context) {
-            const channelId = context.state.channelId;
-            const filePath = event.data?.path;
-            const toolCallId = event.meta?.toolCallId;
-            if (!filePath) {
-                yield {
-                    type: 'action:get_workspace_file_url:result',
-                    data: { success: false, path: '', error: 'Path is required', output: 'Path is required' },
-                    meta: { ...(event.meta || {}), toolCallId },
-                };
-                return;
-            }
-            try {
-                const { size, mimeType } = await storage.getChannelFileStat({ channelId, path: filePath });
-                const url = buildWorkspaceFileUrl({
-                    baseUrl: resolvePublicBaseUrl(),
-                    channelId,
-                    filePath,
-                });
-                const output = JSON.stringify({ path: filePath, url, mimeType, size });
-                yield {
-                    type: 'action:get_workspace_file_url:result',
-                    data: { success: true, path: filePath, url, mimeType, size, output },
-                    meta: { ...(event.meta || {}), toolCallId },
-                };
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : 'Unknown error';
-                yield {
-                    type: 'action:get_workspace_file_url:result',
-                    data: { success: false, path: filePath, error: message, output: message },
-                    meta: { ...(event.meta || {}), toolCallId },
-                };
-            }
-        });
     },
 };
 export default storagePlugin;

package/dist/plugins/storage/service.js

@@ -1,5 +1,5 @@
 import { ORCHESTRATOR_AGENT_ID, STATE_AGENT_ID } from '../../app/agent-ids.js';
-import { assertCloudSystemAgentPluginsMutable, CLOUD_SYSTEM_MODEL, isCloudMode, } from '../../app/cloud-mode.js';
+import { assertCloudSystemAgentPluginsMutable, DEFAULT_CLOUD_OPENBOT_AUTH_MODE, isCloudMode, } from '../../app/cloud-mode.js';
 import { DEFAULT_PLUGINS_DIR, DEFAULT_AGENTS_DIR, DEFAULT_CHANNELS_DIR, getBaseDir, getDefaultChannelCwd, resolvePath, VARIABLES_FILE, } from '../../app/config.js';
 import fs from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
@@ -7,7 +7,7 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import crypto from 'node:crypto';
 import matter from 'gray-matter';
-import { openbotPlugin } from '../openbot/index.js';
+import { OPENBOT_PLUGIN_ID } from '../../app/openbot-plugin.js';
 import { listBuiltInPlugins, parsePluginModule } from '../../services/plugins/registry.js';
 import { enrichOpenbotPluginDescriptor, listRegistryModelOptions, } from '../../services/plugins/model-registry.js';
 import { processService } from '../../services/process.js';
@@ -80,29 +80,28 @@ const getConversationDir = (channelId, threadId) => {
 const SYSTEM_AGENT_ID = ORCHESTRATOR_AGENT_ID;
 const SYSTEM_DEFAULT_PLUGINS = [
     {
-        id: 'openbot',
+        id: OPENBOT_PLUGIN_ID,
         config: {
             model: 'openai/gpt-5.4-mini',
-            approval: {
-                actions: ['action:shell_exec', 'action:create_channel', 'action:delete_channel'],
-            },
         },
     },
 ];
-const CLOUD_SYSTEM_DEFAULT_PLUGINS = [
-    {
-        id: 'openbot',
-        config: {
-            model: CLOUD_SYSTEM_MODEL,
-            approval: {
-                actions: ['action:shell_exec', 'action:create_channel', 'action:delete_channel'],
+function getCloudSystemDefaultPlugins() {
+    return SYSTEM_DEFAULT_PLUGINS.map((ref) => {
+        if (ref.id !== OPENBOT_PLUGIN_ID)
+            return ref;
+        return {
+            ...ref,
+            config: {
+                ...ref.config,
+                authMode: DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
             },
-        },
-    },
-];
+        };
+    });
+}
 function mergeCloudSystemPluginRefs(defaults, diskRefs) {
-    const defaultOpenbot = defaults.find((ref) => ref.id === 'openbot');
-    const diskOpenbot = diskRefs.find((ref) => ref.id === 'openbot');
+    const defaultOpenbot = defaults.find((ref) => ref.id === OPENBOT_PLUGIN_ID);
+    const diskOpenbot = diskRefs.find((ref) => ref.id === OPENBOT_PLUGIN_ID);
     if (!defaultOpenbot)
         return defaults;
     return [
@@ -122,7 +121,7 @@ const STATE_DEFAULT_PLUGINS = [
 ];
 const STATE_AGENT_INSTRUCTIONS = 'Built-in infra agent for deterministic state reads. No conversational model is attached; handle storage, approvals, memory, and plugin marketplace events.';
 function getSystemAgentDetails(overrides) {
-    const defaultPlugins = isCloudMode() ? CLOUD_SYSTEM_DEFAULT_PLUGINS : SYSTEM_DEFAULT_PLUGINS;
+    const defaultPlugins = isCloudMode() ? getCloudSystemDefaultPlugins() : SYSTEM_DEFAULT_PLUGINS;
     const defaults = {
         id: SYSTEM_AGENT_ID,
         name: 'OpenBot',
@@ -210,8 +209,6 @@ const agentSummaryFromDetails = (details) => ({
     createdAt: details.createdAt,
     updatedAt: details.updatedAt,
 });
-// Suppress unused warning until system agent customization re-uses openbotPlugin metadata.
-void openbotPlugin;
 /** Built-in agents may persist optional `agents/<id>/AGENT.md` overlays; read path merges them with defaults. */
 const isBuiltinOverlayAgentId = (agentId) => agentId === SYSTEM_AGENT_ID || agentId === STATE_AGENT_ID;
 const assertAgentIdFormat = (agentId) => {

package/dist/services/plugins/host.js

@@ -0,0 +1,21 @@
+import { DEFAULT_CLOUD_OPENBOT_AUTH_MODE, isCloudMode, isCloudSystemAgent, parseOpenbotAuthMode, } from '../../app/cloud-mode.js';
+import { ORCHESTRATOR_AGENT_ID } from '../../app/agent-ids.js';
+import { OPENBOT_PLUGIN_ID } from '../../app/openbot-plugin.js';
+import { getBaseDir, resolvePath, saveConfig } from '../../app/config.js';
+import { listApiKeyProvidersFromRegistry, resolveModelRegistry, } from './model-registry.js';
+export function createPluginHost(runAgent) {
+    return {
+        runAgent,
+        isCloudSystemAgent,
+        isCloudMode,
+        parseOpenbotAuthMode,
+        resolveModelRegistry,
+        listApiKeyProvidersFromRegistry,
+        saveConfig,
+        getBaseDir,
+        resolvePath,
+        orchestratorAgentId: ORCHESTRATOR_AGENT_ID,
+        openbotPluginId: OPENBOT_PLUGIN_ID,
+        defaultCloudAuthMode: DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
+    };
+}

package/dist/services/plugins/model-registry.js

@@ -1,5 +1,6 @@
 import { DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig, } from '../../app/config.js';
-import { isCloudMode } from '../../app/cloud-mode.js';
+import { OPENBOT_PLUGIN_ID } from '../../app/openbot-plugin.js';
+import { DEFAULT_CLOUD_OPENBOT_AUTH_MODE, isCloudMode, } from '../../app/cloud-mode.js';
 let cachedRegistry = null;
 let cacheUrl = null;
 function getRegistryUrl() {
@@ -57,13 +58,11 @@ function pickDefaultModelValue(options) {
     if (options.length === 0)
         return undefined;
     const values = options.map((option) => option.value);
-    const preferred = isCloudMode()
-        ? values.find((value) => value.startsWith('openbot/'))
-        : values.find((value) => value.startsWith('openai/'));
+    const preferred = values.find((value) => value.startsWith('openai/'));
     return preferred ?? values[0];
 }
 export function enrichOpenbotPluginDescriptor(descriptor, modelOptions) {
-    if (descriptor.id !== 'openbot' || !descriptor.configSchema)
+    if (descriptor.id !== OPENBOT_PLUGIN_ID || !descriptor.configSchema)
         return descriptor;
     const modelProperty = descriptor.configSchema.properties.model;
     if (!modelProperty)
@@ -88,14 +87,40 @@ export function enrichOpenbotPluginDescriptor(descriptor, modelOptions) {
     if (defaultModel) {
         nextModelProperty.default = defaultModel;
     }
+    const { model: _model, authMode: _authMode, ...otherProperties } = descriptor.configSchema.properties;
+    const cloudAuthModeProperty = {
+        type: 'string',
+        description: 'Credits uses OpenBot platform billing. BYOK uses your own API keys.',
+        enum: ['credits', 'byok'],
+        default: DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
+        options: [
+            {
+                label: 'Credits',
+                value: 'credits',
+                description: 'Use OpenBot platform credits.',
+            },
+            {
+                label: 'Bring your own key',
+                value: 'byok',
+                description: 'Use your own provider API keys.',
+            },
+        ],
+    };
+    const nextProperties = isCloudMode()
+        ? {
+            authMode: cloudAuthModeProperty,
+            model: nextModelProperty,
+            ...otherProperties,
+        }
+        : {
+            model: nextModelProperty,
+            ...otherProperties,
+        };
     return {
         ...descriptor,
         configSchema: {
             ...descriptor.configSchema,
-            properties: {
-                ...descriptor.configSchema.properties,
-                model: nextModelProperty,
-            },
+            properties: nextProperties,
         },
     };
 }

package/dist/services/plugins/registry.js

@@ -1,30 +1,14 @@
-import fs from 'node:fs';
+import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { openbotPlugin } from '../../plugins/openbot/index.js';
-import { bashPlugin } from '../../plugins/bash/index.js';
 import { storagePlugin } from '../../plugins/storage/index.js';
-import { approvalPlugin } from '../../plugins/approval/index.js';
-import { memoryPlugin } from '../../plugins/memory/index.js';
-import { todoPlugin } from '../../plugins/todo/index.js';
-import { delegationPlugin } from '../../plugins/delegation/index.js';
-import { uiPlugin } from '../../plugins/ui/index.js';
 import { pluginManagerPlugin } from '../../plugins/plugin-manager/index.js';
-import { previewPlugin } from '../../plugins/preview/index.js';
 import { DEFAULT_PLUGINS_DIR, getBaseDir } from '../../app/config.js';
 import { invalidatePlugin as clearResolvedPluginEntry, loadedCommunityPlugins, resolvedPluginCache, } from './plugin-cache.js';
 let pluginsDir = null;
 const BUILT_IN = {
-    [openbotPlugin.id]: openbotPlugin,
-    [bashPlugin.id]: bashPlugin,
     [storagePlugin.id]: storagePlugin,
-    [approvalPlugin.id]: approvalPlugin,
-    [memoryPlugin.id]: memoryPlugin,
-    [todoPlugin.id]: todoPlugin,
-    [delegationPlugin.id]: delegationPlugin,
-    [uiPlugin.id]: uiPlugin,
     [pluginManagerPlugin.id]: pluginManagerPlugin,
-    [previewPlugin.id]: previewPlugin,
 };
 /** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
 export function parsePluginModule(module) {
@@ -60,46 +44,46 @@ export function initPlugins(dir) {
 }
 /**
  * Resolve a Plugin by id. The id is either:
- *   - a built-in id (e.g. "openbot", "bash"), or
- *   - an npm package name (e.g. "openbot-plugin-foo" or "@scope/foo"),
+ *   - a built-in id (e.g. "storage", "plugin-manager"), or
+ *   - an npm package name (e.g. "@meetopenbot/openbot"),
  *     in which case the folder layout is `plugins/<id>/dist/index.js`.
  */
 export async function resolvePlugin(id) {
     if (resolvedPluginCache.has(id))
         return resolvedPluginCache.get(id);
-    if (BUILT_IN[id]) {
-        resolvedPluginCache.set(id, BUILT_IN[id]);
-        return BUILT_IN[id];
-    }
     if (!pluginsDir) {
         initPlugins();
     }
     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;
+    if (existsSync(distPath)) {
+        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.`);
+            }
+            else {
+                const plugin = { id, ...parsed, name: parsed.name || id };
+                resolvedPluginCache.set(id, plugin);
+                if (!loadedCommunityPlugins.has(id)) {
+                    console.log(`[plugins] Loaded plugin "${id}" from ${distPath}`);
+                    loadedCommunityPlugins.add(id);
+                }
+                return plugin;
+            }
         }
-        const plugin = { id, ...parsed, name: parsed.name || id };
-        resolvedPluginCache.set(id, plugin);
-        if (!loadedCommunityPlugins.has(id)) {
-            console.log(`[plugins] Loaded community plugin "${id}" from ${distPath}`);
-            loadedCommunityPlugins.add(id);
+        catch (e) {
+            console.warn(`[plugins] Failed to load plugin "${id}" from ${distPath}:`, e);
         }
-        return plugin;
     }
-    catch (e) {
-        console.warn(`[plugins] Failed to load plugin "${id}" from ${distPath}:`, e);
-        return null;
+    if (BUILT_IN[id]) {
+        resolvedPluginCache.set(id, BUILT_IN[id]);
+        return BUILT_IN[id];
     }
+    console.warn(`[plugins] Plugin "${id}" not found at ${distPath}.`);
+    return null;
 }
 /** Drop a single id from the in-memory cache (e.g. after fresh install). */
 export function invalidatePlugin(id) {

package/dist/services/plugins/service.js

@@ -6,6 +6,9 @@ import { promisify } from 'node:util';
 import { DEFAULT_PLUGINS_DIR, DEFAULT_MARKETPLACE_REGISTRY_URL, getBaseDir, loadConfig, } from '../../app/config.js';
 import { invalidatePlugin } from './plugin-cache.js';
 const execAsync = promisify(exec);
+function isLatestVersionAlias(version) {
+    return version.trim().toLowerCase() === 'latest';
+}
 const DEFAULT_MARKETPLACE_AGENTS = [];
 const DEFAULT_MARKETPLACE_CHANNELS = [];
 function isRecord(value) {
@@ -155,7 +158,8 @@ export const pluginService = {
         if (existsSync(path.join(finalPath, 'package.json'))) {
             try {
                 const pkgJson = JSON.parse(await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'));
-                if (!version || pkgJson.version === version) {
+                const wantsLatest = version !== undefined && isLatestVersionAlias(version);
+                if (!version || (!wantsLatest && pkgJson.version === version)) {
                     console.log(`[plugins] ${packageName}${version ? `@${version}` : ''} is already installed.`);
                     return { name: pkgJson.name, version: pkgJson.version };
                 }

package/dist/services/todo/types.js

@@ -0,0 +1 @@
+export {};