@code-yeongyu/senpi 2026.8.29 → 2026.8.30-3

package/dist/modes/rpc/connection-handler.d.ts

@@ -14,6 +14,7 @@
  * go to `sink.writeRaw` instead of `writeRawStdout`, and the caller decides how
  * (and whether) to end the process.
  */
+import type { AgentAbortSource } from "../../core/agent-abort-provenance.ts";
 import type { AgentSession } from "../../core/agent-session.ts";
 import type { AgentSessionRuntime } from "../../core/agent-session-runtime.ts";
 import type { RpcSessionState } from "./rpc-types.ts";
@@ -50,6 +51,8 @@ export interface RpcConnectionHandler {
      * host polls this after each command and decides how to tear down.
      */
     isShutdownRequested(): boolean;
+    /** Cancel UI requests that can no longer be answered by this connection. */
+    cancelPendingExtensionUiRequests(): void;
     /** Tear down subscriptions and dispose the runtime. Never calls process.exit. */
     dispose(): Promise<void>;
 }
@@ -59,8 +62,12 @@ export interface RpcConnectionHandler {
  * Shared with `open_session` (session-command-router) so both surfaces answer with the SAME
  * fields: a second hand-rolled literal silently drifts, which is how `serviceTier`/`fastMode`
  * would otherwise be missing from an opened session's initial state.
+ *
+ * `lastAbortSource` is passed in rather than read from the session: `session.currentAbortSource`
+ * is cleared once the turn settles, so only the caller that observed `agent_end` still knows
+ * who owned the abort.
  */
-export declare function buildRpcSessionState(session: AgentSession): RpcSessionState;
+export declare function buildRpcSessionState(session: AgentSession, lastAbortSource?: AgentAbortSource): RpcSessionState;
 /**
  * Create a per-connection RPC handler bound to one runtime host and one sink.
  *

package/dist/modes/rpc/connection-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection-handler.d.ts","sourceRoot":"","sources":["../../../src/modes/rpc/connection-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAwC/E,OAAO,KAAK,EAWX,eAAe,EAEf,MAAM,gBAAgB,CAAC;AAGxB,kFAAkF;AAClF,MAAM,WAAW,oBAAoB;IACpC,mFAAmF;IACnF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,iFAAiF;IACjF,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,0DAA0D;IAC1D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,oBAAoB;IACpC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,sEAAsE;IACtE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C;;;OAGG;IACH,mBAAmB,IAAI,OAAO,CAAC;IAC/B,iFAAiF;IACjF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AA4BD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,eAAe,CAsC3E;AA4BD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACzC,WAAW,EAAE,mBAAmB,EAChC,IAAI,EAAE,iBAAiB,EACvB,OAAO,GAAE,oBAAyB,GAChC,oBAAoB,CA4pCtB"}
+{"version":3,"file":"connection-handler.d.ts","sourceRoot":"","sources":["../../../src/modes/rpc/connection-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAyC/E,OAAO,KAAK,EAYX,eAAe,EAEf,MAAM,gBAAgB,CAAC;AAGxB,kFAAkF;AAClF,MAAM,WAAW,oBAAoB;IACpC,mFAAmF;IACnF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,iFAAiF;IACjF,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,0DAA0D;IAC1D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,oBAAoB;IACpC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,sEAAsE;IACtE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C;;;OAGG;IACH,mBAAmB,IAAI,OAAO,CAAC;IAC/B,4EAA4E;IAC5E,gCAAgC,IAAI,IAAI,CAAC;IACzC,iFAAiF;IACjF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AA4BD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,EAAE,eAAe,CAAC,EAAE,gBAAgB,GAAG,eAAe,CAkD/G;AA4BD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACzC,WAAW,EAAE,mBAAmB,EAChC,IAAI,EAAE,iBAAiB,EACvB,OAAO,GAAE,oBAAyB,GAChC,oBAAoB,CAyvCtB"}

package/dist/modes/rpc/connection-handler.js

@@ -25,11 +25,12 @@ import { CLAUDE_SDK_OAUTH_PROVIDER_ID } from "../../core/extensions/builtin/clau
 import { isMcpControlInventoryChanged, MCP_CONTROL_INVENTORY_CHANGED_EVENT, MCP_CONTROL_INVENTORY_REQUEST_EVENT, } from "../../core/extensions/builtin/mcp/control-inventory.js";
 import { applyFastMode, resolveServiceTierMemoryModel, } from "../../core/extensions/builtin/service-tier.js";
 import { getSupportedThinkingLevels } from "../../core/thinking-levels.js";
+import { ProjectTrustStore } from "../../core/trust-manager.js";
 import { theme } from "../interactive/theme/theme.js";
 import { buildCustomUnsupportedRequest, DEFAULT_CUSTOM_EXTENSION_LABEL, EXTENSION_EVENTS_CAPABILITY, } from "./custom-capability.js";
 import { createRpcEventOutputBuffer } from "./event-output-buffer.js";
 import { buildRpcCommandsForSession, createCommandsChangedEvent, rpcCommandListDigest } from "./rpc-command-surface.js";
-import { rpcCommandShapeError, rpcMessageLengthError } from "./rpc-input-validation.js";
+import { rpcCommandPayloadError, rpcCommandShapeError, rpcMessageLengthError } from "./rpc-input-validation.js";
 import { SessionExtensionUiRequests } from "./session-extension-ui-requests.js";
 function loadedExtensionName(path) {
     const synthetic = /^<(?:builtin|inline):([^>]+)>$/.exec(path);
@@ -65,11 +66,24 @@ function loadedMcpStatus(server) {
  * Shared with `open_session` (session-command-router) so both surfaces answer with the SAME
  * fields: a second hand-rolled literal silently drifts, which is how `serviceTier`/`fastMode`
  * would otherwise be missing from an opened session's initial state.
+ *
+ * `lastAbortSource` is passed in rather than read from the session: `session.currentAbortSource`
+ * is cleared once the turn settles, so only the caller that observed `agent_end` still knows
+ * who owned the abort.
  */
-export function buildRpcSessionState(session) {
+export function buildRpcSessionState(session, lastAbortSource) {
+    const cwd = session.sessionManager.getCwd();
+    // Trust gates project-source settings (shell prefixes, project resources), so every
+    // session state projection must have an authoritative store to consult.
+    if (!session.agentDir) {
+        throw new Error("RPC session invariant violated: agentDir is required");
+    }
+    const projectTrusted = new ProjectTrustStore(session.agentDir).get(cwd) === true;
     return {
         model: session.model,
         thinkingLevel: session.thinkingLevel,
+        ...(session.thinkingSelection ? { thinkingSelection: session.thinkingSelection } : {}),
+        ...(lastAbortSource ? { lastAbortSource } : {}),
         serviceTier: session.effectiveServiceTier,
         fastMode: session.isFastModeActive(),
         isStreaming: session.isStreaming,
@@ -81,8 +95,8 @@ export function buildRpcSessionState(session) {
         sessionFile: session.sessionFile,
         sessionId: session.sessionId,
         sessionName: session.sessionName,
-        cwd: session.sessionManager.getCwd(),
-        projectTrusted: session.settingsManager?.isProjectTrusted?.() ?? true,
+        cwd,
+        projectTrusted,
         ...(session.sessionFile &&
             !existsSync(session.sessionFile) &&
             session.sessionManager
@@ -99,6 +113,9 @@ export function buildRpcSessionState(session) {
         messageCount: session.messages.length,
         pendingMessageCount: session.pendingMessageCount,
         usageTotals: session.sessionManager.getUsageTotals(),
+        contextUsage: typeof session.getContextUsage === "function" ? session.getContextUsage() : undefined,
+        favoriteModels: session.favoriteModels?.map((entry) => ({ ...entry })) ?? [],
+        scopedModels: session.scopedModels?.map((entry) => ({ ...entry })) ?? [],
     };
 }
 function loadedMcpServers(snapshot) {
@@ -131,12 +148,17 @@ function loadedSurfacesFingerprint(session, extensions, mcpServers) {
 export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     const clientCapabilities = options.capabilities;
     const routingSessionId = options.sessionId;
+    // True only while THIS connection's own command drives a replacement; the issuer
+    // already learns the new identity from its command response.
+    let replacementIssuedHere = false;
     let session = runtimeHost.session;
     let unsubscribe;
     let unsubscribeBackpressure;
     let unsubscribeLoadedSurfaces;
     let unsubscribeExtensionEvents;
     let mcpWireStatus = { servers: [] };
+    /** Abort owner of the last settled turn; `session.currentAbortSource` clears on settle. */
+    let lastAbortSource;
     let loadedSurfacesDigest;
     let rpcCommandsDigest;
     let suppressLoadedSurfaceEvents = false;
@@ -306,7 +328,6 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             // Hidden thinking label not supported in RPC mode - requires TUI message rendering access
         },
         setWidget(key, content, options) {
-            // Only support string arrays in RPC mode - factory functions are ignored
             if (content === undefined || Array.isArray(content)) {
                 output({
                     type: "extension_ui_request",
@@ -316,8 +337,14 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     widgetLines: content,
                     widgetPlacement: options?.placement,
                 });
+                return;
             }
-            // Component factories are not supported in RPC mode - would need TUI access
+            // A component factory closes over live TUI/theme state and cannot cross
+            // the RPC boundary. Never drop it silently: an opted-in client can show
+            // the same explicit degradation notice used by ctx.ui.custom.
+            const request = buildCustomUnsupportedRequest(clientCapabilities, "widget component");
+            if (request)
+                output(request);
         },
         setFooter(_factory) {
             // Custom footer not supported in RPC mode - requires TUI access
@@ -443,19 +470,60 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         }
     };
     runtimeHost.setRebindSession(async () => {
-        await rebindSession();
+        // AgentSessionRuntime invokes this callback while completing a replacement.
+        // Do not await extension binding here: extensions may wait for session work
+        // that the replacement still owns. The command response must acknowledge the
+        // committed replacement; derived surfaces refresh out of band afterwards.
+        await rebindSession(true);
     });
-    const rebindSession = async () => {
+    const rebindAfterLocalReplacement = async () => {
+        replacementIssuedHere = true;
+        try {
+            await rebindSession();
+        }
+        finally {
+            replacementIssuedHere = false;
+        }
+    };
+    const rebindSession = async (deferRefresh = false) => {
         unsubscribeLoadedSurfaces?.();
         unsubscribeExtensionEvents?.();
+        const replacedSession = session !== runtimeHost.session;
         session = runtimeHost.session;
+        if (replacedSession) {
+            lastAbortSource = undefined;
+            if (routingSessionId !== undefined || !replacementIssuedHere) {
+                // A replacement can be driven by ANY attached client, so every connection must be
+                // told the live binding moved and given the new authoritative identity. Emitted
+                // before the derived-surface refresh so a client cannot act on the old identity in
+                // the window the refresh takes.
+                outputEvent({
+                    type: "session_replaced",
+                    durableSessionId: session.sessionId,
+                    sessionFile: session.sessionFile,
+                    cwd: session.sessionManager.getCwd(),
+                    sessionName: session.sessionName,
+                });
+            }
+        }
         unsubscribeExtensionEvents = clientCapabilities?.includes(EXTENSION_EVENTS_CAPABILITY)
             ? session.extensionRunner.onRpcEvent(({ name, data }) => {
                 outputEvent({ type: "extension_event", name, data });
             })
             : undefined;
         subscribeLoadedSurfaceEvents();
-        await refreshLoadedSurfacesAfter(() => session.bindExtensions({
+        // Subscribe to the replaced session before its bind runs, not after. The bind
+        // is deferred by design - awaiting it would deadlock a client whose
+        // session_start handler blocks on an extension_ui_request it cannot answer
+        // while still awaiting the replacement response - and it still mutates the
+        // session it owns: pi-rules appends a durable scan entry from session_start.
+        // Those entries must reach every attached connection, and nothing else can
+        // carry them, because the session file is not written until an assistant
+        // message exists, so a client that misses the notification can never
+        // reconstruct the session it is bound to. Installing here also drops the
+        // previous session's subscription immediately instead of after the bind.
+        installSessionSubscriptions();
+        const refresh = refreshLoadedSurfacesAfter(() => session.bindExtensions({
             uiContext: createExtensionUIContext(),
             mode: "rpc",
             commandContextActions: {
@@ -500,22 +568,52 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 });
             },
         }), true);
-        unsubscribe?.();
-        unsubscribeBackpressure?.();
-        unsubscribe = session.subscribe((event) => {
-            if (event.type === "skill_invocation") {
-                outputEvent(event);
-                return;
-            }
-            if (event.type === "command_invocation") {
+        function installSessionSubscriptions() {
+            unsubscribe?.();
+            unsubscribeBackpressure?.();
+            unsubscribe = session.subscribe((event) => {
+                if (event.type === "skill_invocation") {
+                    outputEvent(event);
+                    return;
+                }
+                if (event.type === "command_invocation") {
+                    outputEvent(event);
+                    return;
+                }
+                if (event.type === "thinking_level_changed" || event.type === "model_changed") {
+                    // Core emits the effective level only; the selection provenance lives beside it
+                    // on the session and is what distinguishes an explicit choice from a default.
+                    const thinkingSelection = session.thinkingSelection;
+                    outputEvent(thinkingSelection === undefined ? event : { ...event, thinkingSelection });
+                    return;
+                }
+                if (event.type === "agent_end") {
+                    // The subscribe-path `agent_end` carries only { type, messages, willRetry };
+                    // the abort provenance the extension hook receives is stripped from it. Read
+                    // it from the session, which still reports the owner at this point, and retain
+                    // it for `get_state` because the getter clears once the turn settles.
+                    const abortSource = session.currentAbortSource;
+                    if (abortSource !== undefined)
+                        lastAbortSource = abortSource;
+                    outputEvent(abortSource === undefined ? event : { ...event, aborted: true, abortSource });
+                    return;
+                }
                 outputEvent(event);
-                return;
-            }
-            outputEvent(event);
-        });
-        unsubscribeBackpressure = session.agent.subscribe(async () => {
-            await waitForRpcBackpressure();
-        });
+            });
+            unsubscribeBackpressure = session.agent.subscribe(async () => {
+                await waitForRpcBackpressure();
+            });
+        }
+        if (deferRefresh) {
+            // The subscription is already installed on the replaced session above, so
+            // the deferred refresh only needs its failure reported. Re-installing here
+            // would replay the settings-source selection a second time.
+            void refresh.catch((cause) => {
+                outputEvent({ type: "rpc_error", error: String(cause) });
+            });
+            return;
+        }
+        await refresh;
     };
     /**
      * Drive an OAuth login for one provider as fire-command-then-subscribe.
@@ -623,6 +721,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     images: command.images,
                     streamingBehavior: command.streamingBehavior,
                     thinkingLevel: command.thinkingLevel,
+                    sessionTitlePrompt: command.sessionTitlePrompt,
                     expandPromptTemplates: command.expandPromptTemplates,
                     source: "rpc",
                     promptDisposition: (nextDisposition) => {
@@ -648,13 +747,11 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     ? { role: "user", content, timestamp: Date.now() }
                     : { role: "user", content, timestamp: Date.now() };
                 session.sessionManager.appendMessage(message);
-                session.messages.push(message);
+                session.agent.state.messages = session.sessionManager.buildSessionContext().messages;
                 return success(id, "append_user_message");
             }
             case "append_session_entry": {
-                session.sessionManager.appendEntry(command.entry);
-                if (command.entry.type === "message")
-                    session.messages.push(command.entry.message);
+                session.appendSessionEntry(command.entry);
                 return success(id, "append_session_entry");
             }
             case "send_custom_message": {
@@ -707,16 +804,15 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             case "new_session": {
                 const options = command.parentSession ? { parentSession: command.parentSession } : undefined;
                 const result = await runtimeHost.newSession(options);
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
                 return success(id, "new_session", result);
             }
             // =================================================================
             // State
             // =================================================================
             case "get_state":
-                return success(id, "get_state", buildRpcSessionState(session));
+                return success(id, "get_state", buildRpcSessionState(session, lastAbortSource));
             // =================================================================
             // Model
             // =================================================================
@@ -729,8 +825,14 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 const systemPromptChange = await session.setModel(model);
                 return success(id, "set_model", { ...model, systemPromptName: systemPromptChange?.systemPromptName });
             }
+            case "set_favorite_models":
+                session.setFavoriteModels(command.models);
+                return success(id, "set_favorite_models");
+            case "set_scoped_models":
+                session.setScopedModels(command.models);
+                return success(id, "set_scoped_models");
             case "cycle_model": {
-                const result = await session.cycleModel();
+                const result = await session.cycleModel(command.direction);
                 if (!result) {
                     return success(id, "cycle_model", null);
                 }
@@ -861,7 +963,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 session.sessionManager.appendLabelChange(command.entryId, command.label);
                 return success(id, "set_label");
             case "bash": {
-                outputEvent({ type: "bash_start" });
+                if (routingSessionId !== undefined)
+                    outputEvent({ type: "bash_start" });
                 try {
                     const eventResult = await session.extensionRunner.emitUserBash({
                         type: "user_bash",
@@ -877,6 +980,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     }
                     const result = await session.executeBash(command.command, undefined, {
                         excludeFromContext: command.excludeFromContext,
+                        id: command.executionId,
                         // Functions cannot cross JSONL. Host extensions may still provide the
                         // executable operations object; client-supplied data is only a wire-safe hint.
                         operations: eventResult?.operations,
@@ -884,13 +988,17 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     return success(id, "bash", result);
                 }
                 finally {
-                    outputEvent({ type: "bash_end" });
+                    if (routingSessionId !== undefined)
+                        outputEvent({ type: "bash_end" });
                 }
             }
             case "abort_bash": {
                 session.abortBash();
                 return success(id, "abort_bash");
             }
+            case "cleanup_bash_output":
+                await session.cleanupBashOutput(command.path);
+                return success(id, "cleanup_bash_output");
             // =================================================================
             // Session
             // =================================================================
@@ -899,7 +1007,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 return success(id, "get_session_stats", stats);
             }
             case "export_html": {
-                const path = await session.exportToHtml(command.outputPath);
+                const path = await session.exportToHtml(command.outputPath, { themeName: command.themeName });
                 return success(id, "export_html", { path });
             }
             case "export_jsonl": {
@@ -907,16 +1015,14 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             }
             case "switch_session": {
                 const result = await runtimeHost.switchSession(command.sessionPath, { cwdOverride: command.cwdOverride });
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
                 return success(id, "switch_session", result);
             }
             case "fork": {
                 const result = await runtimeHost.fork(command.entryId, { position: command.position });
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
                 return success(id, "fork", { text: result.selectedText, cancelled: result.cancelled });
             }
             case "clone": {
@@ -925,9 +1031,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     return error(id, "clone", "Cannot clone session: no current entry selected");
                 }
                 const result = await runtimeHost.fork(leafId, { position: "at" });
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
                 return success(id, "clone", { cancelled: result.cancelled });
             }
             case "get_fork_messages": {
@@ -956,8 +1061,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             }
             case "import_jsonl": {
                 const result = await runtimeHost.importFromJsonl(command.inputPath, command.cwdOverride);
-                if (!result.cancelled)
-                    await rebindSession();
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
                 return success(id, "import_jsonl", result);
             }
             case "set_session_name": {
@@ -1079,9 +1184,10 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             return;
         }
         const command = parsed;
+        const payloadError = rpcCommandPayloadError(command);
         const messageLengthError = rpcMessageLengthError(command);
-        if (messageLengthError) {
-            output(error(command.id, command.type, messageLengthError));
+        if (payloadError || messageLengthError) {
+            output(error(command.id, command.type, payloadError ?? messageLengthError));
             await waitForRpcBackpressure();
             return;
         }
@@ -1125,6 +1231,9 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         isShutdownRequested() {
             return shutdownRequested;
         },
+        cancelPendingExtensionUiRequests() {
+            pendingExtensionRequests.cancelAll();
+        },
         async dispose() {
             await ready;
             await dispose();