openbot 0.4.0 → 0.4.3

package/src/plugins/storage/service.ts

@@ -4,6 +4,7 @@ import {
   DEFAULT_AGENTS_DIR,
   DEFAULT_BASE_DIR,
   DEFAULT_CHANNELS_DIR,
+  getDefaultChannelCwd,
   loadConfig,
   resolvePath,
   StoredVariable,
@@ -26,11 +27,15 @@ import {
 } from '../../services/plugins/domain.js';
 import type { PluginRef } from '../../services/plugins/types.js';
 import { openbotPlugin } from '../openbot/index.js';
-import { OPENBOT_SYSTEM_PROMPT } from '../openbot/system-prompt.js';
 import { listBuiltInPlugins, parsePluginModule } from '../../services/plugins/registry.js';
 import { OpenBotEvent, OpenBotState } from '../../app/types.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();
@@ -110,15 +115,18 @@ const getConversationDir = (channelId: string, threadId?: string) => {
 const SYSTEM_AGENT_ID = ORCHESTRATOR_AGENT_ID;
 
 const SYSTEM_DEFAULT_PLUGINS: PluginRef[] = [
-  { 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: PluginRef[] = [
   { id: 'storage' },
   { id: 'plugin-manager' },
@@ -134,7 +142,7 @@ function getSystemAgentDetails(overrides?: Partial<AgentDetails>): AgentDetails
     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(),
@@ -232,6 +240,25 @@ 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__';
+
+export type LastReadMap = Record<string, Record<string, string>>;
+
+const readLastReadMap = async (): Promise<LastReadMap> => {
+  const raw = await readJsonFile<Record<string, any>>(getLastReadFilePath(), {});
+  const map: LastReadMap = {};
+  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 as Record<string, string>;
+    }
+  }
+  return map;
+};
+
 const THREAD_TITLE_MAX_LENGTH = 80;
 
 const buildThreadTitleFromEvent = (event: OpenBotEvent): string | undefined => {
@@ -257,13 +284,23 @@ const buildThreadTitleFromEvent = (event: OpenBotEvent): string | undefined => {
 
 const readJsonFile = async <T>(filePath: string, fallback: T): Promise<T> => {
   try {
-    return JSON.parse(await fs.readFile(filePath, 'utf-8')) as T;
+    const content = (await fs.readFile(filePath, 'utf-8')).trim();
+    if (!content) return fallback;
+    return JSON.parse(content) as T;
   } catch (e: unknown) {
     if ((e as { code?: string })?.code === 'ENOENT') return fallback;
+    if (e instanceof SyntaxError) return fallback;
     throw e;
   }
 };
 
+const writeJsonFileAtomically = async (filePath: string, data: unknown): Promise<void> => {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp`;
+  await fs.writeFile(tmp, JSON.stringify(data, null, 2), 'utf-8');
+  await fs.rename(tmp, filePath);
+};
+
 const toVariablesRecord = (raw: unknown): Record<string, string> => {
   if (!raw || typeof raw !== 'object') {
     return {};
@@ -426,22 +463,27 @@ const serializePluginRefs = (refs: PluginRef[]): unknown[] =>
   refs.map((ref) => (ref.config ? { id: ref.id, config: ref.config } : { id: ref.id }));
 
 export const storageService = {
-  getLastReadByChannel: async (): Promise<Record<string, string>> => {
-    return readJsonFile(getLastReadFilePath(), {});
+  getLastReadMap: async (): Promise<LastReadMap> => {
+    return readLastReadMap();
   },
 
-  setLastReadForChannel: async ({
+  setLastRead: async ({
     channelId,
+    threadId,
     lastReadEventId,
   }: {
     channelId: string;
+    threadId?: string;
     lastReadEventId: string;
   }): Promise<void> => {
     const p = getLastReadFilePath();
     await fs.mkdir(path.dirname(p), { recursive: true });
-    const map = await readJsonFile<Record<string, string>>(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 (): Promise<Channel[]> => {
@@ -455,19 +497,19 @@ export const storageService = {
     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: string | undefined;
         let displayName = name;
         let participants: string[] = [];
 
         try {
-          const stateContent = await fs.readFile(statePath, 'utf-8');
-          const parsed = JSON.parse(stateContent);
+          const parsed = await readJsonFile(statePath, {});
           const fields = readChannelStateFileFields(parsed);
           cwd = fields.cwd;
           displayName = fields.name ?? name;
@@ -482,24 +524,28 @@ 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 = [];
         }
 
@@ -507,7 +553,7 @@ export const storageService = {
       }),
     );
 
-    return channels;
+    return channels.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
   },
   createChannel: async ({
     channelId,
@@ -539,21 +585,62 @@ export const storageService = {
       }
     }
 
-    const finalState = {
+    const finalState: Record<string, unknown> = {
       ...(initialState || {}),
     };
 
-    if (cwd) {
-      (finalState as Record<string, unknown>).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));
+    await writeJsonFileAtomically(statePath, finalState);
+  },
+  deleteChannel: async ({ channelId }: { channelId: string }): Promise<void> => {
+    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: unknown) {
+      if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') {
+        const err = new Error(`Channel "${normalizedChannelId}" does not exist.`);
+        (err as Error & { code?: string }).code = 'CHANNEL_NOT_FOUND';
+        throw err;
+      }
+      throw error;
+    }
+
+    await fs.rm(channelDir, { recursive: true, force: true });
+
+    try {
+      const lastReadPath = getLastReadFilePath();
+      const map = await readJsonFile<Record<string, string>>(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,
@@ -592,8 +679,7 @@ export const storageService = {
       baseState.name = threadTitle.trim();
     }
 
-    await fs.mkdir(threadDir, { recursive: true });
-    await fs.writeFile(statePath, JSON.stringify(baseState, null, 2));
+    await writeJsonFileAtomically(statePath, baseState);
   },
   getThreads: async ({ channelId }: { channelId: string }): Promise<Thread[]> => {
     const threadsDir = resolvePath(
@@ -605,6 +691,8 @@ export const storageService = {
       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(
@@ -615,8 +703,7 @@ export const storageService = {
         let threadDisplayName = name;
 
         try {
-          const threadStateRaw = await fs.readFile(threadStatePath, 'utf-8');
-          const threadState = JSON.parse(threadStateRaw) as Record<string, unknown>;
+          const threadState = await readJsonFile<Record<string, unknown>>(threadStatePath, {});
           const threadName =
             typeof threadState.name === 'string' ? threadState.name.trim() : '';
           if (threadName) {
@@ -631,12 +718,22 @@ export const storageService = {
           }
         }
 
+        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,
         };
       }),
     );
@@ -655,8 +752,7 @@ export const storageService = {
 
     let state: unknown = {};
     try {
-      const stateContent = await fs.readFile(statePath, 'utf-8');
-      state = JSON.parse(stateContent);
+      state = await readJsonFile(statePath, {});
     } catch (error: unknown) {
       if ((error as NodeJS.ErrnoException)?.code !== 'ENOENT') {
         console.error(
@@ -694,8 +790,7 @@ export const storageService = {
 
     let state: unknown = {};
     try {
-      const stateContent = await fs.readFile(statePath, 'utf-8');
-      state = JSON.parse(stateContent);
+      state = await readJsonFile(statePath, {});
     } catch (error: unknown) {
       if ((error as NodeJS.ErrnoException)?.code !== 'ENOENT') {
         console.error(`Failed to read state file for channel ${channelId}`, error);
@@ -738,8 +833,7 @@ export const storageService = {
         ...(patch as Record<string, unknown>),
       };
 
-      await fs.mkdir(channelDir, { recursive: true });
-      await fs.writeFile(statePath, JSON.stringify(newState, null, 2));
+      await writeJsonFileAtomically(statePath, newState);
     } catch (error) {
       console.error(`Failed to patch channel state for channel ${channelId}`, error);
       throw error;
@@ -766,8 +860,7 @@ export const storageService = {
         ...(patch as Record<string, unknown>),
       };
 
-      await fs.mkdir(threadDir, { recursive: true });
-      await fs.writeFile(statePath, JSON.stringify(newState, null, 2));
+      await writeJsonFileAtomically(statePath, newState);
     } catch (error) {
       console.error(
         `Failed to patch thread state for channel ${channelId} thread ${threadId}`,
@@ -1357,12 +1450,9 @@ export const storageService = {
       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
@@ -1387,14 +1477,142 @@ export const storageService = {
       throw new Error('Channel has no CWD configured');
     }
 
-    const resolvedBase = path.resolve(baseCwd);
-    const targetFile = path.resolve(resolvedBase, filePath);
+    const targetFile = resolveChannelFile(baseCwd, filePath);
+    return fs.readFile(targetFile, 'utf-8');
+  },
 
-    if (!targetFile.startsWith(resolvedBase)) {
-      throw new Error('Access denied: directory escape');
+  readChannelFile: async ({
+    channelId,
+    path: filePath,
+    encoding = 'utf8',
+  }: {
+    channelId: string;
+    path: string;
+    encoding?: 'utf8' | 'base64';
+  }): Promise<{ content: string; mimeType: string; size: number }> => {
+    const details = await storageService.getChannelDetails({ channelId });
+    const baseCwd = details.cwd;
+
+    if (!baseCwd) {
+      throw new Error('Channel has no CWD configured');
     }
 
-    return fs.readFile(targetFile, 'utf-8');
+    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,
+  }: {
+    channelId: string;
+    path: string;
+    content: string;
+    encoding?: 'utf8' | 'base64';
+    overwrite?: boolean;
+  }): Promise<{ path: string; size: number; mimeType: string }> => {
+    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: unknown) {
+        const code = (error as NodeJS.ErrnoException)?.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,
+  }: {
+    channelId: string;
+    path: string;
+    body: Buffer;
+    overwrite?: boolean;
+  }): Promise<{ path: string; size: number; mimeType: string }> => {
+    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: unknown) {
+        const code = (error as NodeJS.ErrnoException)?.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,
+  }: {
+    channelId: string;
+    path: string;
+  }): Promise<{ abs: string; size: number; mimeType: string }> => {
+    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,
@@ -1443,12 +1661,17 @@ export const storageService = {
       }
     }
 
+    const threadState = (threadDetails?.state as Record<string, unknown>) || {};
+
     return {
       runId,
       agentId,
       channelId,
       threadId,
       triggerEvent: event,
+      pendingToolCallIds: Array.isArray(threadState.pendingToolCallIds)
+        ? (threadState.pendingToolCallIds as string[])
+        : undefined,
       agentDetails: {
         id: agentDetails.id,
         name: agentDetails.name,

package/src/plugins/ui/index.ts

@@ -0,0 +1,123 @@
+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',
+  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;