@meetopenbot/openbot 1.7.0 → 1.8.0

package/dist/build-tools.js

@@ -3,6 +3,7 @@ import { todoTools } from "./tools/todo.js";
 import { storageTools } from "./tools/storage.js";
 import { startThreadTools } from "./tools/start-thread.js";
 import { askAgentTools } from "./tools/ask-agent.js";
+import { askUserTools } from "./tools/ask-user.js";
 import { installAgentTools } from "./tools/install-agent.js";
 import { threadStatusTools } from "./tools/thread-status.js";
 import { threadTitleTools } from "./tools/thread-title.js";
@@ -22,6 +23,7 @@ export function buildOpenbotTools(args) {
         ...storageTools,
         ...startThreadTools,
         ...askAgentTools,
+        ...askUserTools,
         ...installAgentTools,
         ...threadStatusTools,
         ...threadTitleTools,

package/dist/runtime.js

@@ -299,6 +299,21 @@ export async function* runOpenbotTurn(args, options) {
             });
             systemPrompt = `${await buildSystemPrompt(state, storage, instructions, host)}\n\n${FAST_FORWARD_CLOSE_HINT}`;
         }
+        // Messages the human sent while this run is going. They join the conversation
+        // before the next model step, like a reply typed between tool calls, and stay in
+        // it for every later step (and a retry on another model).
+        const steered = [];
+        const takeSteering = !surface && !args.event?.meta?.parentToolCallId ? host.takeSteeringMessages : undefined;
+        const prepareStep = takeSteering
+            ? ({ messages }) => {
+                const known = new Set([...events, ...steered].map((event) => event.id).filter(Boolean));
+                const fresh = takeSteering().filter((event) => !event.id || !known.has(event.id));
+                if (fresh.length === 0)
+                    return undefined;
+                steered.push(...fresh);
+                return { messages: [...messages, ...eventsToModelMessages(fresh)] };
+            }
+            : undefined;
         let lastError;
         let started = false;
         for (let i = 0; i < candidates.length; i++) {
@@ -311,7 +326,7 @@ export async function* runOpenbotTurn(args, options) {
             };
             const tools = toAiTools(toolDefinitions, args, flushPendingOutput);
             try {
-                let messages = eventsToModelMessages(events);
+                let messages = eventsToModelMessages([...events, ...steered]);
                 if (hasAttachments) {
                     const includeImages = modelSupportsImages(candidate, { authMode });
                     messages = await addAttachmentParts(messages, events, {
@@ -330,6 +345,7 @@ export async function* runOpenbotTurn(args, options) {
                     reasoning: reasoningForModel(candidate),
                     stopWhen: surface ? [stepCountIs(8), hasToolCall(RESPOND_TOOL)] : stepCountIs(20),
                     allowSystemInMessages: true,
+                    ...(prepareStep ? { prepareStep } : {}),
                 });
                 for await (const part of result.fullStream) {
                     if (abortSignal?.aborted)

package/dist/system-prompt.js

@@ -4,12 +4,13 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "",
     "# SECURITY POLICY",
     "- **CRITICAL**: Never ask for API keys, passwords, or sensitive credentials in chat or through form widgets; values must never enter your context.",
-    "- **Credential Guidance**: Only ask for a variable after a specialist or tool actually reports it missing. Then call `request_variables` once with every exact name it reported (backend and build-time `VITE_*` alike), each with a short hint. The human fills them in an inline card that saves straight to Space variables and resumes this thread — do not also link to Settings or list the names as links. Never guess, invent, or name an API key or provider that no agent or tool reported.",
+    "- **Credential Guidance**: Only ask for a variable after a specialist or tool actually reports it missing. Then call `request_variables` once with every exact name it reported (backend and build-time `VITE_*` alike), each with a short hint. The human fills them in an inline card that saves straight to Space variables; your run waits on the card and continues once they are saved — do not also link to Settings or list the names as links. Never guess, invent, or name an API key or provider that no agent or tool reported.",
     "",
     "# CORE MISSION",
     "You are a high-level manager. Not every message is project work.",
     "- Answer questions, listings, setup, and status directly from `## SPACES`, `## INSTALLED AGENTS`, and `## AVAILABLE AGENTS`. Do not create a Space to look anything up.",
     "- For real project work (build, code, design, ops) you decide **who** (which installed agent), then ask that agent in the current Space, close without restating their work, and keep todos current.",
+    "- A quick question gets a plain answer and no todo list. A task gets a todo list first; the human follows progress there, not in your messages.",
     "",
     "# THE AGENT LOOP",
     "You operate in an iterative loop:",
@@ -17,19 +18,26 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "2. **Right Space**: Every Space, `#general` included, is a place to do work. Do it in the current Space by default. Only if the human's request clearly belongs to a different existing Space from `## SPACES` — for example it names that project — explain in text which Space it belongs in and why. Then either wait for the human to continue there, or — when the request is clear enough to act on — call `start_thread` to open a thread in that Space with their request, written in their own first-person voice because it is posted as them; the human approves it before it starts. Never start a thread in the Space you are already in. Otherwise continue here with `ask_agent`. Create a new Space only when the human named one or explicitly asked for it. Never invent placeholder ids (`noop`, `temp`, `misc`, `untitled`).",
     "3. **Ask people**: Use `ask_agent` to send a message to a specialist. Write it as a request to a colleague, not as a tool invocation.",
     "4. **Wait**: Let the asked agent run in its own harness. Read their reply, then continue or ask someone else.",
-    "5. **Close**: The human already saw the specialist speak in this thread. Do not restate, re-bullet, or paraphrase their findings. Name who you asked, then add only what is new — a decision, a conflict, a next step, or a caveat. If nothing is new, close in one or two sentences.",
+    "5. **Close**: Write one short final message when the task is done or blocked. The human already saw the specialist speak in this thread. Do not restate, re-bullet, or paraphrase their findings. Name who you asked, then add only what is new — a decision, a conflict, a next step, or a caveat. If nothing is new, close in one or two sentences. Never post progress recaps between steps; the todo list shows progress.",
     "6. **Enter Standby**: Idle until the next human message.",
+    "- The human can write while you work. Their message shows up in the conversation between your steps: read it, adjust the plan or the next ask to fit, and keep going. If they ask you to stop or change course, do that first.",
     "",
     "# TASK TRACKING (TODOS)",
     "- For any complex multi-step task (3+ steps), you **MUST** maintain a todo list with `todo_write`.",
     "- Write the full intended list at task start. Each call replaces the previous list (not a partial patch).",
-    "- Keep exactly one item `in_progress` while working. Mark items `completed` immediately after finishing them.",
+    "- Mark an item `in_progress` while it is being worked on; when you ask several agents at once, each of their items is `in_progress`. Mark items `completed` immediately after finishing them.",
+    "- Each item is usually one `ask_agent` call. Mark it `in_progress` before you ask, and keep the same list across turns — update it, never start a second one.",
     "- Use `cancelled` for steps that are no longer needed. When the overall task is done, mark all items `completed` and leave the list intact (do not clear with empty `items`).",
     "- The current list is injected into context each turn as `## TODOS`; call `todo_read` only if you need an explicit refresh.",
     "- Do not stop with open `pending` or `in_progress` items unless you are blocked and have told the user why.",
     "",
+    "# ASKING THE HUMAN",
+    "- One way to ask: when a step needs a decision or answer from the human, call `ask_user`. It shows a card, pauses your run, and returns their answer, so you continue the same step. Never ask a blocking question in prose and never continue past it.",
+    "- Missing variables go through `request_variables`, which also waits. Missing agent accounts are the host's job: the host shows the connect card and the asked agent waits for it. Do not ask the human to connect or to paste keys for an agent that is already connected.",
+    "- Ask once. If an answer or card is already pending, wait for it instead of asking again.",
+    "",
     "# WIDGETS",
-    "- Call `render_widget` when your own answer is structured: 3+ similar records (Spaces, agents, options, statuses), a side-by-side comparison, a decision with fixed choices, or a few fields you need from the human. Use plain text for everything else.",
+    "- Call `render_widget` when your own answer is structured: 3+ similar records (Spaces, agents, options, statuses) or a side-by-side comparison. Use plain text for everything else. Decisions go through `ask_user`, not `render_widget`.",
     "- Never use it to restate or re-format what a specialist already said in this thread; that rule from Close still applies.",
     "- Do not repeat the widget's contents in text. A click or form submission arrives as the human's next message, quoting what they picked.",
     "- Forms never ask for secrets; use `request_variables` for those.",
@@ -42,7 +50,7 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "# JOB STATUS",
     "- Every thread is a job. Status is `working` (in progress), `needs_input`, `ready_for_review`, `completed`, or `archived`.",
     "- Status is the job's workflow state, not whether an agent is currently executing.",
-    "- When you need a blocking answer from the human, call `set_thread_status` with `needs_input` and a short `reason`.",
+    "- `ask_user`, `request_variables`, and connect cards set `needs_input` while they wait; do not set it yourself for those.",
     "- When you believe the job is done, set `ready_for_review`. Never set `completed` or `archived` — only the human can.",
     "- The current status is injected each turn as `## THREAD STATUS`.",
     "",

package/dist/tools/ask-agent.js

@@ -21,16 +21,24 @@ export const toolDefinitions = {
         }),
     },
 };
-/** The host's connect card: the asked agent has no account yet and did not run. */
-function connectionRequestName(event) {
+/**
+ * The host's connect card: the asked agent has no account yet. Newer runtimes
+ * wait on the card and close it once connected; `open` is false from then on.
+ */
+function connectionCard(event) {
     if (event.type !== "client:ui:widget")
         return undefined;
-    const metadata = event.data?.metadata;
+    const data = event.data;
+    const metadata = data?.metadata;
     if (metadata?.type !== "connection_request")
         return undefined;
     // `pluginName` is what runtimes before scoped connections send.
     const name = metadata.name ?? metadata.pluginName;
-    return typeof name === "string" ? name : "This agent";
+    return {
+        widgetId: data?.widgetId ?? "",
+        name: typeof name === "string" ? name : "This agent",
+        open: !data?.state || data.state === "open",
+    };
 }
 async function runAskedAgent(ctx, args) {
     if (ctx.agentId !== ctx.host.orchestratorAgentId) {
@@ -61,7 +69,8 @@ async function runAskedAgent(ctx, args) {
     }
     const runId = `ask_${randomUUID()}`;
     let lastAgentOutput = "";
-    let needsConnection;
+    // Latest state of each connect card the asked agent showed, by widgetId.
+    const connectCards = new Map();
     const eventQueue = [];
     let resolveNext = null;
     let isFinished = false;
@@ -99,7 +108,9 @@ async function runAskedAgent(ctx, args) {
             if (outEvent.type === "agent:output") {
                 lastAgentOutput = outEvent.data.content;
             }
-            needsConnection ?? (needsConnection = connectionRequestName(outEvent));
+            const card = connectionCard(outEvent);
+            if (card)
+                connectCards.set(card.widgetId, card);
             if (resolveNext) {
                 resolveNext();
                 resolveNext = null;
@@ -128,8 +139,10 @@ async function runAskedAgent(ctx, args) {
         }
     }
     await runPromise;
+    // A card still open when the run ended means the agent never got its account.
+    const needsConnection = [...connectCards.values()].find((card) => card.open)?.name;
     if (needsConnection) {
-        const output = `${needsConnection} is not connected yet, so it did not run. The human now sees a ` +
+        const output = `${needsConnection} is not connected yet, so it did not run. The human sees a ` +
             "card to connect it; once they do, the conversation continues on its own. " +
             "Do not ask them for keys or retry; say in one short line that it needs connecting.";
         return { success: false, needsConnection: true, error: output, output };

package/dist/tools/ask-user.js

@@ -0,0 +1,77 @@
+import z from 'zod';
+import { requestQuestion } from '@meetopenbot/plugin-sdk';
+/**
+ * `ask_user` — OpenBot asks the human one question and waits for the answer.
+ * The run pauses on the card (thread status `needs_input`) and the answer is
+ * the tool result, so the plan continues from the same step.
+ */
+const MAX_OPTIONS = 6;
+export const toolDefinitions = {
+    ask_user: {
+        description: 'Ask the human one question and wait for their answer before continuing. Use it for a decision the next step depends on (e.g. test or live mode, which option to pick). Give 2-6 short options for a choice; omit options for a free-text answer. Never ask the same question in prose.',
+        inputSchema: z.object({
+            question: z.string().min(1).describe('The question, one short sentence.'),
+            description: z.string().optional().describe('Optional one-line context under the question.'),
+            options: z
+                .array(z.string().min(1).max(40))
+                .max(MAX_OPTIONS)
+                .optional()
+                .describe('Button labels, recommended option first. Omit for a free-text answer.'),
+        }),
+    },
+};
+async function askUser(rawArgs, ctx) {
+    const args = (rawArgs ?? {});
+    const question = args.question?.trim();
+    if (!question) {
+        const message = 'Pass the question to ask.';
+        return { success: false, error: message, output: message };
+    }
+    const options = [...new Set((args.options ?? []).map((option) => option.trim()).filter(Boolean))].slice(0, MAX_OPTIONS);
+    const description = args.description?.trim() || undefined;
+    const hitl = {
+        emit: ctx.emit,
+        host: ctx.host,
+        abortSignal: ctx.abortSignal,
+        agentId: ctx.agentId,
+        threadId: ctx.threadId ?? ctx.state.threadId,
+        channelId: ctx.channelId ?? ctx.state.channelId,
+        storage: ctx.storage,
+    };
+    try {
+        const response = options.length > 0
+            ? await requestQuestion({
+                ...hitl,
+                title: question,
+                description,
+                actions: options.map((label, index) => ({
+                    id: label,
+                    label,
+                    variant: index === 0 ? 'primary' : 'secondary',
+                })),
+            })
+            : await requestQuestion({
+                ...hitl,
+                title: question,
+                description,
+                fields: [{ id: 'answer', label: question, type: 'textarea', required: true }],
+            });
+        const answer = options.length > 0 ? response.actionId : String(response.values?.answer ?? '').trim();
+        if (!answer || response.actionId === 'deny') {
+            const output = 'The human dismissed the question without answering.';
+            return { success: false, error: output, output };
+        }
+        return { success: true, answer, output: `The human answered: ${answer}` };
+    }
+    catch {
+        const output = 'The run stopped before the human answered.';
+        return { success: false, error: output, output };
+    }
+}
+export const tools = {
+    ask_user: {
+        ...toolDefinitions.ask_user,
+        execute: askUser,
+    },
+};
+export const askUserTools = tools;

package/dist/tools/todo-items.js

@@ -0,0 +1,43 @@
+/** Todo list shape and validation; no I/O, so it loads without the build. */
+export const MAX_TODO_ITEMS = 20;
+const TODO_STATUSES = new Set([
+    'pending',
+    'in_progress',
+    'completed',
+    'cancelled',
+]);
+/**
+ * Validate and normalize a todo list write. Throws on invalid input.
+ * Enforces: non-empty content, known statuses, unique ids, max size.
+ * Several items may be `in_progress`: steps asked in parallel run together.
+ */
+export function validateTodoItems(items) {
+    if (!Array.isArray(items)) {
+        throw new Error('todos must be an array');
+    }
+    if (items.length > MAX_TODO_ITEMS) {
+        throw new Error(`At most ${MAX_TODO_ITEMS} todos allowed`);
+    }
+    const seen = new Set();
+    const normalized = [];
+    for (const raw of items) {
+        if (!raw || typeof raw !== 'object') {
+            throw new Error('Each todo must be an object');
+        }
+        const id = typeof raw.id === 'string' ? raw.id.trim() : '';
+        const content = typeof raw.content === 'string' ? raw.content.trim() : '';
+        const status = raw.status;
+        if (!id)
+            throw new Error('Each todo requires a non-empty id');
+        if (!content)
+            throw new Error(`Todo "${id}" requires non-empty content`);
+        if (!TODO_STATUSES.has(status)) {
+            throw new Error(`Todo "${id}" has invalid status "${String(status)}"; expected pending|in_progress|completed|cancelled`);
+        }
+        if (seen.has(id))
+            throw new Error(`Duplicate todo id "${id}"`);
+        seen.add(id);
+        normalized.push({ id, content, status: status });
+    }
+    return normalized;
+}

package/dist/tools/todo-service.js

@@ -1,13 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { DEFAULT_CHANNELS_DIR, getBaseDir, resolvePath } from '../utils/paths.js';
-export const MAX_TODO_ITEMS = 20;
-const TODO_STATUSES = new Set([
-    'pending',
-    'in_progress',
-    'completed',
-    'cancelled',
-]);
+import { MAX_TODO_ITEMS, validateTodoItems } from './todo-items.js';
+export { MAX_TODO_ITEMS, validateTodoItems };
 const getThreadDir = (channelId, threadId) => {
     const base = resolvePath(path.join(getBaseDir(), DEFAULT_CHANNELS_DIR, channelId));
     return path.join(base, 'threads', threadId);
@@ -17,47 +12,6 @@ const emptyList = () => ({
     items: [],
     updatedAt: new Date().toISOString(),
 });
-/**
- * Validate and normalize a todo list write. Throws on invalid input.
- * Enforces: non-empty content, known statuses, unique ids, max size,
- * and at most one `in_progress` item.
- */
-export function validateTodoItems(items) {
-    if (!Array.isArray(items)) {
-        throw new Error('todos must be an array');
-    }
-    if (items.length > MAX_TODO_ITEMS) {
-        throw new Error(`At most ${MAX_TODO_ITEMS} todos allowed`);
-    }
-    const seen = new Set();
-    let inProgressCount = 0;
-    const normalized = [];
-    for (const raw of items) {
-        if (!raw || typeof raw !== 'object') {
-            throw new Error('Each todo must be an object');
-        }
-        const id = typeof raw.id === 'string' ? raw.id.trim() : '';
-        const content = typeof raw.content === 'string' ? raw.content.trim() : '';
-        const status = raw.status;
-        if (!id)
-            throw new Error('Each todo requires a non-empty id');
-        if (!content)
-            throw new Error(`Todo "${id}" requires non-empty content`);
-        if (!TODO_STATUSES.has(status)) {
-            throw new Error(`Todo "${id}" has invalid status "${String(status)}"; expected pending|in_progress|completed|cancelled`);
-        }
-        if (seen.has(id))
-            throw new Error(`Duplicate todo id "${id}"`);
-        seen.add(id);
-        if (status === 'in_progress')
-            inProgressCount += 1;
-        normalized.push({ id, content, status: status });
-    }
-    if (inProgressCount > 1) {
-        throw new Error('At most one todo may be in_progress');
-    }
-    return normalized;
-}
 export const todoService = {
     getTodos: async (args) => {
         const filePath = getTodosPath(args.channelId, args.threadId);

package/dist/tools/todo.js

@@ -35,8 +35,8 @@ function todoListWidget(args) {
     return {
         type: 'client:ui:widget',
         data: {
-            // One widget per agent run — repeated todo_write calls update in place.
-            widgetId: `todos:${args.runId}`,
+            // One plan per thread — every todo_write, in any run, updates it in place.
+            widgetId: `todos:${args.threadId}`,
             kind: 'list',
             layout: 'checklist',
             title: 'Todos',
@@ -51,11 +51,11 @@ const todoItemSchema = z.object({
     content: z.string().min(1).describe('Short imperative description of the step.'),
     status: z
         .enum(['pending', 'in_progress', 'completed', 'cancelled'])
-        .describe('Todo status. At most one item may be in_progress.'),
+        .describe('Todo status. Every step being worked on is in_progress, including steps run in parallel.'),
 });
 export const toolDefinitions = {
     todo_write: {
-        description: 'Replace the current thread todo list with the provided items. Use for multi-step tasks: write the plan first, keep exactly one item in_progress while working, mark items completed immediately after finishing, and when done leave all items as completed (do not clear the list). Pass the full intended list each call (not a partial patch).',
+        description: 'Replace the current thread todo list with the provided items. Use for multi-step tasks: write the plan first, mark each step in_progress while it is being worked on (several when they run in parallel), mark items completed immediately after finishing, and when done leave all items as completed (do not clear the list). Pass the full intended list each call (not a partial patch).',
         inputSchema: z.object({
             items: z
                 .array(todoItemSchema)
@@ -81,16 +81,13 @@ export const tools = {
                 const items = (rawArgs ?? {}).items;
                 const list = await todoService.writeTodos({ channelId, threadId, items });
                 const runId = ctx.runId ?? ctx.state.runId;
-                if (!runId) {
-                    throw new Error('Missing runId for todo_write widget');
-                }
                 await ctx.emit(todoListWidget({
-                    runId,
+                    threadId,
                     list,
                     meta: {
                         agentId: ctx.agentId,
                         threadId,
-                        runId,
+                        ...(runId ? { runId } : {}),
                         toolCallId: ctx.toolCallId,
                     },
                 }));

package/dist/tools/variables-request.js

@@ -1,4 +1,5 @@
 import z from 'zod';
+import { markThreadNeedsInput, restoreThreadWorking } from '@meetopenbot/plugin-sdk';
 /** `metadata.type` of the card the host shows to collect missing variables. */
 export const VARIABLES_REQUEST_TYPE = 'variables_request';
 const ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -63,22 +64,70 @@ async function requestVariables(rawArgs, ctx) {
         const message = 'Pass at least one variable name such as FIREBASE_PROJECT_ID.';
         return { success: false, error: message, output: message };
     }
-    await ctx.emit(variablesRequestEvent({
+    const card = variablesRequestEvent({
         variables,
         reason: typeof data.reason === 'string' ? data.reason : undefined,
         agentId: ctx.agentId,
         threadId,
-    }));
+    });
+    await ctx.emit(card);
+    const names = variables.map((variable) => variable.key).join(', ');
+    if (ctx.host?.resumesCardsInPlace)
+        return waitForVariables(ctx, card, names);
     return {
         success: true,
         output: 'Shown a card asking the human for ' +
-            variables.map((variable) => variable.key).join(', ') +
+            names +
             '. They save the values there; you will get a message when they do. Do not ask them to paste values in chat.',
     };
 }
+/**
+ * Hold the run on the card until the human saves every key. The runtime's
+ * variables route resolves the wait and sends the closed card's body back.
+ * If the run stops first the card stays open: saving later resumes the thread
+ * with a message, also after a restart.
+ */
+async function waitForVariables(ctx, card, names) {
+    const data = card.data;
+    const hitl = {
+        emit: ctx.emit,
+        host: ctx.host,
+        agentId: ctx.agentId,
+        channelId: ctx.channelId ?? ctx.state.channelId,
+        threadId: ctx.threadId ?? ctx.state.threadId,
+        storage: ctx.storage,
+    };
+    const paused = await markThreadNeedsInput(hitl, `Add ${names}`);
+    let response;
+    try {
+        response = await ctx.host.awaitWidgetResponse(data.widgetId, ctx.abortSignal, { resumable: true });
+    }
+    catch {
+        // The card stays open and the thread stays `needs_input`; saving later resumes it.
+        const output = `The run stopped before ${names} were saved. The card stays open; saving it continues the thread.`;
+        return { success: false, error: output, output };
+    }
+    const body = typeof response.metadata?.body === 'string' ? response.metadata.body : `Saved ${names}.`;
+    const scope = response.metadata?.scope;
+    await ctx.emit({
+        ...card,
+        data: {
+            ...data,
+            state: 'submitted',
+            body,
+            metadata: { ...data.metadata, ...(scope ? { scope } : {}) },
+        },
+    });
+    if (paused)
+        await restoreThreadWorking(hitl);
+    return {
+        success: true,
+        output: `${body} They are in the environment now; ask the specialist to restart whatever needed them.`,
+    };
+}
 export const toolDefinitions = {
     request_variables: {
-        description: 'Ask the human for missing environment variables with an inline card in the thread. Values are saved as Space variables by default (or for all spaces if they choose) and never appear in chat. Pass every missing name at once, including build-time ones like VITE_*.',
+        description: 'Ask the human for missing environment variables with an inline card in the thread, and wait until they are saved. Values are saved as Space variables by default (or for all spaces if they choose) and never appear in chat. Pass every missing name at once, including build-time ones like VITE_*.',
         inputSchema: z.object({
             variables: z
                 .array(z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "@ai-sdk/openai": "^4.0.72",
     "ai": "^7.0.111",
     "zod": "^4.3.5",
-    "@meetopenbot/plugin-sdk": "^2.3.0"
+    "@meetopenbot/plugin-sdk": "^2.4.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",