@code-yeongyu/senpi 2026.8.14 → 2026.8.17

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

@@ -20,10 +20,13 @@ import { buildLoginProviderInfos } from "../../core/auth-providers.js";
 import { emitProviderAccountsChanged, subscribeProviderAccountEvents, } from "../../core/extensions/builtin/claude-sdk-oauth/account-events.js";
 import { CLAUDE_SDK_OAUTH_PROVIDER_ID, getProviderAccounts, pinProviderAccount, removeProviderAccount, } from "../../core/extensions/builtin/claude-sdk-oauth/account-management.js";
 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 { 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 { SessionExtensionUiRequests } from "./session-extension-ui-requests.js";
 function loadedExtensionName(path) {
     const synthetic = /^<(?:builtin|inline):([^>]+)>$/.exec(path);
@@ -53,6 +56,31 @@ function loadedMcpStatus(server) {
         return "needs_auth";
     return "enabled";
 }
+/**
+ * Project one session into the wire state shape.
+ *
+ * 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.
+ */
+export function buildRpcSessionState(session) {
+    return {
+        model: session.model,
+        thinkingLevel: session.thinkingLevel,
+        serviceTier: session.effectiveServiceTier,
+        fastMode: session.isFastModeActive(),
+        isStreaming: session.isStreaming,
+        isCompacting: session.isCompacting,
+        steeringMode: session.steeringMode,
+        followUpMode: session.followUpMode,
+        sessionFile: session.sessionFile,
+        sessionId: session.sessionId,
+        sessionName: session.sessionName,
+        autoCompactionEnabled: session.autoCompactionEnabled,
+        messageCount: session.messages.length,
+        pendingMessageCount: session.pendingMessageCount,
+    };
+}
 function loadedMcpServers(snapshot) {
     return snapshot.servers.map((server) => ({
         name: server.name,
@@ -90,6 +118,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     let unsubscribeExtensionEvents;
     let mcpWireStatus = { servers: [] };
     let loadedSurfacesDigest;
+    let rpcCommandsDigest;
     let suppressLoadedSurfaceEvents = false;
     const eventOutput = createRpcEventOutputBuffer(sink.writeRaw);
     const tagSessionRecord = (value) => routingSessionId === undefined ? value : { ...value, sessionId: routingSessionId };
@@ -366,14 +395,21 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         suppressLoadedSurfaceEvents = true;
         if (resetMcp)
             mcpWireStatus = { servers: [] };
+        let commandsChanged;
         try {
             await operation();
             await requestMcpWireStatus();
             loadedSurfacesDigest = currentLoadedSurfaces().digest;
+            const commands = buildRpcCommandsForSession(session);
+            commandsChanged = createCommandsChangedEvent(rpcCommandsDigest, commands);
+            rpcCommandsDigest = rpcCommandListDigest(commands);
         }
         finally {
             suppressLoadedSurfaceEvents = wasSuppressed;
         }
+        if (!wasSuppressed && commandsChanged) {
+            outputEvent(commandsChanged);
+        }
         if (!wasSuppressed && previousDigest !== undefined && previousDigest !== loadedSurfacesDigest) {
             outputEvent({ type: "loaded_surfaces_changed" });
         }
@@ -439,6 +475,14 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         unsubscribe?.();
         unsubscribeBackpressure?.();
         unsubscribe = session.subscribe((event) => {
+            if (event.type === "skill_invocation") {
+                outputEvent(event);
+                return;
+            }
+            if (event.type === "command_invocation") {
+                outputEvent(event);
+                return;
+            }
             outputEvent(event);
         });
         unsubscribeBackpressure = session.agent.subscribe(async () => {
@@ -493,6 +537,27 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             }
         }
     };
+    /**
+     * Host capabilities for `applyFastMode`, mirroring what the `/fast` command passes from its
+     * extension context. The notification is dropped: a command response carries the message
+     * (`data` on success, `error` on refusal), so a duplicate `extension_ui_request` would be noise.
+     */
+    const fastModeContext = () => ({
+        cwd: session.cwd,
+        agentDir: session.agentDir,
+        model: session.model,
+        modelRegistry: session.modelRegistry,
+        serviceTier: session.serviceTier,
+        isProjectTrusted: () => session.settingsManager.isProjectTrusted(),
+        notify: () => { },
+        setSessionModel: async (model) => {
+            if (!session.modelRuntime.hasConfiguredAuth(model.provider))
+                return false;
+            await session.setSessionModel(model);
+            return true;
+        },
+        setSessionFastMode: (enabled) => session.setSessionFastMode(enabled),
+    });
     // Handle a single command
     const handleCommand = async (command) => {
         const id = command.id;
@@ -524,7 +589,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     thinkingLevel: command.thinkingLevel,
                     source: "rpc",
                     preflightResult: (didSucceed) => {
-                        if (didSucceed) {
+                        if (didSucceed && !preflightSucceeded) {
                             preflightSucceeded = true;
                             output(success(id, "prompt"));
                         }
@@ -560,23 +625,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             // =================================================================
             // State
             // =================================================================
-            case "get_state": {
-                const state = {
-                    model: session.model,
-                    thinkingLevel: session.thinkingLevel,
-                    isStreaming: session.isStreaming,
-                    isCompacting: session.isCompacting,
-                    steeringMode: session.steeringMode,
-                    followUpMode: session.followUpMode,
-                    sessionFile: session.sessionFile,
-                    sessionId: session.sessionId,
-                    sessionName: session.sessionName,
-                    autoCompactionEnabled: session.autoCompactionEnabled,
-                    messageCount: session.messages.length,
-                    pendingMessageCount: session.pendingMessageCount,
-                };
-                return success(id, "get_state", state);
-            }
+            case "get_state":
+                return success(id, "get_state", buildRpcSessionState(session));
             // =================================================================
             // Model
             // =================================================================
@@ -610,10 +660,13 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             // =================================================================
             case "set_thinking_level": {
                 if (command.scope === "turn") {
-                    session.setSessionThinkingLevel(command.level);
-                    if (session.thinkingLevel !== command.level) {
+                    // Validate BEFORE mutating: the session clamps an unsupported level to a supported
+                    // neighbour, so applying first would leave a REJECTED request's clamped level in
+                    // place. A failed command must not change session state.
+                    if (!session.getAvailableThinkingLevels().includes(command.level)) {
                         return error(id, "set_thinking_level", `Thinking level ${command.level} is not supported by the active model.`);
                     }
+                    session.setSessionThinkingLevel(command.level);
                 }
                 else {
                     session.setThinkingLevel(command.level);
@@ -632,6 +685,39 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     levels: session.getAvailableThinkingLevels(),
                 });
             // =================================================================
+            // Fast mode
+            // =================================================================
+            case "set_fast_mode": {
+                if (typeof command.enabled !== "boolean") {
+                    return error(id, "set_fast_mode", "set_fast_mode requires a boolean 'enabled' field.");
+                }
+                const model = session.model;
+                if (!model) {
+                    return error(id, "set_fast_mode", "No active model.");
+                }
+                // Same entry point as the /fast command: persistence, `-fast` key normalization,
+                // and pin precedence live in applyFastMode, never duplicated here.
+                const result = await applyFastMode(fastModeContext(), command.enabled);
+                if (!result.applied) {
+                    // A refusal (non-Codex model, active `:priority` pin, failed model switch) has no
+                    // notification channel for a command response, so it is reported as an error
+                    // instead of a success that silently did nothing.
+                    return error(id, "set_fast_mode", result.message);
+                }
+                const memoryModel = resolveServiceTierMemoryModel(session.modelRegistry, session.model ?? model);
+                return success(id, "set_fast_mode", {
+                    enabled: result.enabled,
+                    serviceTier: result.recordedTier,
+                    provider: memoryModel.provider,
+                    modelId: memoryModel.id,
+                });
+            }
+            case "get_fast_mode":
+                return success(id, "get_fast_mode", {
+                    enabled: session.isFastModeActive(),
+                    serviceTier: session.effectiveServiceTier ?? null,
+                });
+            // =================================================================
             // Queue Modes
             // =================================================================
             case "set_steering_mode": {
@@ -768,32 +854,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             // Commands (available for invocation via prompt)
             // =================================================================
             case "get_commands": {
-                const commands = [];
-                for (const command of session.extensionRunner.getRegisteredCommands()) {
-                    commands.push({
-                        name: command.invocationName,
-                        description: command.description,
-                        source: "extension",
-                        sourceInfo: command.sourceInfo,
-                    });
-                }
-                for (const template of session.promptTemplates) {
-                    commands.push({
-                        name: template.name,
-                        description: template.description,
-                        source: "prompt",
-                        sourceInfo: template.sourceInfo,
-                    });
-                }
-                for (const skill of session.resourceLoader.getSkills().skills) {
-                    commands.push({
-                        name: `skill:${skill.name}`,
-                        description: skill.description,
-                        source: "skill",
-                        sourceInfo: skill.sourceInfo,
-                    });
-                }
-                return success(id, "get_commands", { commands });
+                return success(id, "get_commands", { commands: buildRpcCommandsForSession(session) });
             }
             case "get_loaded_surfaces": {
                 await requestMcpWireStatus();
@@ -874,6 +935,12 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             await waitForRpcBackpressure();
             return;
         }
+        const shapeError = rpcCommandShapeError(parsed);
+        if (shapeError) {
+            output(error(undefined, "parse", shapeError));
+            await waitForRpcBackpressure();
+            return;
+        }
         // Handle extension UI responses
         if (typeof parsed === "object" &&
             parsed !== null &&
@@ -888,6 +955,12 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             return;
         }
         const command = parsed;
+        const messageLengthError = rpcMessageLengthError(command);
+        if (messageLengthError) {
+            output(error(command.id, command.type, messageLengthError));
+            await waitForRpcBackpressure();
+            return;
+        }
         try {
             const response = await handleCommand(command);
             if (response) {