openbot 0.3.6 → 0.4.2

package/src/plugins/ui/index.ts

@@ -1,227 +1,123 @@
-import { MelonyPlugin } from 'melony';
-import z from 'zod';
-import type { Plugin } from '../../bus/plugin.js';
-import {
-  OpenBotEvent,
-  OpenBotState,
-  RenderUIWidgetData,
-  UIWidgetField,
-  UIWidgetListItem,
-  UIWidgetSpec,
-} from '../../app/types.js';
-
-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('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(),
-  }),
-  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: unknown): value is Record<string, unknown> =>
-  !!value && typeof value === 'object' && !Array.isArray(value);
-
-const readString = (value: unknown): string | undefined =>
-  typeof value === 'string' && value.trim() ? value : undefined;
-
-const asFields = (value: unknown): UIWidgetField[] | undefined =>
-  Array.isArray(value) ? (value as UIWidgetField[]) : undefined;
-
-const asListItems = (value: unknown): UIWidgetListItem[] | undefined =>
-  Array.isArray(value) ? (value as UIWidgetListItem[]) : undefined;
-
-const todoToListItem = (todo: unknown, index: number): UIWidgetListItem => {
-  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) as UIWidgetListItem['status'],
-    metadata: todo,
-  };
-};
-
-const createWidgetId = (data: RenderUIWidgetData, toolCallId?: string): string => {
-  if ('widgetId' in data && data.widgetId) return data.widgetId;
-  if (toolCallId) return `widget_${toolCallId}`;
-  return `widget_${Date.now()}`;
-};
-
-const normalizeWidget = (
-  data: RenderUIWidgetData,
-  state: OpenBotState,
-  toolCallId?: string,
-): UIWidgetSpec => {
-  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 as Record<string, unknown>).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 as unknown as { props?: unknown }).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 as { kind?: string }).kind || 'unknown'}`);
-};
-
-const uiToolDefinitions = {
-  render_ui_widget: {
-    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 accepted.',
-    inputSchema: renderWidgetSchema,
-  },
-};
-
-const uiPluginRuntime = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
-  builder.on('action:render_ui_widget', async function* (event, context) {
-    const widget = normalizeWidget(event.data, context.state, event.meta?.toolCallId);
-    yield {
-      type: 'client:ui:widget',
-      data: widget,
-      meta: event.meta,
-    };
-  });
-};
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import type { Plugin } from '../../services/plugins/types.js';
+import { OpenBotEvent, RenderWidgetEvent, UIWidgetResponseEvent } from '../../app/types.js';
+
+/**
+ * `ui` — provides a tool for the agent to render interactive UI widgets.
+ * 
+ * The model can choose which widget to render (form, choice, list, message)
+ * depending on the situation.
+ */
 
 export const uiPlugin: Plugin = {
   id: 'ui',
-  name: 'UI Widgets',
-  description: 'Render server-driven UI widgets (messages, choices, forms, lists) in the conversation.',
-  toolDefinitions: uiToolDefinitions,
-  factory: () => uiPluginRuntime(),
+  name: 'UI',
+  description: 'Render interactive UI widgets to interact with the user.',
+  toolDefinitions: {
+    render_widget: {
+      description: 'Render a UI widget to the user. Use "form" for data collection, "choice" for simple selection, "list" for displaying items, and "message" for simple notifications with actions. When using form widge to unquire user, do not provide complex forms with many fields, always try to make it simple to keep the experience smooth and straightforward.',
+      inputSchema: z.object({
+        kind: z.enum(['message', 'choice', 'form', 'list']).describe('The type of widget to render.'),
+        title: z.string().describe('The title of the widget.'),
+        description: z.string().optional().describe('A description or body text.'),
+        fields: z.array(z.object({
+          id: z.string().describe('Unique ID for the field.'),
+          label: z.string().describe('Label shown to the user.'),
+          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(z.object({ label: z.string(), value: z.string() })).optional(),
+          defaultValue: z.any().optional()
+        })).optional().describe('Required for kind="form". List of form fields.'),
+        actions: z.array(z.object({
+          id: z.string(),
+          label: z.string(),
+          variant: z.enum(['primary', 'secondary', 'danger']).optional(),
+        })).optional().describe('Buttons or actions available on the widget.'),
+        items: z.array(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.any()).optional()
+        })).optional().describe('Required for kind="list". List of items to display.'),
+        submitLabel: z.string().optional().describe('Label for the primary action button (e.g. "Submit", "Save").')
+      })
+    }
+  },
+  factory: () => (builder) => {
+    // Handle the tool call from the agent
+    builder.on('action:render_widget', async function* (event, context) {
+      const widgetEvent = event as RenderWidgetEvent;
+      const toolCallId = widgetEvent.meta?.toolCallId;
+      const threadId = widgetEvent.meta?.threadId || context.state.threadId;
+
+      if (!toolCallId) return;
+
+      const widgetId = randomUUID();
+
+      // Emit the UI widget event to the client
+      yield {
+        type: 'client:ui:widget',
+        data: {
+          ...widgetEvent.data,
+          widgetId,
+          metadata: {
+            type: 'ui:request',
+            originalEvent: widgetEvent
+          }
+        },
+        meta: { agentId: context.state.agentId, threadId }
+      } as OpenBotEvent;
+    });
+
+    // Handle the user's response from the UI widget
+    builder.on('client:ui:widget:response', async function* (event, context) {
+      const responseEvent = event as UIWidgetResponseEvent;
+      const { widgetId, actionId, values, metadata } = responseEvent.data;
+      if (metadata?.type !== 'ui:request') return;
+
+      const originalEvent = metadata.originalEvent as RenderWidgetEvent;
+      const toolCallId = originalEvent?.meta?.toolCallId;
+      const threadId = originalEvent?.meta?.threadId || context.state.threadId;
+
+      if (!toolCallId) return;
+
+      // Yield a "submitted" widget update to the UI to collapse/disable it
+      yield {
+        type: 'client:ui:widget',
+        data: {
+          widgetId,
+          title: originalEvent.data.title,
+          kind: originalEvent.data.kind as any,
+          state: 'submitted',
+          body: "Thank you for your response. We will process it and get back to you soon.",
+          display: 'collapsed',
+          disabled: true,
+          actions: [], // Clear actions to disable buttons in UI
+        },
+        meta: { agentId: context.state.agentId, threadId },
+      } as OpenBotEvent;
+
+      // Emit the tool result event so the agent runtime can resume
+      yield {
+        type: 'action:render_widget:result',
+        data: {
+          success: true,
+          actionId,
+          values,
+          output: JSON.stringify(values)
+        },
+        meta: {
+          agentId: context.state.agentId,
+          threadId,
+          toolCallId
+        }
+      } as any as OpenBotEvent;
+    });
+  },
 };
 
 export default uiPlugin;

package/src/services/abort.ts

@@ -0,0 +1,46 @@
+/**
+ * Tracks in-flight agent runs so they can be cancelled.
+ *
+ * Runs are grouped by `channelId:threadId`. Delegated sub-agents run in the
+ * same channel/thread as their parent, so aborting that key stops the whole
+ * chain (parent + any delegated runs) in one shot.
+ */
+
+export const abortKey = (channelId: string, threadId?: string): string =>
+  `${channelId}:${threadId || ''}`;
+
+class AbortRegistry {
+  private entries = new Map<string, { controller: AbortController; refs: number }>();
+
+  /** Register interest in a run. Returns a shared signal for the key. */
+  acquire(key: string): AbortSignal {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = { controller: new AbortController(), refs: 0 };
+      this.entries.set(key, entry);
+    }
+    entry.refs += 1;
+    return entry.controller.signal;
+  }
+
+  /** Release interest. Removes the entry once no runs reference it. */
+  release(key: string): void {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    entry.refs -= 1;
+    if (entry.refs <= 0) {
+      this.entries.delete(key);
+    }
+  }
+
+  /** Abort all runs for the key. Returns true if something was active. */
+  abort(key: string): boolean {
+    const entry = this.entries.get(key);
+    if (!entry) return false;
+    entry.controller.abort();
+    this.entries.delete(key);
+    return true;
+  }
+}
+
+export const abortRegistry = new AbortRegistry();

package/src/{bus/types.ts → services/plugins/domain.ts}

@@ -1,13 +1,13 @@
-import type { OpenBotEvent } from '../app/types.js';
-import type { PluginRef } from './plugin.js';
-import type { MemoryRecord, ListMemoriesArgs } from '../services/memory.js';
+import type { OpenBotEvent } from '../../app/types.js';
+import type { PluginRef } from './types.js';
+import type { MemoryRecord, ListMemoriesArgs } from '../../plugins/memory/service.js';
 
 /**
- * Public data types exposed by the OpenBot bus.
+ * Public data types exposed by the OpenBot platform.
  *
- * The bus is the platform layer that owns channels, threads, the agent registry,
- * and the event stream. Agents are composed entirely of Plugins (see
- * `bus/plugin.ts`); their internal implementation is opaque to the bus.
+ * The platform layer owns channels, threads, the agent registry, and the event
+ * stream. Agents are composed entirely of Plugins (see `./types.ts`); their
+ * internal implementation is opaque to the platform.
  */
 
 export type Agent = {
@@ -17,6 +17,8 @@ export type Agent = {
   image?: string;
   /** Plugin ids that compose this agent (mirrors AGENT.md `plugins[].id`). */
   plugins: string[];
+  /** When true, omitted from `action:storage:get-agents` (still available via get-agent-details). */
+  hidden?: boolean;
   createdAt: Date;
   updatedAt: Date;
 };
@@ -43,13 +45,15 @@ export type ConfigSchema = {
   type: 'object';
   properties: {
     [key: string]: {
-      type: 'string' | 'number' | 'boolean' | 'integer';
+      type: 'string' | 'number' | 'boolean' | 'integer' | 'object' | 'array';
       description?: string;
       default?: unknown;
       enum?: unknown[];
       minimum?: number;
       maximum?: number;
       format?: 'password' | 'url' | 'email';
+      properties?: ConfigSchema['properties'];
+      items?: ConfigSchema['properties'][string];
     };
   };
   required?: string[];
@@ -74,6 +78,7 @@ export type Thread = {
   channelId: string;
   createdAt: Date;
   updatedAt: Date;
+  hasUnseenMessages?: boolean;
 };
 
 export type ThreadDetails = {
@@ -102,6 +107,8 @@ export interface Storage {
     initialState?: Record<string, unknown>;
     cwd?: string;
   }) => Promise<void>;
+  /** Removes the channel directory and cleans up `_meta/last-read.json`. */
+  deleteChannel: (args: { channelId: string }) => Promise<void>;
   createThread: (args: {
     channelId: string;
     threadId: string;
@@ -110,29 +117,42 @@ export interface Storage {
   }) => Promise<void>;
   getThreads: (args: { channelId: string }) => Promise<Thread[]>;
   getThreadDetails: (args: { channelId: string; threadId: string }) => Promise<ThreadDetails>;
+  setLastRead: (args: { channelId: string; threadId?: string; lastReadEventId: string }) => Promise<void>;
+  /** User-facing agent list; excludes agents with `hidden: true` (e.g. built-in `state`). */
   getAgents: () => Promise<Agent[]>;
   getPlugins: () => Promise<PluginDescriptor[]>;
   getAgentDetails: (args: { agentId: string }) => Promise<AgentDetails>;
+  /** Includes built-in `system` / `state` agents as optional AGENT.md overlays. */
   createAgent: (args: {
     agentId: string;
     name: string;
     description?: string;
     /** Avatar/logo URL or data URI; persisted in AGENT.md frontmatter. */
     image?: string;
+    /** When true, agent is omitted from `getAgents` / `action:storage:get-agents`. */
+    hidden?: boolean;
     instructions: string;
     plugins: PluginRef[];
   }) => Promise<void>;
+  /** Partial update; for `system` / `state`, creates overlay file if missing. */
   updateAgent: (args: {
     agentId: string;
     name?: string;
     description?: string;
     /** Omit to leave unchanged; empty string removes stored image. */
     image?: string;
+    hidden?: boolean;
     instructions?: string;
     plugins?: PluginRef[];
   }) => Promise<void>;
+  /** For `system` / `state`, removes only `AGENT.md` (reverts to code defaults). */
   deleteAgent: (args: { agentId: string }) => Promise<void>;
   getEvents: (args: { channelId: string; threadId?: string }) => Promise<OpenBotEvent[]>;
+  storeEvent: (args: {
+    channelId: string;
+    threadId?: string;
+    event: OpenBotEvent;
+  }) => Promise<void>;
   getChannelDetails: (args: { channelId: string }) => Promise<ChannelDetails>;
   patchChannelState: (args: { channelId: string; state: unknown }) => Promise<void>;
   patchThreadState: (args: {
@@ -149,6 +169,28 @@ export interface Storage {
     path?: string;
   }) => Promise<Array<{ name: string; isDirectory: boolean }>>;
   readFile: (args: { channelId: string; path: string }) => Promise<string>;
+  readChannelFile: (args: {
+    channelId: string;
+    path: string;
+    encoding?: 'utf8' | 'base64';
+  }) => Promise<{ content: string; mimeType: string; size: number }>;
+  writeChannelFile: (args: {
+    channelId: string;
+    path: string;
+    content: string;
+    encoding?: 'utf8' | 'base64';
+    overwrite?: boolean;
+  }) => Promise<{ path: string; size: number; mimeType: string }>;
+  uploadChannelFile: (args: {
+    channelId: string;
+    path: string;
+    body: Buffer;
+    overwrite?: boolean;
+  }) => Promise<{ path: string; size: number; mimeType: string }>;
+  getChannelFileStat: (args: {
+    channelId: string;
+    path: string;
+  }) => Promise<{ abs: string; size: number; mimeType: string }>;
   /** Persist a memory record into the global memory log. */
   appendMemory: (args: {
     scope: string;

package/src/services/plugins/plugin-cache.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from './types.js';
+
+/** Resolved plugins (built-in + community); shared with registry resolution. */
+export const resolvedPluginCache = new Map<string, Plugin>();
+
+/** Community plugin ids that have already been logged as loaded once. */
+export const loadedCommunityPlugins = new Set<string>();
+
+/** Drop a single id from the in-memory resolver cache (e.g. after install/uninstall). */
+export function invalidatePlugin(id: string): void {
+  resolvedPluginCache.delete(id);
+  loadedCommunityPlugins.delete(id);
+}

package/src/{registry/plugins.ts → services/plugins/registry.ts}

@@ -1,32 +1,33 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import type { Plugin } from '../bus/plugin.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 { todoPlugin } from '../plugins/todo/index.js';
-import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
+import type { Plugin } from './types.js';
+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 { delegationPlugin } from '../../plugins/delegation/index.js';
+import { uiPlugin } from '../../plugins/ui/index.js';
+import { pluginManagerPlugin } from '../../plugins/plugin-manager/index.js';
+import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
+import {
+  invalidatePlugin as clearResolvedPluginEntry,
+  loadedCommunityPlugins,
+  resolvedPluginCache,
+} from './plugin-cache.js';
 
 let pluginsDir: string | null = null;
-const loadedPlugins = new Set<string>();
-const cache = new Map<string, Plugin>();
 
 const BUILT_IN: Record<string, Plugin> = {
-  [aiSdkPlugin.id]: aiSdkPlugin,
-  [shellPlugin.id]: shellPlugin,
-  [mcpPlugin.id]: mcpPlugin,
-  [delegationPlugin.id]: delegationPlugin,
-  [storageToolsPlugin.id]: storageToolsPlugin,
-  [uiPlugin.id]: uiPlugin,
+  [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,
 };
 
 /**
@@ -78,14 +79,14 @@ export function initPlugins(dir?: string) {
 
 /**
  * Resolve a Plugin by id. The id is either:
- *   - a built-in id (e.g. "ai-sdk", "shell"), or
+ *   - a built-in id (e.g. "openbot", "bash"), 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(id: string): Promise<Plugin | null> {
-  if (cache.has(id)) return cache.get(id)!;
+  if (resolvedPluginCache.has(id)) return resolvedPluginCache.get(id)!;
   if (BUILT_IN[id]) {
-    cache.set(id, BUILT_IN[id]);
+    resolvedPluginCache.set(id, BUILT_IN[id]);
     return BUILT_IN[id];
   }
 
@@ -109,10 +110,10 @@ export async function resolvePlugin(id: string): Promise<Plugin | null> {
       return null;
     }
     const plugin: Plugin = { id, ...parsed, name: parsed.name || id };
-    cache.set(id, plugin);
-    if (!loadedPlugins.has(id)) {
+    resolvedPluginCache.set(id, plugin);
+    if (!loadedCommunityPlugins.has(id)) {
       console.log(`[plugins] Loaded community plugin "${id}" from ${distPath}`);
-      loadedPlugins.add(id);
+      loadedCommunityPlugins.add(id);
     }
     return plugin;
   } catch (e) {
@@ -123,8 +124,7 @@ export async function resolvePlugin(id: string): Promise<Plugin | null> {
 
 /** Drop a single id from the in-memory cache (e.g. after fresh install). */
 export function invalidatePlugin(id: string): void {
-  cache.delete(id);
-  loadedPlugins.delete(id);
+  clearResolvedPluginEntry(id);
 }
 
 /** List built-in plugins (for marketplace/registry views). */