openbot 0.4.0 → 0.4.3

package/src/app/types.ts

@@ -21,6 +21,12 @@ export interface OpenBotState {
   triggerEvent?: OpenBotEvent;
   /** Active model string (e.g. `openai/gpt-4o-mini`). */
   model?: string;
+  /** Persisted tool call IDs waiting for results. */
+  pendingToolCallIds?: string[];
+  /** Current user information if available. */
+  currentUser?: {
+    userName?: string;
+  };
 }
 
 export type BaseEvent = {
@@ -63,6 +69,23 @@ export type GetThreadsResultEvent = BaseEvent & {
   };
 };
 
+export type SetLastReadEvent = BaseEvent & {
+  type: 'action:storage:set-last-read';
+  data: {
+    channelId?: string;
+    threadId?: string;
+    lastReadEventId: string;
+  };
+};
+
+export type SetLastReadResultEvent = BaseEvent & {
+  type: 'action:storage:set-last-read-result';
+  data: {
+    success: boolean;
+    error?: string;
+  };
+};
+
 export type GetChannelDetailsEvent = BaseEvent & {
   type: 'action:storage:get-channel-details';
 };
@@ -322,6 +345,7 @@ export type ReadFileEvent = BaseEvent & {
   type: 'action:storage:read-file';
   data: {
     path: string;
+    encoding?: 'utf8' | 'base64';
   };
 };
 
@@ -331,6 +355,107 @@ export type ReadFileResultEvent = BaseEvent & {
     success: boolean;
     content?: string;
     path: string;
+    encoding?: 'utf8' | 'base64';
+    mimeType?: string;
+    size?: number;
+    error?: string;
+  };
+};
+
+export type ServeFileEvent = BaseEvent & {
+  type: 'action:storage:serve-file';
+  data: {
+    path: string;
+  };
+};
+
+export type WriteFileEvent = BaseEvent & {
+  type: 'action:storage:write-file';
+  data: {
+    path: string;
+    content: string;
+    encoding?: 'utf8' | 'base64';
+    overwrite?: boolean;
+  };
+};
+
+export type WriteFileResultEvent = BaseEvent & {
+  type: 'action:storage:write-file:result';
+  data: {
+    success: boolean;
+    path: string;
+    url?: string;
+    mimeType?: string;
+    size?: number;
+    error?: string;
+  };
+};
+
+export type GetFileUrlEvent = BaseEvent & {
+  type: 'action:storage:get-file-url';
+  data: {
+    path: string;
+  };
+};
+
+export type GetFileUrlResultEvent = BaseEvent & {
+  type: 'action:storage:get-file-url:result';
+  data: {
+    success: boolean;
+    path: string;
+    url?: string;
+    mimeType?: string;
+    size?: number;
+    error?: string;
+  };
+};
+
+export type GetWorkspaceFileUrlEvent = BaseEvent & {
+  type: 'action:get_workspace_file_url';
+  data: {
+    path: string;
+  };
+  meta?: {
+    toolCallId?: string;
+    agentId?: string;
+    threadId?: string;
+  };
+};
+
+export type GetWorkspaceFileUrlResultEvent = BaseEvent & {
+  type: 'action:get_workspace_file_url:result';
+  data: {
+    success: boolean;
+    path: string;
+    url?: string;
+    mimeType?: string;
+    size?: number;
+    output?: string;
+    error?: string;
+  };
+  meta?: {
+    toolCallId?: string;
+    agentId?: string;
+    threadId?: string;
+  };
+};
+
+export type UploadFileEvent = BaseEvent & {
+  type: 'action:storage:upload-file';
+  data: {
+    path: string;
+    overwrite?: boolean;
+  };
+};
+
+export type UploadFileResultEvent = BaseEvent & {
+  type: 'action:storage:upload-file:result';
+  data: {
+    success: boolean;
+    path: string;
+    url?: string;
+    mimeType?: string;
+    size?: number;
     error?: string;
   };
 };
@@ -479,6 +604,42 @@ export type UpdateChannelResultEvent = BaseEvent & {
   };
 };
 
+export type DeleteChannelEvent = BaseEvent & {
+  type: 'action:storage:delete-channel';
+  data: {
+    channelId: string;
+  };
+};
+
+export type DeleteChannelResultEvent = BaseEvent & {
+  type: 'action:storage:delete-channel-result';
+  data: {
+    success: boolean;
+    error?: string;
+  };
+};
+
+export type DeleteChannelToolEvent = BaseEvent & {
+  type: 'action:delete_channel';
+  data: {
+    channelId: string;
+  };
+  meta?: {
+    toolCallId?: string;
+    agentId?: string;
+    threadId?: string;
+  };
+};
+
+export type DeleteChannelToolResultEvent = BaseEvent & {
+  type: 'action:delete_channel:result';
+  data: {
+    success: boolean;
+    channelId: string;
+    error?: string;
+  };
+};
+
 export type UIWidgetAction = {
   id: string;
   label: string;
@@ -573,13 +734,11 @@ export type UIWidgetResponseEvent = BaseEvent & {
   };
 };
 
-export type ShellExecEvent = BaseEvent & {
-  type: 'action:shell_exec';
+export type BashEvent = BaseEvent & {
+  type: 'action:bash';
   data: {
     command: string;
-    cwd?: string;
-    shell?: string;
-    timeoutMs?: number;
+    restart?: boolean;
   };
   meta?: {
     toolCallId?: string;
@@ -589,8 +748,8 @@ export type ShellExecEvent = BaseEvent & {
   };
 };
 
-export type ShellExecResultEvent = BaseEvent & {
-  type: 'action:shell_exec:result';
+export type BashResultEvent = BaseEvent & {
+  type: 'action:bash:result';
   data: {
     success: boolean;
     approved?: boolean;
@@ -602,6 +761,37 @@ export type ShellExecResultEvent = BaseEvent & {
   };
 };
 
+export type BashStopEvent = BaseEvent & {
+  type: 'action:bash_stop';
+  data: {
+    channelId?: string;
+  };
+};
+
+export type BashStopResultEvent = BaseEvent & {
+  type: 'action:bash_stop:result';
+  data: {
+    success: boolean;
+  };
+};
+
+export type BashListSessionsEvent = BaseEvent & {
+  type: 'action:bash_list_sessions';
+  data: {};
+};
+
+export type BashListSessionsResultEvent = BaseEvent & {
+  type: 'action:bash_list_sessions:result';
+  data: {
+    success: boolean;
+    sessions: Array<{
+      channelId: string;
+      cwd: string;
+      lastActivity: number;
+    }>;
+  };
+};
+
 export type InstallPluginEvent = BaseEvent & {
   type: 'action:plugin:install';
   data: {
@@ -634,11 +824,11 @@ export type UninstallPluginResultEvent = BaseEvent & {
   };
 };
 
-export type ListMarketplaceAgentsEvent = BaseEvent & {
+export type ListMarketplaceRegistryEvent = BaseEvent & {
   type: 'action:marketplace:list';
 };
 
-export type ListMarketplaceAgentsResultEvent = BaseEvent & {
+export type ListMarketplaceRegistryResultEvent = BaseEvent & {
   type: 'action:marketplace:list:result';
   data: {
     success: boolean;
@@ -650,6 +840,36 @@ export type ListMarketplaceAgentsResultEvent = BaseEvent & {
       instructions: string;
       plugins: PluginRef[];
     }>;
+    channels: Array<{
+      id: string;
+      name: string;
+      description: string;
+      image?: string;
+      spec?: string;
+      initialState?: Record<string, unknown>;
+      participants: string[];
+      starterPrompts?: Array<{ label: string; prompt: string }>;
+    }>;
+    error?: string;
+  };
+};
+
+export type InstallChannelEvent = BaseEvent & {
+  type: 'action:channel:install';
+  data: {
+    channelId: string;
+    name?: string;
+    participants?: string[];
+    initialState?: Record<string, unknown>;
+  };
+};
+
+export type InstallChannelResultEvent = BaseEvent & {
+  type: 'action:channel:install:result';
+  data: {
+    success: boolean;
+    channelId?: string;
+    channelUrl?: string;
     error?: string;
   };
 };
@@ -764,6 +984,33 @@ export type DelegateTaskResultEvent = BaseEvent & {
   };
 };
 
+export type RenderWidgetEvent = BaseEvent & {
+  type: 'action:render_widget';
+  data: {
+    kind: 'message' | 'choice' | 'form' | 'list';
+    title: string;
+    description?: string;
+    fields?: UIWidgetField[];
+    actions?: UIWidgetAction[];
+    items?: UIWidgetListItem[];
+    submitLabel?: string;
+  };
+  meta?: {
+    toolCallId?: string;
+    threadId?: string;
+    [key: string]: any;
+  };
+};
+
+export type RenderWidgetResultEvent = BaseEvent & {
+  type: 'action:render_widget:result';
+  data: {
+    success: boolean;
+    actionId: string;
+    values?: Record<string, unknown>;
+  };
+};
+
 /**
  * Internal message representation to decouple harness history from specific AI SDKs.
  */
@@ -792,6 +1039,8 @@ export type OpenBotEvent =
   | GetChannelsResultEvent
   | GetThreadsEvent
   | GetThreadsResultEvent
+  | SetLastReadEvent
+  | SetLastReadResultEvent
   | GetChannelDetailsEvent
   | GetChannelDetailsResultEvent
   | GetThreadDetailsEvent
@@ -829,24 +1078,43 @@ export type OpenBotEvent =
   | ListFilesResultEvent
   | ReadFileEvent
   | ReadFileResultEvent
+  | ServeFileEvent
+  | WriteFileEvent
+  | WriteFileResultEvent
+  | GetFileUrlEvent
+  | GetFileUrlResultEvent
+  | GetWorkspaceFileUrlEvent
+  | GetWorkspaceFileUrlResultEvent
+  | UploadFileEvent
+  | UploadFileResultEvent
   | CreateThreadEvent
   | CreateThreadResultEvent
   | CreateChannelEvent
   | CreateChannelResultEvent
   | UpdateChannelEvent
   | UpdateChannelResultEvent
+  | DeleteChannelEvent
+  | DeleteChannelResultEvent
+  | DeleteChannelToolEvent
+  | DeleteChannelToolResultEvent
   | UIWidgetEvent
   | UIWidgetResponseEvent
-  | ShellExecEvent
-  | ShellExecResultEvent
+  | BashEvent
+  | BashResultEvent
+  | BashStopEvent
+  | BashStopResultEvent
+  | BashListSessionsEvent
+  | BashListSessionsResultEvent
   | InstallPluginEvent
   | InstallPluginResultEvent
   | UninstallPluginEvent
   | UninstallPluginResultEvent
-  | ListMarketplaceAgentsEvent
-  | ListMarketplaceAgentsResultEvent
+  | ListMarketplaceRegistryEvent
+  | ListMarketplaceRegistryResultEvent
   | InstallAgentEvent
   | InstallAgentResultEvent
+  | InstallChannelEvent
+  | InstallChannelResultEvent
   | RememberEvent
   | RememberResultEvent
   | RecallEvent
@@ -854,4 +1122,6 @@ export type OpenBotEvent =
   | ForgetEvent
   | ForgetResultEvent
   | DelegateTaskEvent
-  | DelegateTaskResultEvent;
+  | DelegateTaskResultEvent
+  | RenderWidgetEvent
+  | RenderWidgetResultEvent;

package/src/harness/index.ts

@@ -5,6 +5,9 @@ import { storageService } from '../plugins/storage/service.js';
 import { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../app/agent-ids.js';
 import { resolvePlugin } from '../services/plugins/registry.js';
 import { ToolDefinition } from '../services/plugins/types.js';
+import { abortRegistry, abortKey } from '../services/abort.js';
+import { loadConfig } from '../app/config.js';
+import { getPublicBaseUrl } from '../plugins/storage/files.js';
 
 export { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID };
 
@@ -15,6 +18,8 @@ export interface RunAgentOptions {
   channelId: string;
   threadId?: string;
   persistEvents?: boolean;
+  /** Resolved public base URL for the server. */
+  publicBaseUrl?: string;
   onEvent: (event: OpenBotEvent, state?: OpenBotState) => Promise<void>;
 }
 
@@ -67,6 +72,13 @@ export async function runAgent(options: RunAgentOptions): Promise<void> {
   const { runId, agentId, event, channelId, threadId, onEvent } = options;
   const persistEvents = options.persistEvents !== false;
 
+  let publicBaseUrl = options.publicBaseUrl;
+  if (!publicBaseUrl) {
+    const config = loadConfig();
+    const port = Number(config.port ?? process.env.PORT ?? 4132);
+    publicBaseUrl = getPublicBaseUrl(port, config.publicUrl);
+  }
+
   const parentAgentId = event.meta?.parentAgentId;
   const parentToolCallId = event.meta?.parentToolCallId;
 
@@ -80,6 +92,11 @@ export async function runAgent(options: RunAgentOptions): Promise<void> {
     event,
   });
 
+  // Shared per-thread abort signal so a stop request cancels this run and any
+  // delegated sub-agent runs (which execute in the same channel/thread).
+  const runKey = abortKey(channelId, threadId);
+  const abortSignal = abortRegistry.acquire(runKey);
+
   await emitEvent(
     {
       type: 'agent:run:start',
@@ -113,6 +130,8 @@ export async function runAgent(options: RunAgentOptions): Promise<void> {
           config: ref.config ?? {},
           storage: storageService,
           tools,
+          publicBaseUrl,
+          abortSignal,
         }),
       );
     }
@@ -121,6 +140,7 @@ export async function runAgent(options: RunAgentOptions): Promise<void> {
     const generator = runtime.run(event, { runId, state });
 
     for await (const outputEvent of generator) {
+      if (abortSignal.aborted) break;
       await emitEvent(outputEvent, state, {
         persistEvents,
         channelId,
@@ -133,6 +153,7 @@ export async function runAgent(options: RunAgentOptions): Promise<void> {
   } catch (error) {
     console.error(`[harness] Error running agent ${agentId}:`, error);
   } finally {
+    abortRegistry.release(runKey);
     await emitEvent(
       {
         type: 'agent:run:end',

package/src/plugins/approval/index.ts

@@ -5,7 +5,7 @@ import { OpenBotEvent } from '../../app/types.js';
 /**
  * `approval` — gates protected tool calls behind a UI confirmation widget.
  * 
- * This is a simplified version that intercepts specified actions (default: shell_exec)
+ * This is a simplified version that intercepts specified actions (default: bash)
  * and requires user approval before they are allowed to proceed.
  */
 
@@ -17,9 +17,9 @@ export const approvalPlugin: Plugin = {
   id: 'approval',
   name: 'Approval',
   description: 'Gate protected tool calls behind a UI confirmation widget.',
-  factory: ({ config }) => (builder) => {
-    // Actions that require approval. Defaults to shell_exec.
-    const actionsToApprove = (config.actions as string[]) || ['action:shell_exec'];
+  factory: ({ config, storage }) => (builder) => {
+    // Actions that require approval. Defaults to bash.
+    const actionsToApprove = (config.actions as string[]) || ['action:bash'];
 
     for (const action of actionsToApprove) {
       builder.intercept(action as OpenBotEvent['type'], (event, context) => {
@@ -27,14 +27,12 @@ export const approvalPlugin: Plugin = {
         if (event.meta?.approvalStatus === 'approved') return event;
 
         // Otherwise, intercept and ask for approval via a UI widget
-        const displayData = action === 'action:shell_exec'
-          ? `\`\`\`bash\n${(event as any).data.command}\n\`\`\``
-          : `\`\`\`json\n${JSON.stringify((event as any).data, null, 2)}\n\`\`\``;
+        const displayData = JSON.stringify((event as any)?.data) || '';
 
         const widgetId = randomUUID();
         pendingApprovals.set(widgetId, Date.now());
 
-        context.suspend({
+        return {
           type: 'client:ui:widget',
           data: {
             widgetId,
@@ -51,7 +49,7 @@ export const approvalPlugin: Plugin = {
             ],
           },
           meta: { agentId: context.state.agentId, threadId: context.state.threadId },
-        } as OpenBotEvent);
+        } as OpenBotEvent;
       });
     }
 
@@ -80,6 +78,8 @@ export const approvalPlugin: Plugin = {
       const originalEvent = metadata.originalEvent as OpenBotEvent;
       const approved = actionId === 'approve';
 
+      const displayData = JSON.stringify((event as any)?.data) || '';
+
       // Yield a "responded" widget update to the UI
       yield {
         type: 'client:ui:widget',
@@ -87,7 +87,7 @@ export const approvalPlugin: Plugin = {
           widgetId,
           kind: 'message',
           title: `Action ${approved ? 'Approved' : 'Denied'}`,
-          body: `The request for \`${originalEvent.type}\` was ${approved ? 'approved' : 'denied'}.`,
+          body: displayData,
           state: approved ? 'submitted' : 'cancelled',
           display: 'collapsed',
           disabled: true,
@@ -106,16 +106,33 @@ export const approvalPlugin: Plugin = {
           },
         };
       } else {
-        // Emit a failure result event for the denied action
-        // yield {
-        //   type: `${originalEvent.type}:result` as OpenBotEvent['type'],
-        //   data: {
-        //     success: false,
-        //     error: 'Action denied by user.',
-        //     stderr: 'Action denied by user.',
-        //   },
-        //   meta: originalEvent.meta,
-        // } as OpenBotEvent;
+        // Manually store the original event with denied status so it's recorded in history
+        // but NOT re-emitted to the pipeline (to avoid actual execution).
+        if (storage) {
+          await storage.storeEvent({
+            channelId: context.state.channelId,
+            threadId: context.state.threadId,
+            event: {
+              ...originalEvent,
+              meta: {
+                ...(originalEvent.meta || {}),
+                approvalStatus: 'denied',
+              },
+            },
+          });
+        }
+
+        // Emit a failure result event for the denied action to clear the pending tool batch
+        yield {
+          type: `${originalEvent.type}:result` as OpenBotEvent['type'],
+          data: {
+            success: false,
+            error: 'Action denied by user.',
+            stderr: 'Action denied by user.',
+            output: 'Action denied by user.',
+          },
+          meta: originalEvent.meta,
+        } as OpenBotEvent;
 
         yield {
           type: 'agent:output',