openbot 0.2.11 → 0.2.13

package/src/plugins/ui.ts

@@ -0,0 +1,57 @@
+import { MelonyPlugin } from 'melony';
+import { OpenBotEvent, OpenBotState } from '../app/types.js';
+import z from 'zod';
+
+/**
+ * UI Plugin for Melony.
+ * Provides tools for agents to trigger interactive UI widgets.
+ */
+export const uiPlugin = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
+  builder.on('action:render_ui_widget', async function* (event, context) {
+    const { kind, title, props } = event.data;
+
+    const finalProps = { ...(props as Record<string, unknown>) };
+
+    // 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 as any)?.todos || [];
+    }
+
+    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,
+      },
+      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 }'
+      ),
+    }),
+  },
+};
+
+export const plugin = {
+  name: 'ui',
+  description: 'UI Widgets plugin',
+  version: '1.0.0',
+  author: 'OpenBot',
+  license: 'MIT',
+  factory: uiPlugin,
+  toolDefinitions: uiToolDefinitions,
+};

package/src/registry/plugins.ts

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { MelonyPlugin } from 'melony';
+import { OpenBotEvent, OpenBotState } from '../app/types.js';
+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 { orchestratorService } from '../harness/orchestrator.js';
+
+let pluginsDir: string | null = null;
+const loadedPlugins = new Set<string>();
+
+/**
+ * Initializes the plugins directory.
+ */
+export function initPlugins(dir?: string) {
+  if (dir) {
+    pluginsDir = dir;
+  } else {
+    const config = loadConfig();
+    const baseDir = config.baseDir || DEFAULT_BASE_DIR;
+    pluginsDir = path.join(resolvePath(baseDir), 'plugins');
+  }
+}
+
+/**
+ * Resolves a plugin from its name and config.
+ */
+export async function resolvePlugin(
+  pluginName: string,
+  config: any = {},
+): Promise<MelonyPlugin<OpenBotState, OpenBotEvent> | null> {
+  // 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();
+  }
+
+  // 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);
+      }
+    }
+  }
+
+  console.warn(`[plugins] Plugin "${pluginName}" not found in registry or external directory.`);
+  return null;
+}