@dan-ai-studio/dshopencodego 0.1.82 → 0.1.83

package/README.en.md

@@ -152,7 +152,7 @@ The API key comes from the Harness credential store (reference name `OPENCODE_GO
 - **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 open and on manual refresh, plus once a second while any request is running, 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. A request gets a "Requesting" placeholder row the moment it starts (the status column counts its seconds) and the row is completed in place when it ends. Failed requests are recorded with their error code; a stream the consumer abandoned early is recorded as `ABORTED` instead of vanishing silently.
+- The credential never enters a record: the recorder takes no headers argument at all, only the allowlisted session id and user agent. A request gets a "Requesting" placeholder row the moment it starts (the status column counts its seconds) and the row is completed in place when it ends. Failed requests are recorded with their error code — including failures before the first byte (unresolvable models, missing credentials), whose rows carry the reason but no usage. A stream the consumer abandoned early is recorded as `ABORTED` instead of vanishing silently.
 
 **Images**: an over-budget image is refused explicitly rather than silently downscaled or dropped. The budgets ride one preset `imageBudgetPreset` (three choices, default `dsh`), not three numbers:
 

package/README.md

@@ -151,7 +151,7 @@ API Key 通过 Harness 凭证库提供（引用名 `OPENCODE_GO_API_KEY`），
 - **内容拆分**：明细里"请求体"下面跟一行"文本 X ／图片 Y"——图片是各去重后附件按 base64 估的占比（单张按路由的编码上限封顶），文本是总数减图片的剩余，两者恒等于请求体总数。图片 dominant 的请求一眼就能看出来。
 - 会话 id **始终完整记录**（它是会话身份，不是凭据；截断后两个会话会读成一个）。
 - 记录的是环形缓冲（超限丢最旧），进程重启即清；页面平时只在打开与手动刷新时读快照，有请求中时每秒自动刷新一次直到结束，没人打开的页面零流量。
-- 凭据永远不进记录：记录器根本不接收请求头参数，只收白名单里的会话 id 与 UA；请求一开始就有一条"请求中"占位行（状态列读秒），结束时原位补全为完整记录。失败的请求同样记一条（含错误码）；消费者提前终止的流记一条 `ABORTED`，不再无声丢失。
+- 凭据永远不进记录：记录器根本不接收请求头参数，只收白名单里的会话 id 与 UA；请求一开始就有一条"请求中"占位行（状态列读秒），结束时原位补全为完整记录。失败的请求同样记一条（含错误码）——包括目录解析失败（未知模型）与凭证缺失这类"第一个字节之前"的失败，行里没有用量只有原因；消费者提前终止的流记一条 `ABORTED`，不再无声丢失。
 
 **图片**：三个字段各管一层，超限的图片会被明确拒绝，而不是静默降质或丢弃：
 

package/lib/index.js

@@ -76907,30 +76907,113 @@ var OpencodeGoAdapter = class extends LlmAdapter {
       "UNSUPPORTED_REASONING_EFFORT"
     );
   }
+  /**
+   * Open the request's log row.
+   *
+   * Called before any wait the request may hit — the catalog included — so
+   * a cold catalog reads as preparation instead of invisible time, and a
+   * failure before the first byte still leaves a row behind. Everything
+   * here is already known or pure: the protocol arrives later, through
+   * `identify`, once the catalog has answered.
+   */
+  startSpan(options, config, protocol) {
+    const containsImage = options.messages.some((message) => contentHasImage2(message.content));
+    const headers = providerHeaders(options.sessionId === void 0 ? void 0 : String(options.sessionId));
+    const imageBudget = IMAGE_BUDGETS[config.imageBudgetPreset];
+    const imageBytes = containsImage ? estimateImageWireBytes(options.messages, imageBudget.maxBytes) : void 0;
+    return this.options.requestLog?.start({
+      model: options.model,
+      sessionId: options.sessionId === void 0 ? void 0 : String(options.sessionId),
+      ...protocol === void 0 ? {} : { protocol },
+      method: "POST",
+      url: config.baseURL,
+      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"] } : {}
+      }
+    });
+  }
+  /**
+   * Record a failure that happened before any request was built.
+   *
+   * Preparation (unlike dispatch) knows no session and no messages, so the
+   * row reads as unbuilt rather than empty — but it still names the model
+   * and the code, instead of leaving the caller with an error the log never
+   * heard of.
+   */
+  logUnstartedFailure(config, model, error) {
+    this.options.requestLog?.start({
+      model,
+      sessionId: void 0,
+      method: "POST",
+      url: config.baseURL,
+      messageCount: 0,
+      hasImage: false,
+      toolCount: 0,
+      headers: {}
+    })?.finish(false, error instanceof LlmError9 ? error.code : void 0);
+  }
   async prepareCall(_provider, model, _signal) {
     const config = this.options.config();
     assertStreamIdleTimeoutMs(config.streamIdleTimeoutMs);
-    const snapshot2 = await this.catalogOf(config).forModel(model);
+    let snapshot2;
+    try {
+      snapshot2 = await this.catalogOf(config).forModel(model);
+    } catch (error) {
+      this.logUnstartedFailure(config, model, error);
+      throw error;
+    }
     const facts = snapshot2.facts.get(model);
-    if (facts === void 0) throw new LlmError9(`opencode-go has no model "${model}"`, "UNKNOWN_MODEL");
+    if (facts === void 0) {
+      const error = new LlmError9(`opencode-go has no model "${model}"`, "UNKNOWN_MODEL");
+      this.logUnstartedFailure(config, model, error);
+      throw error;
+    }
     const prepared = this.modelInfo(withModelLimit(toPiModel(facts, config.baseURL), config.modelLimits));
     return {
       model: prepared,
-      stream: (options) => this.streamWithSnapshot(options, config, snapshot2)
+      stream: (options) => {
+        const span = this.startSpan(options, config, facts.api);
+        return this.streamWithSnapshot(options, config, snapshot2, span);
+      }
     };
   }
   async *stream(options) {
     const config = this.options.config();
     assertStreamIdleTimeoutMs(config.streamIdleTimeoutMs);
-    const snapshot2 = await this.catalogOf(config).forModel(options.model);
-    yield* this.streamWithSnapshot(options, config, snapshot2);
+    const span = this.startSpan(options, config);
+    let snapshot2;
+    try {
+      snapshot2 = await this.catalogOf(config).forModel(options.model);
+    } catch (error) {
+      span?.finish(false, error instanceof LlmError9 ? error.code : void 0);
+      throw error;
+    }
+    yield* this.streamWithSnapshot(options, config, snapshot2, span);
   }
-  async *streamWithSnapshot(options, config, snapshot2) {
+  async *streamWithSnapshot(options, config, snapshot2, outerSpan) {
     var _stack = [];
     try {
-      assertStreamIdleTimeoutMs(config.streamIdleTimeoutMs);
+      const span = outerSpan ?? this.startSpan(options, config);
+      const failSpan = (error) => {
+        span?.finish(false, error instanceof LlmError9 ? error.code : void 0);
+        throw error;
+      };
+      try {
+        assertStreamIdleTimeoutMs(config.streamIdleTimeoutMs);
+      } catch (error) {
+        failSpan(error);
+      }
       const facts = snapshot2.facts.get(options.model);
-      if (facts === void 0) throw new LlmError9(`opencode-go has no model "${options.model}"`, "UNKNOWN_MODEL");
+      if (facts === void 0) {
+        const error = new LlmError9(`opencode-go has no model "${options.model}"`, "UNKNOWN_MODEL");
+        span?.finish(false, error.code);
+        throw error;
+      }
       const model = withModelLimit(toPiModel(facts, config.baseURL), config.modelLimits);
       const rates2 = usableRates(facts.cost);
       const stop = stopSequencesFor(model, options.stop);
@@ -76938,32 +77021,24 @@ var OpencodeGoAdapter = class extends LlmAdapter {
       const maxTokens = options.maxTokens === void 0 || ceiling === null || ceiling === void 0 ? options.maxTokens : Math.min(options.maxTokens, ceiling);
       const apiKey = await this.options.resolveApiKey();
       if (apiKey === void 0 || apiKey.length === 0) {
-        throw new LlmError9("dshopencodego: no credential resolved for the opencode-go route", "MISSING_CREDENTIAL");
+        const error = new LlmError9("dshopencodego: no credential resolved for the opencode-go route", "MISSING_CREDENTIAL");
+        span?.finish(false, error.code);
+        throw error;
+      }
+      let reasoning;
+      try {
+        reasoning = this.resolveReasoningLevel(model, options.reasoningEffort);
+      } catch (error) {
+        failSpan(error);
       }
-      const reasoning = this.resolveReasoningLevel(model, options.reasoningEffort);
       const consumer = new AbortController();
       const upstream = options.signal === void 0 ? consumer.signal : AbortSignal.any([options.signal, consumer.signal]);
       const watchdog = __using(_stack, idleWatchdog(upstream, config.streamIdleTimeoutMs, "LLM_STREAM_IDLE_TIMEOUT"));
       let timedOut = false;
+      span?.identify(facts.api);
       const containsImage = options.messages.some((message) => contentHasImage2(message.content));
       const headers = providerHeaders(options.sessionId === void 0 ? void 0 : String(options.sessionId));
       const imageBudget = IMAGE_BUDGETS[config.imageBudgetPreset];
-      const imageBytes = containsImage ? estimateImageWireBytes(options.messages, imageBudget.maxBytes) : void 0;
-      const span = this.options.requestLog?.start({
-        model: options.model,
-        sessionId: options.sessionId === void 0 ? void 0 : String(options.sessionId),
-        protocol: facts.api,
-        method: "POST",
-        url: config.baseURL,
-        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 = span === void 0 || fetchFactory === void 0 ? fetchFactory : () => {
         const base = fetchFactory();
@@ -77937,6 +78012,9 @@ var RequestLog = class {
     let reported = false;
     let finished = false;
     return {
+      identify: (protocol) => {
+        if (record2.protocol === void 0) record2.protocol = protocol;
+      },
       token: () => {
         const now = Date.now();
         if (firstTokenAt === void 0) {
@@ -77969,7 +78047,10 @@ var RequestLog = class {
           seq,
           atMs: startedAt,
           model: detail.model,
-          ...detail.protocol === void 0 ? {} : { protocol: detail.protocol },
+          // The protocol may have arrived after the row opened, through
+          // `identify` — the running row and the completion read the same
+          // field, so they never disagree.
+          ...record2.protocol === void 0 ? {} : { protocol: record2.protocol },
           session,
           method: record2.method,
           url: record2.url,
@@ -78134,7 +78215,7 @@ function createUpdateChecker(deps) {
 }
 
 // src/update/version.ts
-var PLUGIN_VERSION = true ? "0.1.82" : "0.0.0-dev";
+var PLUGIN_VERSION = true ? "0.1.83" : "0.0.0-dev";
 
 // src/update/service.ts
 import { TypertRemoteService as TypertRemoteService4 } from "@deepseek-ai/dsh-typert-protocol";

package/lib/types/adapter.d.ts

@@ -156,6 +156,25 @@ export declare class OpencodeGoAdapter extends LlmAdapter {
     providerRetryPolicy(_provider: string): ResolvedRetryPolicy | undefined;
     /** Validate an explicit effort against the model's own levels, without clamping. */
     private resolveReasoningLevel;
+    /**
+     * Open the request's log row.
+     *
+     * Called before any wait the request may hit — the catalog included — so
+     * a cold catalog reads as preparation instead of invisible time, and a
+     * failure before the first byte still leaves a row behind. Everything
+     * here is already known or pure: the protocol arrives later, through
+     * `identify`, once the catalog has answered.
+     */
+    private startSpan;
+    /**
+     * Record a failure that happened before any request was built.
+     *
+     * Preparation (unlike dispatch) knows no session and no messages, so the
+     * row reads as unbuilt rather than empty — but it still names the model
+     * and the code, instead of leaving the caller with an error the log never
+     * heard of.
+     */
+    private logUnstartedFailure;
     prepareCall(_provider: string, model: string, _signal?: AbortSignal): Promise<PreparedAdapterCall>;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
     private streamWithSnapshot;

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

@@ -83,10 +83,12 @@ export interface RequestLogEntry {
      */
     readonly streamMs?: number;
     /**
-     * Wall time from request start to the moment the fetch actually went out,
-     * in milliseconds — the local preparation (catalog, conversion, images).
-     * The rest of the first-token wait belongs to the wire and the gateway.
-     * Absent when the request never reached the wire (rejected up front).
+     * Wall time from request start to the moment the fetch went out,
+     * in milliseconds — the whole local path, catalog wait included: the row
+     * opens before the catalog is consulted, so a cold catalog reads as
+     * preparation rather than invisible time. The rest of the first-token
+     * wait belongs to the wire and the gateway. Absent when the request never
+     * reached the wire (rejected up front).
      */
     readonly prepMs?: number;
     /** Wall time from request start to terminal event, in milliseconds. */
@@ -218,6 +220,14 @@ export interface RequestSpan {
     request(method: string, url: string, requestBytes?: number): void;
     /** Mark the response status line's arrival. */
     status(status: number): void;
+    /**
+     * Fill in the wire protocol once the catalog has answered.
+     *
+     * The row opens before the catalog wait (so the wait itself is recorded),
+     * but the protocol is only known after it. Called at most once, before
+     * `finish`; a second call keeps the first.
+     */
+    identify(protocol: WireProtocol): void;
     /**
      * Close the span and complete its running row in place.
      * @param ok - whether the request completed.

package/package.json

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