@getpaseo/server 0.1.61 → 0.1.63

package/dist/server/server/websocket-server.js

@@ -1,68 +1,84 @@
 import { WebSocketServer } from "ws";
-import { join } from "path";
+import { basename, join } from "path";
 import { hostname as getHostname } from "node:os";
+import { applyMutableProviderConfigToOverrides } from "./daemon-config-store.js";
 import { WSInboundMessageSchema, wrapSessionMessage, } from "./messages.js";
 import { asUint8Array, decodeTerminalStreamFrame } from "../shared/terminal-stream-protocol.js";
 import { isHostnameAllowed } from "./hostnames.js";
 import { Session } from "./session.js";
 import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
-import { buildProviderRegistry } from "./agent/provider-registry.js";
+import { buildProviderRegistry, createClientsFromRegistry } from "./agent/provider-registry.js";
+import { buildWorkspaceGitMetadataFromSnapshot } from "./workspace-git-metadata.js";
 import { PushTokenStore } from "./push/token-store.js";
 import { PushService } from "./push/push-service.js";
 import { computeNotificationPlan } from "./agent-attention-policy.js";
 import { buildAgentAttentionNotificationPayload, findLatestPermissionRequest, } from "../shared/agent-attention-notification.js";
 import { createGitHubService } from "../services/github-service.js";
+function createFallbackWorkspaceGitSnapshot(cwd) {
+    return {
+        cwd,
+        git: {
+            isGit: false,
+            repoRoot: null,
+            mainRepoRoot: null,
+            currentBranch: null,
+            remoteUrl: null,
+            isPaseoOwnedWorktree: false,
+            isDirty: null,
+            baseRef: null,
+            aheadBehind: null,
+            aheadOfOrigin: null,
+            behindOfOrigin: null,
+            hasRemote: false,
+            diffStat: null,
+        },
+        github: {
+            featuresEnabled: false,
+            pullRequest: null,
+            error: null,
+        },
+    };
+}
 function createFallbackWorkspaceGitService() {
     return {
-        subscribe: async ({ cwd }) => ({
-            initial: {
-                cwd,
-                git: {
-                    isGit: false,
-                    repoRoot: null,
-                    mainRepoRoot: null,
-                    currentBranch: null,
-                    remoteUrl: null,
-                    isPaseoOwnedWorktree: false,
-                    isDirty: null,
-                    aheadBehind: null,
-                    aheadOfOrigin: null,
-                    behindOfOrigin: null,
-                    diffStat: null,
-                },
-                github: {
-                    featuresEnabled: false,
-                    pullRequest: null,
-                    error: null,
-                },
-            },
+        registerWorkspace: () => ({
             unsubscribe: () => { },
         }),
         peekSnapshot: () => null,
-        getSnapshot: async (cwd) => ({
+        getCheckout: async (cwd) => ({
             cwd,
-            git: {
-                isGit: false,
-                repoRoot: null,
-                mainRepoRoot: null,
-                currentBranch: null,
-                remoteUrl: null,
-                isPaseoOwnedWorktree: false,
-                isDirty: null,
-                aheadBehind: null,
-                aheadOfOrigin: null,
-                behindOfOrigin: null,
-                diffStat: null,
-            },
-            github: {
-                featuresEnabled: false,
-                pullRequest: null,
-                error: null,
-            },
+            isGit: false,
+            currentBranch: null,
+            remoteUrl: null,
+            worktreeRoot: null,
+            isPaseoOwnedWorktree: false,
+            mainRepoRoot: null,
         }),
+        getSnapshot: async (cwd) => createFallbackWorkspaceGitSnapshot(cwd),
+        getCheckoutDiff: async () => ({ diff: "" }),
+        validateBranchRef: async () => ({ kind: "not-found" }),
+        hasLocalBranch: async () => false,
+        suggestBranchesForCwd: async () => [],
+        listStashes: async () => [],
+        listWorktrees: async () => [],
+        getWorkspaceGitMetadata: async (cwd, options) => {
+            const snapshot = createFallbackWorkspaceGitSnapshot(cwd);
+            return buildWorkspaceGitMetadataFromSnapshot({
+                cwd,
+                directoryName: options?.directoryName ?? basename(cwd),
+                isGit: snapshot.git.isGit,
+                repoRoot: snapshot.git.repoRoot,
+                mainRepoRoot: snapshot.git.mainRepoRoot,
+                currentBranch: snapshot.git.currentBranch,
+                remoteUrl: snapshot.git.remoteUrl,
+            });
+        },
+        resolveRepoRoot: async (cwd) => cwd,
+        resolveDefaultBranch: async () => "main",
+        resolveRepoRemoteUrl: async () => null,
         refresh: async () => { },
-        requestWorkingTreeWatch: async (cwd) => ({
-            repoRoot: cwd,
+        requestWorkingTreeWatch: async () => ({
+            repoRoot: null,
             unsubscribe: () => { },
         }),
         scheduleRefreshForCwd: () => { },
@@ -163,6 +179,22 @@ export class MissingDaemonVersionError extends Error {
         this.name = "MissingDaemonVersionError";
     }
 }
+function requireWebSocketServices(params) {
+    const { chatService, loopService, scheduleService, checkoutDiffManager } = params;
+    if (!chatService) {
+        throw new Error("VoiceAssistantWebSocketServer requires a chat service.");
+    }
+    if (!loopService) {
+        throw new Error("VoiceAssistantWebSocketServer requires a loop service.");
+    }
+    if (!scheduleService) {
+        throw new Error("VoiceAssistantWebSocketServer requires a schedule service.");
+    }
+    if (!checkoutDiffManager) {
+        throw new Error("VoiceAssistantWebSocketServer requires a checkout diff manager.");
+    }
+    return { chatService, loopService, scheduleService, checkoutDiffManager };
+}
 /**
  * WebSocket server that only accepts sockets + parses/forwards messages to the session layer.
  */
@@ -214,47 +246,43 @@ export class VoiceAssistantWebSocketServer {
         this.agentStorage = agentStorage;
         this.projectRegistry = projectRegistry ?? createNoopProjectRegistry();
         this.workspaceRegistry = workspaceRegistry ?? createNoopWorkspaceRegistry();
-        if (!chatService) {
-            throw new Error("VoiceAssistantWebSocketServer requires a chat service.");
-        }
-        this.chatService = chatService;
-        if (!loopService) {
-            throw new Error("VoiceAssistantWebSocketServer requires a loop service.");
-        }
-        this.loopService = loopService;
-        if (!scheduleService) {
-            throw new Error("VoiceAssistantWebSocketServer requires a schedule service.");
-        }
-        this.scheduleService = scheduleService;
-        if (!checkoutDiffManager) {
-            throw new Error("VoiceAssistantWebSocketServer requires a checkout diff manager.");
-        }
-        this.checkoutDiffManager = checkoutDiffManager;
+        const requiredServices = requireWebSocketServices({
+            chatService,
+            loopService,
+            scheduleService,
+            checkoutDiffManager,
+        });
+        this.chatService = requiredServices.chatService;
+        this.loopService = requiredServices.loopService;
+        this.scheduleService = requiredServices.scheduleService;
+        this.checkoutDiffManager = requiredServices.checkoutDiffManager;
         this.github = github ?? createGitHubService();
         this.workspaceGitService = workspaceGitService ?? createFallbackWorkspaceGitService();
         this.downloadTokenStore = downloadTokenStore;
         this.paseoHome = paseoHome;
         this.daemonConfigStore = daemonConfigStore;
         this.mcpBaseUrl = mcpBaseUrl;
-        this.speech = speech ?? null;
-        this.terminalManager = terminalManager ?? null;
-        this.dictation = dictation ?? null;
-        this.agentProviderRuntimeSettings = agentProviderRuntimeSettings;
-        this.providerOverrides = providerOverrides;
-        this.isDev = isDev === true;
+        this.assignOptionalServices({
+            speech,
+            terminalManager,
+            dictation,
+            agentProviderRuntimeSettings,
+            providerOverrides,
+            isDev,
+            onLifecycleIntent,
+            scriptRouteStore,
+            scriptRuntimeStore,
+            onBranchChanged,
+            getDaemonTcpPort,
+            getDaemonTcpHost,
+            resolveScriptHealth,
+        });
         const providerSnapshotLogger = this.logger.child({ module: "provider-snapshot-manager" });
         this.providerSnapshotManager = new ProviderSnapshotManager(buildProviderRegistry(providerSnapshotLogger, {
             runtimeSettings: this.agentProviderRuntimeSettings,
             providerOverrides: this.providerOverrides,
             isDev: this.isDev,
         }), providerSnapshotLogger);
-        this.onLifecycleIntent = onLifecycleIntent ?? null;
-        this.scriptRouteStore = scriptRouteStore ?? null;
-        this.scriptRuntimeStore = scriptRuntimeStore ?? null;
-        this.onBranchChanged = onBranchChanged ?? null;
-        this.getDaemonTcpPort = getDaemonTcpPort ?? null;
-        this.getDaemonTcpHost = getDaemonTcpHost ?? null;
-        this.resolveScriptHealth = resolveScriptHealth ?? null;
         this.serverCapabilities = buildServerCapabilities({
             readiness: this.speech?.getReadiness() ?? null,
         });
@@ -263,6 +291,15 @@ export class VoiceAssistantWebSocketServer {
                 this.publishSpeechReadiness(snapshot);
             }) ?? null;
         this.unsubscribeDaemonConfigChange = this.daemonConfigStore.onChange((config) => {
+            this.providerOverrides = applyMutableProviderConfigToOverrides(this.providerOverrides, config.providers);
+            const registry = buildProviderRegistry(providerSnapshotLogger, {
+                runtimeSettings: this.agentProviderRuntimeSettings,
+                providerOverrides: this.providerOverrides,
+                isDev: this.isDev,
+            });
+            const clients = createClientsFromRegistry(registry, providerSnapshotLogger);
+            this.providerSnapshotManager.replaceRegistry(registry);
+            this.agentManager.updateProviderRegistry({ providerDefinitions: registry, clients });
             this.broadcastDaemonConfigChanged(config);
         });
         const pushLogger = this.logger.child({ module: "push" });
@@ -273,42 +310,67 @@ export class VoiceAssistantWebSocketServer {
                 this.logger.warn({ err, agentId: params.agentId }, "Failed to broadcast agent attention");
             });
         });
+        this.wss = this.createWebSocketServer(server, wsConfig);
+        this.startRuntimeMetricsInterval();
+        this.logger.info("WebSocket server initialized on /ws");
+    }
+    assignOptionalServices(params) {
+        this.speech = params.speech ?? null;
+        this.terminalManager = params.terminalManager ?? null;
+        this.dictation = params.dictation ?? null;
+        this.agentProviderRuntimeSettings = params.agentProviderRuntimeSettings;
+        this.providerOverrides = params.providerOverrides;
+        this.isDev = params.isDev === true;
+        this.onLifecycleIntent = params.onLifecycleIntent ?? null;
+        this.scriptRouteStore = params.scriptRouteStore ?? null;
+        this.scriptRuntimeStore = params.scriptRuntimeStore ?? null;
+        this.onBranchChanged = params.onBranchChanged ?? null;
+        this.getDaemonTcpPort = params.getDaemonTcpPort ?? null;
+        this.getDaemonTcpHost = params.getDaemonTcpHost ?? null;
+        this.resolveScriptHealth = params.resolveScriptHealth ?? null;
+    }
+    createWebSocketServer(server, wsConfig) {
         const { allowedOrigins, hostnames } = wsConfig;
-        this.wss = new WebSocketServer({
+        const wss = new WebSocketServer({
             server,
             path: "/ws",
             verifyClient: ({ req }, callback) => {
-                const requestMetadata = extractSocketRequestMetadata(req);
-                const origin = requestMetadata.origin;
-                const requestHost = requestMetadata.host ?? null;
-                if (requestHost && !isHostnameAllowed(requestHost, hostnames)) {
-                    this.incrementRuntimeCounter("hostRejected");
-                    this.logger.warn({ ...requestMetadata, host: requestHost }, "Rejected connection from disallowed host");
-                    callback(false, 403, "Host not allowed");
-                    return;
-                }
-                const sameOrigin = !!origin &&
-                    !!requestHost &&
-                    (origin === `http://${requestHost}` || origin === `https://${requestHost}`);
-                if (!origin || allowedOrigins.has("*") || allowedOrigins.has(origin) || sameOrigin) {
-                    callback(true);
-                }
-                else {
-                    this.incrementRuntimeCounter("originRejected");
-                    this.logger.warn({ ...requestMetadata, origin }, "Rejected connection from origin");
-                    callback(false, 403, "Origin not allowed");
-                }
+                this.verifyWsClient(req, allowedOrigins, hostnames, callback);
             },
         });
-        this.wss.on("connection", (ws, request) => {
+        wss.on("connection", (ws, request) => {
             void this.attachSocket(ws, request);
         });
+        return wss;
+    }
+    startRuntimeMetricsInterval() {
         const runtimeMetricsInterval = setInterval(() => {
             this.flushRuntimeMetrics();
         }, WS_RUNTIME_METRICS_FLUSH_MS);
         this.runtimeMetricsInterval = runtimeMetricsInterval;
         runtimeMetricsInterval.unref?.();
-        this.logger.info("WebSocket server initialized on /ws");
+    }
+    verifyWsClient(req, allowedOrigins, hostnames, callback) {
+        const requestMetadata = extractSocketRequestMetadata(req);
+        const origin = requestMetadata.origin;
+        const requestHost = requestMetadata.host ?? null;
+        if (requestHost && !isHostnameAllowed(requestHost, hostnames)) {
+            this.incrementRuntimeCounter("hostRejected");
+            this.logger.warn({ ...requestMetadata, host: requestHost }, "Rejected connection from disallowed host");
+            callback(false, 403, "Host not allowed");
+            return;
+        }
+        const sameOrigin = !!origin &&
+            !!requestHost &&
+            (origin === `http://${requestHost}` || origin === `https://${requestHost}`);
+        if (!origin || allowedOrigins.has("*") || allowedOrigins.has(origin) || sameOrigin) {
+            callback(true);
+        }
+        else {
+            this.incrementRuntimeCounter("originRejected");
+            this.logger.warn({ ...requestMetadata, origin }, "Rejected connection from origin");
+            callback(false, 403, "Origin not allowed");
+        }
     }
     broadcast(message) {
         const payload = JSON.stringify(message);
@@ -672,16 +734,20 @@ export class VoiceAssistantWebSocketServer {
         this.broadcast(this.createDaemonConfigChangedMessage(config));
     }
     bindSocketHandlers(ws) {
-        ws.on("message", (data) => {
+        ws.on("message", (...args) => {
+            const data = args[0];
             void this.handleRawMessage(ws, data);
         });
-        ws.on("close", async (code, reason) => {
+        ws.on("close", async (...args) => {
+            const code = args[0];
+            const reason = args[1];
             await this.detachSocket(ws, {
                 code: typeof code === "number" ? code : undefined,
                 reason,
             });
         });
-        ws.on("error", async (error) => {
+        ws.on("error", async (...args) => {
+            const error = args[0];
             const err = error instanceof Error ? error : new Error(String(error));
             const active = this.sessions.get(ws);
             const pending = this.pendingConnections.get(ws);
@@ -762,81 +828,126 @@ export class VoiceAssistantWebSocketServer {
         connection.connectionLogger.trace({ clientId: connection.clientId, totalSessions: this.sessions.size }, logMessage);
         await connection.session.cleanup();
     }
+    handleInvalidInboundMessage(args) {
+        const { ws, parsed, parsedMessage, pendingConnection, activeConnection, log } = args;
+        this.incrementRuntimeCounter("validationFailed");
+        if (pendingConnection) {
+            pendingConnection.connectionLogger.warn({ error: parsedMessage.error.message }, "Rejected pending message before hello");
+            this.clearPendingConnection(ws);
+            try {
+                ws.close(WS_CLOSE_INVALID_HELLO, "Invalid hello");
+            }
+            catch {
+                // ignore close errors
+            }
+            return;
+        }
+        const requestInfo = extractRequestInfoFromUnknownWsInbound(parsed);
+        const isUnknownSchema = requestInfo?.requestId != null &&
+            typeof parsed === "object" &&
+            parsed != null &&
+            "type" in parsed &&
+            parsed.type === "session";
+        log.warn({
+            clientId: activeConnection?.clientId,
+            requestId: requestInfo?.requestId,
+            requestType: requestInfo?.requestType,
+            error: parsedMessage.error.message,
+        }, "WS inbound message validation failed");
+        if (requestInfo) {
+            this.sendToClient(ws, wrapSessionMessage({
+                type: "rpc_error",
+                payload: {
+                    requestId: requestInfo.requestId,
+                    requestType: requestInfo.requestType,
+                    error: isUnknownSchema ? "Unknown request schema" : "Invalid message",
+                    code: isUnknownSchema ? "unknown_schema" : "invalid_message",
+                },
+            }));
+            return;
+        }
+        const errorMessage = `Invalid message: ${parsedMessage.error.message}`;
+        this.sendToClient(ws, wrapSessionMessage({
+            type: "status",
+            payload: {
+                status: "error",
+                message: errorMessage,
+            },
+        }));
+    }
+    maybeHandleBinaryFrame(params) {
+        const { ws, buffer, activeConnection, log } = params;
+        const asBytes = asUint8Array(buffer);
+        if (!asBytes) {
+            return false;
+        }
+        const frame = decodeTerminalStreamFrame(asBytes);
+        if (!frame) {
+            return false;
+        }
+        if (!activeConnection) {
+            this.incrementRuntimeCounter("binaryBeforeHelloRejected");
+            log.warn("Rejected binary frame before hello");
+            this.clearPendingConnection(ws);
+            try {
+                ws.close(WS_CLOSE_INVALID_HELLO, "Session message before hello");
+            }
+            catch {
+                // ignore close errors
+            }
+            return true;
+        }
+        activeConnection.session.handleBinaryFrame(frame);
+        return true;
+    }
+    handlePendingConnectionMessage(params) {
+        const { ws, message, pendingConnection } = params;
+        if (message.type === "hello") {
+            this.handleHello({
+                ws,
+                message,
+                pending: pendingConnection,
+            });
+            return;
+        }
+        pendingConnection.connectionLogger.warn({
+            messageType: message.type,
+        }, "Rejected pending message before hello");
+        this.incrementRuntimeCounter("pendingMessageRejectedBeforeHello");
+        this.clearPendingConnection(ws);
+        try {
+            ws.close(WS_CLOSE_INVALID_HELLO, "Session message before hello");
+        }
+        catch {
+            // ignore close errors
+        }
+    }
     async handleRawMessage(ws, data) {
         const activeConnection = this.sessions.get(ws);
         const pendingConnection = this.pendingConnections.get(ws);
         const log = activeConnection?.connectionLogger ?? pendingConnection?.connectionLogger ?? this.logger;
         try {
             const buffer = bufferFromWsData(data);
-            const asBytes = asUint8Array(buffer);
-            if (asBytes) {
-                const frame = decodeTerminalStreamFrame(asBytes);
-                if (frame) {
-                    if (!activeConnection) {
-                        this.incrementRuntimeCounter("binaryBeforeHelloRejected");
-                        log.warn("Rejected binary frame before hello");
-                        this.clearPendingConnection(ws);
-                        try {
-                            ws.close(WS_CLOSE_INVALID_HELLO, "Session message before hello");
-                        }
-                        catch {
-                            // ignore close errors
-                        }
-                        return;
-                    }
-                    activeConnection.session.handleBinaryFrame(frame);
-                    return;
-                }
+            const binaryHandled = this.maybeHandleBinaryFrame({
+                ws,
+                buffer,
+                activeConnection,
+                log,
+            });
+            if (binaryHandled) {
+                return;
             }
             const parsed = JSON.parse(buffer.toString());
             const parsedMessage = WSInboundMessageSchema.safeParse(parsed);
             if (!parsedMessage.success) {
-                this.incrementRuntimeCounter("validationFailed");
-                if (pendingConnection) {
-                    pendingConnection.connectionLogger.warn({
-                        error: parsedMessage.error.message,
-                    }, "Rejected pending message before hello");
-                    this.clearPendingConnection(ws);
-                    try {
-                        ws.close(WS_CLOSE_INVALID_HELLO, "Invalid hello");
-                    }
-                    catch {
-                        // ignore close errors
-                    }
-                    return;
-                }
-                const requestInfo = extractRequestInfoFromUnknownWsInbound(parsed);
-                const isUnknownSchema = requestInfo?.requestId != null &&
-                    typeof parsed === "object" &&
-                    parsed != null &&
-                    "type" in parsed &&
-                    parsed.type === "session";
-                log.warn({
-                    clientId: activeConnection?.clientId,
-                    requestId: requestInfo?.requestId,
-                    requestType: requestInfo?.requestType,
-                    error: parsedMessage.error.message,
-                }, "WS inbound message validation failed");
-                if (requestInfo) {
-                    this.sendToClient(ws, wrapSessionMessage({
-                        type: "rpc_error",
-                        payload: {
-                            requestId: requestInfo.requestId,
-                            requestType: requestInfo.requestType,
-                            error: isUnknownSchema ? "Unknown request schema" : "Invalid message",
-                            code: isUnknownSchema ? "unknown_schema" : "invalid_message",
-                        },
-                    }));
-                    return;
-                }
-                const errorMessage = `Invalid message: ${parsedMessage.error.message}`;
-                this.sendToClient(ws, wrapSessionMessage({
-                    type: "status",
-                    payload: {
-                        status: "error",
-                        message: errorMessage,
-                    },
-                }));
+                this.handleInvalidInboundMessage({
+                    ws,
+                    parsed,
+                    parsedMessage,
+                    pendingConnection,
+                    activeConnection,
+                    log,
+                });
                 return;
             }
             const message = parsedMessage.data;
@@ -849,25 +960,11 @@ export class VoiceAssistantWebSocketServer {
                 return;
             }
             if (pendingConnection) {
-                if (message.type === "hello") {
-                    this.handleHello({
-                        ws,
-                        message,
-                        pending: pendingConnection,
-                    });
-                    return;
-                }
-                pendingConnection.connectionLogger.warn({
-                    messageType: message.type,
-                }, "Rejected pending message before hello");
-                this.incrementRuntimeCounter("pendingMessageRejectedBeforeHello");
-                this.clearPendingConnection(ws);
-                try {
-                    ws.close(WS_CLOSE_INVALID_HELLO, "Session message before hello");
-                }
-                catch {
-                    // ignore close errors
-                }
+                this.handlePendingConnectionMessage({
+                    ws,
+                    message,
+                    pendingConnection,
+                });
                 return;
             }
             if (!activeConnection) {
@@ -887,74 +984,85 @@ export class VoiceAssistantWebSocketServer {
                 return;
             }
             if (message.type === "session") {
-                this.recordInboundSessionRequestType(message.message.type);
-                const startMs = performance.now();
-                await activeConnection.session.handleMessage(message.message);
-                const durationMs = performance.now() - startMs;
-                this.recordRequestLatency(message.message.type, durationMs);
-                if (durationMs >= SLOW_REQUEST_THRESHOLD_MS) {
-                    activeConnection.connectionLogger.warn({
-                        requestType: message.message.type,
-                        durationMs: Math.round(durationMs),
-                        inflightRequests: activeConnection.session.getRuntimeMetrics().inflightRequests,
-                    }, "ws_slow_request");
-                }
+                await this.dispatchSessionMessage(activeConnection, message);
             }
         }
         catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            let rawPayload = null;
-            let parsedPayload = null;
+            this.handleRawMessageError({ ws, data, error, log });
+        }
+    }
+    async dispatchSessionMessage(activeConnection, message) {
+        this.recordInboundSessionRequestType(message.message.type);
+        const startMs = performance.now();
+        await activeConnection.session.handleMessage(message.message);
+        const durationMs = performance.now() - startMs;
+        this.recordRequestLatency(message.message.type, durationMs);
+        if (durationMs >= SLOW_REQUEST_THRESHOLD_MS) {
+            activeConnection.connectionLogger.warn({
+                requestType: message.message.type,
+                durationMs: Math.round(durationMs),
+                inflightRequests: activeConnection.session.getRuntimeMetrics().inflightRequests,
+            }, "ws_slow_request");
+        }
+    }
+    handleRawMessageError(params) {
+        const { ws, data, error, log } = params;
+        const err = error instanceof Error ? error : new Error(String(error));
+        const { rawPayload, parsedPayload } = this.decodeRawMessagePayloadForError(data);
+        const trimmedRawPayload = typeof rawPayload === "string" && rawPayload.length > 2000
+            ? `${rawPayload.slice(0, 2000)}... (truncated)`
+            : rawPayload;
+        log.error({
+            err,
+            rawPayload: trimmedRawPayload,
+            parsedPayload,
+        }, "Failed to parse/handle message");
+        if (this.pendingConnections.has(ws)) {
+            this.clearPendingConnection(ws);
             try {
-                const buffer = bufferFromWsData(data);
-                rawPayload = buffer.toString();
-                parsedPayload = JSON.parse(rawPayload);
-            }
-            catch (payloadError) {
-                rawPayload = rawPayload ?? "<unreadable>";
-                parsedPayload = parsedPayload ?? rawPayload;
-                const payloadErr = payloadError instanceof Error ? payloadError : new Error(String(payloadError));
-                this.logger.error({ err: payloadErr }, "Failed to decode raw payload");
-            }
-            const trimmedRawPayload = typeof rawPayload === "string" && rawPayload.length > 2000
-                ? `${rawPayload.slice(0, 2000)}... (truncated)`
-                : rawPayload;
-            log.error({
-                err,
-                rawPayload: trimmedRawPayload,
-                parsedPayload,
-            }, "Failed to parse/handle message");
-            if (this.pendingConnections.has(ws)) {
-                this.clearPendingConnection(ws);
-                try {
-                    ws.close(WS_CLOSE_INVALID_HELLO, "Invalid hello");
-                }
-                catch {
-                    // ignore close errors
-                }
-                return;
+                ws.close(WS_CLOSE_INVALID_HELLO, "Invalid hello");
             }
-            const requestInfo = extractRequestInfoFromUnknownWsInbound(parsedPayload);
-            if (requestInfo) {
-                this.sendToClient(ws, wrapSessionMessage({
-                    type: "rpc_error",
-                    payload: {
-                        requestId: requestInfo.requestId,
-                        requestType: requestInfo.requestType,
-                        error: "Invalid message",
-                        code: "invalid_message",
-                    },
-                }));
-                return;
+            catch {
+                // ignore close errors
             }
+            return;
+        }
+        const requestInfo = extractRequestInfoFromUnknownWsInbound(parsedPayload);
+        if (requestInfo) {
             this.sendToClient(ws, wrapSessionMessage({
-                type: "status",
+                type: "rpc_error",
                 payload: {
-                    status: "error",
-                    message: `Invalid message: ${err.message}`,
+                    requestId: requestInfo.requestId,
+                    requestType: requestInfo.requestType,
+                    error: "Invalid message",
+                    code: "invalid_message",
                 },
             }));
+            return;
+        }
+        this.sendToClient(ws, wrapSessionMessage({
+            type: "status",
+            payload: {
+                status: "error",
+                message: `Invalid message: ${err.message}`,
+            },
+        }));
+    }
+    decodeRawMessagePayloadForError(data) {
+        let rawPayload = null;
+        let parsedPayload = null;
+        try {
+            const buffer = bufferFromWsData(data);
+            rawPayload = buffer.toString();
+            parsedPayload = JSON.parse(rawPayload);
+        }
+        catch (payloadError) {
+            rawPayload = rawPayload ?? "<unreadable>";
+            parsedPayload = parsedPayload ?? rawPayload;
+            const payloadErr = payloadError instanceof Error ? payloadError : new Error(String(payloadError));
+            this.logger.error({ err: payloadErr }, "Failed to decode raw payload");
         }
+        return { rawPayload, parsedPayload };
     }
     incrementRuntimeCounter(counter) {
         this.runtimeCounters[counter] += 1;