openbot 0.5.8 → 0.5.10

package/src/app/run-event-handler.ts

@@ -0,0 +1,55 @@
+import { ActiveRunsTracker } from './active-runs.js';
+import { OpenBotEvent, OpenBotState } from './types.js';
+import type { WebhookHttpResponse } from './webhook-routing.js';
+
+const LIFECYCLE_RUN_TYPES = new Set(['agent:run:start', 'agent:run:end', 'agent:run:stopped']);
+
+export type RunEventHandlerDeps = {
+  defaultChannelId?: string;
+  defaultThreadId?: string;
+  activeRuns: ActiveRunsTracker;
+  sendToClientKey: (clientKey: string, event: OpenBotEvent) => void;
+  getClientKey: (channelId: string, threadId?: string) => string;
+  globalChannelId: string;
+  onRunStopped?: (channelId: string, threadId?: string) => void;
+  onWebhookHttpResponse?: (response: WebhookHttpResponse) => void;
+};
+
+export function createRunEventHandler(deps: RunEventHandlerDeps) {
+  return async (chunk: OpenBotEvent, state?: OpenBotState): Promise<void> => {
+    if (chunk.type === 'action:webhook:http-response' && deps.onWebhookHttpResponse) {
+      deps.onWebhookHttpResponse(chunk.data as WebhookHttpResponse);
+      return;
+    }
+
+    const targetChannelId = state?.channelId || deps.defaultChannelId;
+    const targetThreadId = state?.threadId || deps.defaultThreadId;
+
+    if (chunk.type === 'agent:run:start' && chunk.data.channelId) {
+      deps.activeRuns.trackStart({
+        runId: chunk.data.runId,
+        channelId: chunk.data.channelId,
+        threadId: chunk.data.threadId,
+        agentId: chunk.data.agentId,
+      });
+    } else if (chunk.type === 'agent:run:end' && chunk.data.channelId) {
+      deps.activeRuns.trackEnd({
+        runId: chunk.data.runId,
+        channelId: chunk.data.channelId,
+        threadId: chunk.data.threadId,
+        agentId: chunk.data.agentId,
+      });
+    } else if (chunk.type === 'agent:run:stopped' && chunk.data.channelId) {
+      deps.onRunStopped?.(chunk.data.channelId, chunk.data.threadId);
+    }
+
+    if (targetChannelId) {
+      const targetClientKey = deps.getClientKey(targetChannelId, targetThreadId);
+      deps.sendToClientKey(targetClientKey, chunk);
+    }
+
+    if (LIFECYCLE_RUN_TYPES.has(chunk.type)) {
+      deps.sendToClientKey(deps.globalChannelId, chunk);
+    }
+  };
+}

package/src/app/server.ts

@@ -10,7 +10,10 @@ const pkg = require('../../package.json');
 import { generateId } from 'melony';
 import { getBaseDir, loadConfig } from '../app/config.js';
 import { isCloudMode } from './cloud-mode.js';
-import { ActiveRunsSnapshotEvent, OpenBotEvent, OpenBotState } from './types.js';
+import { OpenBotEvent } from './types.js';
+import { ActiveRunsTracker } from './active-runs.js';
+import { broadcastLifecycleEvent } from './lifecycle-events.js';
+import { createRunEventHandler } from './run-event-handler.js';
 import { processService } from '../services/process.js';
 import { runAgent, STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID } from '../harness/index.js';
 import { initPlugins } from '../services/plugins/registry.js';
@@ -23,12 +26,14 @@ import {
 import { ensureEventId, openBotEventFromQuery } from './utils.js';
 import { abortRegistry, abortKey } from '../services/abort.js';
 import { resolvePublishTargetAgentId, resolveRespondingAgentId } from './responding-agent.js';
+import { DEFAULT_UNCATEGORIZED_SPEC, UNCATEGORIZED_CHANNEL_ID } from './channel-ids.js';
 import {
-  DEFAULT_UNCATEGORIZED_SPEC,
-  UNCATEGORIZED_CHANNEL_ID,
-} from './channel-ids.js';
-
-type Bucket = { channelId: string; threadId?: string; activeCount: number; agentIds: Set<string> };
+  pickWebhookHeaders,
+  resolveWebhookAgentId,
+  respondAgentDispatchError,
+  sendWebhookHttpResponse,
+  type WebhookHttpResponse,
+} from './webhook-routing.js';
 
 export interface ServerOptions {
   port?: number;
@@ -56,10 +61,7 @@ export async function startServer(options: ServerOptions = {}) {
   const app = express();
   const clients: Map<string, express.Response[]> = new Map();
   const GLOBAL_CHANNEL_ID = '__global__';
-  const activeRuns = new Map<
-    string,
-    { runId: string; channelId: string; threadId?: string; agentId: string }
-  >();
+  const activeRunsTracker = new ActiveRunsTracker();
 
   const agentsDir = path.join(openBotDir, 'agents');
   const pluginsDir = path.join(openBotDir, 'plugins');
@@ -70,14 +72,16 @@ export async function startServer(options: ServerOptions = {}) {
   initPlugins(pluginsDir);
 
   // Pre-warm caches for agents and plugins to speed up first UI load
-  storageService.getAgents().catch((err) => console.warn('[server] Failed to pre-warm agents cache', err));
-  storageService.getPlugins().catch((err) => console.warn('[server] Failed to pre-warm plugins cache', err));
+  storageService
+    .getAgents()
+    .catch((err) => console.warn('[server] Failed to pre-warm agents cache', err));
+  storageService
+    .getPlugins()
+    .catch((err) => console.warn('[server] Failed to pre-warm plugins cache', err));
 
   const getRawChannelId = (req: express.Request): string | undefined => {
     const raw =
-      req.get('x-openbot-channel-id') ||
-      req.query.channelId ||
-      (req.body && req.body.channelId);
+      req.get('x-openbot-channel-id') || req.query.channelId || (req.body && req.body.channelId);
     if (typeof raw !== 'string') return undefined;
     const trimmed = raw.trim();
     return trimmed || undefined;
@@ -111,8 +115,6 @@ export async function startServer(options: ServerOptions = {}) {
 
   const getClientKey = (channelId: string, threadId?: string) =>
     threadId ? `${channelId}:${threadId}` : channelId;
-  const getRunKey = (runId: string, agentId: string, channelId: string, threadId?: string) =>
-    `${runId}:${agentId}:${channelId}:${threadId || ''}`;
 
   const sendToClientKey = (clientKey: string, chunk: OpenBotEvent) => {
     const threadClients = clients.get(clientKey);
@@ -123,7 +125,9 @@ export async function startServer(options: ServerOptions = {}) {
       const parts = clientKey.split(':');
       const channelId = parts[0];
       const threadId = parts[1]; // undefined if no ":"
-      storageService.setLastRead({ channelId, threadId, lastReadEventId: chunk.id }).catch(() => {});
+      storageService
+        .setLastRead({ channelId, threadId, lastReadEventId: chunk.id })
+        .catch(() => { });
     }
 
     threadClients.forEach((client) => {
@@ -133,70 +137,18 @@ export async function startServer(options: ServerOptions = {}) {
     });
   };
 
-  const buildActiveRunsSnapshot = (): ActiveRunsSnapshotEvent => {
-    const byBucket = new Map<string, Bucket>();
-    for (const run of activeRuns.values()) {
-      const threadId = run.threadId || undefined;
-      const key = JSON.stringify([run.channelId, threadId ?? null]);
-      let bucket = byBucket.get(key);
-      if (!bucket) {
-        bucket = { channelId: run.channelId, threadId, activeCount: 0, agentIds: new Set<string>() };
-        byBucket.set(key, bucket);
-      }
-      bucket.activeCount += 1;
-      bucket.agentIds.add(run.agentId);
-    }
-    const channels = Array.from(byBucket.values())
-      .sort((a, b) => {
-        const c = a.channelId.localeCompare(b.channelId);
-        if (c !== 0) return c;
-        return (a.threadId ?? '').localeCompare(b.threadId ?? '');
-      })
-      .map(({ channelId, threadId, activeCount, agentIds }) => {
-        const row: ActiveRunsSnapshotEvent['data']['channels'][number] = {
-          channelId,
-          activeCount,
-          agentIds: Array.from(agentIds),
-        };
-        if (threadId !== undefined) {
-          row.threadId = threadId;
-        }
-        return row;
-      });
-    return {
-      type: 'agent:active-runs:snapshot',
-      data: { channels },
-    };
+  const lifecycleDeps = {
+    sendToClientKey,
+    getClientKey,
+    globalChannelId: GLOBAL_CHANNEL_ID,
   };
 
   const broadcastActiveRunsSnapshot = (): void => {
-    const snapshot = buildActiveRunsSnapshot();
+    const snapshot = activeRunsTracker.buildSnapshot();
     ensureEventId(snapshot);
     sendToClientKey(GLOBAL_CHANNEL_ID, snapshot);
   };
 
-  const persistLifecycleEvent = (
-    event: OpenBotEvent,
-    targetChannelId: string,
-    targetThreadId?: string,
-  ): void => {
-    ensureEventId(event);
-    storageService
-      .storeEvent({
-        channelId: targetChannelId,
-        threadId: targetThreadId,
-        event,
-      })
-      .catch((error) => {
-        console.error('[server] Failed to persist lifecycle event', {
-          type: event.type,
-          channelId: targetChannelId,
-          threadId: targetThreadId,
-          error,
-        });
-      });
-  };
-
   // Drop every tracked run for a channel/thread. A stop aborts the whole
   // chain (parent + delegated sub-agents), but the sub-agents' `agent:run:end`
   // events can be swallowed when the parent run loop breaks on abort, leaving
@@ -204,22 +156,7 @@ export async function startServer(options: ServerOptions = {}) {
   // `agent:run:end` for each purged run and refresh the global snapshot so
   // clients stay in sync even when the parent harness stops yielding.
   const purgeActiveRunsForThread = (channelId: string, threadId?: string): void => {
-    const target = threadId || undefined;
-    const removed: Array<{
-      runId: string;
-      channelId: string;
-      threadId?: string;
-      agentId: string;
-    }> = [];
-
-    for (const [key, run] of activeRuns) {
-      if (run.channelId === channelId && (run.threadId || undefined) === target) {
-        removed.push(run);
-        activeRuns.delete(key);
-      }
-    }
-
-    for (const run of removed) {
+    for (const run of activeRunsTracker.purgeForThread(channelId, threadId)) {
       const endEvent: OpenBotEvent = {
         type: 'agent:run:end',
         data: {
@@ -229,13 +166,15 @@ export async function startServer(options: ServerOptions = {}) {
           threadId: run.threadId,
         },
       } as OpenBotEvent;
-      ensureEventId(endEvent);
-      persistLifecycleEvent(endEvent, run.channelId, run.threadId);
-      sendToClientKey(getClientKey(run.channelId, run.threadId), endEvent);
-      sendToClientKey(GLOBAL_CHANNEL_ID, endEvent);
+      broadcastLifecycleEvent(endEvent, run.channelId, run.threadId, lifecycleDeps);
     }
   };
 
+  const handleRunStopped = (channelId: string, threadId?: string): void => {
+    purgeActiveRunsForThread(channelId, threadId);
+    broadcastActiveRunsSnapshot();
+  };
+
   // Support for Chrome's Private Network Access (PNA)
   // https://developer.chrome.com/blog/private-network-access-preflight/
   app.use((req, res, next) => {
@@ -254,7 +193,11 @@ export async function startServer(options: ServerOptions = {}) {
   const gatewayToken = process.env.OPENBOT_GATEWAY_TOKEN?.trim();
   if (gatewayToken) {
     app.use((req, res, next) => {
-      if (req.path === '/api/health' || req.method === 'OPTIONS') {
+      if (
+        req.path === '/api/health' ||
+        req.method === 'OPTIONS' ||
+        req.path.startsWith('/api/webhooks/')
+      ) {
         next();
         return;
       }
@@ -275,9 +218,10 @@ export async function startServer(options: ServerOptions = {}) {
       req.method === 'POST' &&
       req.path === '/api/publish' &&
       req.get('x-openbot-event-type') === 'action:storage:upload-file';
+    const isWebhook = req.method === 'POST' && req.path.startsWith('/api/webhooks/');
 
-    if (isWorkspaceUpload) {
-      express.raw({ type: () => true, limit: '100mb' })(req, res, next);
+    if (isWorkspaceUpload || isWebhook) {
+      express.raw({ type: () => true, limit: isWebhook ? '5mb' : '100mb' })(req, res, next);
       return;
     }
 
@@ -322,11 +266,11 @@ export async function startServer(options: ServerOptions = {}) {
             return storageService.setLastRead({ channelId, threadId, lastReadEventId: latestId });
           }
         })
-        .catch(() => {});
+        .catch(() => { });
     }
 
     if (channelId === GLOBAL_CHANNEL_ID) {
-      const snapshot = buildActiveRunsSnapshot();
+      const snapshot = activeRunsTracker.buildSnapshot();
 
       ensureEventId(snapshot);
       res.write(`data: ${JSON.stringify(snapshot)}\n\n`);
@@ -521,48 +465,21 @@ export async function startServer(options: ServerOptions = {}) {
         },
       } as OpenBotEvent;
       ensureEventId(stoppedEvent);
-      persistLifecycleEvent(stoppedEvent, targetChannelId, targetThreadId);
-      sendToClientKey(getClientKey(targetChannelId, targetThreadId), stoppedEvent);
-      sendToClientKey(GLOBAL_CHANNEL_ID, stoppedEvent);
+      broadcastLifecycleEvent(stoppedEvent, targetChannelId, targetThreadId, lifecycleDeps);
 
       res.json({ success: stopped });
       return;
     }
 
-    const onEvent = async (chunk: OpenBotEvent, state?: OpenBotState) => {
-      const targetChannelId = state?.channelId || channelId;
-      const targetThreadId = state?.threadId || threadId;
-      const targetClientKey = getClientKey(targetChannelId, targetThreadId);
-
-      if (chunk.type === 'agent:run:start') {
-        activeRuns.set(
-          getRunKey(chunk.data.runId, chunk.data.agentId, chunk.data.channelId, chunk.data.threadId),
-          {
-            runId: chunk.data.runId,
-            channelId: chunk.data.channelId,
-            threadId: chunk.data.threadId,
-            agentId: chunk.data.agentId,
-          },
-        );
-      } else if (chunk.type === 'agent:run:end') {
-        activeRuns.delete(
-          getRunKey(chunk.data.runId, chunk.data.agentId, chunk.data.channelId, chunk.data.threadId),
-        );
-      } else if (chunk.type === 'agent:run:stopped') {
-        purgeActiveRunsForThread(chunk.data.channelId, chunk.data.threadId);
-        broadcastActiveRunsSnapshot();
-      }
-
-      sendToClientKey(targetClientKey, chunk);
-
-      if (
-        chunk.type === 'agent:run:start' ||
-        chunk.type === 'agent:run:end' ||
-        chunk.type === 'agent:run:stopped'
-      ) {
-        sendToClientKey(GLOBAL_CHANNEL_ID, chunk);
-      }
-    };
+    const onEvent = createRunEventHandler({
+      defaultChannelId: channelId,
+      defaultThreadId: threadId,
+      activeRuns: activeRunsTracker,
+      sendToClientKey,
+      getClientKey,
+      globalChannelId: GLOBAL_CHANNEL_ID,
+      onRunStopped: handleRunStopped,
+    });
 
     try {
       ensureEventId(event);
@@ -599,21 +516,15 @@ export async function startServer(options: ServerOptions = {}) {
       await runAgent({
         runId,
         agentId: target.agentId,
-        event,
-        channelId,
-        threadId,
+        event: {
+          ...event,
+          meta: { ...event.meta, channelId, threadId },
+        },
         publicBaseUrl: resolvePublicBaseUrl(),
         onEvent,
       });
       res.sendStatus(200);
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      const isUnknownAgent =
-        (error instanceof Error &&
-          ((error as Error & { code?: string }).code === 'AGENT_NOT_FOUND' ||
-            error.message.includes('does not exist'))) ||
-        message.includes('does not exist');
-
       console.error('[publish] Failed to dispatch event', {
         runId,
         channelId,
@@ -622,12 +533,93 @@ export async function startServer(options: ServerOptions = {}) {
         error,
       });
 
-      if (isUnknownAgent) {
-        res.status(400).json({ error: message });
+      respondAgentDispatchError(res, error, 'Failed to process publish event');
+    }
+  });
+
+  const WEBHOOK_TIMEOUT_MS = Number(process.env.OPENBOT_WEBHOOK_TIMEOUT_MS ?? 30_000);
+
+  app.post('/api/webhooks/:provider', async (req, res) => {
+    const provider = req.params.provider?.trim();
+    if (!provider || !/^[a-z0-9][a-z0-9_-]*$/i.test(provider)) {
+      res.status(400).json({ error: 'Invalid webhook provider' });
+      return;
+    }
+
+    const rawBody = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
+    const runId = `run_${generateId()}`;
+    const agentId = await resolveWebhookAgentId(provider);
+
+    let httpResponse: WebhookHttpResponse | null = null;
+
+    const onEvent = createRunEventHandler({
+      activeRuns: activeRunsTracker,
+      sendToClientKey,
+      getClientKey,
+      globalChannelId: GLOBAL_CHANNEL_ID,
+      onRunStopped: handleRunStopped,
+      onWebhookHttpResponse: (response) => {
+        httpResponse = response;
+      },
+    });
+
+    const event: OpenBotEvent = {
+      type: 'action:webhook',
+      data: {
+        provider,
+        rawBody: rawBody.toString('base64'),
+        headers: pickWebhookHeaders(req),
+        query: req.query as Record<string, unknown>,
+      },
+    };
+
+    try {
+      ensureEventId(event);
+
+      console.log('runAgent', {
+        runId,
+        agentId,
+        event,
+        persistEvents: true,
+        publicBaseUrl: resolvePublicBaseUrl(),
+        onEvent,
+      });
+
+      const runPromise = runAgent({
+        runId,
+        agentId,
+        event,
+        persistEvents: true,
+        publicBaseUrl: resolvePublicBaseUrl(),
+        onEvent,
+      });
+
+      let timeoutId: ReturnType<typeof setTimeout> | undefined;
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error('webhook_timeout')), WEBHOOK_TIMEOUT_MS);
+      });
+
+      try {
+        await Promise.race([runPromise, timeoutPromise]);
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+      }
+
+      sendWebhookHttpResponse(res, httpResponse ?? { status: 200, body: {} });
+    } catch (error) {
+      const isTimeout = error instanceof Error && error.message === 'webhook_timeout';
+      console.error('[webhook] Failed to process inbound webhook', {
+        provider,
+        agentId,
+        error,
+      });
+
+      if (isTimeout) {
+        res.status(504).json({ error: 'Webhook handler timed out' });
         return;
       }
 
-      res.status(500).json({ error: 'Failed to process publish event' });
+      respondAgentDispatchError(res, error, 'Failed to process webhook');
     }
   });
 
@@ -645,7 +637,7 @@ export async function startServer(options: ServerOptions = {}) {
 
     // In-memory active runs (not persisted). Mirrors the initial SSE frame on __global__.
     if (channelId === GLOBAL_CHANNEL_ID && event.type === 'action:storage:get-active-runs') {
-      const snapshot = buildActiveRunsSnapshot();
+      const snapshot = activeRunsTracker.buildSnapshot();
       ensureEventId(snapshot);
       res.json({ events: [snapshot] });
       return;
@@ -691,9 +683,10 @@ export async function startServer(options: ServerOptions = {}) {
       await runAgent({
         runId,
         agentId: agentId || STATE_AGENT_ID,
-        event,
-        channelId,
-        threadId,
+        event: {
+          ...event,
+          meta: { ...event.meta, channelId, threadId },
+        },
         persistEvents: false,
         publicBaseUrl: resolvePublicBaseUrl(),
         onEvent,

package/src/app/types.ts

@@ -14,7 +14,7 @@ import type { TodoList } from '../services/todo/types.js';
 export interface OpenBotState {
   agentId: string;
   runId: string;
-  channelId: string;
+  channelId?: string;
   threadId?: string;
   agentDetails?: AgentDetails;
   channelDetails?: ChannelDetails;
@@ -42,6 +42,8 @@ export type AgentInvokeEvent = BaseEvent & {
     role?: 'user' | 'assistant' | 'system';
     content: string;
     agentId?: string;
+    /** Per-run config overrides: flat fields (e.g. model) or nested by plugin id. */
+    config?: Record<string, unknown>;
   };
 };
 
@@ -146,6 +148,31 @@ export type GetActiveRunsEvent = BaseEvent & {
   type: 'action:storage:get-active-runs';
 };
 
+/** Inbound third-party webhook forwarded from `POST /api/webhooks/:provider`. */
+export type WebhookEvent = BaseEvent & {
+  type: 'action:webhook';
+  data: {
+    provider: string;
+    /** Request body encoded as base64 so plugins can verify HMACs on the raw bytes. */
+    rawBody: string;
+    headers: Record<string, string | string[] | undefined>;
+    query: Record<string, unknown>;
+  };
+};
+
+/**
+ * Plugin yields this to control the HTTP response for a webhook request
+ * (e.g. Slack URL verification, signature failures, provider-specific acks).
+ */
+export type WebhookHttpResponseEvent = BaseEvent & {
+  type: 'action:webhook:http-response';
+  data: {
+    status: number;
+    body?: unknown;
+    headers?: Record<string, string>;
+  };
+};
+
 export type GetAgentDetailsEvent = BaseEvent & {
   type: 'action:storage:get-agent-details';
   data: {
@@ -479,7 +506,7 @@ export type AgentRunStartEvent = BaseEvent & {
   data: {
     runId: string;
     agentId: string;
-    channelId: string;
+    channelId?: string;
     threadId?: string;
   };
 };
@@ -489,7 +516,7 @@ export type AgentRunEndEvent = BaseEvent & {
   data: {
     runId: string;
     agentId: string;
-    channelId: string;
+    channelId?: string;
     threadId?: string;
   };
 };
@@ -1253,4 +1280,6 @@ export type OpenBotEvent =
   | DelegateTaskEvent
   | DelegateTaskResultEvent
   | RenderWidgetEvent
-  | RenderWidgetResultEvent;
+  | RenderWidgetResultEvent
+  | WebhookEvent
+  | WebhookHttpResponseEvent;

package/src/app/webhook-routing.ts

@@ -0,0 +1,70 @@
+import type { Request, Response } from 'express';
+import { ORCHESTRATOR_AGENT_ID } from '../harness/index.js';
+import { storageService } from '../plugins/storage/service.js';
+
+/** Default agent when no `agents/<provider>/AGENT.md` exists. */
+export const WEBHOOK_AGENT_FALLBACK_ID = ORCHESTRATOR_AGENT_ID;
+
+export const isAgentNotFound = (error: unknown): boolean =>
+  error instanceof Error &&
+  ((error as Error & { code?: string }).code === 'AGENT_NOT_FOUND' ||
+    error.message.includes('does not exist'));
+
+export function respondAgentDispatchError(
+  res: Response,
+  error: unknown,
+  fallbackMessage: string,
+): void {
+  const message = error instanceof Error ? error.message : String(error);
+  if (isAgentNotFound(error) || message.includes('does not exist')) {
+    res.status(400).json({ error: message });
+    return;
+  }
+  res.status(500).json({ error: fallbackMessage });
+}
+
+/**
+ * Routes `POST /api/webhooks/:provider` to agent `<provider>` when that agent exists,
+ * otherwise falls back to {@link WEBHOOK_AGENT_FALLBACK_ID}.
+ */
+export async function resolveWebhookAgentId(provider: string): Promise<string> {
+  try {
+    await storageService.getAgentDetails({ agentId: provider });
+    return provider;
+  } catch (error) {
+    if (isAgentNotFound(error)) {
+      return WEBHOOK_AGENT_FALLBACK_ID;
+    }
+    throw error;
+  }
+}
+
+/** Copy request headers for plugin-side signature verification. */
+export function pickWebhookHeaders(req: Request): Record<string, string | string[] | undefined> {
+  return { ...req.headers };
+}
+
+export type WebhookHttpResponse = {
+  status: number;
+  body?: unknown;
+  headers?: Record<string, string>;
+};
+
+export function sendWebhookHttpResponse(res: Response, out: WebhookHttpResponse): void {
+  if (out.headers) {
+    for (const [key, value] of Object.entries(out.headers)) {
+      res.setHeader(key, value);
+    }
+  }
+
+  const status = out.status;
+  if (out.body === undefined) {
+    res.sendStatus(status);
+    return;
+  }
+  if (typeof out.body === 'string') {
+    res.status(status).send(out.body);
+    return;
+  }
+  res.status(status).json(out.body);
+}