@code-yeongyu/senpi 2026.9.15 → 2026.9.16-2

package/dist/core/settings-manager.js

@@ -20,6 +20,14 @@ import { ASK_USER_DEFAULT_TIMEOUT_MINUTES, ASK_USER_MAX_TIMEOUT_MINUTES, ASK_USE
 import { isTerminalMouseMode, } from "./terminal-settings.js";
 export const DEFAULT_STREAM_START_TIMEOUT_MS = 300_000;
 export const DEFAULT_PROVIDER_STREAM_RETRY_TIMEOUT_MS = 30_000;
+/** Warn threshold for a single `session_shutdown` extension handler. */
+export const DEFAULT_SESSION_SHUTDOWN_HANDLER_WARN_MS = 2_000;
+/**
+ * Hard cap for a single `session_shutdown` extension handler. Higher than the
+ * 2s warning because several extensions persist durable state at shutdown; a
+ * hung handler still must not hold quit/reload/new/resume hostage.
+ */
+export const DEFAULT_SESSION_SHUTDOWN_HANDLER_TIMEOUT_MS = 10_000;
 const THINKING_LEVEL_VALUES = new Set([
     "off",
     "minimal",
@@ -1049,6 +1057,39 @@ export class SettingsManager {
         this.markModified("httpIdleTimeoutMs");
         this.save();
     }
+    /**
+     * How long one extension's `session_shutdown` handler may run before the host
+     * warns about it. 0 disables the warning.
+     */
+    getSessionShutdownHandlerWarnMs() {
+        return (parseTimeoutSetting(this.settings.sessionShutdownHandlerWarnMs, "sessionShutdownHandlerWarnMs") ??
+            DEFAULT_SESSION_SHUTDOWN_HANDLER_WARN_MS);
+    }
+    setSessionShutdownHandlerWarnMs(warnMs) {
+        if (!Number.isFinite(warnMs) || warnMs < 0) {
+            throw new Error(`Invalid sessionShutdownHandlerWarnMs setting: ${String(warnMs)}`);
+        }
+        this.globalSettings.sessionShutdownHandlerWarnMs = Math.floor(warnMs);
+        this.markModified("sessionShutdownHandlerWarnMs");
+        this.save();
+    }
+    /**
+     * Hard cap on one extension's `session_shutdown` handler. On expiry the host
+     * aborts that handler's `event.signal`, reports an extension error and moves
+     * on to the next handler. 0 disables the cap (unbounded, pre-budget behavior).
+     */
+    getSessionShutdownHandlerTimeoutMs() {
+        return (parseTimeoutSetting(this.settings.sessionShutdownHandlerTimeoutMs, "sessionShutdownHandlerTimeoutMs") ??
+            DEFAULT_SESSION_SHUTDOWN_HANDLER_TIMEOUT_MS);
+    }
+    setSessionShutdownHandlerTimeoutMs(timeoutMs) {
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+            throw new Error(`Invalid sessionShutdownHandlerTimeoutMs setting: ${String(timeoutMs)}`);
+        }
+        this.globalSettings.sessionShutdownHandlerTimeoutMs = Math.floor(timeoutMs);
+        this.markModified("sessionShutdownHandlerTimeoutMs");
+        this.save();
+    }
     getProviderRetrySettings() {
         return {
             timeoutMs: this.settings.retry?.provider?.timeoutMs,
@@ -1166,6 +1207,27 @@ export class SettingsManager {
         }
         return Math.min(DEFAULT_STREAM_START_TIMEOUT_MS, idleTimeoutMs);
     }
+    /**
+     * Sustained-throughput guard for an in-progress provider stream. The
+     * stream-start bound stops applying at the first event and the idle bound is
+     * re-armed by every event, so a provider that keeps answering at a uselessly
+     * low rate trips neither (#1739). `retry.provider.minThroughputTokensPerSecond`
+     * (floor, `0` disables), `retry.provider.throughputWindowMs` (`0` disables)
+     * and `retry.provider.throughputGraceMs` override the agent defaults; an
+     * unset knob keeps the shipped default. Returns undefined when nothing is
+     * configured, so the agent loop applies its own defaults.
+     */
+    getAgentStreamThroughputOptions() {
+        const provider = this.settings.retry?.provider;
+        const options = {
+            ...(provider?.minThroughputTokensPerSecond === undefined
+                ? {}
+                : { floorTokensPerSecond: provider.minThroughputTokensPerSecond }),
+            ...(provider?.throughputWindowMs === undefined ? {} : { windowMs: provider.throughputWindowMs }),
+            ...(provider?.throughputGraceMs === undefined ? {} : { graceMs: provider.throughputGraceMs }),
+        };
+        return Object.keys(options).length === 0 ? undefined : options;
+    }
     getWebSocketConnectTimeoutMs() {
         return parseTimeoutSetting(this.settings.websocketConnectTimeoutMs, "websocketConnectTimeoutMs");
     }