@dan-ai-studio/dshopencodego 0.1.60 → 0.1.62

package/README.en.md

@@ -97,6 +97,10 @@ Configuration lives in the profile's `cordis.patch.yml`:
                                               # or https://opencode.ai/inference/v1 (Console main endpoint, pay-as-you-go/free models)
     refreshMinutes: 60                        # live catalog TTL, 1 ~ 10080 (7 days)
     streamIdleTimeoutMs: 300000               # stream idle timeout: longest silence between events (ms)
+    keepAliveTimeoutMs: 600000                # connection kept idle between requests (ms, 1 ~ 1800000)
+                                               # the timer restarts on every answer, so a connection in
+                                               # frequent use is never dropped; a long pause in a
+                                               # conversation costs one handshake (about 200ms)
     maxRequestImageBytes: 6291456             # whole-request image payload cap (after base64, bytes)
     requestImagePixelBudget: 1440000          # total-pixel budget for one image
     requestImageMaxBytes: 400000              # encoded-byte target for one image (before base64)
@@ -121,12 +125,19 @@ Configuration lives in the profile's `cordis.patch.yml`:
         jitterRatio: 0.1                      # default 0.1, range 0 ~ 1
 ```
 
-**Validated on save**: those constraints are checked when the profile is **written**, not at the first request — `baseURL` must be http(s) with no query or fragment; `refreshMinutes` ranges from 1 to 10080; every `modelLimits` field may be `null`, meaning "select the catalog value explicitly" (`modelLimits.<id>: null` sends both fields back); `modelProtocols` accepts only those three values, and a wrong one makes that model appear as *configuration missing* (switch off, not selectable) rather than falling back to a guess; `retryPolicy` is a union (`normal` reads `maxRetries`/`retryableCodes`/`backoff`, `always` reads only `backoff`) and unknown keys are rejected.
+**Validated on save**: those constraints are checked when the profile is **written**, not at the first request — `baseURL` must be http(s) with no query or fragment; `refreshMinutes` ranges from 1 to 10080; `keepAliveTimeoutMs` ranges from 1 to 1800000; every `modelLimits` field may be `null`, meaning "select the catalog value explicitly" (`modelLimits.<id>: null` sends both fields back); `modelProtocols` accepts only those three values, and a wrong one makes that model appear as *configuration missing* (switch off, not selectable) rather than falling back to a guess; `retryPolicy` is a union (`normal` reads `maxRetries`/`retryableCodes`/`backoff`, `always` reads only `backoff`) and unknown keys are rejected.
 
 The API key comes from the Harness credential store (reference name `OPENCODE_GO_API_KEY`), or from `export OPENCODE_GO_API_KEY=...`.
 
 **Stream timeout**: `streamIdleTimeoutMs` bounds the **longest silence between two stream events**, not the total request duration — a long-thinking model that keeps producing events is never cut off. Default 5 minutes; the ceiling is `2147483647` (about 24.8 days). Exceeding it raises `TIMEOUT`, which is retryable.
 
+**Connection kept**: `keepAliveTimeoutMs` decides **how long a connection to the gateway is held between two requests**. The timer **restarts on every answer**, so a connection in frequent use is never dropped; it bounds only the silence between two requests. Default 10 minutes.
+
+- The reason is practical: once a connection is dropped, the next request pays a TCP and a TLS handshake again — **about 200 milliseconds** from here to the gateway — and that cost lands on the **first token of the next turn**. A pause in a conversation (reading the answer, thinking, typing) usually runs 5 to 30 seconds, which is longer than the HTTP client's own 4-second default, so **almost every turn paid for a handshake it did not need**.
+- This only affects deployments that **pin an address** (`pinnedAddresses`): with no pin the request goes through the system's own fetch, and this plugin adds nothing to it.
+- The settings page shows and accepts the value in **seconds** (a number of milliseconds is not readable at a glance) and stores it in milliseconds. Range: 1 to 1800000 milliseconds.
+- Once a connection has been idle that long, the pool **reclaims it** on its own — no separate mechanism is needed. The actual release comes a couple of seconds later than the setting, which is the client's own small margin beyond the deadline the server states. When the plugin is unloaded, the pool is **closed with it**: the pool belongs to the plugin and should not be left behind on the machine.
+
 **Images**: three fields, one layer each. An image outside a bound is refused explicitly rather than silently downscaled or dropped:
 
 | Field | What it bounds | Default |

package/README.md

@@ -97,6 +97,9 @@ DSH 桌面端是 Electron 壳 + 完整的 dsh Web 应用，本插件对它同样
                                               # 也可指定为 https://opencode.ai/inference/v1（Console 主端点，含按量/免费模型）
     refreshMinutes: 60                        # 目录缓存时长，1 ~ 10080（7 天）
     streamIdleTimeoutMs: 300000               # 流空闲超时：两次流事件之间的最长静默（毫秒）
+    keepAliveTimeoutMs: 600000                # 连接空闲保留：两次请求之间连接留多久（毫秒，1 ~ 1800000）
+                                               # 每次收到回答后重新计时，所以常用时连接不会被断开；
+                                               # 对话中每次停顿较久都要重新握手一次（约 200ms）
     maxRequestImageBytes: 6291456             # 整个请求的图片载荷上限（base64 之后，字节）
     requestImagePixelBudget: 1440000          # 单张图的总像素预算
     requestImageMaxBytes: 400000              # 单张图编码前的字节目标（base64 之前）
@@ -121,12 +124,19 @@ DSH 桌面端是 Electron 壳 + 完整的 dsh Web 应用，本插件对它同样
         jitterRatio: 0.1                      # 默认 0.1，取值 0 ~ 1
 ```
 
-**保存即校验**：上面这些约束在**写入 profile 时**就检查，不会拖到第一次请求——`baseURL` 必须是 http(s) 且不带 query/fragment；`refreshMinutes` 取值 1 ~ 10080；`modelLimits` 的每个字段都可以写 `null`，语义是"显式选回目录值"（`modelLimits.<模型>: null` 表示两个字段一起回退）；`modelProtocols` 只接受那三个合法值，写错会让该模型以"配置缺失"出现（开关关闭、不可选），而不是回退到猜测；`retryPolicy` 是联合类型（`normal` 读 `maxRetries`/`retryableCodes`/`backoff`，`always` 只读 `backoff`），未知字段会被拒绝。
+**保存即校验**：上面这些约束在**写入 profile 时**就检查，不会拖到第一次请求——`baseURL` 必须是 http(s) 且不带 query/fragment；`refreshMinutes` 取值 1 ~ 10080；`keepAliveTimeoutMs` 取值 1 ~ 1800000；`modelLimits` 的每个字段都可以写 `null`，语义是"显式选回目录值"（`modelLimits.<模型>: null` 表示两个字段一起回退）；`modelProtocols` 只接受那三个合法值，写错会让该模型以"配置缺失"出现（开关关闭、不可选），而不是回退到猜测；`retryPolicy` 是联合类型（`normal` 读 `maxRetries`/`retryableCodes`/`backoff`，`always` 只读 `backoff`），未知字段会被拒绝。
 
 API Key 通过 Harness 凭证库提供（引用名 `OPENCODE_GO_API_KEY`），也可以直接 `export OPENCODE_GO_API_KEY=...`。
 
 **流超时**：`streamIdleTimeoutMs` 约束的是**两次流事件之间的最长静默**，不是请求总时长——长思考模型只要持续产出事件就不会被误判。默认 5 分钟，上限为 `2147483647`（约 24.8 天）。超时抛出 `TIMEOUT`（可重试类）。
 
+**连接保留**：`keepAliveTimeoutMs` 决定**与网关的连接在两次请求之间保留多久**。计时器**每次收到回答后重新开始**，所以常用时连接不会被断开，它约束的只是两次请求之间的静默。默认 10 分钟。
+
+- 背后的原因很实际：连接一旦被断开，下一次请求要重新做一次 TCP 与 TLS 握手，**到网关这一侧约 200 毫秒**，而这笔开销正好落在**下一轮的第一个 token 上**。对话里的停顿（读答案、思考、再打字）通常在 5 ~ 30 秒，正好跨过 HTTP 客户端默认的 4 秒，于是**几乎每一轮都在白付一次握手**。
+- 这条只影响**固定了地址**（`pinnedAddresses`）的部署：没有固定地址时走的是系统自己的 fetch，本插件不加任何东西。
+- 设置页里以**秒**显示与填写（毫秒的数字人读不出量级），存储时换算成毫秒。取值 1 ~ 1800000 毫秒。
+- 空闲满这个时间之后，连接由连接池**自己回收**，不需要额外的清理机制（实际释放时间比设置值多约 2 秒，那是客户端在服务端给的期限之外自留的一点缓冲）。插件被卸载时，连接池也会**一并关掉**——它是插件的，不该留在机器上。
+
 **图片**：三个字段各管一层，超限的图片会被明确拒绝，而不是静默降质或丢弃：
 
 | 字段 | 约束对象 | 默认 |

package/lib/client.js

@@ -386,6 +386,8 @@ var en = {
   catalogRefreshing: "Showing the last known catalog; a refresh is running in the background.",
   refreshLabel: "Catalog refresh (minutes)",
   refreshHint: "How long requests and the model picker reuse one listing.",
+  keepAliveLabel: "Connection kept idle (seconds)",
+  keepAliveHint: "How long a connection to the gateway is held between requests. Longer pauses in a conversation cost one handshake each; the timer restarts on every answer.",
   writeRejected: "The settings write was rejected (the namespace was reloaded) \u2014 try again",
   writeFailed: "The settings write failed",
   filterPlaceholder: "Filter by name or id",
@@ -496,6 +498,8 @@ var zh = {
   catalogRefreshing: "\u663E\u793A\u4E0A\u6B21\u5DF2\u77E5\u7684\u76EE\u5F55\uFF0C\u540E\u53F0\u6B63\u5728\u5237\u65B0\u3002",
   refreshLabel: "\u76EE\u5F55\u5237\u65B0\uFF08\u5206\u949F\uFF09",
   refreshHint: "\u8BF7\u6C42\u4E0E\u6A21\u578B\u9009\u62E9\u5668\u590D\u7528\u540C\u4E00\u4EFD\u5217\u8868\u7684\u65F6\u957F\u3002",
+  keepAliveLabel: "\u8FDE\u63A5\u7A7A\u95F2\u4FDD\u7559\uFF08\u79D2\uFF09",
+  keepAliveHint: "\u4E0E\u7F51\u5173\u7684\u8FDE\u63A5\u5728\u4E24\u6B21\u8BF7\u6C42\u4E4B\u95F4\u4FDD\u7559\u591A\u4E45\u3002\u5BF9\u8BDD\u4E2D\u6BCF\u6B21\u505C\u987F\u8F83\u4E45\u90FD\u8981\u91CD\u65B0\u63E1\u624B\u4E00\u6B21\uFF1B\u6BCF\u6B21\u6536\u5230\u56DE\u7B54\u540E\u8BA1\u65F6\u90FD\u4F1A\u91CD\u65B0\u5F00\u59CB\u3002",
   writeRejected: "\u8BBE\u7F6E\u5199\u5165\u88AB\u62D2\u7EDD\uFF08\u5DF2\u91CD\u65B0\u8F7D\u5165\uFF09\uFF0C\u8BF7\u91CD\u8BD5",
   writeFailed: "\u8BBE\u7F6E\u5199\u5165\u5931\u8D25",
   filterPlaceholder: "\u6309\u540D\u79F0\u6216 ID \u7B5B\u9009",
@@ -578,6 +582,12 @@ var REPOSITORY = "dan-ai-studio/dshopencodego";
 var REGISTRY_LATEST_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`;
 var CHECK_CACHE_MS = 6 * 60 * 60 * 1e3;
 
+// src/network/keep-alive.ts
+var DEFAULT_KEEP_ALIVE_TIMEOUT_SECONDS = 600;
+var MAX_KEEP_ALIVE_TIMEOUT_SECONDS = 1800;
+var DEFAULT_KEEP_ALIVE_TIMEOUT_MS = DEFAULT_KEEP_ALIVE_TIMEOUT_SECONDS * 1e3;
+var MAX_KEEP_ALIVE_TIMEOUT_MS = MAX_KEEP_ALIVE_TIMEOUT_SECONDS * 1e3;
+
 // src/go-limits.ts
 var SEED_TRANSCRIBED = "2026-09-25";
 function monthlyRequestsRank(quota) {
@@ -738,10 +748,12 @@ function settingsOf(value) {
   const entries = Object.entries(visibility).filter(([, enabled]) => typeof enabled === "boolean");
   const pins = record["pinnedAddresses"];
   const pinEntries = pins !== null && typeof pins === "object" ? Object.entries(pins).filter(([, address]) => typeof address === "string") : [];
+  const keepAlive = record["keepAliveTimeoutMs"];
   return {
     modelVisibility: Object.fromEntries(entries),
     refreshMinutes: minutes,
-    pinnedAddresses: Object.fromEntries(pinEntries)
+    pinnedAddresses: Object.fromEntries(pinEntries),
+    keepAliveTimeoutMs: typeof keepAlive === "number" ? keepAlive : DEFAULT_KEEP_ALIVE_TIMEOUT_MS
   };
 }
 var SectionController = class _SectionController {
@@ -1122,6 +1134,25 @@ var SectionController = class _SectionController {
       () => this.set({ settings: { ...current, refreshMinutes: minutes } })
     );
   }
+  /**
+   * Set how long an idle gateway connection is kept, clamped to the schema's
+   * own bounds.
+   *
+   * The value is in seconds here and stored in milliseconds, because a
+   * person reading a number of seconds can tell whether it is right and a
+   * person reading a number of milliseconds cannot.
+   */
+  async setKeepAliveTimeoutSeconds(seconds) {
+    const scope = this.services.scope;
+    const current = this.state.settings;
+    if (scope === void 0 || current === void 0 || !this.state.writable) return;
+    if (!Number.isSafeInteger(seconds) || seconds < 1 || seconds > MAX_KEEP_ALIVE_TIMEOUT_SECONDS) return;
+    const milliseconds = seconds * 1e3;
+    await this.write(
+      () => scope.set("keepAliveTimeoutMs", milliseconds),
+      () => this.set({ settings: { ...current, keepAliveTimeoutMs: milliseconds } })
+    );
+  }
   async write(operation, onAccepted) {
     this.set({ saving: true });
     try {
@@ -1500,6 +1531,25 @@ function Section({ controller, t, getLocale }) {
         ),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: section_default.hint, children: t("refreshHint") })
       ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: section_default.row, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("label", { className: section_default.hint, htmlFor: "dshopencodego-keepalive", children: t("keepAliveLabel") }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "input",
+          {
+            id: "dshopencodego-keepalive",
+            className: section_default.number,
+            type: "number",
+            min: 1,
+            max: MAX_KEEP_ALIVE_TIMEOUT_SECONDS,
+            disabled: !editable || state.saving,
+            value: state.settings === void 0 ? "" : Math.round(state.settings.keepAliveTimeoutMs / 1e3),
+            onChange: (event) => {
+              void controller.setKeepAliveTimeoutSeconds(Number(event.target.value));
+            }
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: section_default.hint, children: t("keepAliveHint") })
+      ] }),
       state.writeFailure !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: section_default.warn, children: state.writeFailure.kind === "rejected" ? t("writeRejected") : state.writeFailure.message.length === 0 ? t("writeFailed") : `${t("writeFailed")}: ${state.writeFailure.message}` }),
       reading !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: section_default.row, children: [
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(

package/lib/index.js

@@ -53107,6 +53107,7 @@ var require_client_h2 = __commonJS({
     var kGoAwayReplayAttempts = /* @__PURE__ */ Symbol("goaway replay attempts");
     var kRefusedStreamRetry = /* @__PURE__ */ Symbol("refused stream retry");
     var MAX_GOAWAY_REPLAY_ATTEMPTS = 1;
+    var MIN_PROBE_TIMEOUT = 1e3;
     var extractBody2;
     var http2;
     try {
@@ -53267,6 +53268,9 @@ var require_client_h2 = __commonJS({
         // Armed while the peer advertises MAX_CONCURRENT_STREAMS = 0 and we have
         // work that cannot start. See setNoStreamsTimeout.
         noStreamsTimeout: null,
+        // Armed while a PING checks whether the peer is still there after a
+        // stream timed out. See probeHttp2Session.
+        probeTimeout: null,
         // Sockets start out ref'd. Session ref/unref proxies to the socket, so a
         // single cached flag lets us skip redundant uv ref/unref calls, provided
         // every ref/unref of the session or its socket goes through
@@ -53336,6 +53340,9 @@ var require_client_h2 = __commonJS({
           if (session[kRemoteSettings] === false && client[kRunning] > 0) {
             return true;
           }
+          if (session[kHTTP2SessionState].probeTimeout != null) {
+            return true;
+          }
           if (client[kRunning] >= client[kMaxConcurrentStreams]) {
             return true;
           }
@@ -53420,6 +53427,41 @@ var require_client_h2 = __commonJS({
       session[kError] = err;
       resetHttp2Session(session, err);
     }
+    function probeHttp2Session(session, timeout) {
+      const state2 = session[kHTTP2SessionState];
+      if (state2.probeTimeout != null || session.closed || session.destroyed) {
+        return;
+      }
+      try {
+        session.ping(onHttp2ProbeAck.bind(session));
+      } catch {
+        return;
+      }
+      state2.probeTimeout = setTimeout(onHttp2ProbeTimeout, Math.max(timeout, MIN_PROBE_TIMEOUT), session).unref();
+    }
+    function clearHttp2ProbeTimeout(session) {
+      const state2 = session[kHTTP2SessionState];
+      if (state2?.probeTimeout != null) {
+        clearTimeout(state2.probeTimeout);
+        state2.probeTimeout = null;
+      }
+    }
+    function onHttp2ProbeAck() {
+      if (this[kHTTP2SessionState].probeTimeout == null) {
+        return;
+      }
+      clearHttp2ProbeTimeout(this);
+      this[kClient][kResume]();
+    }
+    function onHttp2ProbeTimeout(session) {
+      session[kHTTP2SessionState].probeTimeout = null;
+      if (session.closed || session.destroyed) {
+        return;
+      }
+      const err = new SocketError("HTTP/2: connection unresponsive", util2.getSocketInfo(session[kSocket]));
+      session[kError] = err;
+      resetHttp2Session(session, err);
+    }
     function clearHttp2IdleTimeout(session) {
       const state2 = session[kHTTP2SessionState];
       if (state2?.idleTimeout != null) {
@@ -53554,6 +53596,7 @@ var require_client_h2 = __commonJS({
       }
       clearHttp2IdleTimeout(this);
       clearNoStreamsTimeout(this);
+      clearHttp2ProbeTimeout(this);
       if (!this.closed && !this.destroyed) {
         this.close();
       }
@@ -53571,6 +53614,7 @@ var require_client_h2 = __commonJS({
       }
       clearHttp2IdleTimeout(this);
       clearNoStreamsTimeout(this);
+      clearHttp2ProbeTimeout(this);
       if (state2.ping.interval != null) {
         clearInterval(state2.ping.interval);
         state2.ping.interval = null;
@@ -54157,7 +54201,9 @@ var require_client_h2 = __commonJS({
         return;
       }
       stream5.off("timeout", onTimeout);
-      const err = state2.responseReceived ? new BodyTimeoutError(`HTTP/2: "stream timeout after ${state2.bodyTimeout}"`) : new HeadersTimeoutError(`HTTP/2: "headers timeout after ${state2.headersTimeout}"`);
+      const { responseReceived, session, bodyTimeout, headersTimeout } = state2;
+      const err = responseReceived ? new BodyTimeoutError(`HTTP/2: "stream timeout after ${bodyTimeout}"`) : new HeadersTimeoutError(`HTTP/2: "headers timeout after ${headersTimeout}"`);
+      probeHttp2Session(session, responseReceived ? bodyTimeout : headersTimeout);
       state2.abort(err);
     }
     function onTrailers(trailers) {
@@ -55031,6 +55077,7 @@ var require_fixed_queue = __commonJS({
 var require_pool_base = __commonJS({
   "node_modules/undici/lib/dispatcher/pool-base.js"(exports, module) {
     "use strict";
+    var { AsyncResource } = __require("node:async_hooks");
     var { PoolStats } = require_stats();
     var DispatcherBase = require_dispatcher_base();
     var FixedQueue = require_fixed_queue();
@@ -55052,6 +55099,16 @@ var require_pool_base = __commonJS({
     var kRemoveClient = /* @__PURE__ */ Symbol("remove client");
     var kRetireClient = /* @__PURE__ */ Symbol("retire client");
     var kRetiring = /* @__PURE__ */ Symbol("retiring clients");
+    var QueuedRequest = class extends AsyncResource {
+      constructor(opts, handler) {
+        super("UNDICI_POOL_QUEUED_REQUEST");
+        this.opts = opts;
+        this.handler = handler;
+      }
+      dispatch(dispatcher) {
+        return this.runInAsyncScope(dispatcher.dispatch, dispatcher, this.opts, this.handler);
+      }
+    };
     function closeClients(pool) {
       const closeAll = [];
       for (let i = 0; i < pool[kClients].length; i++) {
@@ -55086,7 +55143,7 @@ var require_pool_base = __commonJS({
             break;
           }
           this[kQueued]--;
-          needDrain = !client.dispatch(item.opts, item.handler);
+          needDrain = !item.dispatch(client);
         }
         client[kNeedDrain] = needDrain;
         if (needDrain) {
@@ -55118,7 +55175,7 @@ var require_pool_base = __commonJS({
           }
           const item = queue.shift();
           this[kQueued]--;
-          if (!dispatcher.dispatch(item.opts, item.handler)) {
+          if (!item.dispatch(dispatcher)) {
             dispatcher[kNeedDrain] = true;
             this[kOnClientBusy](dispatcher);
             hasDispatcher = this[kHasDispatcher]();
@@ -55215,7 +55272,7 @@ var require_pool_base = __commonJS({
         const dispatcher = this[kGetDispatcher]();
         if (!dispatcher) {
           this[kNeedDrain] = true;
-          this[kQueue].push({ opts, handler });
+          this[kQueue].push(new QueuedRequest(opts, handler));
           this[kQueued]++;
         } else if (!dispatcher.dispatch(opts, handler)) {
           dispatcher[kNeedDrain] = true;
@@ -75658,6 +75715,12 @@ defineMethod("transform", [
   "preserve"
 ], ({ inner }, isInner) => inner.toString(isInner));
 
+// src/network/keep-alive.ts
+var DEFAULT_KEEP_ALIVE_TIMEOUT_SECONDS = 600;
+var MAX_KEEP_ALIVE_TIMEOUT_SECONDS = 1800;
+var DEFAULT_KEEP_ALIVE_TIMEOUT_MS = DEFAULT_KEEP_ALIVE_TIMEOUT_SECONDS * 1e3;
+var MAX_KEEP_ALIVE_TIMEOUT_MS = MAX_KEEP_ALIVE_TIMEOUT_SECONDS * 1e3;
+
 // src/config.ts
 var DEFAULT_API_KEY_ENV = "OPENCODE_GO_API_KEY";
 var DEFAULT_REFRESH_MINUTES = 60;
@@ -75672,6 +75735,12 @@ var fields = {
   baseURL: Schema.string().default(DEFAULT_BASE_URL),
   refreshMinutes: Schema.number().step(1).min(1).max(7 * 24 * 60).default(DEFAULT_REFRESH_MINUTES),
   streamIdleTimeoutMs: Schema.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS).default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
+  // The ceiling is the plugin's own, and it is well under the point where a
+  // Node timer overflows: a value above 2^31-1 does not become a longer
+  // timer, it becomes ONE MILLISECOND, which would drop the connection at
+  // once and say so only in a warning on stderr. The bound here is what
+  // keeps that unreachable.
+  keepAliveTimeoutMs: Schema.number().step(1).min(1).max(MAX_KEEP_ALIVE_TIMEOUT_MS).default(DEFAULT_KEEP_ALIVE_TIMEOUT_MS),
   maxRequestImageBytes: Schema.number().step(1).min(1).default(DEFAULT_MAX_REQUEST_IMAGE_BYTES),
   requestImagePixelBudget: Schema.number().step(1).min(1).default(DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET),
   requestImageMaxBytes: Schema.number().step(1).min(1).default(DEFAULT_REQUEST_IMAGE_MAX_BYTES),
@@ -77269,14 +77338,23 @@ function pinnedLookup(address) {
   };
 }
 var current;
-function dispatcherFor(host, address) {
-  const key = `${host}@${address}`;
+function dispatcherFor(host, address, keepAliveTimeoutMs) {
+  const key = `${host}@${address}@${String(keepAliveTimeoutMs)}`;
   if (current?.key === key) return current.agent;
   void current?.agent.close();
-  const agent = new import_undici.Agent({ connect: { lookup: pinnedLookup(address) } });
+  const agent = new import_undici.Agent({
+    connect: { lookup: pinnedLookup(address) },
+    keepAliveTimeout: keepAliveTimeoutMs,
+    keepAliveMaxTimeout: keepAliveTimeoutMs
+  });
   current = { key, agent };
   return agent;
 }
+async function closeDispatcher() {
+  const agent = current?.agent;
+  current = void 0;
+  if (agent !== void 0) await agent.close();
+}
 var SPENT_ADDRESS_CODES = /* @__PURE__ */ new Set([
   // The socket never came up.
   "ECONNREFUSED",
@@ -77342,7 +77420,7 @@ async function edgeRefused(response) {
     return false;
   }
 }
-function gatewayFetch(pin) {
+function gatewayFetch(pin, keepAliveTimeoutMs) {
   const address = pin.address;
   if (address === void 0) return globalThis.fetch;
   return async (input, init) => {
@@ -77350,7 +77428,7 @@ function gatewayFetch(pin) {
     if (host !== pin.host) return globalThis.fetch(input, init);
     if (isPinSpent(pin)) return globalThis.fetch(input, init);
     try {
-      const dispatcher = dispatcherFor(pin.host, address);
+      const dispatcher = dispatcherFor(pin.host, address, keepAliveTimeoutMs);
       const response = await dispatchingFetch(input, {
         ...init,
         dispatcher
@@ -77483,7 +77561,7 @@ function createUpdateChecker(deps) {
 }
 
 // src/update/version.ts
-var PLUGIN_VERSION = true ? "0.1.60" : "0.0.0-dev";
+var PLUGIN_VERSION = true ? "0.1.62" : "0.0.0-dev";
 
 // src/update/service.ts
 import { TypertRemoteService as TypertRemoteService3 } from "@deepseek-ai/dsh-typert-protocol";
@@ -77654,7 +77732,8 @@ function apply(ctx, raw) {
   const meter = new UsageMeter();
   const cacheDir = resolveCacheDir(ctx);
   const gatewayRequest = () => gatewayFetch(
-    resolveGatewayPin(current2().pinnedAddresses, current2().baseURL)
+    resolveGatewayPin(current2().pinnedAddresses, current2().baseURL),
+    current2().keepAliveTimeoutMs
   );
   const adapter = new OpencodeGoAdapter({
     config: current2,
@@ -77766,6 +77845,7 @@ function apply(ctx, raw) {
   ctx.effect(() => () => {
     registration?.();
     undiscover();
+    return closeDispatcher();
   });
   ctx.on("internal/config", function(_raw, next) {
     const value = next();

package/lib/types/config.d.ts

@@ -13,6 +13,8 @@
  */
 import type { RetryPolicyConfig } from '@deepseek-ai/dsh-llm';
 import z from '@deepseek-ai/schemastery';
+import { DEFAULT_KEEP_ALIVE_TIMEOUT_MS, DEFAULT_KEEP_ALIVE_TIMEOUT_SECONDS, MAX_KEEP_ALIVE_TIMEOUT_MS, MAX_KEEP_ALIVE_TIMEOUT_SECONDS, TIMER_CEILING_MS } from './network/keep-alive.ts';
+export { DEFAULT_KEEP_ALIVE_TIMEOUT_MS, DEFAULT_KEEP_ALIVE_TIMEOUT_SECONDS, MAX_KEEP_ALIVE_TIMEOUT_MS, MAX_KEEP_ALIVE_TIMEOUT_SECONDS, TIMER_CEILING_MS, };
 /** Credential reference resolving the OpenCode Go API key. */
 export declare const DEFAULT_API_KEY_ENV = "OPENCODE_GO_API_KEY";
 /** Requests and pickers share this cache lifetime; explicit discovery revalidates immediately. */
@@ -50,6 +52,14 @@ export interface OpencodeGoConfig {
     refreshMinutes: number;
     /** Largest idle gap between stream events before the request fails. */
     streamIdleTimeoutMs: number;
+    /**
+     * Idle time a gateway connection is kept between requests, in milliseconds.
+     *
+     * The timer is reset by every response, so a connection that is used
+     * often is never dropped; this bounds only the silence between two
+     * requests.
+     */
+    keepAliveTimeoutMs: number;
     /** Request-level bound on base64-encoded image payload, in bytes. */
     maxRequestImageBytes: number;
     /** Total-pixel budget for one request image. */
@@ -106,4 +116,3 @@ export declare function readConfig(config: LiveConfig): OpencodeGoConfig;
  * @returns the normalized base URL without trailing slashes.
  */
 export declare function assertBaseURL(raw: string): string;
-export {};

package/lib/types/network/keep-alive.d.ts

@@ -0,0 +1,52 @@
+/**
+ * How long a gateway connection is kept between requests.
+ *
+ * These two numbers are declared apart from `config.ts` on purpose. The
+ * configuration module imports the Harness' own packages — a schema library
+ * and the retry policy type — and the settings page must not drag those into
+ * the browser bundle: the page is shipped to a page, and a package that
+ * reaches for `node:module` cannot be bundled for one.
+ *
+ * @module @dan-ai-studio/dshopencodego/network/keep-alive
+ */
+/**
+ * Default idle time a gateway connection is kept between requests, in seconds.
+ *
+ * Undici's own default is four seconds, and a conversation pauses for longer
+ * than that all the time: a person reads the answer, thinks, and types the
+ * next question. A connection dropped during such a pause has to be built
+ * again — a TCP and a TLS handshake, roughly a fifth of a second from here
+ * to the gateway — and that cost lands on the first token of the next turn.
+ *
+ * The timer is reset by every response, so this bounds only the silence
+ * between two requests: a connection that is used often is never dropped.
+ *
+ * The unit is seconds because that is what the settings page shows and
+ * accepts; a number of milliseconds is not readable at a glance. The
+ * millisecond value below is derived from it, never written separately, so
+ * the two can never disagree.
+ */
+export declare const DEFAULT_KEEP_ALIVE_TIMEOUT_SECONDS = 600;
+/**
+ * Largest idle time a connection may be kept, in seconds.
+ *
+ * A connection held for hours belongs to a machine that never talks to the
+ * gateway, and a socket that outlives the server's own idea of the address
+ * it is talking to is a socket that fails on first use rather than on the
+ * one that mattered. Half an hour is longer than any conversation and short
+ * enough that the address is re-checked often.
+ */
+export declare const MAX_KEEP_ALIVE_TIMEOUT_SECONDS = 1800;
+/**
+ * The ceiling Node's timers can hold, in milliseconds.
+ *
+ * A value above this does not become a longer timer: it overflows and
+ * becomes **one millisecond**, so the connection would be dropped at once —
+ * and silently, because the warning goes to stderr and nothing else. This
+ * is the reason the maximum below is far smaller than the ceiling.
+ */
+export declare const TIMER_CEILING_MS = 2147483647;
+/** Default idle time a gateway connection is kept between requests, in milliseconds. */
+export declare const DEFAULT_KEEP_ALIVE_TIMEOUT_MS: number;
+/** Largest idle time a connection may be kept, in milliseconds. */
+export declare const MAX_KEEP_ALIVE_TIMEOUT_MS: number;

package/lib/types/network/pinning.d.ts

@@ -100,6 +100,7 @@ export declare function resetSpentAddresses(): void;
  * by the address the system would have chosen — so the request is sent
  * again, that way, and the answer is the one the caller gets.
  * @param pin - the gateway's name and its pinned address.
+ * @param keepAliveTimeoutMs - how long an idle connection is kept.
  * @returns the fetch to use.
  */
-export declare function gatewayFetch(pin: GatewayPin): typeof fetch;
+export declare function gatewayFetch(pin: GatewayPin, keepAliveTimeoutMs: number): typeof fetch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dan-ai-studio/dshopencodego",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "description": "OpenCode Go provider for DeepSeek Harness: live gateway catalog, per-conversation session header, usage",
   "type": "module",
   "license": "MIT",
@@ -145,6 +145,7 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "typescript": "^7.0.2",
+    "undici": "~8.12.3",
     "vitest": "^5.0.5"
   },
   "keywords": [