openbot 0.5.9 → 0.5.11

package/dist/harness/index.js

@@ -9,7 +9,7 @@ import { getPublicBaseUrl } from '../plugins/storage/files.js';
 import { createPluginHost } from '../services/plugins/host.js';
 import { getInvokeConfigOverrides, mergePluginConfig } from './merge-plugin-config.js';
 export { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID };
-async function emitEvent(chunk, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId, }) {
+async function emitEvent(chunk, state, { persistEvents, onEvent, parentAgentId, parentToolCallId, }) {
     ensureEventId(chunk);
     // Enrich event with parent metadata if not already present
     if (parentAgentId || parentToolCallId) {
@@ -19,10 +19,11 @@ async function emitEvent(chunk, state, { persistEvents, channelId, threadId, onE
             parentToolCallId: chunk.meta?.parentToolCallId || parentToolCallId,
         };
     }
-    if (persistEvents) {
+    const channelId = state?.channelId;
+    if (persistEvents && channelId) {
         await storageService.storeEvent({
-            channelId: state?.channelId || channelId,
-            threadId: state?.threadId || threadId,
+            channelId,
+            threadId: state?.threadId,
             event: chunk,
         });
     }
@@ -33,7 +34,7 @@ async function emitEvent(chunk, state, { persistEvents, channelId, threadId, onE
  * Fire and forget.
  */
 export async function runAgent(options) {
-    const { runId, agentId, event, channelId, threadId, onEvent } = options;
+    const { runId, agentId, event, onEvent } = options;
     const persistEvents = options.persistEvents !== false;
     let publicBaseUrl = options.publicBaseUrl;
     if (!publicBaseUrl) {
@@ -47,18 +48,16 @@ export async function runAgent(options) {
     const state = await storageService.getOpenBotState({
         runId,
         agentId,
-        channelId,
-        threadId,
         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 runKey = state.channelId ? abortKey(state.channelId, state.threadId) : runId;
     const abortSignal = abortRegistry.acquire(runKey);
     await emitEvent({
         type: 'agent:run:start',
-        data: { runId, agentId, channelId, threadId },
-    }, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId });
+        data: { runId, agentId, channelId: state.channelId, threadId: state.threadId },
+    }, state, { persistEvents, onEvent, parentAgentId, parentToolCallId });
     try {
         const pluginRefs = agentDetails.pluginRefs ?? [];
         const tools = {};
@@ -97,8 +96,6 @@ export async function runAgent(options) {
                 break;
             await emitEvent(outputEvent, state, {
                 persistEvents,
-                channelId,
-                threadId,
                 onEvent,
                 parentAgentId,
                 parentToolCallId,
@@ -112,7 +109,7 @@ export async function runAgent(options) {
         abortRegistry.release(runKey);
         await emitEvent({
             type: 'agent:run:end',
-            data: { runId, agentId, channelId, threadId },
-        }, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId });
+            data: { runId, agentId, channelId: state.channelId, threadId: state.threadId },
+        }, state, { persistEvents, onEvent, parentAgentId, parentToolCallId });
     }
 }

package/dist/plugins/slack-webhook/index.js

@@ -0,0 +1,51 @@
+import { parseSlackWebhookPayload, SLACK_WEBHOOK_PROVIDER } from '../../app/slack-webhook.js';
+/**
+ * Handles `action:webhook` for the Slack Events API: URL verification challenges and
+ * `message` events transformed into `agent:invoke` turns.
+ */
+export const slackWebhookPlugin = {
+    id: 'slack-webhook',
+    name: 'Slack webhook',
+    description: 'Parses inbound Slack Events API webhooks and forwards user messages to the runtime.',
+    factory: ({ agentId }) => (builder) => {
+        builder.on('action:webhook', async function* (event) {
+            if (event.data?.provider !== SLACK_WEBHOOK_PROVIDER)
+                return;
+            const rawBody = Buffer.from(event.data.rawBody, 'base64');
+            const parsed = parseSlackWebhookPayload(rawBody);
+            if (!parsed)
+                return;
+            if (parsed.kind === 'url_verification') {
+                yield {
+                    type: 'action:webhook:http-response',
+                    data: {
+                        status: 200,
+                        body: { challenge: parsed.challenge },
+                    },
+                };
+                return;
+            }
+            if (parsed.kind === 'ignored') {
+                yield {
+                    type: 'action:webhook:http-response',
+                    data: { status: 200, body: { ok: true, ignored: parsed.reason } },
+                };
+                return;
+            }
+            const userLabel = parsed.userId ? `<@${parsed.userId}>` : 'Slack user';
+            yield {
+                type: 'agent:invoke',
+                data: {
+                    role: 'user',
+                    content: `${userLabel}: ${parsed.text}`,
+                },
+                meta: {
+                    agentId,
+                    slackChannelId: parsed.slackChannelId,
+                    slackThreadTs: parsed.threadTs,
+                    slackUserId: parsed.userId,
+                },
+            };
+        });
+    },
+};

package/dist/plugins/storage/index.js

@@ -43,7 +43,8 @@ export const storagePlugin = {
         });
         builder.on('agent:usage', async function* (event, context) {
             const { usage } = event.data;
-            if (!context.state.threadId)
+            const channelId = context.state.channelId;
+            if (!channelId || !context.state.threadId)
                 return;
             const currentState = context.state.threadDetails?.state || {};
             const currentUsage = currentState.usage || {
@@ -57,12 +58,12 @@ export const storagePlugin = {
                 totalTokens: (currentUsage.totalTokens || 0) + usage.totalTokens,
             };
             await storage.patchThreadState({
-                channelId: context.state.channelId,
+                channelId,
                 threadId: context.state.threadId,
                 state: { usage: nextUsage },
             });
             context.state.threadDetails = await storage.getThreadDetails({
-                channelId: context.state.channelId,
+                channelId,
                 threadId: context.state.threadId,
             });
         });
@@ -76,9 +77,17 @@ export const storagePlugin = {
         });
         builder.on('action:storage:set-last-read', async function* (event, context) {
             const { channelId, threadId, lastReadEventId } = event.data;
+            const resolvedChannelId = channelId || context.state.channelId;
+            if (!resolvedChannelId) {
+                yield {
+                    type: 'action:storage:set-last-read-result',
+                    data: { success: false, error: 'channelId is required' },
+                };
+                return;
+            }
             try {
                 await storage.setLastRead({
-                    channelId: channelId || context.state.channelId,
+                    channelId: resolvedChannelId,
                     threadId: threadId || context.state.threadId,
                     lastReadEventId,
                 });
@@ -95,15 +104,29 @@ export const storagePlugin = {
             }
         });
         builder.on('action:storage:get-channel-details', async function* (_, state) {
-            const channelDetails = await storage.getChannelDetails({
-                channelId: state.state.channelId,
-            });
+            const channelId = state.state.channelId;
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:get-channel-details-result',
+                    data: { channelDetails: null, error: 'channelId is required' },
+                };
+                return;
+            }
+            const channelDetails = await storage.getChannelDetails({ channelId });
             yield { type: 'action:storage:get-channel-details-result', data: { channelDetails } };
         });
         builder.on('action:storage:get-thread-details', async function* (_, state) {
+            const channelId = state.state.channelId;
             const threadId = state.state.threadId;
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:get-thread-details-result',
+                    data: { threadDetails: null, error: 'channelId is required' },
+                };
+                return;
+            }
             const threadDetails = threadId
-                ? await storage.getThreadDetails({ channelId: state.state.channelId, threadId })
+                ? await storage.getThreadDetails({ channelId, threadId })
                 : null;
             yield { type: 'action:storage:get-thread-details-result', data: { threadDetails } };
         });
@@ -210,7 +233,12 @@ export const storagePlugin = {
             }
         });
         builder.on('action:storage:get-events', async function* (_, state) {
-            const events = await storage.getEvents(state.state);
+            const channelId = state.state.channelId;
+            if (!channelId) {
+                yield { type: 'action:storage:get-events-result', data: { events: [] } };
+                return;
+            }
+            const events = await storage.getEvents({ channelId, threadId: state.state.threadId });
             yield { type: 'action:storage:get-events-result', data: { events } };
         });
         builder.on('action:storage:get-variables', async function* () {
@@ -261,9 +289,14 @@ export const storagePlugin = {
             }
         });
         builder.on('action:storage:patch-channel-state', async function* (event, state) {
+            const channelId = state.state.channelId;
+            if (!channelId) {
+                yield { type: 'action:storage:patch-channel-state-result', data: { success: false } };
+                return;
+            }
             try {
                 await storage.patchChannelState({
-                    channelId: state.state.channelId,
+                    channelId,
                     state: event.data.state,
                 });
                 yield { type: 'action:storage:patch-channel-state-result', data: { success: true } };
@@ -273,12 +306,13 @@ export const storagePlugin = {
             }
         });
         builder.on('action:storage:patch-thread-state', async function* (event, state) {
+            const channelId = state.state.channelId;
             try {
-                if (!state.state.threadId) {
-                    throw new Error('Missing threadId in state for patch-thread-state');
+                if (!channelId || !state.state.threadId) {
+                    throw new Error('Missing channelId or threadId in state for patch-thread-state');
                 }
                 await storage.patchThreadState({
-                    channelId: state.state.channelId,
+                    channelId,
                     threadId: state.state.threadId,
                     state: event.data.state,
                 });
@@ -291,6 +325,13 @@ export const storagePlugin = {
         builder.on('action:storage:list-files', async function* (event, context) {
             const channelId = context.state.channelId;
             const subPath = event.data?.path || '';
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:list-files:result',
+                    data: { success: false, files: [], error: 'channelId is required' },
+                };
+                return;
+            }
             try {
                 const files = await storage.listFiles({ channelId, path: subPath });
                 yield {
@@ -321,6 +362,13 @@ export const storagePlugin = {
                 };
                 return;
             }
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:read-file:result',
+                    data: { success: false, path: filePath, error: 'channelId is required' },
+                };
+                return;
+            }
             try {
                 if (encoding === 'utf8') {
                     const content = await storage.readFile({ channelId, path: filePath });
@@ -361,8 +409,18 @@ export const storagePlugin = {
                 };
                 return;
             }
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:get-file-url:result',
+                    data: { success: false, path: filePath, error: 'channelId is required' },
+                };
+                return;
+            }
             try {
-                const { size, mimeType } = await storage.getChannelFileStat({ channelId, path: filePath });
+                const { size, mimeType } = await storage.getChannelFileStat({
+                    channelId,
+                    path: filePath,
+                });
                 const url = buildWorkspaceFileUrl({
                     baseUrl: resolvePublicBaseUrl(),
                     channelId,

package/dist/plugins/storage/service.js

@@ -1360,7 +1360,13 @@ export const storageService = {
      * Hydrates the full OpenBot state from disk/storage before a run.
      */
     getOpenBotState: async (options) => {
-        const { runId, agentId, channelId, threadId, event } = options;
+        const { runId, agentId, event } = options;
+        const channelId = typeof event.meta?.channelId === 'string'
+            ? event.meta.channelId.trim() || undefined
+            : undefined;
+        const threadId = typeof event.meta?.threadId === 'string'
+            ? event.meta.threadId.trim() || undefined
+            : undefined;
         let agentDetails;
         try {
             agentDetails = await storageService.getAgentDetails({ agentId });

package/docs/plugins.md

@@ -60,6 +60,45 @@ model as the tool result (`history.ts`). Structured fields (e.g. `list`,
 | `todo`           | Tool    | `todo_write`, `todo_read` (inbuilt in `openbot`)              |
 | `plugin-manager` | Infra   | Marketplace list, npm plugin install/uninstall, agent install |
 
+## Inbound webhooks
+
+`GET` and `POST /api/webhooks/:provider` forward third-party HTTP requests onto the
+bus as `action:webhook`. The URL segment is used as the target agent id when
+`~/.openbot/agents/<provider>/AGENT.md` exists; otherwise the request falls back
+to the `system` agent. Attach a plugin to the routed agent and handle
+verification, channel/thread routing, transforms, and HTTP responses there.
+
+GET requests have an empty `rawBody`; use `event.data.method` and `event.data.query`
+for URL verification challenges (for example Meta `hub.challenge`).
+
+```ts
+builder.on('action:webhook', async function* (event) {
+  if (event.data?.provider !== 'slack') return;
+
+  if (event.data.method === 'GET') {
+    const challenge = event.data.query?.['hub.challenge'];
+    yield {
+      type: 'action:webhook:http-response',
+      data: { status: 200, body: String(challenge) },
+    };
+    return;
+  }
+
+  const rawBody = Buffer.from(event.data.rawBody, 'base64');
+
+  // Optional: control the HTTP response (URL challenges, 401s, custom acks)
+  yield {
+    type: 'action:webhook:http-response',
+    data: { status: 200, body: { ok: true } },
+  };
+
+  yield {
+    type: 'agent:invoke',
+    data: { role: 'user', content: '...' },
+  };
+});
+```
+
 ## Batteries-included: `openbot` runtime
 
 The `openbot` plugin is the standard runtime for OpenBot agents. It is designed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "private": false,
   "type": "module",
   "engines": {
@@ -11,7 +11,7 @@
     "build": "tsc && mkdir -p dist/assets && cp src/assets/icon.svg dist/assets/icon.svg",
     "start": "node dist/app/cli.js start",
     "format": "prettier --write .",
-    "push": "fly deploy --build-only --push --config deploy/fly.toml -a openbot-runtime --image-label v0.5.9"
+    "push": "fly deploy --build-only --push --config deploy/fly.toml -a openbot-runtime --image-label v0.5.11"
   },
   "bin": {
     "openbot": "./dist/app/cli.js"

package/src/app/active-runs.ts

@@ -0,0 +1,95 @@
+import { ActiveRunsSnapshotEvent } from './types.js';
+
+export type ActiveRunRecord = {
+  runId: string;
+  channelId: string;
+  threadId?: string;
+  agentId: string;
+};
+
+type Bucket = {
+  channelId: string;
+  threadId?: string;
+  activeCount: number;
+  agentIds: Set<string>;
+};
+
+export function getRunKey(
+  runId: string,
+  agentId: string,
+  channelId: string,
+  threadId?: string,
+): string {
+  return `${runId}:${agentId}:${channelId}:${threadId || ''}`;
+}
+
+export class ActiveRunsTracker {
+  private runs = new Map<string, ActiveRunRecord>();
+
+  trackStart(data: ActiveRunRecord): void {
+    this.runs.set(getRunKey(data.runId, data.agentId, data.channelId, data.threadId), data);
+  }
+
+  trackEnd(data: ActiveRunRecord): void {
+    this.runs.delete(getRunKey(data.runId, data.agentId, data.channelId, data.threadId));
+  }
+
+  buildSnapshot(): ActiveRunsSnapshotEvent {
+    const byBucket = new Map<string, Bucket>();
+    for (const run of this.runs.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 },
+    };
+  }
+
+  /**
+   * Drop every tracked run for a channel/thread. Returns the purged records so
+   * callers can emit synthetic `agent:run:end` events to SSE clients.
+   */
+  purgeForThread(channelId: string, threadId?: string): ActiveRunRecord[] {
+    const target = threadId || undefined;
+    const removed: ActiveRunRecord[] = [];
+
+    for (const [key, run] of this.runs) {
+      if (run.channelId === channelId && (run.threadId || undefined) === target) {
+        removed.push(run);
+        this.runs.delete(key);
+      }
+    }
+
+    return removed;
+  }
+}

package/src/app/cli.ts

@@ -27,7 +27,7 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.5.9');
+program.name('openbot').description('OpenBot CLI').version('0.5.11');
 
 program
   .command('start')

package/src/app/lifecycle-events.ts

@@ -0,0 +1,46 @@
+import { storageService } from '../plugins/storage/service.js';
+import { OpenBotEvent } from './types.js';
+import { ensureEventId } from './utils.js';
+
+export function 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,
+      });
+    });
+}
+
+export type LifecycleBroadcastDeps = {
+  sendToClientKey: (clientKey: string, event: OpenBotEvent) => void;
+  getClientKey: (channelId: string, threadId?: string) => string;
+  globalChannelId: string;
+};
+
+export function broadcastLifecycleEvent(
+  event: OpenBotEvent,
+  channelId: string,
+  threadId: string | undefined,
+  deps: LifecycleBroadcastDeps,
+  options?: { persist?: boolean },
+): void {
+  ensureEventId(event);
+  if (options?.persist !== false) {
+    persistLifecycleEvent(event, channelId, threadId);
+  }
+  deps.sendToClientKey(deps.getClientKey(channelId, threadId), event);
+  deps.sendToClientKey(deps.globalChannelId, event);
+}

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);
+    }
+  };
+}