openbot 0.3.6 → 0.4.2

package/README.md

@@ -18,7 +18,8 @@ OpenBot is a local-first harness for running AI agents. It is built around a sma
 
 - Runs a local agent server.
 - Stores channels, threads, agents, plugins, config, and variables under `~/.openbot`.
-- Ships with a built-in `system` agent named OpenBot.
+- Ships with a built-in `system` agent named OpenBot (orchestrator, includes the LLM runtime).
+- Ships with a built-in `state` agent for deterministic, non-LLM handling (e.g. `/api/state` defaults).
 - Loads custom agents from `~/.openbot/agents/<agent-id>/AGENT.md`.
 - Loads shared plugins from `~/.openbot/plugins`.
 - Streams events to clients with Server-Sent Events.
@@ -50,15 +51,17 @@ npm run dev
 OpenBot intentionally keeps the public API small:
 
 - `GET /api/events` opens an SSE stream for a channel or thread.
-- `POST /api/publish` publishes an event into the harness.
-- `GET /api/state` runs an event and returns the resulting events without opening a stream.
+- `POST /api/publish` publishes an event into the harness (defaults to the built-in `system` agent with the OpenBot / LLM runtime).
+- `GET /api/state` runs an event and returns the resulting events without opening a stream (defaults to the built-in `state` agent: storage-oriented plugins, no LLM).
+
+You can override the agent with `agentId` (header, query, or body where applicable).
 
 Example:
 
 ```bash
 curl -X POST http://localhost:4132/api/publish \
   -H "content-type: application/json" \
-  -d '{"type":"user:input","data":{"content":"hello"}}'
+  -d '{"type":"agent:invoke","data":{"role":"user","content":"hello"}}'
 ```
 
 Useful context can be passed as headers, query params, or body fields:
@@ -76,8 +79,7 @@ OpenBot reads config from `~/.openbot/config.json`.
 {
   "port": 4132,
   "baseDir": "~/.openbot",
-  "model": "openai/gpt-4o-mini",
-  "mcpServers": []
+  "model": "openai/gpt-4o-mini"
 }
 ```
 
@@ -91,12 +93,11 @@ The built-in `system` agent is always available. Add a custom agent by creating
 ---
 name: Researcher
 description: Helps collect and summarize information.
-runtime:
-  name: ai-sdk
-  config:
-    model: openai/gpt-4o-mini
 plugins:
-  - name: storage
+  - id: openbot
+    config:
+      model: openai/gpt-4o-mini
+  - id: storage
 ---
 
 You are a careful research assistant.
@@ -109,18 +110,16 @@ Agents are discovered from disk when the server starts.
 
 Built-in plugins include:
 
-- `storage`
+- `storage-tools`
 - `delegation`
-- `mcp`
-- `ui`
-- `ai-sdk`
+- `openbot`
 
 Shared plugins can be placed in `~/.openbot/plugins` and referenced by agents.
 
 ## Project Layout
 
 - `src/app`: CLI, server, event types, and app config.
-- `src/harness`: orchestration, process, and MCP runtime helpers.
+- `src/harness`: orchestration and process helpers.
 - `src/plugins`: built-in plugin implementations.
 - `src/services`: local storage service.
 - `src/registry`: plugin registry.

package/dist/app/agent-ids.js

@@ -0,0 +1,4 @@
+/** Built-in orchestrator agent id. Optional `agents/system/AGENT.md` overrides code defaults. */
+export const ORCHESTRATOR_AGENT_ID = 'system';
+/** Built-in infra agent for deterministic `/api/state` and marketplace/plugin lifecycle; optional AGENT.md overlay. */
+export const STATE_AGENT_ID = 'state';

package/dist/app/cli.js

@@ -16,7 +16,7 @@ function checkNodeVersion() {
     }
 }
 checkNodeVersion();
-program.name('openbot').description('OpenBot CLI').version('0.3.6');
+program.name('openbot').description('OpenBot CLI').version('0.4.2');
 program
     .command('start')
     .description('Start the OpenBot harness')

package/dist/app/config.js

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 export const DEFAULT_BASE_DIR = '~/.openbot';
+/** Default parent directory for per-channel working directories (user-facing workspace). */
+export const DEFAULT_CHANNELS_WORKSPACE_DIR = '~/openbot';
 export const DEFAULT_PLUGINS_DIR = 'plugins';
 export const DEFAULT_AGENTS_DIR = 'agents';
 export const DEFAULT_CHANNELS_DIR = 'channels';
@@ -12,6 +14,14 @@ export const DEFAULT_MARKETPLACE_REGISTRY_URL = 'https://raw.githubusercontent.c
 export function resolvePath(p) {
     return p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : path.resolve(p);
 }
+/** Default absolute cwd for a channel when none is provided at creation time. */
+export function getDefaultChannelCwd(channelId) {
+    const id = channelId.trim();
+    if (!id) {
+        throw new Error('channelId is required');
+    }
+    return resolvePath(`${DEFAULT_CHANNELS_WORKSPACE_DIR}/${id}`);
+}
 export function loadConfig() {
     const configPath = path.join(os.homedir(), '.openbot', CONFIG_FILE);
     if (fs.existsSync(configPath)) {
@@ -46,22 +56,3 @@ export function loadVariables() {
     }
     return { version: 1, variables: [] };
 }
-export const DEFAULT_AGENT_MD = `---
-description: A specialized AI agent
----
-
-# Agent Profile
-
-You are a specialized AI agent within the OpenBot system.
-Your role is defined by your configuration and the tools you have access to.
-
-## Persona
-- Helpful and precise
-- Focused on my specific domain
-- Professional in all interactions
-`;
-export const DEFAULT_USER_MD = `# About Me
-
-<!-- OpenBot reads this file to understand who you are and how you like to work. -->
-<!-- Edit it here or just chat — agents can update it with the "remember" tool. -->
-`;

package/dist/app/server.js

@@ -9,11 +9,13 @@ const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 import { generateId } from 'melony';
 import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
-import { processService } from '../harness/process.js';
-import { storageService } from '../services/storage.js';
-import { dispatch } from '../harness/dispatcher.js';
-import { initPlugins } from '../registry/plugins.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';
+import { storageService } from '../plugins/storage/service.js';
+import { buildWorkspaceFileUrl, getPublicBaseUrl, openChannelFileStream, } from '../plugins/storage/files.js';
 import { ensureEventId, openBotEventFromQuery } from './utils.js';
+import { abortRegistry, abortKey } from '../services/abort.js';
 export async function startServer(options = {}) {
     const publishEventSchema = z
         .object({
@@ -37,6 +39,9 @@ export async function startServer(options = {}) {
     await fs.mkdir(agentsDir, { recursive: true });
     await fs.mkdir(pluginsDir, { recursive: true });
     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));
     const getContext = (req) => {
         const channelId = req.get('x-openbot-channel-id') || req.query.channelId || (req.body && req.body.channelId);
         const threadId = req.get('x-openbot-thread-id') || req.query.threadId || (req.body && req.body.threadId);
@@ -49,7 +54,7 @@ export async function startServer(options = {}) {
             req.query.responseType ||
             (req.body && req.body.responseType);
         return {
-            channelId: (channelId || (threadId ? 'general' : 'general')), // Default to general if none
+            channelId: (channelId || (threadId ? 'uncategorized' : 'uncategorized')), // Default to uncategorized if none
             threadId: threadId,
             agentId: agentId,
             runId: runId,
@@ -60,8 +65,15 @@ export async function startServer(options = {}) {
     const getRunKey = (runId, agentId, channelId, threadId) => `${runId}:${agentId}:${channelId}:${threadId || ''}`;
     const sendToClientKey = (clientKey, chunk) => {
         const threadClients = clients.get(clientKey);
-        if (!threadClients)
+        if (!threadClients || threadClients.length === 0)
             return;
+        // Auto-detect "read" state: if someone is listening, they just "read" this event.
+        if (chunk.id && clientKey !== GLOBAL_CHANNEL_ID) {
+            const parts = clientKey.split(':');
+            const channelId = parts[0];
+            const threadId = parts[1]; // undefined if no ":"
+            storageService.setLastRead({ channelId, threadId, lastReadEventId: chunk.id }).catch(() => { });
+        }
         threadClients.forEach((client) => {
             if (!client.writableEnded) {
                 client.write(`data: ${JSON.stringify(chunk)}\n\n`);
@@ -104,8 +116,31 @@ export async function startServer(options = {}) {
             data: { channels },
         };
     };
+    // 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
+    // orphaned entries that keep a channel falsely "active". Purging by
+    // channel/thread guarantees the snapshot self-heals after a stop.
+    const purgeActiveRunsForThread = (channelId, threadId) => {
+        const target = threadId || undefined;
+        for (const [key, run] of activeRuns) {
+            if (run.channelId === channelId && (run.threadId || undefined) === target) {
+                activeRuns.delete(key);
+            }
+        }
+    };
     app.use(cors());
-    app.use(express.json({ limit: '20mb' }));
+    const resolvePublicBaseUrl = () => getPublicBaseUrl(PORT, config.publicUrl);
+    app.use((req, res, next) => {
+        const isWorkspaceUpload = req.method === 'POST' &&
+            req.path === '/api/publish' &&
+            req.get('x-openbot-event-type') === 'action:storage:upload-file';
+        if (isWorkspaceUpload) {
+            express.raw({ type: () => true, limit: '100mb' })(req, res, next);
+            return;
+        }
+        express.json({ limit: '20mb' })(req, res, next);
+    });
     app.get('/api/health', (req, res) => {
         res.json({ status: 'ok', version: pkg.version });
     });
@@ -129,6 +164,18 @@ export async function startServer(options = {}) {
             clients.set(clientKey, []);
         }
         clients.get(clientKey).push(res);
+        // Auto-detect "read" state on connection: mark the latest event as seen.
+        if (channelId !== GLOBAL_CHANNEL_ID) {
+            storageService
+                .getEvents({ channelId, threadId })
+                .then((events) => {
+                const latestId = events[events.length - 1]?.id;
+                if (latestId) {
+                    return storageService.setLastRead({ channelId, threadId, lastReadEventId: latestId });
+                }
+            })
+                .catch(() => { });
+        }
         if (channelId === GLOBAL_CHANNEL_ID) {
             const snapshot = buildActiveRunsSnapshot();
             ensureEventId(snapshot);
@@ -156,6 +203,53 @@ export async function startServer(options = {}) {
         });
     });
     app.post('/api/publish', async (req, res) => {
+        if (req.get('x-openbot-event-type') === 'action:storage:upload-file') {
+            const channelId = req.get('x-openbot-channel-id') ||
+                (typeof req.query.channelId === 'string' ? req.query.channelId : undefined);
+            const filePath = req.get('x-openbot-file-path');
+            const overwrite = req.get('x-openbot-file-overwrite') === 'true';
+            if (!channelId?.trim()) {
+                res.status(400).json({ error: 'channelId is required' });
+                return;
+            }
+            if (!filePath?.trim()) {
+                res.status(400).json({ error: 'x-openbot-file-path header is required' });
+                return;
+            }
+            const body = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
+            if (body.length === 0) {
+                res.status(400).json({ error: 'Request body is empty' });
+                return;
+            }
+            try {
+                const result = await storageService.uploadChannelFile({
+                    channelId: channelId.trim(),
+                    path: filePath.trim(),
+                    body,
+                    overwrite,
+                });
+                const url = buildWorkspaceFileUrl({
+                    baseUrl: resolvePublicBaseUrl(),
+                    channelId: channelId.trim(),
+                    filePath: result.path,
+                });
+                res.json({
+                    type: 'action:storage:upload-file:result',
+                    data: { success: true, ...result, url },
+                });
+            }
+            catch (error) {
+                res.status(400).json({
+                    type: 'action:storage:upload-file:result',
+                    data: {
+                        success: false,
+                        path: filePath,
+                        error: error instanceof Error ? error.message : 'Upload failed',
+                    },
+                });
+            }
+            return;
+        }
         const parseResult = publishEventSchema.safeParse(req.body);
         if (!parseResult.success) {
             res.status(400).json({
@@ -170,8 +264,77 @@ export async function startServer(options = {}) {
             res.status(400).json({ error: 'channelId is required' });
             return;
         }
+        if (event.type === 'action:storage:write-file') {
+            const data = (event.data ?? {});
+            if (!data.path?.trim()) {
+                res.status(400).json({
+                    type: 'action:storage:write-file:result',
+                    data: { success: false, path: '', error: 'path is required' },
+                });
+                return;
+            }
+            if (typeof data.content !== 'string') {
+                res.status(400).json({
+                    type: 'action:storage:write-file:result',
+                    data: { success: false, path: data.path, error: 'content is required' },
+                });
+                return;
+            }
+            try {
+                const result = await storageService.writeChannelFile({
+                    channelId,
+                    path: data.path.trim(),
+                    content: data.content,
+                    encoding: data.encoding ?? 'utf8',
+                    overwrite: data.overwrite ?? false,
+                });
+                const url = buildWorkspaceFileUrl({
+                    baseUrl: resolvePublicBaseUrl(),
+                    channelId,
+                    filePath: result.path,
+                });
+                res.json({
+                    type: 'action:storage:write-file:result',
+                    data: { success: true, ...result, url },
+                });
+            }
+            catch (error) {
+                res.status(400).json({
+                    type: 'action:storage:write-file:result',
+                    data: {
+                        success: false,
+                        path: data.path,
+                        error: error instanceof Error ? error.message : 'Write failed',
+                    },
+                });
+            }
+            return;
+        }
+        // Stop request: cancel the in-flight run (and any delegated sub-agents in the
+        // same thread) instead of spinning up a new agent turn.
+        if (event.type === 'action:agent_run_stop') {
+            const data = (event.data ?? {});
+            const targetChannelId = data.channelId || channelId;
+            const targetThreadId = data.threadId || threadId;
+            const stopped = abortRegistry.abort(abortKey(targetChannelId, targetThreadId));
+            purgeActiveRunsForThread(targetChannelId, targetThreadId);
+            const stoppedEvent = {
+                type: 'agent:run:stopped',
+                data: {
+                    runId: data.runId || runId,
+                    agentId: data.agentId || agentId || ORCHESTRATOR_AGENT_ID,
+                    channelId: targetChannelId,
+                    threadId: targetThreadId,
+                    reason: data.reason,
+                },
+            };
+            ensureEventId(stoppedEvent);
+            sendToClientKey(getClientKey(targetChannelId, targetThreadId), stoppedEvent);
+            sendToClientKey(GLOBAL_CHANNEL_ID, stoppedEvent);
+            res.json({ success: stopped });
+            return;
+        }
         const onEvent = async (chunk, state) => {
-            ensureEventId(chunk);
             const targetChannelId = state?.channelId || channelId;
             const targetThreadId = state?.threadId || threadId;
             const targetClientKey = getClientKey(targetChannelId, targetThreadId);
@@ -186,11 +349,9 @@ export async function startServer(options = {}) {
             else if (chunk.type === 'agent:run:end') {
                 activeRuns.delete(getRunKey(chunk.data.runId, chunk.data.agentId, chunk.data.channelId, chunk.data.threadId));
             }
-            await storageService.storeEvent({
-                channelId: targetChannelId,
-                threadId: targetThreadId,
-                event: chunk,
-            });
+            else if (chunk.type === 'agent:run:stopped') {
+                purgeActiveRunsForThread(chunk.data.channelId, chunk.data.threadId);
+            }
             sendToClientKey(targetClientKey, chunk);
             if (chunk.type === 'agent:run:start' ||
                 chunk.type === 'agent:run:end' ||
@@ -200,12 +361,13 @@ export async function startServer(options = {}) {
         };
         try {
             ensureEventId(event);
-            await dispatch({
+            await runAgent({
                 runId,
-                agentId: agentId || 'system',
+                agentId: agentId || ORCHESTRATOR_AGENT_ID,
                 event,
                 channelId,
                 threadId,
+                publicBaseUrl: resolvePublicBaseUrl(),
                 onEvent,
             });
             res.sendStatus(200);
@@ -232,18 +394,47 @@ export async function startServer(options = {}) {
             return;
         }
         const { channelId, threadId, agentId, runId } = getContext(req);
+        if (event.type === 'action:storage:serve-file') {
+            const filePath = event.data?.path;
+            if (!channelId?.trim()) {
+                res.status(400).json({ error: 'channelId is required' });
+                return;
+            }
+            if (!filePath?.trim()) {
+                res.status(400).json({ error: 'path is required' });
+                return;
+            }
+            try {
+                const { abs, size, mimeType } = await storageService.getChannelFileStat({
+                    channelId,
+                    path: filePath.trim(),
+                });
+                res.setHeader('Content-Type', mimeType);
+                res.setHeader('Content-Length', String(size));
+                res.setHeader('Cache-Control', 'private, max-age=3600');
+                openChannelFileStream(abs).pipe(res);
+            }
+            catch (error) {
+                res.status(404).json({
+                    error: error instanceof Error ? error.message : 'File not found',
+                });
+            }
+            return;
+        }
         const events = [];
         const onEvent = async (chunk) => {
             events.push(chunk);
         };
         try {
             ensureEventId(event);
-            await dispatch({
+            await runAgent({
                 runId,
-                agentId: agentId || 'system',
+                agentId: agentId || STATE_AGENT_ID,
                 event,
                 channelId,
                 threadId,
+                persistEvents: false,
+                publicBaseUrl: resolvePublicBaseUrl(),
                 onEvent,
             });
             res.json({ events });

package/dist/bus/services.js

@@ -1,25 +1,6 @@
 import { DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig } from '../app/config.js';
 import { storageService } from '../services/storage.js';
 import { pluginService } from '../services/plugins.js';
-const readTodos = (state) => {
-    const raw = state.threadDetails?.state?.todos;
-    return Array.isArray(raw) ? raw : [];
-};
-let todoCounter = 0;
-const newTodoId = (now, idx) => `todo_${now.toString(36)}_${(todoCounter++).toString(36)}_${idx}`;
-async function persistTodos(storage, state, todos) {
-    if (!state.threadId)
-        throw new Error('No active thread');
-    await storage.patchThreadState({
-        channelId: state.channelId,
-        threadId: state.threadId,
-        state: { todos },
-    });
-    state.threadDetails = await storage.getThreadDetails({
-        channelId: state.channelId,
-        threadId: state.threadId,
-    });
-}
 /**
  * Resolve a scope alias to a concrete scope string. Aliases let tools accept
  * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
@@ -44,26 +25,7 @@ function resolveMemoryScopeFilter(alias, state) {
     }
     return [resolveMemoryScope(alias, state)];
 }
-const DEFAULT_MARKETPLACE_AGENTS = [
-    {
-        id: 'researcher',
-        name: 'Researcher',
-        description: 'Specialized in web research and information synthesis.',
-        instructions: 'You are a research assistant. Use available tools to find information.',
-        plugins: [
-            { id: 'ai-sdk', config: { model: 'openai/gpt-4o' } },
-            { id: 'mcp' },
-            { id: 'shell' },
-        ],
-    },
-    {
-        id: 'coder',
-        name: 'Coder',
-        description: 'Expert in multiple programming languages and software architecture.',
-        instructions: 'You are an expert software engineer. Help the user with coding tasks.',
-        plugins: [{ id: 'claude-code' }],
-    },
-];
+const DEFAULT_MARKETPLACE_AGENTS = [];
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -311,6 +273,15 @@ export const busServicesPlugin = (options) => (builder) => {
             context.state.channelDetails = await storage.getChannelDetails({
                 channelId: context.state.channelId,
             });
+            yield {
+                type: "client:ui:widget",
+                data: {
+                    kind: "message",
+                    title: "Channel details updated.",
+                    body: "The channel details have been updated.",
+                },
+                meta: resultMeta,
+            };
             yield {
                 type: 'action:patch_channel_details:result',
                 data: { success: true, updatedFields },
@@ -358,91 +329,30 @@ export const busServicesPlugin = (options) => (builder) => {
             };
         }
     });
-    builder.on('action:todo_write', async function* (event, context) {
-        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-        try {
-            if (!context.state.threadId) {
-                throw new Error('todo_write requires an active thread');
-            }
-            const existing = readTodos(context.state);
-            const byId = new Map(existing.map((t) => [t.id, t]));
-            const now = Date.now();
-            const author = context.state.agentId || 'system';
-            const inputs = event.data.todos || [];
-            const next = inputs.map((raw, idx) => {
-                const prior = raw.id ? byId.get(raw.id) : undefined;
-                return {
-                    id: prior?.id || raw.id || newTodoId(now, idx),
-                    content: raw.content,
-                    status: raw.status || prior?.status || 'pending',
-                    assignee: raw.assignee ?? prior?.assignee,
-                    createdBy: prior?.createdBy || author,
-                    createdAt: prior?.createdAt || now,
-                    updatedAt: now,
-                    ...(prior?.result !== undefined ? { result: prior.result } : {}),
-                };
-            });
-            await persistTodos(storage, context.state, next);
-            yield {
-                type: 'action:todo_write:result',
-                data: { success: true, todos: next },
-                meta: resultMeta,
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:todo_write:result',
-                data: {
-                    success: false,
-                    todos: readTodos(context.state),
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-                meta: resultMeta,
-            };
-        }
-    });
-    builder.on('action:todo_update', async function* (event, context) {
-        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
-        const patch = event.data;
-        try {
-            if (!context.state.threadId) {
-                throw new Error('todo_update requires an active thread');
-            }
-            const existing = readTodos(context.state);
-            const idx = existing.findIndex((t) => t.id === patch.id);
-            if (idx === -1) {
-                throw new Error(`Todo "${patch.id}" not found`);
-            }
-            const now = Date.now();
-            const updated = {
-                ...existing[idx],
-                ...(patch.content !== undefined ? { content: patch.content } : {}),
-                ...(patch.status !== undefined ? { status: patch.status } : {}),
-                ...(patch.assignee !== undefined
-                    ? { assignee: patch.assignee === '' ? undefined : patch.assignee }
-                    : {}),
-                updatedAt: now,
-            };
-            const next = [...existing];
-            next[idx] = updated;
-            await persistTodos(storage, context.state, next);
-            yield {
-                type: 'action:todo_update:result',
-                data: { success: true, todo: updated, todos: next },
-                meta: resultMeta,
-            };
-        }
-        catch (error) {
-            yield {
-                type: 'action:todo_update:result',
-                data: {
-                    success: false,
-                    todos: readTodos(context.state),
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                },
-                meta: resultMeta,
-            };
-        }
+    builder.on('agent:usage', async function* (event, context) {
+        const { usage } = event.data;
+        if (!context.state.threadId)
+            return;
+        const currentState = context.state.threadDetails?.state || {};
+        const currentUsage = currentState.usage || {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+        };
+        const nextUsage = {
+            promptTokens: (currentUsage.promptTokens || 0) + usage.promptTokens,
+            completionTokens: (currentUsage.completionTokens || 0) + usage.completionTokens,
+            totalTokens: (currentUsage.totalTokens || 0) + usage.totalTokens,
+        };
+        await storage.patchThreadState({
+            channelId: context.state.channelId,
+            threadId: context.state.threadId,
+            state: { usage: nextUsage },
+        });
+        context.state.threadDetails = await storage.getThreadDetails({
+            channelId: context.state.channelId,
+            threadId: context.state.threadId,
+        });
     });
     builder.on('action:storage:get-channels', async function* () {
         const channels = await storage.getChannels();