openbot 0.4.0 → 0.4.2

package/dist/plugins/storage/service.js

@@ -1,5 +1,5 @@
 import { ORCHESTRATOR_AGENT_ID, STATE_AGENT_ID } from '../../app/agent-ids.js';
-import { DEFAULT_PLUGINS_DIR, DEFAULT_AGENTS_DIR, DEFAULT_BASE_DIR, DEFAULT_CHANNELS_DIR, loadConfig, resolvePath, VARIABLES_FILE, } from '../../app/config.js';
+import { DEFAULT_PLUGINS_DIR, DEFAULT_AGENTS_DIR, DEFAULT_BASE_DIR, DEFAULT_CHANNELS_DIR, getDefaultChannelCwd, loadConfig, resolvePath, VARIABLES_FILE, } from '../../app/config.js';
 import fs from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
@@ -7,10 +7,10 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import crypto from 'node:crypto';
 import matter from 'gray-matter';
 import { openbotPlugin } from '../openbot/index.js';
-import { OPENBOT_SYSTEM_PROMPT } from '../openbot/system-prompt.js';
 import { listBuiltInPlugins, parsePluginModule } from '../../services/plugins/registry.js';
 import { processService } from '../../services/process.js';
 import { memoryService } from '../memory/service.js';
+import { guessMimeType, resolveChannelFile, statChannelFile, } from './files.js';
 const resolveBaseDir = () => {
     const config = loadConfig();
     return resolvePath(config.baseDir || DEFAULT_BASE_DIR);
@@ -80,14 +80,17 @@ const getConversationDir = (channelId, threadId) => {
 /** Built-in orchestrator agent id. Not creatable as a normal disk agent. */
 const SYSTEM_AGENT_ID = ORCHESTRATOR_AGENT_ID;
 const SYSTEM_DEFAULT_PLUGINS = [
-    { id: 'openbot', config: { model: 'openai/gpt-5.4-mini' } },
-    { id: 'shell' },
-    { id: 'approval' },
-    { id: 'memory' },
-    { id: 'delegation' },
-    { id: 'storage' },
+    {
+        id: 'openbot',
+        config: {
+            model: 'openai/gpt-5.4-mini',
+            approval: {
+                actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
+            },
+        },
+    },
 ];
-/** No `openbot` / `shell` — storage-side effects and infra plugins only. */
+/** No `openbot` / `bash` — storage-side effects and infra plugins only. */
 const STATE_DEFAULT_PLUGINS = [
     { id: 'storage' },
     { id: 'plugin-manager' },
@@ -99,7 +102,7 @@ function getSystemAgentDetails(overrides) {
         name: 'OpenBot',
         image: getBundledSystemAgentImage(),
         description: 'First-party orchestration agent for OpenBot.',
-        instructions: OPENBOT_SYSTEM_PROMPT,
+        instructions: '',
         plugins: SYSTEM_DEFAULT_PLUGINS.map((ref) => ref.id),
         pluginRefs: SYSTEM_DEFAULT_PLUGINS,
         createdAt: new Date(),
@@ -179,6 +182,22 @@ const assertAgentIdFormat = (agentId) => {
 };
 const getAgentsRootDir = () => path.join(resolveBaseDir(), DEFAULT_AGENTS_DIR);
 const getLastReadFilePath = () => path.join(resolvePath(resolveBaseDir() + '/' + DEFAULT_CHANNELS_DIR), '_meta', 'last-read.json');
+/** Sentinel key for channel-root events (no threadId). */
+export const ROOT_THREAD_KEY = '__root__';
+const readLastReadMap = async () => {
+    const raw = await readJsonFile(getLastReadFilePath(), {});
+    const map = {};
+    for (const [channelId, value] of Object.entries(raw)) {
+        if (typeof value === 'string') {
+            // Migrate old format
+            map[channelId] = { [ROOT_THREAD_KEY]: value };
+        }
+        else if (value && typeof value === 'object') {
+            map[channelId] = value;
+        }
+    }
+    return map;
+};
 const THREAD_TITLE_MAX_LENGTH = 80;
 const buildThreadTitleFromEvent = (event) => {
     let rawContent = '';
@@ -197,11 +216,16 @@ const buildThreadTitleFromEvent = (event) => {
 };
 const readJsonFile = async (filePath, fallback) => {
     try {
-        return JSON.parse(await fs.readFile(filePath, 'utf-8'));
+        const content = (await fs.readFile(filePath, 'utf-8')).trim();
+        if (!content)
+            return fallback;
+        return JSON.parse(content);
     }
     catch (e) {
         if (e?.code === 'ENOENT')
             return fallback;
+        if (e instanceof SyntaxError)
+            return fallback;
         throw e;
     }
 };
@@ -352,15 +376,19 @@ const parsePluginRefs = (raw) => {
 };
 const serializePluginRefs = (refs) => refs.map((ref) => (ref.config ? { id: ref.id, config: ref.config } : { id: ref.id }));
 export const storageService = {
-    getLastReadByChannel: async () => {
-        return readJsonFile(getLastReadFilePath(), {});
+    getLastReadMap: async () => {
+        return readLastReadMap();
     },
-    setLastReadForChannel: async ({ channelId, lastReadEventId, }) => {
+    setLastRead: async ({ channelId, threadId, lastReadEventId, }) => {
         const p = getLastReadFilePath();
         await fs.mkdir(path.dirname(p), { recursive: true });
-        const map = await readJsonFile(p, {});
-        map[channelId] = lastReadEventId;
-        await fs.writeFile(p, JSON.stringify(map, null, 2), 'utf-8');
+        const map = await readLastReadMap();
+        if (!map[channelId])
+            map[channelId] = {};
+        map[channelId][threadId || ROOT_THREAD_KEY] = lastReadEventId;
+        const tmp = `${p}.tmp`;
+        await fs.writeFile(tmp, JSON.stringify(map, null, 2), 'utf-8');
+        await fs.rename(tmp, p);
     },
     getChannels: async () => {
         const channelsDir = resolvePath(resolveBaseDir() + '/' + DEFAULT_CHANNELS_DIR);
@@ -371,9 +399,10 @@ export const storageService = {
             await fs.mkdir(channelsDir, { recursive: true });
         }
         const channelNames = (await fs.readdir(channelsDir)).filter((name) => !name.startsWith('.') && name !== '_meta');
-        const lastReadByChannel = await storageService.getLastReadByChannel();
+        const lastReadMap = await storageService.getLastReadMap();
         const channels = await Promise.all(channelNames.map(async (name) => {
             const channelDir = getConversationDir(name);
+            const stats = await fs.stat(channelDir);
             const statePath = path.join(channelDir, 'state.json');
             let cwd;
             let displayName = name;
@@ -395,30 +424,30 @@ export const storageService = {
                 description: '',
                 cwd,
                 participants,
-                createdAt: new Date(),
-                updatedAt: new Date(),
+                createdAt: stats.birthtime,
+                updatedAt: stats.mtime,
             };
-            const rid = lastReadByChannel[name];
-            try {
-                const events = await storageService.getEvents({ channelId: name });
-                const latestId = events[events.length - 1]?.id;
-                channel.hasUnseenMessages = !!(latestId && latestId !== rid);
-            }
-            catch {
-                channel.hasUnseenMessages = false;
-            }
+            const channelLastRead = lastReadMap[name] || {};
             try {
+                // Check root unread
+                const rootEvents = await storageService.getEvents({ channelId: name });
+                const rootLatestId = rootEvents[rootEvents.length - 1]?.id;
+                const rootUnseen = !!(rootLatestId && rootLatestId !== channelLastRead[ROOT_THREAD_KEY]);
+                // Check threads unread
                 const allThreads = await storageService.getThreads({ channelId: name });
                 channel.recentThreads = allThreads
                     .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
                     .slice(0, 5);
+                const threadsUnseen = allThreads.some(t => t.hasUnseenMessages);
+                channel.hasUnseenMessages = rootUnseen || threadsUnseen;
             }
             catch {
+                channel.hasUnseenMessages = false;
                 channel.recentThreads = [];
             }
             return channel;
         }));
-        return channels;
+        return channels.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     },
     createChannel: async ({ channelId, spec, initialState, cwd, }) => {
         const normalizedChannelId = channelId.trim();
@@ -441,14 +470,53 @@ export const storageService = {
         const finalState = {
             ...(initialState || {}),
         };
-        if (cwd) {
-            finalState.cwd = cwd;
-        }
+        const rawCwd = (typeof cwd === 'string' && cwd.trim()) ||
+            (typeof finalState.cwd === 'string' && finalState.cwd.trim()) ||
+            getDefaultChannelCwd(normalizedChannelId);
+        const resolvedCwd = resolvePath(rawCwd);
+        finalState.cwd = resolvedCwd;
+        await fs.mkdir(resolvedCwd, { recursive: true });
         await fs.mkdir(channelDir, { recursive: true });
         await fs.writeFile(specPath, spec?.trim() ||
-            `# ${normalizedChannelId}\n\nDefine the goals and rules for this channel here.\n`);
+            `# ${normalizedChannelId}\n\n`);
         await fs.writeFile(statePath, JSON.stringify(finalState, null, 2));
     },
+    deleteChannel: async ({ channelId }) => {
+        const normalizedChannelId = channelId.trim();
+        if (!normalizedChannelId) {
+            throw new Error('channelId is required');
+        }
+        if (normalizedChannelId === '_meta') {
+            throw new Error('Cannot delete reserved channel path');
+        }
+        const channelDir = getConversationDir(normalizedChannelId);
+        try {
+            await fs.access(channelDir);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                const err = new Error(`Channel "${normalizedChannelId}" does not exist.`);
+                err.code = 'CHANNEL_NOT_FOUND';
+                throw err;
+            }
+            throw error;
+        }
+        await fs.rm(channelDir, { recursive: true, force: true });
+        try {
+            const lastReadPath = getLastReadFilePath();
+            const map = await readJsonFile(lastReadPath, {});
+            if (normalizedChannelId in map) {
+                delete map[normalizedChannelId];
+                await fs.mkdir(path.dirname(lastReadPath), { recursive: true });
+                const tmp = `${lastReadPath}.tmp`;
+                await fs.writeFile(tmp, JSON.stringify(map, null, 2), 'utf-8');
+                await fs.rename(tmp, lastReadPath);
+            }
+        }
+        catch {
+            // ignore last-read cleanup failures
+        }
+    },
     createThread: async ({ channelId, threadId, threadTitle, initialState, }) => {
         const normalizedChannelId = channelId.trim();
         const normalizedThreadId = threadId.trim();
@@ -483,6 +551,8 @@ export const storageService = {
         catch {
             return [];
         }
+        const lastReadMap = await storageService.getLastReadMap();
+        const channelLastRead = lastReadMap[channelId] || {};
         const threadNames = (await fs.readdir(threadsDir)).filter((name) => !name.startsWith('.'));
         const threads = await Promise.all(threadNames.map(async (name) => {
             const threadPath = path.join(threadsDir, name);
@@ -502,12 +572,22 @@ export const storageService = {
                     console.error(`Failed to read thread state for channel ${channelId} thread ${name}`, error);
                 }
             }
+            let hasUnseen = false;
+            try {
+                const events = await storageService.getEvents({ channelId, threadId: name });
+                const latestId = events[events.length - 1]?.id;
+                hasUnseen = !!(latestId && latestId !== channelLastRead[name]);
+            }
+            catch {
+                // ignore
+            }
             return {
                 id: name,
                 name: threadDisplayName,
                 channelId,
                 createdAt: stats.birthtime,
                 updatedAt: stats.mtime,
+                hasUnseenMessages: hasUnseen,
             };
         }));
         return threads;
@@ -1074,11 +1154,9 @@ export const storageService = {
         if (!baseCwd) {
             throw new Error('Channel has no CWD configured');
         }
-        const resolvedBase = path.resolve(baseCwd);
-        const targetDir = path.resolve(resolvedBase, subPath);
-        if (!targetDir.startsWith(resolvedBase)) {
-            throw new Error('Access denied: directory escape');
-        }
+        const targetDir = subPath
+            ? resolveChannelFile(baseCwd, subPath)
+            : resolvePath(baseCwd);
         const entries = await fs.readdir(targetDir, { withFileTypes: true });
         return entries
             .filter((e) => !e.name.startsWith('.'))
@@ -1093,13 +1171,88 @@ export const storageService = {
         if (!baseCwd) {
             throw new Error('Channel has no CWD configured');
         }
-        const resolvedBase = path.resolve(baseCwd);
-        const targetFile = path.resolve(resolvedBase, filePath);
-        if (!targetFile.startsWith(resolvedBase)) {
-            throw new Error('Access denied: directory escape');
-        }
+        const targetFile = resolveChannelFile(baseCwd, filePath);
         return fs.readFile(targetFile, 'utf-8');
     },
+    readChannelFile: async ({ channelId, path: filePath, encoding = 'utf8', }) => {
+        const details = await storageService.getChannelDetails({ channelId });
+        const baseCwd = details.cwd;
+        if (!baseCwd) {
+            throw new Error('Channel has no CWD configured');
+        }
+        const targetFile = resolveChannelFile(baseCwd, filePath);
+        const buf = await fs.readFile(targetFile);
+        const content = encoding === 'base64' ? buf.toString('base64') : buf.toString('utf-8');
+        return {
+            content,
+            mimeType: guessMimeType(targetFile),
+            size: buf.length,
+        };
+    },
+    writeChannelFile: async ({ channelId, path: filePath, content, encoding = 'utf8', overwrite = false, }) => {
+        const details = await storageService.getChannelDetails({ channelId });
+        const baseCwd = details.cwd;
+        if (!baseCwd) {
+            throw new Error('Channel has no CWD configured');
+        }
+        const abs = resolveChannelFile(baseCwd, filePath);
+        await fs.mkdir(path.dirname(abs), { recursive: true });
+        if (!overwrite) {
+            try {
+                await fs.access(abs);
+                throw new Error('File already exists');
+            }
+            catch (error) {
+                const code = error?.code;
+                if (code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        }
+        const buf = encoding === 'base64' ? Buffer.from(content, 'base64') : Buffer.from(content, 'utf8');
+        await fs.writeFile(abs, buf);
+        return {
+            path: filePath,
+            size: buf.length,
+            mimeType: guessMimeType(abs),
+        };
+    },
+    uploadChannelFile: async ({ channelId, path: filePath, body, overwrite = false, }) => {
+        const details = await storageService.getChannelDetails({ channelId });
+        const baseCwd = details.cwd;
+        if (!baseCwd) {
+            throw new Error('Channel has no CWD configured');
+        }
+        const abs = resolveChannelFile(baseCwd, filePath);
+        await fs.mkdir(path.dirname(abs), { recursive: true });
+        if (!overwrite) {
+            try {
+                await fs.access(abs);
+                throw new Error('File already exists');
+            }
+            catch (error) {
+                const code = error?.code;
+                if (code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        }
+        await fs.writeFile(abs, body);
+        return {
+            path: filePath,
+            size: body.length,
+            mimeType: guessMimeType(abs),
+        };
+    },
+    getChannelFileStat: async ({ channelId, path: filePath, }) => {
+        const details = await storageService.getChannelDetails({ channelId });
+        const baseCwd = details.cwd;
+        if (!baseCwd) {
+            throw new Error('Channel has no CWD configured');
+        }
+        const { abs, size } = await statChannelFile(baseCwd, filePath);
+        return { abs, size, mimeType: guessMimeType(abs) };
+    },
     appendMemory: memoryService.appendMemory,
     listMemories: memoryService.listMemories,
     deleteMemory: memoryService.deleteMemory,
@@ -1135,12 +1288,16 @@ export const storageService = {
                 console.warn(`[storage] Failed to load thread details for channel ${channelId} thread: ${threadId}`, error);
             }
         }
+        const threadState = threadDetails?.state || {};
         return {
             runId,
             agentId,
             channelId,
             threadId,
             triggerEvent: event,
+            pendingToolCallIds: Array.isArray(threadState.pendingToolCallIds)
+                ? threadState.pendingToolCallIds
+                : undefined,
             agentDetails: {
                 id: agentDetails.id,
                 name: agentDetails.name,

package/dist/plugins/ui/index.js

@@ -1,154 +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.literal('approval').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 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 === '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 preset approval is 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;