openbot 0.3.6 → 0.4.2

package/dist/plugins/ui/index.js

@@ -1,184 +1,113 @@
-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('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) => !!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'}`);
-};
-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 = () => (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';
+/**
+ * `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 = {
     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;
+            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 }
+            };
+        });
+        // Handle the user's response from the UI widget
+        builder.on('client:ui:widget:response', async function* (event, context) {
+            const responseEvent = event;
+            const { widgetId, actionId, values, metadata } = responseEvent.data;
+            if (metadata?.type !== 'ui:request')
+                return;
+            const originalEvent = metadata.originalEvent;
+            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,
+                    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 },
+            };
+            // 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
+                }
+            };
+        });
+    },
 };
 export default uiPlugin;

package/dist/registry/plugins.js

@@ -1,29 +1,23 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { aiSdkPlugin } from '../plugins/ai-sdk/index.js';
+import { openbotPlugin } from '../plugins/openbot/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';
 let pluginsDir = null;
 const loadedPlugins = new Set();
 const cache = new Map();
 const BUILT_IN = {
-    [aiSdkPlugin.id]: aiSdkPlugin,
+    [openbotPlugin.id]: openbotPlugin,
     [shellPlugin.id]: shellPlugin,
-    [mcpPlugin.id]: mcpPlugin,
-    [delegationPlugin.id]: delegationPlugin,
     [storageToolsPlugin.id]: storageToolsPlugin,
     [uiPlugin.id]: uiPlugin,
     [approvalPlugin.id]: approvalPlugin,
     [memoryPlugin.id]: memoryPlugin,
-    [todoPlugin.id]: todoPlugin,
 };
 /** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
 export function parsePluginModule(module) {
@@ -61,7 +55,7 @@ export function initPlugins(dir) {
 }
 /**
  * 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", "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`.
  */

package/dist/services/abort.js

@@ -0,0 +1,43 @@
+/**
+ * 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, threadId) => `${channelId}:${threadId || ''}`;
+class AbortRegistry {
+    constructor() {
+        this.entries = new Map();
+    }
+    /** Register interest in a run. Returns a shared signal for the key. */
+    acquire(key) {
+        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) {
+        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) {
+        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/dist/services/plugins/domain.js

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

package/dist/services/plugins/plugin-cache.js

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

package/dist/services/plugins/registry.js

@@ -0,0 +1,112 @@
+import fs 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 { 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 = null;
+const BUILT_IN = {
+    [openbotPlugin.id]: openbotPlugin,
+    [bashPlugin.id]: bashPlugin,
+    [storagePlugin.id]: storagePlugin,
+    [approvalPlugin.id]: approvalPlugin,
+    [memoryPlugin.id]: memoryPlugin,
+    [delegationPlugin.id]: delegationPlugin,
+    [uiPlugin.id]: uiPlugin,
+    [pluginManagerPlugin.id]: pluginManagerPlugin,
+};
+/** 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 configSchema = raw.configSchema;
+    const toolDefinitions = raw.toolDefinitions;
+    return {
+        name,
+        description,
+        image,
+        configSchema,
+        toolDefinitions,
+        factory: factory,
+    };
+}
+/** Initialize the on-disk plugins directory (defaults to ~/.openbot/plugins). */
+export function initPlugins(dir) {
+    if (dir) {
+        pluginsDir = dir;
+    }
+    else {
+        const config = loadConfig();
+        const baseDir = config.baseDir || DEFAULT_BASE_DIR;
+        pluginsDir = path.join(resolvePath(baseDir), DEFAULT_PLUGINS_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"),
+ *     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;
+        }
+        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);
+        }
+        return plugin;
+    }
+    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) {
+    clearResolvedPluginEntry(id);
+}
+/** List built-in plugins (for marketplace/registry views). */
+export function listBuiltInPlugins() {
+    return Object.values(BUILT_IN);
+}
+export function getPluginsDir() {
+    return pluginsDir;
+}