@dan-ai-studio/dshopencodego 0.1.70 → 0.1.73

package/README.en.md

@@ -101,7 +101,6 @@ Configuration lives in the profile's `cordis.patch.yml`:
                                                # 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)
-    requestGzip: true                         # gzip JSON request bodies of 1 KB or more; turn off if the gateway rejects them
     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)
@@ -142,8 +141,6 @@ The API key comes from the Harness credential store (reference name `OPENCODE_GO
 - 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.
 
-**Request body gzip**: `requestGzip` is on by default; JSON bodies of 1 KB or more are gzipped (fastest level, off the event loop) with a `Content-Encoding: gzip` header, smaller bodies travel plain. The log's body size is the **actual wire bytes** — compare the same large request with the switch on and off to see what it saved. **If the gateway does not accept gzip it fails requests outright; turn the switch off** (one setting, no other coupling).
-
 **Request log**: per-request records, on by default; turning them off returns the request path to exactly as without the log. The settings page's "Request log" group holds the master switch, the debug switch (pool events and the request user agent, default off), and the retention count (default 200).
 
 - **Two entries, one page**:
@@ -154,6 +151,7 @@ The API key comes from the Harness credential store (reference name `OPENCODE_GO
 - The session column names the **session title** (from the session catalog; falls back to the id, whose full spelling stays one hover away). The session filter matches titles and ids; session groups are headed the same way. **Clicking a title opens that session** (an archived one refuses, and says so).
 - **Cache hit** is the share of input tokens served from cache (cache reads over uncached input plus cache reads). No reported input means no share — none is invented either.
 - **The In column is uncached new input**: the gateway reports a prompt as "uncached plus cache hits" and the log records only the new part — a fully prefix-cached turn reads as a tiny input with a 100% hit, which is not a bug. Hover a column head for its definition.
+- **Content split**: below the body size the detail shows **Text X / Images Y** — images estimated as base64 per deduped attachment (each capped at the route's encoded target), text as the residual, so the two always sum to the total. Image-dominated turns read at a glance.
 - Session ids are **always stored whole**: an id is a conversation identity, not a credential, and a truncated one reads two conversations as one.
 - The log is a ring buffer (oldest dropped first) that dies with the process; snapshots are read on demand, never polled, so a page nobody opens costs no traffic.
 - The credential never enters a record: the recorder takes no headers argument at all, only the allowlisted session id and user agent. Failed requests are recorded with their error code; a request cut off before any terminal event is not recorded — no total reported, none invented.

package/README.md

@@ -100,7 +100,6 @@ DSH 桌面端是 Electron 壳 + 完整的 dsh Web 应用，本插件对它同样
     keepAliveTimeoutMs: 600000                # 连接空闲保留：两次请求之间连接留多久（毫秒，1 ~ 1800000）
                                                # 每次收到回答后重新计时，所以常用时连接不会被断开；
                                                # 对话中每次停顿较久都要重新握手一次（约 200ms）
-    requestGzip: true                       # 1KB 以上的 JSON 请求体先 gzip 再发；网关如果拒绝就关掉它
     maxRequestImageBytes: 6291456             # 整个请求的图片载荷上限（base64 之后，字节）
     requestImagePixelBudget: 1440000          # 单张图的总像素预算
     requestImageMaxBytes: 400000              # 单张图编码前的字节目标（base64 之前）
@@ -136,8 +135,6 @@ API Key 通过 Harness 凭证库提供（引用名 `OPENCODE_GO_API_KEY`），
 
 **连接保留**：`keepAliveTimeoutMs` 决定**与网关的连接在两次请求之间保留多久**。计时器**每次收到回答后重新开始**，所以常用时连接不会被断开，它约束的只是两次请求之间的静默。默认 10 分钟。
 
-**请求体压缩**：`requestGzip` 默认开启，1KB 以上的 JSON 请求先 gzip（最快档，异步压，不堵事件循环）再发，`Content-Encoding: gzip` 随行；1KB 以下原样走（压了也省不出什么）。日志里"请求体"记的是** wire 上的实际字节**——同一条大请求，开关两边对比一下就知道压了多少。**网关如果不吃 gzip 会直接 4xx，那时关掉这个开关就行**（一处配置，没有别的连带）。
-
 - 背后的原因很实际：连接一旦被断开，下一次请求要重新做一次 TCP 与 TLS 握手，**到网关这一侧约 200 毫秒**，而这笔开销正好落在**下一轮的第一个 token 上**。对话里的停顿（读答案、思考、再打字）通常在 5 ~ 30 秒，正好跨过 HTTP 客户端默认的 4 秒，于是**几乎每一轮都在白付一次握手**。
 - 这条只影响**固定了地址**（`pinnedAddresses`）的部署：没有固定地址时走的是系统自己的 fetch，本插件不加任何东西。
 - 设置页里以**秒**显示与填写（毫秒的数字人读不出量级），存储时换算成毫秒。取值 1 ~ 1800000 毫秒。
@@ -153,6 +150,7 @@ API Key 通过 Harness 凭证库提供（引用名 `OPENCODE_GO_API_KEY`），
 - 会话列显示**会话标题**（标题来自会话目录；拿不到时回退显示 id，悬停可见完整 id）。会话筛选同时匹配标题与 id；按会话分组的组头同样显示标题。**点标题直接打开那个会话**（归档的打不开，会明说）。
 - **缓存命中**是输入 token 里走缓存的占比（缓存读取／（未缓存输入＋缓存读取））。网关没报输入就没有占比——同样不编数。
 - **输入列是未缓存的新增 token**：网关把整段 prompt 拆成"未缓存＋缓存命中"两部分上报，输入列只记新增的——同一会话前缀缓存全中时输入很小、缓存命中 100%，不是 bug。悬停列头有口径说明。
+- **内容拆分**：明细里"请求体"下面跟一行"文本 X ／图片 Y"——图片是各去重后附件按 base64 估的占比（单张按路由的编码上限封顶），文本是总数减图片的剩余，两者恒等于请求体总数。图片 dominant 的请求一眼就能看出来。
 - 会话 id **始终完整记录**（它是会话身份，不是凭据；截断后两个会话会读成一个）。
 - 记录的是环形缓冲（超限丢最旧），进程重启即清；只读快照，不轮询，没人打开的页面零流量。
 - 凭据永远不进记录：记录器根本不接收请求头参数，只收白名单里的会话 id 与 UA；失败的请求同样记一条（含错误码），中断到没有终端事件的不记（网关没报总数就不编数）。

package/lib/client.js

@@ -252,6 +252,7 @@ function parseEntry(value) {
     ...row["reasoningTokens"] === void 0 ? {} : { reasoningTokens: count("reasoningTokens", row) },
     ...row["costUsd"] === void 0 ? {} : { costUsd: rate("costUsd", row) },
     ...row["requestBytes"] === void 0 ? {} : { requestBytes: count("requestBytes", row) },
+    ...row["imageBytes"] === void 0 ? {} : { imageBytes: count("imageBytes", row) },
     ...row["durationMs"] === void 0 ? {} : { durationMs: count("durationMs", row) },
     ...row["firstTokenMs"] === void 0 ? {} : { firstTokenMs: count("firstTokenMs", row) },
     ...row["decodeMs"] === void 0 ? {} : { decodeMs: count("decodeMs", row) },
@@ -506,8 +507,6 @@ var en = {
   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.",
-  requestGzipLabel: "Gzip request bodies",
-  requestGzipHint: "Compress JSON bodies of 1 KB or more before sending. Turn off if the gateway rejects requests.",
   requestLogTitle: "Request log",
   requestLogHint: "Per-request records for troubleshooting. On by default; turning it off returns the request path to exactly as without the log.",
   requestLogPageHint: "One row per request. Click a column head to sort; the table scrolls and the filters stay put.",
@@ -566,6 +565,9 @@ var en = {
   requestLogDetailProtocol: "Protocol",
   requestLogDetailUrl: "URL",
   requestLogDetailRequestBytes: "Request body",
+  requestLogDetailContentSplit: "Content split",
+  requestLogDetailText: "Text",
+  requestLogDetailImages: "Images",
   requestLogDetailSession: "Session",
   requestLogDetailPool: "Pool",
   requestLogDetailError: "Error",
@@ -698,8 +700,6 @@ var zh = {
   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",
-  requestGzipLabel: "\u8BF7\u6C42\u4F53 gzip \u538B\u7F29",
-  requestGzipHint: "1KB \u4EE5\u4E0A\u7684 JSON \u8BF7\u6C42\u4F53\u5148\u538B\u7F29\u518D\u53D1\uFF1B\u7F51\u5173\u5982\u679C\u62D2\u7EDD\u8BF7\u6C42\u5C31\u5173\u6389\u5B83\u3002",
   requestLogTitle: "\u8BF7\u6C42\u65E5\u5FD7",
   requestLogHint: "\u6392\u67E5\u7528\u7684\u9010\u8BF7\u6C42\u8BB0\u5F55\u3002\u9ED8\u8BA4\u5F00\u542F\uFF1B\u5173\u95ED\u540E\u8BF7\u6C42\u8DEF\u5F84\u4E0E\u6CA1\u6709\u8BE5\u65E5\u5FD7\u9010\u5B57\u8282\u4E00\u81F4\u3002",
   requestLogPageHint: "\u6BCF\u4E2A\u8BF7\u6C42\u4E00\u884C\u3002\u70B9\u5217\u5934\u53EF\u6392\u5E8F\uFF1B\u8868\u683C\u6EDA\u52A8\uFF0C\u7B5B\u9009\u680F\u56FA\u5B9A\u5728\u4E0A\u65B9\u3002",
@@ -758,6 +758,9 @@ var zh = {
   requestLogDetailProtocol: "\u534F\u8BAE",
   requestLogDetailUrl: "\u5730\u5740",
   requestLogDetailRequestBytes: "\u8BF7\u6C42\u4F53",
+  requestLogDetailContentSplit: "\u5185\u5BB9\u62C6\u5206",
+  requestLogDetailText: "\u6587\u672C",
+  requestLogDetailImages: "\u56FE\u7247",
   requestLogDetailSession: "\u4F1A\u8BDD",
   requestLogDetailPool: "\u8FDE\u63A5\u6C60",
   requestLogDetailError: "\u9519\u8BEF",
@@ -1035,13 +1038,11 @@ function settingsOf(value) {
   const requestLogEnabled = record["requestLogEnabled"];
   const requestLogDebug = record["requestLogDebug"];
   const requestLogMaxEntries = record["requestLogMaxEntries"];
-  const requestGzip = record["requestGzip"];
   return {
     modelVisibility: Object.fromEntries(entries),
     refreshMinutes: minutes,
     pinnedAddresses: Object.fromEntries(pinEntries),
     keepAliveTimeoutMs: typeof keepAlive === "number" ? keepAlive : DEFAULT_KEEP_ALIVE_TIMEOUT_MS,
-    requestGzip: typeof requestGzip === "boolean" ? requestGzip : true,
     requestLogEnabled: typeof requestLogEnabled === "boolean" ? requestLogEnabled : true,
     requestLogDebug: typeof requestLogDebug === "boolean" ? requestLogDebug : false,
     requestLogMaxEntries: typeof requestLogMaxEntries === "number" ? requestLogMaxEntries : DEFAULT_REQUEST_LOG_MAX_ENTRIES
@@ -1456,20 +1457,6 @@ var SectionController = class _SectionController {
       () => this.set({ settings: { ...current, keepAliveTimeoutMs: milliseconds } })
     );
   }
-  /**
-   * Flip request-body gzip. Off returns every request to plain JSON; it is
-   * the whole fallback plan if the gateway ever rejects a compressed body.
-   */
-  async setRequestGzip(enabled) {
-    const scope = this.services.scope;
-    const current = this.state.settings;
-    if (scope === void 0 || current === void 0 || !this.state.writable) return;
-    if (typeof enabled !== "boolean") return;
-    await this.write(
-      () => scope.set("requestGzip", enabled),
-      () => this.set({ settings: { ...current, requestGzip: enabled } })
-    );
-  }
   /**
    * Flip the request-log master switch. Off (the default) means no record is
    * kept and the request path reads exactly as without the log.
@@ -1911,25 +1898,6 @@ function Section({ controller, t, getLocale, openRequestLog }) {
         ),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: section_default.hint, children: t("keepAliveHint") })
       ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: section_default.row, children: [
-        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { className: section_default.hint, children: [
-          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-            "input",
-            {
-              type: "checkbox",
-              checked: state.settings?.requestGzip ?? true,
-              disabled: !editable || state.saving,
-              onChange: (event) => {
-                void act(async () => {
-                  await controller.setRequestGzip(event.target.checked);
-                });
-              }
-            }
-          ),
-          ` ${t("requestGzipLabel")}`
-        ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: section_default.hint, children: t("requestGzipHint") })
-      ] }),
       /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: section_default.row, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: t("requestLogTitle") }) }),
       /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: section_default.hint, children: t("requestLogHint") }),
       /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: section_default.row, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { className: section_default.hint, children: [
@@ -2179,6 +2147,11 @@ function bytes(value) {
   if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)} KB`;
   return `${(value / (1024 * 1024)).toFixed(2)} MB`;
 }
+function contentSplit(entry, text2, images) {
+  const imageBytes = entry.imageBytes ?? 0;
+  const textBytes = entry.requestBytes === void 0 ? void 0 : Math.max(0, entry.requestBytes - imageBytes);
+  return `${text2} ${textBytes === void 0 ? "\u2014" : bytes(textBytes)} / ${images} ${bytes(imageBytes)}`;
+}
 function cacheRate(entry) {
   if (entry.inputTokens === void 0) return void 0;
   const cached = entry.cacheReadTokens ?? 0;
@@ -2391,6 +2364,10 @@ function RequestLogPage({ readLog, enabled, canOpenSession, openSession, t, getL
               /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: request_log_default.detailLabel, children: t("requestLogDetailRequestBytes") }),
               /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: request_log_default.detailValue, children: bytes(entry.requestBytes) })
             ] }),
+            entry.imageBytes !== void 0 && entry.imageBytes > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: request_log_default.detailItem, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: request_log_default.detailLabel, children: t("requestLogDetailContentSplit") }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: request_log_default.detailValue, children: contentSplit(entry, t("requestLogDetailText"), t("requestLogDetailImages")) })
+            ] }),
             /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: request_log_default.detailItem, children: [
               /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: request_log_default.detailLabel, children: t("requestLogDetailSession") }),
               /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(

package/lib/index.js

@@ -59979,7 +59979,7 @@ var require_mock_interceptor = __commonJS({
 var require_mock_client = __commonJS({
   "node_modules/undici/lib/mock/mock-client.js"(exports, module) {
     "use strict";
-    var { promisify: promisify2 } = __require("node:util");
+    var { promisify } = __require("node:util");
     var Client = require_client();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -60027,7 +60027,7 @@ var require_mock_client = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify2(this[kOriginalClose])();
+        await promisify(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -60240,7 +60240,7 @@ var require_mock_call_history = __commonJS({
 var require_mock_pool = __commonJS({
   "node_modules/undici/lib/mock/mock-pool.js"(exports, module) {
     "use strict";
-    var { promisify: promisify2 } = __require("node:util");
+    var { promisify } = __require("node:util");
     var Pool = require_pool();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -60288,7 +60288,7 @@ var require_mock_pool = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify2(this[kOriginalClose])();
+        await promisify(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -73563,8 +73563,6 @@ import {
   resolveRetryPolicy
 } from "@deepseek-ai/dsh-llm";
 import { idleWatchdog, timeoutOf } from "@deepseek-ai/dsh-timeout";
-import { promisify } from "node:util";
-import { constants as zlibConstants, gzip as gzipCallback } from "node:zlib";
 
 // src/catalog/index.ts
 init_models();
@@ -75759,10 +75757,6 @@ var fields = {
     maxTokens: Schema.union([Schema.const(null), Schema.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER)])
   })])).default({}),
   modelProtocols: Schema.dict(Schema.string()).default({}),
-  // On by default, off is the whole fallback plan: if the gateway ever
-  // rejects a compressed body, one switch returns every request to plain
-  // JSON with no other change.
-  requestGzip: Schema.boolean().default(true),
   // On by default: recording costs one call and one boolean per request
   // plus a bounded ring, and buys a per-request trail whenever something
   // looks wrong. Off returns the request path to exactly as without the
@@ -76616,20 +76610,20 @@ function bodyBytes(body) {
   if (ArrayBuffer.isView(body)) return body.byteLength;
   return void 0;
 }
-var MIN_GZIP_BODY_BYTES = 1024;
-var gzipAsync = promisify(gzipCallback);
-async function gzipBody(armed, input, init) {
-  const original = init?.body;
-  const originalBytes = bodyBytes(original ?? void 0);
-  if (!armed || typeof input !== "string" && !(input instanceof URL) || originalBytes === void 0 || originalBytes < MIN_GZIP_BODY_BYTES || typeof original !== "string" && !(original instanceof ArrayBuffer) && !ArrayBuffer.isView(original)) {
-    return { body: original ?? null, bytes: originalBytes, headers: void 0 };
-  }
-  const bytes = typeof original === "string" ? Buffer.from(original) : original instanceof ArrayBuffer ? Buffer.from(original) : Buffer.from(original.buffer, original.byteOffset, original.byteLength);
-  const compressed = await gzipAsync(bytes, { level: zlibConstants.Z_BEST_SPEED });
-  const headers = new Headers(init?.headers);
-  headers.delete("content-length");
-  headers.set("content-encoding", "gzip");
-  return { body: compressed, bytes: compressed.byteLength, headers };
+function estimateImageWireBytes(messages, capBytes) {
+  const seen = /* @__PURE__ */ new Set();
+  let total = 0;
+  const cap = Math.max(0, capBytes);
+  for (const message of messages) {
+    for (const block of message.content) {
+      if (block.type !== "image" || block.offloaded === true) continue;
+      const id = block.attachment.attachmentId;
+      if (seen.has(id)) continue;
+      seen.add(id);
+      total += Math.ceil(Math.min(block.attachment.bytes, cap) / 3) * 4;
+    }
+  }
+  return seen.size === 0 ? void 0 : total;
 }
 async function* observingTerminalUsage(events, observe) {
   for await (const event of events) {
@@ -76801,6 +76795,7 @@ var OpencodeGoAdapter = class extends LlmAdapter {
       let timedOut = false;
       const containsImage = options.messages.some((message) => contentHasImage2(message.content));
       const headers = providerHeaders(options.sessionId === void 0 ? void 0 : String(options.sessionId));
+      const imageBytes = containsImage ? estimateImageWireBytes(options.messages, config.requestImageMaxBytes) : void 0;
       const span = this.options.requestLog?.start({
         model: options.model,
         sessionId: options.sessionId === void 0 ? void 0 : String(options.sessionId),
@@ -76810,23 +76805,19 @@ var OpencodeGoAdapter = class extends LlmAdapter {
         messageCount: options.messages.length,
         hasImage: containsImage,
         toolCount: options.tools?.length ?? 0,
+        ...imageBytes === void 0 ? {} : { imageBytes },
         headers: {
           ...options.sessionId === void 0 ? {} : { session: String(options.sessionId) },
           ...typeof headers["user-agent"] === "string" ? { userAgent: headers["user-agent"] } : {}
         }
       });
       const fetchFactory = this.options.fetch;
-      const requestFetch = fetchFactory === void 0 || span === void 0 && !config.requestGzip ? fetchFactory : () => {
+      const requestFetch = span === void 0 || fetchFactory === void 0 ? fetchFactory : () => {
         const base = fetchFactory();
         return (async (input, init) => {
-          const outgoing = await gzipBody(config.requestGzip, input, init);
-          const response = await base(input, {
-            ...init,
-            ...outgoing.body === void 0 ? {} : { body: outgoing.body },
-            ...outgoing.headers === void 0 ? {} : { headers: outgoing.headers }
-          });
-          span?.request(typeof init?.method === "string" ? init.method : "POST", requestUrl(input), outgoing.bytes);
-          span?.status(response.status);
+          const response = await base(input, init);
+          span.request(typeof init?.method === "string" ? init.method : "POST", requestUrl(input), bodyBytes(init?.body));
+          span.status(response.status);
           return response;
         });
       };
@@ -77171,6 +77162,7 @@ function parseEntry(value) {
     ...row["reasoningTokens"] === void 0 ? {} : { reasoningTokens: count("reasoningTokens", row) },
     ...row["costUsd"] === void 0 ? {} : { costUsd: rate("costUsd", row) },
     ...row["requestBytes"] === void 0 ? {} : { requestBytes: count("requestBytes", row) },
+    ...row["imageBytes"] === void 0 ? {} : { imageBytes: count("imageBytes", row) },
     ...row["durationMs"] === void 0 ? {} : { durationMs: count("durationMs", row) },
     ...row["firstTokenMs"] === void 0 ? {} : { firstTokenMs: count("firstTokenMs", row) },
     ...row["decodeMs"] === void 0 ? {} : { decodeMs: count("decodeMs", row) },
@@ -77807,6 +77799,7 @@ var RequestLog = class {
           },
           ...costUsd === void 0 ? {} : { costUsd },
           ...requestBytes === void 0 ? {} : { requestBytes },
+          ...detail.imageBytes === void 0 ? {} : { imageBytes: detail.imageBytes },
           durationMs: Math.max(0, endedAt - startedAt),
           ...firstTokenAt === void 0 ? {} : { firstTokenMs: Math.max(0, firstTokenAt - startedAt) },
           ...decodeMs === void 0 ? {} : { decodeMs },
@@ -77951,7 +77944,7 @@ function createUpdateChecker(deps) {
 }
 
 // src/update/version.ts
-var PLUGIN_VERSION = true ? "0.1.70" : "0.0.0-dev";
+var PLUGIN_VERSION = true ? "0.1.73" : "0.0.0-dev";
 
 // src/update/service.ts
 import { TypertRemoteService as TypertRemoteService4 } from "@deepseek-ai/dsh-typert-protocol";

package/lib/types/adapter.d.ts

@@ -20,6 +20,25 @@ import type { GoDoc } from './catalog/go-doc.ts';
 import type { OpencodeGoConfig } from './config.ts';
 import type { RequestRecorder } from './request-log/store.ts';
 import type { MeteredUsage } from './usage/meter.ts';
+/**
+ * Estimate the image share of one request's wire bytes, from the messages
+ * before conversion.
+ *
+ * Every attached image travels as base64 (or raw bytes on the one protocol
+ * that sends them so), so the estimate uses the base64 size — the larger
+ * of the two — and can only understate the text residual, never inflate
+ * the parts past the whole. Repeated occurrences of one attachment travel
+ * once: the conversion dedupes by attachment id, and so does this walk.
+ * An offloaded placeholder travels as text, not bytes, and is skipped the
+ * same way. Each image is capped at the route's encoded-byte target,
+ * mirroring the preparation the conversion applies. Absent when the
+ * request carries no image bytes at all, so the common text-only request
+ * records nothing extra.
+ * @param messages - the request's messages, exactly as the caller passed them.
+ * @param capBytes - per-image encoded-byte target, before base64 expansion.
+ * @returns estimated image wire bytes, or undefined when there are none.
+ */
+export declare function estimateImageWireBytes(messages: GenerateOptions['messages'], capBytes: number): number | undefined;
 /** Image machinery the adapter reads once per request. */
 export interface OpencodeGoImageAccess {
     /** Resolve the durable attachment service at request time. */

package/lib/types/config.d.ts

@@ -75,14 +75,6 @@ export interface OpencodeGoConfig {
      * The escape hatch for a model whose family rule guessed wrong.
      */
     modelProtocols: Record<string, string>;
-    /**
-     * Whether JSON request bodies of 1 KB or more are gzip-compressed before
-     * sending. On by default: the gateway is expected to accept
-     * `Content-Encoding: gzip`, and small bodies are never worth the overhead.
-     * If the gateway ever rejects compressed bodies, turn this off — the
-     * off switch is the whole fallback plan.
-     */
-    requestGzip: boolean;
     /**
      * Whether the request log records anything at all. On by default: one
      * call and one boolean per request, plus a bounded ring. Off returns the

package/lib/types/request-log/store.d.ts

@@ -66,6 +66,14 @@ export interface RequestLogEntry {
      * sensitive: a multi-megabyte turn uploads slowly no matter the model.
      */
     readonly requestBytes?: number;
+    /**
+     * Estimated image share of the wire body, in bytes: unique attached
+     * images as base64, each capped at the route's encoded-byte target.
+     * The text share is the residual (`requestBytes` minus this), so the two
+     * always reconcile with the total. Absent when the request carries no
+     * image bytes at all.
+     */
+    readonly imageBytes?: number;
     /**
      * Wall time from the first to the last content token, in milliseconds —
      * the window the output actually streamed in. Absent when fewer than two
@@ -206,6 +214,8 @@ export interface RequestStart {
     readonly messageCount: number;
     readonly hasImage: boolean;
     readonly toolCount: number;
+    /** Estimated image share of the wire body, in bytes; see the entry field. */
+    readonly imageBytes?: number;
     /** Allowlisted request headers; the recorder never sees the credential. */
     readonly headers: {
         readonly session?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dan-ai-studio/dshopencodego",
-  "version": "0.1.70",
+  "version": "0.1.73",
   "description": "OpenCode Go provider for DeepSeek Harness: live gateway catalog, per-conversation session header, usage",
   "type": "module",
   "license": "MIT",