@ema.co/mcp-toolkit 2026.2.24 → 2026.2.27-2

package/dist/mcp/guidance.js

@@ -366,6 +366,44 @@ export const TOOL_GUIDANCE = {
         ],
         applicableRules: [],
     },
+    template: {
+        toolName: "template",
+        quickTip: "Manage persona templates (blueprints for AI Employees). List, create, update, delete templates.",
+        operations: [
+            {
+                name: "List templates",
+                description: "Browse available persona templates",
+                example: 'template(method="list")',
+            },
+            {
+                name: "Get template",
+                description: "Get full details for a template",
+                example: 'template(method="get", id="...")',
+            },
+            {
+                name: "Create template",
+                description: "Create a new persona template",
+                example: 'template(method="create", name="My Template", type="voice")',
+            },
+            {
+                name: "Delete template",
+                description: "Delete a persona template",
+                example: 'template(method="delete", id="...", confirm=true)',
+            },
+        ],
+        nextSteps: {
+            list: "Get details: template(method='get', id='<id>')",
+            get: "Create persona from template: persona(method='create', from='<template_id>', name='...')",
+            create: "View template: template(method='get', id='<template_id>')",
+            update: "Verify changes: template(method='get', id='<template_id>')",
+            delete: "Template removed. List remaining: template(method='list')",
+        },
+        commonMistakes: [
+            "Deleting a template without confirm=true",
+            "Using template tool for read-only browsing when catalog tool would suffice",
+        ],
+        applicableRules: [],
+    },
     debug: {
         toolName: "debug",
         quickTip: "Inspect workflow executions and audit conversations. Follow the drill-down: conversations → detail → show_work → action_detail.",
@@ -486,6 +524,15 @@ Use the \`debug\` tool to inspect workflow runs and troubleshoot issues:
 3. \`debug(method="action_detail", ...)\` → deep trace with LLM calls, inputs/outputs
 Also available as persona sub-resource: \`persona(id="abc", debug={method:"conversations"})\`
 
+## Template Management
+Use the \`template\` tool to create, browse, update, and delete persona templates (blueprints for AI Employees):
+- \`template(method="list")\` → browse available templates
+- \`template(method="get", id="...")\` → get full template details
+- \`template(method="create", name="...", type="chat", proto_config={...})\` → create new template
+- \`template(method="update", id="...", name="...")\` → update template
+- \`template(method="delete", id="...", confirm=true)\` → delete template
+For read-only browsing, \`catalog(type="templates")\` also works.
+
 ## Resources
 - \`ema://docs/usage-guide\` - Complete guide
 - \`ema://docs/debugging-guide\` - Debugging workflow executions

package/dist/mcp/handlers/conversation/adapter.js

@@ -0,0 +1,13 @@
+/**
+ * Conversation Adapter
+ *
+ * Thin adapter that resolves client from env and delegates to handleConversation.
+ * Same pattern as debug/adapter.ts.
+ */
+import { handleConversation } from "./index.js";
+export async function handleConversationAdapter(args, createClient, getDefaultEnvName) {
+    const targetEnv = args.env ?? getDefaultEnvName();
+    // createClient() returns EmaClientAdapter at runtime (see env/config.ts)
+    const client = createClient(targetEnv);
+    return handleConversation(args, client);
+}

package/dist/mcp/handlers/conversation/create.js

@@ -0,0 +1,19 @@
+import { formatCreateResponse } from "./formatters.js";
+/**
+ * Create a new chat conversation for a persona.
+ * Returns the conversation ID and welcome message.
+ */
+export async function handleCreate(args, client) {
+    const personaId = args.persona_id;
+    if (!personaId) {
+        return {
+            error: "persona_id is required",
+            hint: 'conversation(method="create", persona_id="<uuid>")',
+        };
+    }
+    const result = await client.createConversation(personaId, {
+        userContext: args.user_context,
+        caller: args.caller ?? "mcp-toolkit",
+    });
+    return formatCreateResponse(result);
+}

package/dist/mcp/handlers/conversation/delete.js

@@ -0,0 +1,18 @@
+export async function handleDelete(args, client) {
+    const conversationId = args.conversation_id;
+    if (!conversationId) {
+        return { error: "Missing required parameter: conversation_id" };
+    }
+    const confirm = args.confirm;
+    if (confirm !== true) {
+        return {
+            error: "Deletion requires confirm=true",
+            _tip: `To delete conversation ${conversationId}, call conversation(method='delete', conversation_id='${conversationId}', confirm=true)`,
+        };
+    }
+    await client.deleteConversation(conversationId);
+    return {
+        success: true,
+        deleted_conversation_id: conversationId,
+    };
+}

package/dist/mcp/handlers/conversation/formatters.js

@@ -0,0 +1,62 @@
+/**
+ * Conversation response formatters.
+ *
+ * Shapes raw API responses into agent-friendly output with _tip / _next_step hints.
+ */
+const MAX_MESSAGE_PREVIEW = 2000;
+/**
+ * Truncate a string to max length with ellipsis.
+ */
+function truncate(value, max = MAX_MESSAGE_PREVIEW) {
+    const str = typeof value === "string" ? value : JSON.stringify(value) ?? "";
+    return str.length > max ? str.slice(0, max) + "..." : str;
+}
+export function formatCreateResponse(result) {
+    return {
+        conversation_id: result.conversationId,
+        welcome_message: result.message,
+        _next_step: `conversation(method="send", conversation_id="${result.conversationId}", text="your message here")`,
+        _tip: "Send a text message to start the conversation. The AI Employee will respond with its workflow output.",
+    };
+}
+export function formatSendResponse(result) {
+    const msg = result.message;
+    const msgType = msg?.type ?? "unknown";
+    const response = {
+        conversation_id: result.conversationId,
+        message: result.message,
+        snippets: result.snippets,
+    };
+    // Provide contextual next-step based on response message type
+    if (msgType.includes("BUTTONS")) {
+        response._tip = "The AI responded with buttons. Select one using the buttons parameter.";
+        response._next_step = `conversation(method="send", conversation_id="${result.conversationId}", buttons={selected_button:{label:"<button label>"}})`;
+    }
+    else if (msgType.includes("FORM")) {
+        response._tip = "The AI responded with a form. Echo back the entire formMessage with values filled in using raw_message. The form param only works for cancellation.";
+        response._next_step = `conversation(method="send", conversation_id="${result.conversationId}", original_message_id="<bot_msg_id>", raw_message={type:"MESSAGE_TYPE_FORM", formMessage:{...formMessage from response with values filled...}, isUserMessage:true})`;
+    }
+    else {
+        response._tip = "Check message for the AI's reply. Use method='history' to review the full thread.";
+        response._next_step = `conversation(method="history", conversation_id="${result.conversationId}")`;
+    }
+    return response;
+}
+export function formatHistoryResponse(conversationId, result) {
+    const messages = result.messages.map((m) => {
+        const text = m.textMessage;
+        const contents = text?.contents;
+        return {
+            ...m,
+            // Add a preview field for quick scanning
+            ...(contents?.[0] && { _preview: truncate(contents[0], 200) }),
+        };
+    });
+    return {
+        conversation_id: conversationId,
+        message_count: messages.length,
+        messages,
+        _tip: "Messages are in chronological order. Use method='send' to continue the conversation.",
+        _next_step: `conversation(method="send", conversation_id="${conversationId}", text="your reply")`,
+    };
+}

package/dist/mcp/handlers/conversation/history.js

@@ -0,0 +1,15 @@
+import { formatHistoryResponse } from "./formatters.js";
+/**
+ * Retrieve the message history for a conversation.
+ */
+export async function handleHistory(args, client) {
+    const conversationId = args.conversation_id;
+    if (!conversationId) {
+        return {
+            error: "conversation_id is required",
+            hint: 'conversation(method="history", conversation_id="<uuid>")',
+        };
+    }
+    const result = await client.getConversationHistory(conversationId);
+    return formatHistoryResponse(conversationId, result);
+}

package/dist/mcp/handlers/conversation/index.js

@@ -0,0 +1,43 @@
+import { handleCreate } from "./create.js";
+import { handleSend } from "./send.js";
+import { handleHistory } from "./history.js";
+import { handleList } from "./list.js";
+import { handleMessages } from "./messages.js";
+import { handleDelete } from "./delete.js";
+import { handleRename } from "./rename.js";
+const METHOD_HANDLERS = {
+    create: handleCreate,
+    send: handleSend,
+    history: handleHistory,
+    list: handleList,
+    messages: handleMessages,
+    delete: handleDelete,
+    rename: handleRename,
+};
+/**
+ * Top-level conversation handler.
+ * Routes to method-specific handlers based on the `method` parameter.
+ */
+export async function handleConversation(args, client) {
+    const method = args.method;
+    if (!method) {
+        return {
+            error: "method is required",
+            valid_methods: Object.keys(METHOD_HANDLERS),
+            examples: [
+                'conversation(method="create", persona_id="...") - start a live chat session',
+                'conversation(method="send", conversation_id="...", text="hello") - send a message',
+                'conversation(method="history", conversation_id="...") - view messages',
+            ],
+            _tip: "Start with method='create' to open a new chat session with a persona.",
+        };
+    }
+    const handler = METHOD_HANDLERS[method];
+    if (!handler) {
+        return {
+            error: `Unknown method: ${method}`,
+            valid_methods: Object.keys(METHOD_HANDLERS),
+        };
+    }
+    return handler(args, client);
+}

package/dist/mcp/handlers/conversation/list.js

@@ -0,0 +1,40 @@
+export async function handleList(args, client) {
+    const personaId = args.persona_id;
+    if (personaId) {
+        // List conversations for a specific persona
+        const limit = args.limit;
+        const paginationToken = args.pagination_token;
+        const result = await client.listConversationsForPersona(personaId, {
+            limit,
+            paginationToken,
+        });
+        const conversations = result.conversations ?? result;
+        const count = Array.isArray(conversations) ? conversations.length : 0;
+        return {
+            persona_id: personaId,
+            count,
+            conversations,
+            ...(typeof result.pagination_token === "string" && {
+                pagination_token: result.pagination_token,
+            }),
+            _tip: count > 0
+                ? "Use conversation(method='messages', conversation_id='<id>') to view messages."
+                : "No conversations found for this persona.",
+        };
+    }
+    // List all conversations for the current user
+    const conversations = await client.listConversations();
+    return {
+        count: conversations.length,
+        conversations: conversations.map((c) => ({
+            id: c.id,
+            display_name: c.display_name,
+            persona_id: c.persona_id,
+            persona_display_name: c.persona_display_name,
+            created_at: c.created_at,
+            updated_at: c.updated_at,
+            status: c.status,
+        })),
+        _tip: "Use conversation(method='messages', conversation_id='<id>') to view messages in a conversation.",
+    };
+}

package/dist/mcp/handlers/conversation/messages.js

@@ -0,0 +1,13 @@
+export async function handleMessages(args, client) {
+    const conversationId = args.conversation_id;
+    if (!conversationId) {
+        return { error: "Missing required parameter: conversation_id" };
+    }
+    const messages = await client.getConversationMessages(conversationId);
+    return {
+        conversation_id: conversationId,
+        message_count: messages.length,
+        messages,
+        _tip: "Use conversation(method='send', conversation_id='...', text='...') to continue the conversation.",
+    };
+}

package/dist/mcp/handlers/conversation/rename.js

@@ -0,0 +1,16 @@
+export async function handleRename(args, client) {
+    const conversationId = args.conversation_id;
+    if (!conversationId) {
+        return { error: "Missing required parameter: conversation_id" };
+    }
+    const displayName = args.display_name;
+    if (!displayName) {
+        return { error: "Missing required parameter: display_name" };
+    }
+    await client.updateConversationDisplayName(conversationId, displayName);
+    return {
+        success: true,
+        conversation_id: conversationId,
+        display_name: displayName,
+    };
+}

package/dist/mcp/handlers/conversation/send.js

@@ -0,0 +1,90 @@
+import { formatSendResponse } from "./formatters.js";
+/**
+ * Build a ChatbotMessage proto-dict from convenience parameters.
+ *
+ * Supports three message types:
+ *  - text:    Simple text message or text HITL continuation
+ *  - form:    Form HITL continuation (filled fields or cancellation)
+ *  - buttons: Button HITL continuation (selected button)
+ *
+ * If none of the convenience params are provided, falls back to `raw_message`
+ * which must be a pre-built ChatbotMessage dict with a valid `type` field.
+ */
+function buildChatbotMessage(args) {
+    const text = args.text;
+    const form = args.form;
+    const buttons = args.buttons;
+    const rawMessage = args.raw_message;
+    if (text !== undefined) {
+        return {
+            type: "MESSAGE_TYPE_TEXT",
+            textMessage: { contents: [text] },
+            isUserMessage: true,
+        };
+    }
+    if (buttons !== undefined) {
+        return {
+            type: "MESSAGE_TYPE_BUTTONS",
+            buttonsMessage: {
+                selectedButton: buttons.selected_button ?? buttons.selectedButton,
+            },
+            isUserMessage: true,
+        };
+    }
+    if (form !== undefined) {
+        return {
+            type: "MESSAGE_TYPE_FORM",
+            formMessage: {
+                fields: form.fields,
+                isCancelled: form.is_cancelled ?? form.isCancelled ?? false,
+                ...(form.content !== undefined && { content: form.content }),
+            },
+            isUserMessage: true,
+        };
+    }
+    if (rawMessage !== undefined) {
+        // Validate raw_message has a type field
+        if (!rawMessage.type || typeof rawMessage.type !== "string") {
+            return null; // Will trigger the "no content" error with a specific hint
+        }
+        return rawMessage;
+    }
+    return null;
+}
+/**
+ * Send a message in an existing conversation.
+ */
+export async function handleSend(args, client) {
+    const conversationId = args.conversation_id;
+    if (!conversationId) {
+        return {
+            error: "conversation_id is required",
+            hint: 'conversation(method="send", conversation_id="<uuid>", text="hello")',
+        };
+    }
+    const message = buildChatbotMessage(args);
+    if (!message) {
+        // Distinguish between raw_message validation failure and no content at all
+        if (args.raw_message) {
+            return {
+                error: "raw_message must include a 'type' field (e.g. 'MESSAGE_TYPE_TEXT')",
+                hint: 'raw_message={type:"MESSAGE_TYPE_TEXT", textMessage:{contents:["hello"]}, isUserMessage:true}',
+            };
+        }
+        return {
+            error: "No message content provided. Supply one of: text, form, buttons, or raw_message",
+            hint: 'conversation(method="send", conversation_id="...", text="your message")',
+            examples: [
+                'text="hello" - send a text message',
+                'buttons={selected_button:{label:"Yes",description:"Confirm"}} - select a button',
+                'raw_message={type:"MESSAGE_TYPE_FORM", formMessage:{...}} - submit a form (echo back formMessage with values)',
+                'form={is_cancelled:true} - cancel a form',
+            ],
+        };
+    }
+    const result = await client.sendMessage(conversationId, message, {
+        userContext: args.user_context,
+        originalMessageId: args.original_message_id,
+    });
+    return formatSendResponse(result);
+}

package/dist/mcp/handlers/data/index.js

@@ -18,6 +18,7 @@
  * - regenerate: Modify document section with new query
  * - replace: Replace entire document content (full replacement, not partial)
  * - sanitize: Sanitize data items for a persona
+ * - continue: Respond to HITL pause on a dashboard row (text, button, or form)
  *
  * Note: Schema is now at persona level: persona(method="schema", id="...")
  */
@@ -335,7 +336,11 @@ export async function handleData(args, client, readFile) {
                         persona_id: personaId,
                         uploaded_rows: results.length,
                         row_ids: results.map(r => r.row_id),
-                        _tip: "Dashboard rows created with file attachments trigger workflow execution automatically",
+                        _tip: "Rows created and workflow triggered. Poll for completion using method='result' with each row_id.",
+                        _next_step: results.length === 1
+                            ? `persona(id="${personaId}", data={method:"result", row_id:"${results[0].row_id}"})`
+                            : `Poll each row: ${results.map(r => `persona(id="${personaId}", data={method:"result", row_id:"${r.row_id}"})`).join(", ")}`,
+                        _poll_interval_seconds: 5,
                     };
                 }
                 catch (error) {
@@ -459,10 +464,40 @@ export async function handleData(args, client, readFile) {
                 return { error: `Failed to replace document: ${error instanceof Error ? error.message : String(error)}` };
             }
         }
+        case "result": {
+            // Get dashboard row result/output
+            const rowId = (dataArgs?.row_id ?? dataArgs?.id);
+            if (!rowId) {
+                return errorResult("data.result requires row_id parameter", {
+                    hint: "Get row_id from the upload response: persona(id='abc', data={method:'upload', items:[...]})",
+                });
+            }
+            const includeFileContents = (dataArgs?.include_file_contents ?? dataArgs?.include_files);
+            return handleDashboardResult(personaId, rowId, includeFileContents ?? false, client);
+        }
+        case "continue": {
+            // Respond to HITL pause on a dashboard row
+            const rowId = (dataArgs?.row_id ?? dataArgs?.id);
+            if (!rowId) {
+                return errorResult("data.continue requires row_id parameter", {
+                    hint: "Get row_id from the result response when requires_human_input=true",
+                });
+            }
+            const text = dataArgs?.text;
+            const buttons = dataArgs?.buttons;
+            const form = dataArgs?.form;
+            const rawContinuation = dataArgs?.raw_continuation;
+            if (!text && !buttons && !form && !rawContinuation) {
+                return errorResult("data.continue requires one of: text, buttons, form, or raw_continuation", {
+                    hint: "text='approved' for free-text, buttons={selected_button:{label:'Approve'}} for button selection, form={is_cancelled:true} for form cancellation, raw_continuation={formMessage:{...full form with values...}} for form submission",
+                });
+            }
+            return handleDashboardContinue(personaId, rowId, { text, buttons, form, raw: rawContinuation }, client);
+        }
         default:
             return {
                 error: `Unknown data method: ${method}`,
-                hint: "Valid methods: list, stats, templates, generate, get, copy, replicate, upload, delete, embedding, refresh, regenerate, replace, sanitize",
+                hint: "Valid methods: list, stats, templates, generate, get, copy, replicate, upload, delete, embed, refresh, result, continue, regenerate, replace, sanitize",
             };
     }
 }
@@ -684,6 +719,137 @@ async function handleDashboardRefresh(personaId, rowId, client) {
         return { error: `Failed to refresh dashboard row: ${error instanceof Error ? error.message : String(error)}` };
     }
 }
+/**
+ * Detect the type of continuation message (text, buttons, or form).
+ * Mirrors how chat's formatSendResponse detects MESSAGE_TYPE_BUTTONS/FORM/TEXT.
+ */
+function detectContinuationType(continuation) {
+    if (!continuation)
+        return "unknown";
+    // Check the oneof field that's populated in the ContinuationMessage proto
+    if (continuation.buttonsMessage)
+        return "buttons";
+    if (continuation.formMessage)
+        return "form";
+    if (continuation.textMessage)
+        return "text";
+    // Fallback: check for a `value` wrapper (some proto serializations)
+    const value = continuation.value;
+    if (value?.case === "buttonsMessage")
+        return "buttons";
+    if (value?.case === "formMessage")
+        return "form";
+    if (value?.case === "textMessage")
+        return "text";
+    return "unknown";
+}
+/**
+ * Get the result/output of a dashboard row.
+ * Detects row state and provides polling/debugging guidance.
+ */
+async function handleDashboardResult(personaId, rowId, includeFileContents, client) {
+    try {
+        const result = await client.getDashboardRowResult(personaId, rowId, includeFileContents);
+        const row = result.row;
+        const state = row?.state ?? "unknown";
+        const isComplete = state === "DASHBOARD_ROW_STATE_SUCCESS";
+        const isFailed = state === "DASHBOARD_ROW_STATE_FAILED";
+        const isReviewing = state === "DASHBOARD_ROW_STATE_REVIEWING";
+        const isRunning = [
+            "DASHBOARD_ROW_STATE_RUNNING",
+            "DASHBOARD_ROW_STATE_QUEUED",
+            "DASHBOARD_ROW_STATE_INITIAL",
+        ].includes(state);
+        const response = {
+            method: "result",
+            persona_id: personaId,
+            row_id: rowId,
+            state,
+            is_complete: isComplete,
+            row: result.row,
+        };
+        if (result.additional_column_details?.length) {
+            response.additional_column_details = result.additional_column_details;
+        }
+        if (isReviewing) {
+            // HITL — workflow is paused waiting for human input/approval
+            response.requires_human_input = true;
+            const continuation = (row?.continuationMessage ?? row?.continuation_message);
+            if (continuation) {
+                response.continuation_message = continuation;
+            }
+            // Detect continuation type for type-specific guidance (matches chat's formatSendResponse pattern)
+            const contType = detectContinuationType(continuation);
+            response.continuation_type = contType;
+            if (contType === "buttons") {
+                const buttonsMsg = continuation?.buttonsMessage;
+                const buttons = buttonsMsg?.buttons;
+                const labels = buttons?.map(b => b.label).filter(Boolean) ?? [];
+                response._tip = `HITL: The workflow is asking the user to select a button.${labels.length ? ` Options: ${labels.join(", ")}` : ""} Ask the user which to choose.`;
+                response._next_step = `persona(id="${personaId}", data={method:"continue", row_id:"${rowId}", buttons:{selected_button:{label:"<chosen label>"}}})`;
+            }
+            else if (contType === "form") {
+                const formMsg = continuation?.formMessage;
+                const isIntermediate = formMsg?.isIntermediate === true;
+                response._tip = `HITL: The workflow is asking the user to fill out a form.${isIntermediate ? " This is an INTERMEDIATE form — more fields will follow after submission." : ""} Review the fields in continuation_message.formMessage, ask the user for values, then echo back the full formMessage with values filled in using raw_continuation. Use form={is_cancelled:true} to cancel instead.`;
+                response._next_step = `persona(id="${personaId}", data={method:"continue", row_id:"${rowId}", raw_continuation:{formMessage:{...continuation_message.formMessage with field values filled in...}}})`;
+                response._form_value_guide = "Field values use wellKnown types: {wellKnown:{stringValue:'text'}} for strings, {wellKnown:{int64Value:'42'}} for ints (string-encoded), {wellKnown:{doubleValue:3.14}} for floats, {wellKnown:{boolValue:true}} for bools, {wellKnown:{dateValue:{year,month,day}}} for dates, {wellKnown:{datetimeValue:{utcTime:'ISO'}}} for datetimes. For struct dropdowns use Id as stringValue; for enum dropdowns use enumValue as stringValue.";
+            }
+            else {
+                response._tip = "HITL: Workflow is paused and waiting for human input. Review the continuation_message and ask the user what to do.";
+                response._next_step = `persona(id="${personaId}", data={method:"continue", row_id:"${rowId}", text:"user's response"})`;
+            }
+        }
+        else if (isRunning) {
+            response._tip = "Row is still processing. Poll again in 5-10 seconds.";
+            response._next_step = `persona(id="${personaId}", data={method:"result", row_id:"${rowId}"})`;
+            response._poll_interval_seconds = 5;
+        }
+        else if (isFailed) {
+            response._tip = "Row processing failed. Check workflow execution for details.";
+            const workflowRunId = row?.workflowRunId ?? row?.workflow_run_id;
+            if (workflowRunId) {
+                response._next_step = `debug(method="show_work", persona_id="${personaId}", workflow_run_id="${workflowRunId}")`;
+            }
+        }
+        else if (isComplete && !includeFileContents) {
+            response._tip = "Row complete. Add include_file_contents=true to get generated file contents.";
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            error: `Failed to get dashboard row result: ${error instanceof Error ? error.message : String(error)}`,
+            persona_id: personaId,
+            row_id: rowId,
+        };
+    }
+}
+/**
+ * Continue a paused (HITL) dashboard row with a response.
+ * Sends text, button selection, or form data to resume the workflow.
+ */
+async function handleDashboardContinue(personaId, rowId, continuation, client) {
+    try {
+        await client.continueDashboardRow(rowId, continuation);
+        return {
+            method: "continue",
+            persona_id: personaId,
+            row_id: rowId,
+            sent: continuation.raw ? "raw" : continuation.text ? "text" : continuation.buttons ? "buttons" : "form",
+            _tip: "Continuation sent. The workflow is resuming. Poll for the result.",
+            _next_step: `persona(id="${personaId}", data={method:"result", row_id:"${rowId}"})`,
+            _poll_interval_seconds: 5,
+        };
+    }
+    catch (error) {
+        return {
+            error: `Failed to continue dashboard row: ${error instanceof Error ? error.message : String(error)}`,
+            persona_id: personaId,
+            row_id: rowId,
+        };
+    }
+}
 // ─────────────────────────────────────────────────────────────────────────────
 // Method inference and clarification when method is omitted
 // ─────────────────────────────────────────────────────────────────────────────
@@ -733,7 +899,7 @@ function inferMethodAndClarify(args, dataArgs) {
     return {
         status: "clarification_needed",
         message: "What operation would you like to perform?",
-        options: ["list", "upload", "generate", "templates", "get", "delete", "copy", "replicate", "embedding", "sanitize", "refresh", "regenerate", "replace"],
+        options: ["list", "upload", "generate", "templates", "get", "delete", "copy", "replicate", "embedding", "sanitize", "refresh", "result", "continue", "regenerate", "replace"],
         hint: "Specify method='...' for direct execution. Example: data(persona_id='abc', method='list')",
     };
 }