cursor-opencode-provider 0.5.0 → 0.6.1

package/dist/protocol/interactions.js

@@ -1,6 +1,18 @@
 import { encodeMessage } from "./messages.js";
 import { readAllFields } from "./struct.js";
+import { decodeAskQuestionQuery, MISSING_ARGS_REASON, MISSING_QUERY_REASON, } from "./ask-question.js";
+import { decodeGenerateImageQuery, } from "./generate-image.js";
+import { CURSOR_PLAN_STAGE_TOOL, createPlanApprovalQuestionInput, decodeCreatePlanQuery, renderPlanReviewMessage, resolveCreatePlanBridge, writeOpencodePlanFile, } from "./create-plan.js";
+import { decodeSwitchModeQuery, MISSING_ARGS_REASON as SWITCH_MODE_MISSING_ARGS_REASON, MISSING_QUERY_REASON as SWITCH_MODE_MISSING_QUERY_REASON, resolveSwitchModeBridge, switchModeApprovedResult, } from "./switch-mode.js";
 const HEADLESS_REASON = "This Cursor interaction requires UI approval and is not available through the OpenCode provider.";
+/**
+ * Rejection used when AskQuestion cannot be bridged because the current
+ * OpenCode agent does not advertise `question` (subagents deny it by default,
+ * and compaction turns advertise no tools at all). Naming the actual reason
+ * keeps the model from concluding that asking is impossible in general.
+ */
+const ASK_QUESTION_UNAVAILABLE_REASON = "The OpenCode `question` tool is not available to the current agent, so questions "
+    + "cannot be shown to the user this turn. State the question in your reply instead.";
 const variantNames = {
     2: "web_search_request_query",
     3: "ask_question_interaction_query",
@@ -39,27 +51,37 @@ export function inspectInteractionQueryWire(agentServerPayload) {
     // zero, not a malformed/missing correlation id.
     let id = 0;
     let variantField;
+    let variantBytes;
     for (const field of readAllFields(queryBytes)) {
         if (field.fn === 1 && field.wt === 0)
             id = field.varint;
-        else if (field.wt === 2 && variantField === undefined)
+        else if (field.wt === 2 && variantField === undefined) {
             variantField = field.fn;
+            variantBytes = field.bytes;
+        }
     }
     return {
         id,
         variantField,
         variantName: variantField === undefined ? undefined : variantNames[variantField],
+        variantBytes,
     };
 }
 /**
- * Build the immediate typed response required by Cursor's Run RPC.
+ * Build the typed response required by Cursor's Run RPC.
  *
- * OpenCode has no Cursor UI callbacks, so every InteractionQuery is answered
- * here with a conservative headless policy (reject UI-bound prompts; ack a few
- * no-UI cases). See case 7 / F14 for create_plan auto-ack parity with Cursor
- * CLI headless mode.
+ * OpenCode has no Cursor UI callbacks, so UI-bound queries get a conservative
+ * headless policy (reject; ack a few no-UI cases).
+ *
+ * Bridged / persisted exceptions:
+ * - AskQuestion (#3) → OpenCode `question` tool
+ * - SwitchMode (#4) → OpenCode `plan_enter` / `plan_exit` when advertised
+ * - CreatePlan (#7) → host-calculated plan file via hostPlansDir (project-config
+ *   `plans/` in a git worktree, else host global data/plans); empty args still
+ *   get the CLI empty-`plan_uri` success ack
+ * - GenerateImage (#12) → approve when `cursor_image_save` is advertised
  */
-export function handleInteractionQuery(query, agentServerPayload) {
+export function handleInteractionQuery(query, agentServerPayload, options = {}) {
     const info = inspectInteractionQueryWire(agentServerPayload);
     if (info.id === undefined || info.variantField === undefined || !info.variantName) {
         throw new UnsupportedInteractionQueryError(info);
@@ -67,6 +89,18 @@ export function handleInteractionQuery(query, agentServerPayload) {
     if (typeof query.id === "number" && query.id !== info.id) {
         throw new Error(`Cursor interaction query id mismatch: decoded=${query.id} wire=${info.id}`);
     }
+    if (info.variantField === 3) {
+        return handleAskQuestionQuery(info.id, info.variantBytes, options);
+    }
+    if (info.variantField === 4) {
+        return handleSwitchModeQuery(info.id, info.variantBytes, options);
+    }
+    if (info.variantField === 7) {
+        return handleCreatePlanQuery(info.id, info.variantBytes, options);
+    }
+    if (info.variantField === 12) {
+        return handleGenerateImageQuery(info.id, info.variantBytes, options);
+    }
     let response;
     let outcome;
     switch (info.variantField) {
@@ -74,30 +108,6 @@ export function handleInteractionQuery(query, agentServerPayload) {
             response = { web_search_request_response: { rejected: { reason: HEADLESS_REASON } } };
             outcome = "rejected";
             break;
-        case 3:
-            response = {
-                ask_question_interaction_response: {
-                    result: { rejected: { reason: "Questions must be asked through OpenCode's question tool." } },
-                },
-            };
-            outcome = "rejected";
-            break;
-        case 4:
-            response = { switch_mode_request_response: { rejected: { reason: HEADLESS_REASON } } };
-            outcome = "rejected";
-            break;
-        case 7:
-            // F14: create_plan_request_query auto-ack (Cursor CLI headless parity).
-            // Cursor CLI's headless fallback acknowledges plan creation without a
-            // client-side URI (`success` + empty `plan_uri`); the plan remains in
-            // conversation state / checkpoints. This provider mirrors that reply so
-            // the Run RPC does not deadlock waiting for UI approval. Impact: Cursor
-            // may treat the plan as accepted without an OpenCode UI confirm; local
-            // tool execution is still gated by OpenCode permissions. Do not change
-            // this to reject/prompt without CLI parity evidence.
-            response = { create_plan_request_response: { result: { success: {}, plan_uri: "" } } };
-            outcome = "acknowledged";
-            break;
         case 8:
             // OpenCode owns the local environment; there is no Cursor VM to create.
             response = { setup_vm_environment_result: { success: {} } };
@@ -115,10 +125,6 @@ export function handleInteractionQuery(query, agentServerPayload) {
             response = { mcp_auth_request_response: { rejected: { reason: HEADLESS_REASON } } };
             outcome = "rejected";
             break;
-        case 12:
-            response = { generate_image_request_response: { rejected: { reason: HEADLESS_REASON } } };
-            outcome = "rejected";
-            break;
         case 13:
             response = {
                 replace_env_result: {
@@ -147,3 +153,257 @@ export function handleInteractionQuery(query, agentServerPayload) {
         }),
     };
 }
+/**
+ * AskQuestion is the one interaction OpenCode can genuinely satisfy, so it is
+ * translated instead of refused. Cursor CLI's own handler is mirrored: reject
+ * a malformed query, answer `async` immediately when the server asked for a
+ * non-blocking prompt, and otherwise hold the query open until the user picks.
+ */
+function handleAskQuestionQuery(id, variantBytes, options) {
+    const base = { id, variantField: 3, variantName: "ask_question_interaction_query" };
+    const reject = (reason) => ({
+        ...base,
+        outcome: "rejected",
+        reply: buildAskQuestionInteractionReply(id, { rejected: { reason } }),
+    });
+    if (!variantBytes)
+        return reject(MISSING_QUERY_REASON);
+    const decoded = decodeAskQuestionQuery(variantBytes);
+    if (!decoded)
+        return reject(MISSING_ARGS_REASON);
+    if (!options.canBridgeAskQuestion)
+        return reject(ASK_QUESTION_UNAVAILABLE_REASON);
+    return {
+        ...base,
+        outcome: "bridged",
+        askQuestion: decoded,
+        // Async queries are unblocked now and answered later through a
+        // ConversationAction; synchronous ones keep Cursor waiting, which is what
+        // its CLI does while the user is still choosing.
+        reply: decoded.args.runAsync
+            ? buildAskQuestionInteractionReply(id, { async: {} })
+            : undefined,
+    };
+}
+/** `AgentClientMessage{interaction_response{ask_question_interaction_response}}`. */
+export function buildAskQuestionInteractionReply(id, result) {
+    return encodeMessage("AgentClientMessage", {
+        interaction_response: {
+            id,
+            ask_question_interaction_response: { result },
+        },
+    });
+}
+/**
+ * SwitchMode is bridged to OpenCode `plan_enter` / `plan_exit` when advertised.
+ * Cursor CLI blocks until the user approves or rejects; we hold the query open
+ * until the host tool returns, then reply approved{} or rejected{reason}.
+ */
+function handleSwitchModeQuery(id, variantBytes, options) {
+    const base = { id, variantField: 4, variantName: "switch_mode_request_query" };
+    const reject = (reason) => ({
+        ...base,
+        outcome: "rejected",
+        reply: buildSwitchModeInteractionReply(id, { rejected: { reason } }),
+    });
+    if (!variantBytes)
+        return reject(SWITCH_MODE_MISSING_QUERY_REASON);
+    const decoded = decodeSwitchModeQuery(variantBytes);
+    if (!decoded)
+        return reject(SWITCH_MODE_MISSING_ARGS_REASON);
+    const bridge = resolveSwitchModeBridge(decoded.args.targetModeId, {
+        allowTools: options.allowTools === true,
+        advertised: options.advertisedTools ?? [],
+        ...(options.activeCursorModeId ? { activeModeId: options.activeCursorModeId } : {}),
+    });
+    if (bridge.kind === "reject")
+        return reject(bridge.reason);
+    // Lifecycle turn: approve on the wire so the model never sees a rejection, but
+    // do not attach switchMode — the real turn owns session mode.
+    if (bridge.kind === "ack") {
+        return {
+            ...base,
+            outcome: "acknowledged",
+            reply: buildSwitchModeInteractionReply(id, switchModeApprovedResult()),
+        };
+    }
+    if (bridge.kind === "approve") {
+        // Entering plan mode needs no host tool, so Cursor is released at once and
+        // the caller records the mode for the reminder injected on later Runs.
+        return {
+            ...base,
+            outcome: "approved",
+            switchMode: { ...decoded, bridge },
+            reply: buildSwitchModeInteractionReply(id, switchModeApprovedResult()),
+        };
+    }
+    return {
+        ...base,
+        outcome: "bridged",
+        switchMode: {
+            ...decoded,
+            bridge,
+            toolName: bridge.kind === "native" ? bridge.toolName : "question",
+        },
+        // Keep Cursor waiting until the host tool returns, matching CLI blocking on
+        // the mode-switch approval prompt.
+        reply: undefined,
+    };
+}
+/** `AgentClientMessage{interaction_response{switch_mode_request_response}}`. */
+export function buildSwitchModeInteractionReply(id, result) {
+    return encodeMessage("AgentClientMessage", {
+        interaction_response: {
+            id,
+            switch_mode_request_response: result,
+        },
+    });
+}
+/** `AgentClientMessage{interaction_response{create_plan_request_response}}`. */
+export function buildCreatePlanInteractionReply(id, result) {
+    return encodeMessage("AgentClientMessage", {
+        interaction_response: {
+            id,
+            create_plan_request_response: { result },
+        },
+    });
+}
+/**
+ * Deferred answers for a query already acknowledged with `async`.
+ * `originalArgs` must be the server's own `AskQuestionArgs` bytes so Cursor can
+ * correlate the completion with the tool call it raised.
+ */
+export function buildAsyncAskQuestionCompletion(originalToolCallId, originalArgs, result) {
+    return encodeMessage("AgentClientMessage", {
+        conversation_action: {
+            async_ask_question_completion_action: {
+                original_tool_call_id: originalToolCallId,
+                original_args: originalArgs,
+                result,
+            },
+        },
+    });
+}
+/**
+ * CreatePlan persistence and execution approval. Cursor CLI writes
+ * `~/.cursor/plans/*.plan.md` with YAML frontmatter; this provider writes plain
+ * markdown under the host's calculated plans dir (`hostPlansDir` / path bridge)
+ * so switching models and hosts stays coherent. Empty / missing args keep the
+ * CLI empty-`plan_uri` success ack (nothing to write).
+ *
+ * Writing the plan never asks; executing it always does. Which channel raises
+ * that prompt is resolved from the advertised catalog by
+ * {@link resolveCreatePlanBridge}, and every channel reports the same outcome:
+ * `success` means the user approved execution, `error` means the plan was
+ * written but not accepted, so the model keeps planning.
+ */
+function handleCreatePlanQuery(id, variantBytes, options) {
+    const base = { id, variantField: 7, variantName: "create_plan_request_query" };
+    const reply = (result) => ({
+        ...base,
+        outcome: result.error ? "failed" : "acknowledged",
+        reply: encodeMessage("AgentClientMessage", {
+            interaction_response: {
+                id,
+                create_plan_request_response: { result },
+            },
+        }),
+    });
+    // Missing / empty args: CLI headless fallback — success with empty plan_uri.
+    if (!variantBytes)
+        return reply({ success: {}, plan_uri: "" });
+    const decoded = decodeCreatePlanQuery(variantBytes);
+    if (!decoded)
+        return reply({ success: {}, plan_uri: "" });
+    const bridge = resolveCreatePlanBridge({
+        allowTools: options.allowTools === true,
+        canStage: options.canBridgeCreatePlan === true,
+        planModeActive: options.planModeActive === true,
+        advertised: options.advertisedTools ?? [],
+    });
+    // The host plan-stage tool owns the write and the approval prompt together.
+    if (bridge.kind === "stage") {
+        return {
+            ...base,
+            outcome: "bridged",
+            createPlan: { ...decoded, bridge, toolName: CURSOR_PLAN_STAGE_TOOL },
+            reply: undefined,
+        };
+    }
+    // A lifecycle turn (title generation, compaction) runs alongside the real one
+    // and would otherwise write a second, throwaway plan file for the same
+    // request. Ack it the CLI way instead of persisting anything.
+    if (options.allowTools !== true)
+        return reply({ success: {}, plan_uri: "" });
+    const workspaceRoot = options.workspaceRoot?.trim();
+    if (!workspaceRoot) {
+        return reply({
+            error: { error: "CreatePlan requires a workspace root to write the plan file" },
+            plan_uri: "",
+        });
+    }
+    const written = writeOpencodePlanFile(decoded.args, workspaceRoot);
+    if (!written.ok) {
+        return reply({ error: { error: written.error }, plan_uri: "" });
+    }
+    // The plan is on disk either way; only execution needs the user. Hold Cursor's
+    // query open while the host asks, exactly as the CLI blocks on its own prompt.
+    if (bridge.kind === "approve") {
+        return {
+            ...base,
+            outcome: "bridged",
+            createPlan: {
+                ...decoded,
+                bridge,
+                toolName: "question",
+                planUri: written.planUri,
+                planPath: written.planPath,
+                questionInput: createPlanApprovalQuestionInput(written.planPath),
+                planReview: renderPlanReviewMessage(written.markdown, written.planPath),
+            },
+            reply: undefined,
+        };
+    }
+    return reply({ success: {}, plan_uri: written.planUri });
+}
+/**
+ * GenerateImage approval. Cursor renders its own confirmation in the CLI; here
+ * the meaningful gate is OpenCode's `edit` permission raised by
+ * `cursor_image_save` when the finished bytes are written, so generation itself
+ * is approved whenever the provider can actually commit the result. Approving
+ * without a commit path would spend Cursor quota on an image that then has
+ * nowhere to go.
+ */
+function handleGenerateImageQuery(id, variantBytes, options) {
+    const base = { id, variantField: 12, variantName: "generate_image_request_query" };
+    const reject = (reason) => ({
+        ...base,
+        outcome: "rejected",
+        reply: encodeMessage("AgentClientMessage", {
+            interaction_response: { id, generate_image_request_response: { rejected: { reason } } },
+        }),
+    });
+    if (!variantBytes)
+        return reject("Missing generate image query");
+    const decoded = decodeGenerateImageQuery(variantBytes);
+    if (!decoded)
+        return reject("Missing generate image arguments");
+    if (!options.canSaveGeneratedImage) {
+        return reject("This OpenCode agent cannot save a generated image, so generating one would "
+            + "produce nothing. Describe the image in your reply instead.");
+    }
+    return {
+        ...base,
+        outcome: "acknowledged",
+        generateImage: decoded,
+        reply: encodeMessage("AgentClientMessage", {
+            interaction_response: {
+                id,
+                // Cursor's CLI returns the description the user may have edited at the
+                // prompt. There is no text field on OpenCode's permission, so the
+                // model's own description is passed through unchanged.
+                generate_image_request_response: { approved: { description: decoded.description } },
+            },
+        }),
+    };
+}

package/dist/protocol/messages.js

@@ -174,6 +174,12 @@ export function createMessageTypes() {
     addType(root, "AskQuestionArgs", [
         { id: 1, name: "title", type: "string" },
         { id: 2, name: "questions", type: "AskQuestionItem", repeated: true },
+        // #5/#6 drive Cursor's non-blocking AskQuestion: the client answers the
+        // interaction with `async` right away and delivers the real answers later
+        // through ConversationAction.async_ask_question_completion_action, keyed by
+        // the originating tool call id. See protocol/ask-question.ts.
+        { id: 5, name: "run_async", type: "bool" },
+        { id: 6, name: "async_original_tool_call_id", type: "string" },
     ]);
     addType(root, "AskQuestionToolCall", [{ id: 1, name: "args", type: "AskQuestionArgs" }]);
     addType(root, "FetchToolArgs", [
@@ -187,7 +193,23 @@ export function createMessageTypes() {
         { id: 2, name: "explanation", type: "string" },
         { id: 3, name: "tool_call_id", type: "string" },
     ]);
-    addType(root, "SwitchModeToolCall", [{ id: 1, name: "args", type: "SwitchModeToolArgs" }]);
+    // Display ToolCall.result (CLI success hardcodes from_mode_id=""); distinct from
+    // InteractionResponse approved/rejected, which is the consent gate.
+    addType(root, "SwitchModeSuccess", [
+        { id: 1, name: "from_mode_id", type: "string" },
+        { id: 2, name: "to_mode_id", type: "string" },
+    ]);
+    addType(root, "SwitchModeError", [{ id: 1, name: "error", type: "string" }]);
+    addType(root, "SwitchModeRejected", [{ id: 1, name: "reason", type: "string" }]);
+    addType(root, "SwitchModeResult", [
+        { id: 1, name: "success", type: "SwitchModeSuccess" },
+        { id: 2, name: "error", type: "SwitchModeError" },
+        { id: 3, name: "rejected", type: "SwitchModeRejected" },
+    ], [{ name: "result", fields: ["success", "error", "rejected"] }]);
+    addType(root, "SwitchModeToolCall", [
+        { id: 1, name: "args", type: "SwitchModeToolArgs" },
+        { id: 2, name: "result", type: "SwitchModeResult" },
+    ]);
     addType(root, "PiReadToolArgs", [
         { id: 1, name: "path", type: "string" },
         { id: 2, name: "offset", type: "int32" },
@@ -258,7 +280,27 @@ export function createMessageTypes() {
         { id: 2, name: "file_path", type: "string" },
         { id: 5, name: "reference_image_paths", type: "string", repeated: true },
     ]);
-    addType(root, "GenerateImageToolCall", [{ id: 1, name: "args", type: "GenerateImageToolArgs" }]);
+    // Cursor generates the image server-side and returns it on the display
+    // tool_call frame. `image_data` is a base64 string, not bytes.
+    addType(root, "GenerateImageSuccess", [
+        { id: 1, name: "file_path", type: "string" },
+        { id: 2, name: "image_data", type: "string" },
+    ]);
+    addType(root, "GenerateImageError", [{ id: 1, name: "error", type: "string" }]);
+    addType(root, "GenerateImageResult", [
+        { id: 1, name: "success", type: "GenerateImageSuccess" },
+        { id: 2, name: "error", type: "GenerateImageError" },
+    ], [{ name: "result", fields: ["success", "error"] }]);
+    addType(root, "GenerateImageToolCall", [
+        { id: 1, name: "args", type: "GenerateImageToolArgs" },
+        { id: 2, name: "result", type: "GenerateImageResult" },
+    ]);
+    // InteractionQuery keeps query bodies opaque; decoded on demand like
+    // AskQuestionInteractionQuery.
+    addType(root, "GenerateImageRequestQuery", [
+        { id: 1, name: "args", type: "GenerateImageToolArgs" },
+        { id: 2, name: "tool_call_id", type: "string" },
+    ]);
     addType(root, "ToolCall", [
         { id: 57, name: "tool_call_id", type: "string" },
         { id: 1, name: "shell_tool_call", type: "ShellToolCall" },
@@ -455,10 +497,20 @@ export function createMessageTypes() {
         { id: 1, name: "path", type: "string" },
         { id: 2, name: "error", type: "string" },
     ]);
+    // Cursor's own executor reports a refused write with this variant rather than
+    // a generic error, and its agent reads `operation` / `is_readonly` back.
+    addType(root, "WritePermissionDenied", [
+        { id: 1, name: "path", type: "string" },
+        { id: 2, name: "directory", type: "string" },
+        { id: 3, name: "operation", type: "string" },
+        { id: 4, name: "error", type: "string" },
+        { id: 5, name: "is_readonly", type: "bool" },
+    ]);
     addType(root, "WriteResult", [
         { id: 1, name: "success", type: "WriteSuccess" },
+        { id: 3, name: "permission_denied", type: "WritePermissionDenied" },
         { id: 5, name: "error", type: "WriteError" },
-    ], [{ name: "result", fields: ["success", "error"] }]);
+    ], [{ name: "result", fields: ["success", "permission_denied", "error"] }]);
     // agent.v1 Pi exec results. Cursor places Pi requests at ExecServerMessage
     // fields #45..#51 and their corresponding ExecClientMessage results at
     // #46..#52 (the result fields are deliberately offset by one).
@@ -1069,11 +1121,29 @@ export function createMessageTypes() {
     addType(root, "CancelAction", [
         { id: 1, name: "conversation_id", type: "string" },
     ]);
+    // Deferred answers for an AskQuestion the client already replied to with
+    // `async`. `original_args` is kept as raw bytes so the exact AskQuestionArgs
+    // Cursor sent — including fields this schema does not model — is echoed back
+    // verbatim rather than re-encoded from a lossy decode.
+    addType(root, "AsyncAskQuestionCompletionAction", [
+        { id: 1, name: "original_tool_call_id", type: "string" },
+        { id: 2, name: "original_args", type: "bytes" },
+        { id: 3, name: "result", type: "AskQuestionResult" },
+    ]);
     addType(root, "ConversationAction", [
         { id: 1, name: "user_message_action", type: "UserMessageAction" },
         { id: 2, name: "resume_action", type: "ResumeAction" },
         { id: 3, name: "cancel_action", type: "CancelAction" },
-    ], [{ name: "action", fields: ["user_message_action", "resume_action", "cancel_action"] }]);
+        { id: 8, name: "async_ask_question_completion_action", type: "AsyncAskQuestionCompletionAction" },
+    ], [{
+            name: "action",
+            fields: [
+                "user_message_action",
+                "resume_action",
+                "cancel_action",
+                "async_ask_question_completion_action",
+            ],
+        }]);
     // Seed ConversationStateStructure for turn 1 (system prompt as JSON strings
     // in #1). After the first conversation_checkpoint_update we echo opaque
     // server bytes instead — CLI's live structure uses blob-id bytes in #1/#8.
@@ -1172,18 +1242,42 @@ export function createMessageTypes() {
         { id: 2, name: "rejected", type: "WebSearchRequestRejected" },
     ], [{ name: "result", fields: ["approved", "rejected"] }]);
     addType(root, "AskQuestionRejected", [{ id: 1, name: "reason", type: "string" }]);
+    addType(root, "AskQuestionError", [{ id: 1, name: "error_message", type: "string" }]);
+    addType(root, "AskQuestionAsync", []);
+    addType(root, "AskQuestionSuccessAnswer", [
+        { id: 1, name: "question_id", type: "string" },
+        { id: 2, name: "selected_option_ids", type: "string", repeated: true },
+        { id: 3, name: "freeform_text", type: "string" },
+    ]);
+    addType(root, "AskQuestionSuccess", [
+        { id: 1, name: "answers", type: "AskQuestionSuccessAnswer", repeated: true },
+    ]);
     addType(root, "AskQuestionResult", [
+        { id: 1, name: "success", type: "AskQuestionSuccess" },
+        { id: 2, name: "error", type: "AskQuestionError" },
         { id: 3, name: "rejected", type: "AskQuestionRejected" },
-    ], [{ name: "result", fields: ["rejected"] }]);
+        { id: 4, name: "async", type: "AskQuestionAsync" },
+    ], [{ name: "result", fields: ["success", "error", "rejected", "async"] }]);
     addType(root, "AskQuestionInteractionResponse", [
         { id: 1, name: "result", type: "AskQuestionResult" },
     ]);
+    // InteractionQuery keeps query bodies opaque (see the InteractionQuery
+    // comment); this type decodes only the ask-question body on demand.
+    addType(root, "AskQuestionInteractionQuery", [
+        { id: 1, name: "args", type: "AskQuestionArgs" },
+        { id: 2, name: "tool_call_id", type: "string" },
+    ]);
     addType(root, "SwitchModeRequestApproved", []);
     addType(root, "SwitchModeRequestRejected", [{ id: 1, name: "reason", type: "string" }]);
     addType(root, "SwitchModeRequestResponse", [
         { id: 1, name: "approved", type: "SwitchModeRequestApproved" },
         { id: 2, name: "rejected", type: "SwitchModeRequestRejected" },
     ], [{ name: "result", fields: ["approved", "rejected"] }]);
+    // InteractionQuery keeps query bodies opaque; decoded on demand like
+    // AskQuestionInteractionQuery / CreatePlanRequestQuery.
+    addType(root, "SwitchModeRequestQuery", [
+        { id: 1, name: "args", type: "SwitchModeToolArgs" },
+    ]);
     addType(root, "CreatePlanSuccess", []);
     addType(root, "CreatePlanError", [{ id: 1, name: "error", type: "string" }]);
     addType(root, "CreatePlanResult", [
@@ -1194,6 +1288,12 @@ export function createMessageTypes() {
     addType(root, "CreatePlanRequestResponse", [
         { id: 1, name: "result", type: "CreatePlanResult" },
     ]);
+    // InteractionQuery keeps query bodies opaque; decoded on demand like
+    // AskQuestionInteractionQuery / GenerateImageRequestQuery.
+    addType(root, "CreatePlanRequestQuery", [
+        { id: 1, name: "args", type: "CreatePlanArgs" },
+        { id: 2, name: "tool_call_id", type: "string" },
+    ]);
     addType(root, "SetupVmEnvironmentSuccess", []);
     addType(root, "SetupVmEnvironmentResult", [
         { id: 1, name: "success", type: "SetupVmEnvironmentSuccess" },
@@ -1294,10 +1394,22 @@ export function createMessageTypes() {
         { id: 1, name: "run_request", type: "AgentRunRequest" },
         { id: 2, name: "exec_client_message", type: "ExecClientMessage" },
         { id: 3, name: "kv_client_message", type: "KvClientMessage" },
+        { id: 4, name: "conversation_action", type: "ConversationAction" },
         { id: 5, name: "exec_client_control_message", type: "ExecClientControlMessage" },
         { id: 6, name: "interaction_response", type: "InteractionResponse" },
         { id: 7, name: "client_heartbeat", type: "ClientHeartbeat" },
-    ], [{ name: "message", fields: ["run_request", "exec_client_message", "kv_client_message", "exec_client_control_message", "interaction_response", "client_heartbeat"] }]);
+    ], [{
+            name: "message",
+            fields: [
+                "run_request",
+                "exec_client_message",
+                "kv_client_message",
+                "conversation_action",
+                "exec_client_control_message",
+                "interaction_response",
+                "client_heartbeat",
+            ],
+        }]);
     // ── AgentServerMessage ──
     addType(root, "AgentServerMessage", [
         { id: 1, name: "interaction_update", type: "InteractionUpdate" },

package/dist/protocol/struct.js

@@ -249,7 +249,7 @@ export function encodeJsonAsValue(v) {
     }
     else if (typeof v === "object") {
         const st = [];
-        for (const [key, val] of Object.entries(v)) {
+        for (const [key, val] of Object.entries(v).sort(([left], [right]) => left.localeCompare(right))) {
             if (val === undefined)
                 continue;
             const entry = [];