@dan-ai-studio/dshopencodego 0.1.92 → 0.1.94

package/lib/index.js

@@ -50835,7 +50835,7 @@ var require_parser_h1 = __commonJS({
     var EVENT_RANGE_SIZE = 9;
     var EVENT_HEADERS_SIZE = 19;
     var miloPackage;
-    var useWasmSIMD = process.arch !== "ppc64";
+    var useWasmSIMD = process.arch !== "riscv64" && process.arch !== "ppc64";
     if (process.env.UNDICI_NO_WASM_SIMD === "1") {
       useWasmSIMD = false;
     } else if (process.env.UNDICI_NO_WASM_SIMD === "0") {
@@ -52113,14 +52113,35 @@ Content-Type: ${value.type || "application/octet-stream"}\r
             "Response body object should not be disturbed or locked"
           );
         }
-        stream5 = webidl.is.ReadableStream(object) ? object : ReadableStream.from(object).pipeThrough(new TransformStream({
-          transform(chunk, controller) {
-            const bytes = isUint8Array(chunk) ? chunk : Buffer.from(chunk);
-            if (bytes.byteLength) {
-              controller.enqueue(bytes);
+        if (webidl.is.ReadableStream(object)) {
+          stream5 = object;
+        } else {
+          const reader = ReadableStream.from(object).getReader();
+          let cancelled = false;
+          stream5 = new ReadableStream({
+            async pull(controller) {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (cancelled) {
+                  return;
+                }
+                if (done) {
+                  controller.close();
+                  return;
+                }
+                const bytes = isUint8Array(value) ? value : Buffer.from(value);
+                if (bytes.byteLength) {
+                  controller.enqueue(bytes);
+                  return;
+                }
+              }
+            },
+            cancel(reason) {
+              cancelled = true;
+              return reader.cancel(reason);
             }
-          }
-        }));
+          }, { highWaterMark: 0 });
+        }
       }
       if (typeof source === "string" || isUint8Array(source)) {
         action = () => source;
@@ -52352,7 +52373,9 @@ var require_client_h1 = __commonJS({
       const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
       let mod;
       let useWasmSIMD = true;
-      if (process.arch === "ppc64") {
+      if (process.arch === "riscv64") {
+        useWasmSIMD = false;
+      } else if (process.arch === "ppc64") {
         const [major, minor] = process.versions.node.split(".").map((n) => parseInt(n, 10));
         if (major < 24 || major === 24 && minor < 12) {
           useWasmSIMD = false;
@@ -53673,7 +53696,6 @@ var require_client_h2 = __commonJS({
     } = require_symbols();
     var { channels } = require_diagnostics();
     var kOpenStreams = /* @__PURE__ */ Symbol("open streams");
-    var kRequestStreamId = /* @__PURE__ */ Symbol("request stream id");
     var kRequestStream = /* @__PURE__ */ Symbol("request stream");
     var kRequestStreamCleanup = /* @__PURE__ */ Symbol("request stream cleanup");
     var kRequestStreamState = /* @__PURE__ */ Symbol("request stream state");
@@ -53681,6 +53703,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 HTTP2_FRAME_TYPE_HEADERS = 1;
     var MIN_PROBE_TIMEOUT = 1e3;
     var extractBody2;
     var http2;
@@ -53732,14 +53755,14 @@ var require_client_h2 = __commonJS({
         if (request == null) {
           continue;
         }
-        if (typeof request[kRequestStreamId] !== "number" || request[kRequestStreamId] > maxAcceptedStreamID) {
+        const streamId = request[kRequestStream]?.id;
+        if (typeof streamId !== "number" || streamId > maxAcceptedStreamID) {
           return i;
         }
       }
       return client[kPendingIdx];
     }
     function detachRequestFromStream(request) {
-      request[kRequestStreamId] = null;
       request[kRequestStream] = null;
       request[kRequestStreamCleanup] = null;
     }
@@ -53748,7 +53771,6 @@ var require_client_h2 = __commonJS({
       const previousStream = request[kRequestStream];
       detachRequestFromStream(request);
       previousCleanup?.(previousStream);
-      request[kRequestStreamId] = stream5.id;
       request[kRequestStream] = stream5;
       request[kRequestStreamCleanup] = cleanup;
     }
@@ -53817,7 +53839,8 @@ var require_client_h2 = __commonJS({
         closeStreamSession(stream5);
       }
       if (!stream5.destroyed && !stream5.closed) {
-        stream5.once("error", noop3);
+        stream5.off("error", noop3);
+        stream5.on("error", noop3);
       }
     }
     function connectH2(client, socket) {
@@ -54152,14 +54175,12 @@ var require_client_h2 = __commonJS({
           }
         }
       }
-      for (let i = 0; i < streamsToClose.length; i++) {
-        closeStream(streamsToClose[i]);
-      }
       if (pendingIdx !== previousPendingIdx) {
         const remainingPendingRequests = client[kQueue].slice(previousPendingIdx);
         client[kQueue].length = pendingIdx;
         client[kQueue].push(...retriableRequests, ...remainingPendingRequests);
       }
+      client[kPendingIdx] = pendingIdx;
       if (client[kHTTP2Session] === this) {
         client[kSocket] = null;
         client[kHTTPContext] = null;
@@ -54171,10 +54192,12 @@ var require_client_h2 = __commonJS({
       clearHttp2IdleTimeout(this);
       clearNoStreamsTimeout(this);
       clearHttp2ProbeTimeout(this);
+      for (let i = 0; i < streamsToClose.length; i++) {
+        closeStream(streamsToClose[i]);
+      }
       if (!this.closed && !this.destroyed) {
         this.close();
       }
-      client[kPendingIdx] = pendingIdx;
       client.emit("disconnect", client[kUrl], [client], err);
       client[kResume]();
     }
@@ -54250,7 +54273,6 @@ var require_client_h2 = __commonJS({
       }
     }
     function onUpgradeStreamClose() {
-      this.off("error", noop3);
       const state2 = this[kRequestStreamState];
       this[kRequestStreamState] = null;
       failUpgradeStream(state2, new InformationalError("HTTP/2: stream closed before response headers"));
@@ -54323,7 +54345,7 @@ var require_client_h2 = __commonJS({
       }
       removeUpgradeStreamListeners(stream5);
       if (!stream5.destroyed && !stream5.closed) {
-        stream5.once("error", noop3);
+        stream5.on("error", noop3);
       }
     }
     function failUpgradeStream(state2, err) {
@@ -54617,7 +54639,7 @@ var require_client_h2 = __commonJS({
       }
       if (!stream5.destroyed && !stream5.closed) {
         removeRequestStreamListeners(stream5);
-        stream5.once("error", noop3);
+        stream5.on("error", noop3);
       }
     }
     function onData(chunk) {
@@ -54730,13 +54752,25 @@ var require_client_h2 = __commonJS({
         return false;
       }
       request[kRefusedStreamRetry] = true;
+      requeueStreamRequest(client, state2);
+      return true;
+    }
+    function retryUnsentStream(state2) {
+      const { client, request, session } = state2;
+      if (!session[kReceivedGoAway] || state2.responseReceived || request.aborted || request.completed || !canReplayRequest(request) || !registerGoAwayRefusal(request)) {
+        return false;
+      }
+      requeueStreamRequest(client, state2);
+      return true;
+    }
+    function requeueStreamRequest(client, state2) {
+      const { request } = state2;
       detachRequestStreamForClose(request);
       state2.stream = null;
       state2.requestFinalized = true;
       completeRequest(client, request);
       client[kQueue].splice(client[kPendingIdx], 0, request);
       client[kResume]();
-      return true;
     }
     function onError(err) {
       const stream5 = this;
@@ -54745,6 +54779,7 @@ var require_client_h2 = __commonJS({
         return;
       }
       stream5.off("error", onError);
+      stream5.on("error", noop3);
       if (state2.responseContentLength != null && state2.bytesRead !== state2.responseContentLength) {
         err = new ResponseContentLengthMismatchError();
       }
@@ -54763,6 +54798,9 @@ var require_client_h2 = __commonJS({
         return;
       }
       stream5.off("frameError", onFrameError);
+      if (type === HTTP2_FRAME_TYPE_HEADERS && retryUnsentStream(state2)) {
+        return;
+      }
       state2.abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`));
     }
     function onAborted() {
@@ -60015,13 +60053,18 @@ var require_mock_utils = __commonJS({
       if (typeof path5 !== "string") {
         return path5;
       }
+      const queryIndex = path5.indexOf("?");
+      const search = queryIndex === -1 ? "" : path5.slice(queryIndex);
+      if (queryIndex !== -1) {
+        path5 = path5.slice(0, queryIndex);
+      }
       while (path5.endsWith("/")) {
         path5 = path5.slice(0, -1);
       }
       if (path5.length === 0) {
         path5 = "/";
       }
-      return path5;
+      return path5 + search;
     }
     function buildKey(opts) {
       const { path: path5, method, body, headers, query } = opts;
@@ -60108,6 +60151,9 @@ var require_mock_utils = __commonJS({
         paused: false,
         rawHeaders: null,
         rawTrailers: null,
+        get aborted() {
+          return aborted;
+        },
         pause() {
           this.paused = true;
         },
@@ -61989,8 +62035,11 @@ var require_decorator_handler = __commonJS({
       onResponseStart(...args) {
         assert(!this.#onCompleteCalled);
         assert(!this.#onErrorCalled);
-        assert(!this.#onResponseStartCalled);
-        this.#onResponseStartCalled = true;
+        const statusCode = args[1];
+        if (statusCode >= 200) {
+          assert(!this.#onResponseStartCalled);
+          this.#onResponseStartCalled = true;
+        }
         return this.#handler.onResponseStart?.(...args);
       }
       onResponseData(...args) {
@@ -62110,7 +62159,11 @@ var require_redirect_handler = __commonJS({
           this.handler.onResponseStart?.(controller, statusCode, headers, statusMessage);
           return;
         }
-        this.history[kRedirectCacheControl].push(headers["cache-control"]);
+        this.history[kRedirectCacheControl].push({
+          statusCode,
+          headers: { ...headers },
+          receivedAt: Date.now()
+        });
         const baseUrl = requestOrigin ? new URL(this.opts.path, requestOrigin) : void 0;
         const { origin, pathname, search } = util2.parseURL(new URL(this.location, baseUrl));
         const path5 = search ? `${pathname}${search}` : pathname;
@@ -62178,9 +62231,17 @@ var require_redirect_handler = __commonJS({
     function cleanRequestHeaders(headers, removeContent, unknownOrigin, stripHeaders, stripHeadersOnCrossOrigin) {
       const ret = [];
       if (Array.isArray(headers)) {
-        for (let i = 0; i < headers.length; i += 2) {
-          if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin, stripHeaders, stripHeadersOnCrossOrigin)) {
-            ret.push(headers[i], headers[i + 1]);
+        if (headers.length > 0 && Array.isArray(headers[0])) {
+          for (const [key, value] of headers) {
+            if (!shouldRemoveHeader(key, removeContent, unknownOrigin, stripHeaders, stripHeadersOnCrossOrigin)) {
+              ret.push(key, value);
+            }
+          }
+        } else {
+          for (let i = 0; i < headers.length; i += 2) {
+            if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin, stripHeaders, stripHeadersOnCrossOrigin)) {
+              ret.push(headers[i], headers[i + 1]);
+            }
           }
         }
       } else if (headers && typeof headers === "object") {
@@ -64044,6 +64105,15 @@ var require_cache_handler = __commonJS({
       }
       return false;
     }
+    function appendVaryValues(target, varyValue) {
+      if (Array.isArray(varyValue)) {
+        for (let i = 0; i < varyValue.length; i++) {
+          target.push(varyValue[i]);
+        }
+      } else if (varyValue != null) {
+        target.push(varyValue);
+      }
+    }
     function appendConnectionHeaderTokens(headersToRemove, connectionHeader) {
       const values = Array.isArray(connectionHeader) ? connectionHeader : [connectionHeader];
       for (let i = 0; i < values.length; i++) {
@@ -64105,6 +64175,9 @@ var require_cache_handler = __commonJS({
       deleteLocationTargets(store, cacheKey, resHeaders.location);
       deleteLocationTargets(store, cacheKey, resHeaders["content-location"]);
     }
+    function requestCarriesCredentials(headers) {
+      return headers != null && (Object.hasOwn(headers, "authorization") || Object.hasOwn(headers, "cookie") || Object.hasOwn(headers, "proxy-authorization"));
+    }
     var CacheHandler = class {
       /**
        * @type {import('../../types/cache-interceptor.d.ts').default.CacheKey}
@@ -64137,7 +64210,7 @@ var require_cache_handler = __commonJS({
       /**
        * The URLs visited while following redirects, shared by reference from the
        * redirect handler through the request context. Carries the suppressed hops'
-       * cache-control under {@link kRedirectCacheControl}.
+       * status/headers under {@link kRedirectCacheControl}.
        * @type {URL[] | undefined}
        */
       #history;
@@ -64187,21 +64260,29 @@ var require_cache_handler = __commonJS({
           invalidateUnsafeRequest(this.#store, this.#cacheKey, resHeaders);
           return downstreamOnHeaders();
         }
-        if (this.#history && this.#history.length > 0) {
-          const finalUrl = this.#history[this.#history.length - 1];
-          if (!sameOrigin(finalUrl.origin, this.#cacheKey.origin)) {
-            return downstreamOnHeaders();
-          }
+        if (this.#history && this.#history.length > 1 && requestCarriesCredentials(this.#cacheKey.headers)) {
+          return downstreamOnHeaders();
         }
-        const redirectCacheControl = this.#history?.[kRedirectCacheControl];
-        if (redirectCacheControl) {
-          for (const hopCacheControl of redirectCacheControl) {
-            const hopDirectives = hopCacheControl ? parseCacheControlHeader(hopCacheControl) : {};
-            if (hopDirectives["no-store"] === true || this.#cacheType === "shared" && hopDirectives.private === true) {
+        if (this.#history && this.#history.length > 0) {
+          for (const hopUrl of this.#history) {
+            if (!sameOrigin(hopUrl.origin, this.#cacheKey.origin)) {
               return downstreamOnHeaders();
             }
           }
         }
+        const now = Date.now();
+        const redirectHopInfo = this.#history?.[kRedirectCacheControl];
+        const redirectPolicy = redirectHopInfo?.length > 0 ? getRedirectPolicy(
+          this.#cacheType,
+          this.#cacheKey.method,
+          redirectHopInfo,
+          this.#cacheKey.headers,
+          this.#cacheByDefault,
+          now
+        ) : void 0;
+        if (redirectHopInfo?.length > 0 && redirectPolicy === void 0) {
+          return downstreamOnHeaders();
+        }
         const cacheControlHeader = resHeaders["cache-control"];
         const cacheControlDirectives = cacheControlHeader ? parseCacheControlHeader(cacheControlHeader) : {};
         if (revalidationResponseDisallowsCachedReuse(this.#cacheType, resHeaders, cacheControlDirectives)) {
@@ -64221,7 +64302,6 @@ var require_cache_handler = __commonJS({
           }
           return downstreamOnHeaders();
         }
-        const now = Date.now();
         const resAge = Object.hasOwn(resHeaders, "age") ? getAge(resHeaders.age) : void 0;
         if (resAge !== void 0 && resAge >= MAX_RESPONSE_AGE) {
           deleteCachedValueIfNotModified(statusCode, this.#store, this.#cacheKey);
@@ -64244,27 +64324,53 @@ var require_cache_handler = __commonJS({
           return downstreamOnHeaders();
         }
         const baseTime = now - currentAge;
-        const absoluteStaleAt = staleAt + baseTime;
+        let absoluteStaleAt = staleAt + baseTime;
+        if (redirectPolicy !== void 0) {
+          absoluteStaleAt = Math.min(absoluteStaleAt, redirectPolicy.staleAt);
+        }
         if (now >= absoluteStaleAt && !revalidationOnly) {
           deleteCachedValueIfNotModified(statusCode, this.#store, this.#cacheKey);
           return downstreamOnHeaders();
         }
         let varyDirectives;
-        if (this.#cacheKey.headers && resHeaders.vary) {
-          varyDirectives = parseVaryHeader(resHeaders.vary, this.#cacheKey.headers);
-          if (!varyDirectives) {
-            return downstreamOnHeaders();
+        const combinedVary = [];
+        if (redirectHopInfo) {
+          for (const hop of redirectHopInfo) {
+            appendVaryValues(combinedVary, hop?.headers?.vary);
+          }
+        }
+        appendVaryValues(combinedVary, resHeaders.vary);
+        if (combinedVary.length > 0) {
+          for (const varyHeader of combinedVary) {
+            if (hasVaryStar(varyHeader)) {
+              return downstreamOnHeaders();
+            }
+          }
+          if (this.#cacheKey.headers) {
+            varyDirectives = parseVaryHeader(combinedVary, this.#cacheKey.headers);
+            if (!varyDirectives) {
+              return downstreamOnHeaders();
+            }
+          }
+        }
+        let effectiveCacheControlDirectives = cacheControlDirectives;
+        if (redirectPolicy !== void 0) {
+          effectiveCacheControlDirectives = { ...cacheControlDirectives };
+          delete effectiveCacheControlDirectives["stale-while-revalidate"];
+          delete effectiveCacheControlDirectives["stale-if-error"];
+          if (redirectPolicy.requiresRevalidation === true) {
+            effectiveCacheControlDirectives["proxy-revalidate"] = true;
           }
         }
         const cachedAt = baseTime;
-        const deleteAt = determineDeleteAt(baseTime, now, cacheControlDirectives, absoluteStaleAt);
+        const deleteAt = determineDeleteAt(baseTime, now, effectiveCacheControlDirectives, absoluteStaleAt);
         const strippedHeaders = stripNecessaryHeaders(resHeaders, cacheControlDirectives);
         const value = {
           statusCode,
           statusMessage,
           headers: strippedHeaders,
           vary: varyDirectives,
-          cacheControlDirectives,
+          cacheControlDirectives: effectiveCacheControlDirectives,
           cachedAt,
           staleAt: absoluteStaleAt,
           deleteAt
@@ -64278,6 +64384,13 @@ var require_cache_handler = __commonJS({
             done = true;
             this.#downstreamController.release();
           };
+          const failReplay = (err) => {
+            if (done) {
+              return;
+            }
+            done = true;
+            controller.abort(err);
+          };
           const handle304 = (cachedValue) => {
             if (!cachedValue) {
               downstreamOnHeaders();
@@ -64301,14 +64414,18 @@ var require_cache_handler = __commonJS({
                 if (done) {
                   return;
                 }
-                for (const chunk of bodyIterator) {
-                  const full = this.#writeStream?.write(chunk) === false;
-                  this.#handler.onResponseData?.(this.#downstreamController, chunk);
-                  if (full) {
-                    return;
+                try {
+                  for (const chunk of bodyIterator) {
+                    const full = this.#writeStream?.write(chunk) === false;
+                    this.#handler.onResponseData?.(this.#downstreamController, chunk);
+                    if (full) {
+                      return;
+                    }
                   }
+                  finish304();
+                } catch (err) {
+                  failReplay(err);
                 }
-                finish304();
               };
               this.#writeStream.on("error", function() {
                 handler.#writeStream = void 0;
@@ -64325,8 +64442,13 @@ var require_cache_handler = __commonJS({
               streamCachedBody();
             } else if (typeof cachedValue.body.on === "function") {
               cachedValue.body.on("data", (chunk) => {
-                this.#writeStream?.write(chunk);
-                this.#handler.onResponseData?.(this.#downstreamController, chunk);
+                try {
+                  this.#writeStream?.write(chunk);
+                  this.#handler.onResponseData?.(this.#downstreamController, chunk);
+                } catch (err) {
+                  cachedValue.body.destroy();
+                  failReplay(err);
+                }
               }).on("end", () => {
                 this.#writeStream?.end();
                 finish304();
@@ -64443,6 +64565,74 @@ var require_cache_handler = __commonJS({
       }
       return true;
     }
+    function getRedirectPolicy(cacheType, method, redirectHops, reqHeaders, cacheByDefault, now) {
+      let staleAt = Infinity;
+      let requiresRevalidation = false;
+      for (const hop of redirectHops) {
+        const hopPolicy = getRedirectHopPolicy(cacheType, method, hop, reqHeaders, cacheByDefault);
+        if (hopPolicy === void 0 || hopPolicy.staleAt <= now) {
+          return void 0;
+        }
+        staleAt = Math.min(staleAt, hopPolicy.staleAt);
+        requiresRevalidation ||= hopPolicy.requiresRevalidation;
+      }
+      return { staleAt, requiresRevalidation };
+    }
+    function getRedirectHopPolicy(cacheType, method, hop, reqHeaders, cacheByDefault) {
+      if (!Number.isInteger(hop?.statusCode) || !Number.isFinite(hop?.receivedAt)) {
+        return void 0;
+      }
+      const hopHeaders = hop.headers ?? {};
+      const cacheControlHeader = hopHeaders["cache-control"];
+      const hopCacheControl = cacheControlHeader ? parseCacheControlHeader(cacheControlHeader) : {};
+      if (hopHeaders.vary && hasVaryStar(hopHeaders.vary)) {
+        return void 0;
+      }
+      if (hopCacheControl["no-store"] === true) {
+        return void 0;
+      }
+      if (cacheType === "shared" && Object.hasOwn(hopCacheControl, "private")) {
+        return void 0;
+      }
+      if (Object.hasOwn(hopCacheControl, "no-cache") || hopCacheControl["must-revalidate"] === true || cacheType === "shared" && hopCacheControl["proxy-revalidate"] === true) {
+        return void 0;
+      }
+      const heuristicallyCacheable = hopHeaders["last-modified"] && arrayIncludes(HEURISTICALLY_CACHEABLE_STATUS_CODES, hop.statusCode);
+      if (!cacheControlHeader && !hopHeaders.expires && !heuristicallyCacheable && !cacheByDefault) {
+        return void 0;
+      }
+      if (!canCacheResponse(cacheType, method, hop.statusCode, hopHeaders, hopCacheControl, reqHeaders)) {
+        return void 0;
+      }
+      const age = Object.hasOwn(hopHeaders, "age") ? getAge(hopHeaders.age) : void 0;
+      if (age !== void 0 && age >= MAX_RESPONSE_AGE) {
+        return void 0;
+      }
+      const responseDate = Object.hasOwn(hopHeaders, "date") ? getDate(hopHeaders.date) : void 0;
+      if (responseDate === null) {
+        return void 0;
+      }
+      const apparentAge = responseDate ? Math.max(0, hop.receivedAt - responseDate.getTime()) : 0;
+      const currentAge = Math.max(apparentAge, age ?? 0);
+      const hasValidator = typeof hopHeaders.etag === "string" && isEtagUsable(hopHeaders.etag) || typeof hopHeaders["last-modified"] === "string";
+      const freshnessLifetime = determineStaleAt(
+        cacheType,
+        hop.receivedAt,
+        age,
+        hopHeaders,
+        responseDate,
+        hopCacheControl,
+        hasValidator
+      ) ?? cacheByDefault;
+      if (freshnessLifetime === void 0) {
+        return void 0;
+      }
+      return {
+        staleAt: hop.receivedAt - currentAge + freshnessLifetime,
+        // RFC 9111 §5.2.2.10: s-maxage implies proxy-revalidate for shared caches.
+        requiresRevalidation: cacheType === "shared" && Object.hasOwn(hopCacheControl, "s-maxage")
+      };
+    }
     function getDate(dateHeader) {
       let dateValue = dateHeader;
       if (Array.isArray(dateValue)) {
@@ -64944,7 +65134,8 @@ var require_cache2 = __commonJS({
       normalizeHeaders,
       parseCacheControlHeader,
       isInvalidOrWildcardVaryHeader,
-      parseVaryHeader
+      parseVaryHeader,
+      isEtagUsable
     } = require_cache();
     var { AbortError } = require_errors();
     var { parseHttpDate } = require_date();
@@ -65064,6 +65255,34 @@ var require_cache2 = __commonJS({
       }
       return headers;
     }
+    function revalidationTargetMatchesCacheKey(cacheKey, context) {
+      const history = context?.history;
+      if (!Array.isArray(history) || history.length === 0) {
+        return true;
+      }
+      try {
+        const cachedUrl = new URL(cacheKey.path, cacheKey.origin);
+        const responseUrl = history[history.length - 1];
+        return responseUrl.origin === cachedUrl.origin && responseUrl.pathname === cachedUrl.pathname && responseUrl.search === cachedUrl.search;
+      } catch {
+        return false;
+      }
+    }
+    function revalidationEtagMatchesCachedValue(result, headers) {
+      if (!Object.hasOwn(headers, "etag")) {
+        return true;
+      }
+      const responseEtag = headers.etag;
+      const cachedEtag = result.etag;
+      if (typeof responseEtag !== "string" || typeof cachedEtag !== "string" || !isEtagUsable(responseEtag) || !isEtagUsable(cachedEtag)) {
+        return false;
+      }
+      if (!responseEtag.startsWith("W/")) {
+        return responseEtag === cachedEtag;
+      }
+      const cachedOpaqueTag = cachedEtag.startsWith("W/") ? cachedEtag.slice(2) : cachedEtag;
+      return responseEtag.slice(2) === cachedOpaqueTag;
+    }
     function isStale(result, cacheControlDirectives, cacheType) {
       const now = Date.now();
       if (now > result.staleAt || result.staleAt <= result.cachedAt) {
@@ -65161,18 +65380,23 @@ var require_cache2 = __commonJS({
       };
       stream5.on("error", function(err) {
         if (!this.readableEnded) {
-          if (typeof handler.onResponseError === "function") {
-            handler.onResponseError(controller, err);
-          } else {
-            throw err;
-          }
+          handler.onResponseError?.(controller, err);
         }
       }).on("close", function() {
         if (!this.errored) {
-          handler.onResponseEnd?.(controller, {});
+          try {
+            handler.onResponseEnd?.(controller, {});
+          } catch (err) {
+            handler.onResponseError?.(controller, err);
+          }
         }
       });
-      handler.onRequestStart?.(controller, context);
+      try {
+        handler.onRequestStart?.(controller, context);
+      } catch (err) {
+        stream5.destroy(err);
+        return;
+      }
       if (stream5.destroyed) {
         return;
       }
@@ -65181,12 +65405,21 @@ var require_cache2 = __commonJS({
         headers.warning = '110 - "response is stale"';
       }
       controller.rawHeaders = util2.toRawHeaders(headers);
-      handler.onResponseStart?.(controller, result.statusCode, headers, result.statusMessage);
+      try {
+        handler.onResponseStart?.(controller, result.statusCode, headers, result.statusMessage);
+      } catch (err) {
+        stream5.destroy(err);
+        return;
+      }
       if (opts.method === "HEAD") {
         stream5.destroy();
       } else {
         stream5.on("data", function(chunk) {
-          handler.onResponseData?.(controller, chunk);
+          try {
+            handler.onResponseData?.(controller, chunk);
+          } catch (err) {
+            stream5.destroy(err);
+          }
         });
       }
     }
@@ -65249,6 +65482,13 @@ var require_cache2 = __commonJS({
           }
         }
         const headers = makeRevalidationHeaders(opts, result);
+        const refetch = () => {
+          if (util2.isStream(result.body)) {
+            result.body.on("error", nop).destroy();
+          }
+          deleteCachedValue(globalOpts.store, cacheKey);
+          return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler));
+        };
         return dispatch(
           {
             ...opts,
@@ -65258,21 +65498,13 @@ var require_cache2 = __commonJS({
             (success, context, statusCode, headers2) => {
               if (success) {
                 if (statusCode === 304) {
-                  if (revalidationResponseDisallowsCachedReuse(globalOpts.type, headers2)) {
-                    if (util2.isStream(result.body)) {
-                      result.body.on("error", nop).destroy();
-                    }
-                    deleteCachedValue(globalOpts.store, cacheKey);
-                    return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler));
+                  if (!revalidationTargetMatchesCacheKey(cacheKey, context) || !revalidationEtagMatchesCachedValue(result, headers2) || revalidationResponseDisallowsCachedReuse(globalOpts.type, headers2)) {
+                    return refetch();
                   }
                   if (revalidationResponseUpdatesCacheControl(headers2)) {
                     deleteCachedValue(globalOpts.store, cacheKey);
                   } else if (revalidationResponseAddsVary(result, headers2.vary ? parseVaryHeader(headers2.vary, opts.headers) : void 0)) {
-                    if (util2.isStream(result.body)) {
-                      result.body.on("error", nop).destroy();
-                    }
-                    deleteCachedValue(globalOpts.store, cacheKey);
-                    return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler));
+                    return refetch();
                   }
                 }
                 sendCachedValue(handler, opts, result, age, context, stale);
@@ -65370,7 +65602,31 @@ var require_cache2 = __commonJS({
               opts2,
               reqCacheControl,
               result2
-            ));
+            )).catch((err) => {
+              if (typeof handler.onResponseError === "function") {
+                handler.onResponseError({
+                  rawHeaders: [],
+                  rawTrailers: [],
+                  pause() {
+                  },
+                  resume() {
+                  },
+                  get paused() {
+                    return false;
+                  },
+                  get aborted() {
+                    return false;
+                  },
+                  get reason() {
+                    return null;
+                  },
+                  abort() {
+                  }
+                }, err);
+              } else {
+                throw err;
+              }
+            });
           } else {
             return handleResult(
               dispatch,
@@ -66378,10 +66634,15 @@ var require_sqlite_cache_store = __commonJS({
     var { assertCacheKey, assertCacheValue } = require_cache();
     var { zstdCompressSync, zstdDecompressSync } = __require("node:zlib");
     var DatabaseSync;
-    var VERSION3 = 4;
+    var VERSION3 = 5;
     var MAX_ENTRY_SIZE = 2 * 1e3 * 1e3 * 1e3;
     var COMPRESS_THRESHOLD = 1024 * 1024;
     var hasZstd = typeof zstdCompressSync === "function" && typeof zstdDecompressSync === "function";
+    var SQLITE_BUSY = 5;
+    var SQLITE_LOCKED = 6;
+    function isLockedError(err) {
+      return err?.errcode === SQLITE_BUSY || err?.errcode === SQLITE_LOCKED;
+    }
     module.exports = class SqliteCacheStore {
       #maxEntrySize = MAX_ENTRY_SIZE;
       #maxCount = Infinity;
@@ -66564,7 +66825,7 @@ var require_sqlite_cache_store = __commonJS({
        */
       get(key) {
         assertCacheKey(key);
-        const value = this.#findValue(key);
+        const value = this.#lockSafe(() => this.#findValue(key));
         return value ? {
           body: value.body ? value.compressed === "zstd" ? zstdDecompressSync(Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength)) : Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength) : void 0,
           statusCode: value.statusCode,
@@ -66599,9 +66860,9 @@ var require_sqlite_cache_store = __commonJS({
             compressed = "zstd";
           }
         }
-        const existingValue = this.#findValue(key, true);
+        const existingValue = this.#lockSafe(() => this.#findValue(key, true));
         if (existingValue) {
-          this.#updateValueQuery.run(
+          this.#lockSafe(() => this.#updateValueQuery.run(
             storedBody,
             compressed,
             value.deleteAt,
@@ -66614,9 +66875,9 @@ var require_sqlite_cache_store = __commonJS({
             value.cachedAt,
             value.staleAt,
             existingValue.id
-          );
+          ));
         } else {
-          this.#insertValueQuery.run(
+          this.#lockSafe(() => this.#insertValueQuery.run(
             url,
             key.method,
             storedBody,
@@ -66630,7 +66891,7 @@ var require_sqlite_cache_store = __commonJS({
             value.vary ? JSON.stringify(value.vary) : null,
             value.cachedAt,
             value.staleAt
-          );
+          ));
           this.#prune();
         }
       }
@@ -66669,20 +66930,46 @@ var require_sqlite_cache_store = __commonJS({
         if (typeof key !== "object") {
           throw new TypeError(`expected key to be object, got ${typeof key}`);
         }
-        this.#deleteByUrlQuery.run(this.#makeValueUrl(key));
+        this.#lockSafe(() => this.#deleteByUrlQuery.run(this.#makeValueUrl(key)));
+      }
+      /**
+       * Runs a database operation, skipping it when another connection holds the
+       * database lock.
+       *
+       * The cache store is meant to be shared between processes, and SQLite reports
+       * a concurrent writer as SQLITE_BUSY/SQLITE_LOCKED. Those errors are
+       * transient, and caching is best effort: the entry is skipped and the next
+       * request retries, rather than failing the request that triggered the write.
+       *
+       * @template T
+       * @param {() => T} fn
+       * @returns {T | undefined}
+       */
+      #lockSafe(fn) {
+        try {
+          return fn();
+        } catch (err) {
+          if (!isLockedError(err)) {
+            throw err;
+          }
+          return void 0;
+        }
       }
       #prune() {
-        if (Number.isFinite(this.#maxCount) && this.size <= this.#maxCount) {
-          return 0;
+        if (Number.isFinite(this.#maxCount)) {
+          const size = this.#lockSafe(() => this.size);
+          if (size === void 0 || size <= this.#maxCount) {
+            return 0;
+          }
         }
         {
-          const removed = this.#deleteExpiredValuesQuery.run(Date.now()).changes;
+          const removed = this.#lockSafe(() => this.#deleteExpiredValuesQuery.run(Date.now()).changes);
           if (removed) {
             return removed;
           }
         }
         {
-          const removed = this.#deleteOldValuesQuery?.run(Math.max(Math.floor(this.#maxCount * 0.1), 1)).changes;
+          const removed = this.#lockSafe(() => this.#deleteOldValuesQuery?.run(Math.max(Math.floor(this.#maxCount * 0.1), 1)).changes);
           if (removed) {
             return removed;
           }
@@ -67671,41 +67958,64 @@ var require_request2 = __commonJS({
     var { URLSerializer } = require_data_url();
     var { kConstruct } = require_symbols();
     var assert = __require("node:assert");
-    var { getMaxListeners, setMaxListeners, defaultMaxListeners } = __require("node:events");
-    var kAbortController = /* @__PURE__ */ Symbol("abortController");
-    var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
-      signal.removeEventListener("abort", abort);
+    var requestFinalizer = new FinalizationRegistry(({ signal, reference }) => {
+      removeSignalFollower(signal, reference);
     });
-    var dependentControllerMap = /* @__PURE__ */ new WeakMap();
-    var abortSignalHasEventHandlerLeakWarning;
-    try {
-      abortSignalHasEventHandlerLeakWarning = getMaxListeners(new AbortController().signal) > 0;
-    } catch {
-      abortSignalHasEventHandlerLeakWarning = false;
-    }
-    function buildAbort(acRef) {
-      return abort;
-      function abort() {
-        const ac = acRef.deref();
-        if (ac !== void 0) {
-          requestFinalizer.unregister(abort);
-          this.removeEventListener("abort", abort);
-          ac.abort(this.reason);
-          const controllerList = dependentControllerMap.get(ac.signal);
-          if (controllerList !== void 0) {
-            if (controllerList.size !== 0) {
-              for (const ref of controllerList) {
-                const ctrl = ref.deref();
-                if (ctrl !== void 0) {
-                  ctrl.abort(this.reason);
-                }
-              }
-              controllerList.clear();
-            }
-            dependentControllerMap.delete(ac.signal);
-          }
-        }
+    var requestSignals = /* @__PURE__ */ new WeakMap();
+    var signalFollowers = /* @__PURE__ */ new WeakMap();
+    function removeSignalFollower(signal, reference) {
+      const followers = signalFollowers.get(signal);
+      if (followers instanceof Set) {
+        followers.delete(reference);
+        if (followers.size !== 0) return;
+      }
+      signal.removeEventListener("abort", abortSignalFollowers);
+      signalFollowers.delete(signal);
+    }
+    function abortSignalFollower(reference, reason) {
+      requestFinalizer.unregister(reference);
+      const ac = reference.deref();
+      if (ac !== void 0) {
+        requestSignals.delete(ac.signal);
+        ac.abort(reason);
+      }
+    }
+    function abortSignalFollowers() {
+      this.removeEventListener("abort", abortSignalFollowers);
+      const followers = signalFollowers.get(this);
+      if (followers instanceof Set) {
+        for (const reference of followers) {
+          abortSignalFollower(reference, this.reason);
+        }
+        followers.clear();
+      } else {
+        abortSignalFollower(followers, this.reason);
+      }
+      signalFollowers.delete(this);
+    }
+    function createDependentSignal(signal) {
+      const ac = new AbortController();
+      if (signal == null) return ac.signal;
+      if (signal.aborted) {
+        ac.abort(signal.reason);
+        return ac.signal;
+      }
+      const reference = new WeakRef(ac);
+      const followers = signalFollowers.get(signal);
+      if (followers === void 0) {
+        util2.addAbortListener(signal, abortSignalFollowers);
+        signalFollowers.set(signal, reference);
+      } else if (followers instanceof WeakRef) {
+        const controllers = /* @__PURE__ */ new Set();
+        controllers.add(followers);
+        controllers.add(reference);
+        signalFollowers.set(signal, controllers);
+      } else {
+        followers.add(reference);
       }
+      requestFinalizer.register(ac, { signal, reference }, reference);
+      requestSignals.set(ac.signal, { controller: ac, source: signal, reference });
+      return ac.signal;
     }
     var patchMethodWarning = false;
     var setRequestSignal;
@@ -67723,12 +68033,6 @@ var require_request2 = __commonJS({
       /** @type {Headers} */
       #headers;
       #state;
-      /**
-       * Removes the `abort` listener that makes this request's signal follow the
-       * passed signal. `null` when no such listener was registered.
-       * @type {(() => void) | null}
-       */
-      #abortCleanup = null;
       // https://fetch.spec.whatwg.org/#dom-request
       constructor(input, init = void 0) {
         webidl.util.markAsUncloneable(this);
@@ -67914,27 +68218,7 @@ var require_request2 = __commonJS({
           signal = init.signal;
         }
         this.#state = request;
-        const ac = new AbortController();
-        this.#signal = ac.signal;
-        if (signal != null) {
-          if (signal.aborted) {
-            ac.abort(signal.reason);
-          } else {
-            this[kAbortController] = ac;
-            const acRef = new WeakRef(ac);
-            const abort = buildAbort(acRef);
-            if (abortSignalHasEventHandlerLeakWarning && getMaxListeners(signal) === defaultMaxListeners) {
-              setMaxListeners(1500, signal);
-            }
-            const removeAbortListener = util2.addAbortListener(signal, abort);
-            requestFinalizer.register(ac, { signal, abort }, abort);
-            this.#abortCleanup = () => {
-              requestFinalizer.unregister(abort);
-              removeAbortListener();
-              this.#abortCleanup = null;
-            };
-          }
-        }
+        this.#signal = createDependentSignal(signal);
         this.#headers = new Headers2(kConstruct);
         setHeadersList(this.#headers, request.headersList);
         setHeadersGuard(this.#headers, "request");
@@ -68128,23 +68412,8 @@ var require_request2 = __commonJS({
           throw new TypeError("unusable");
         }
         const clonedRequest = cloneRequest(this.#state);
-        const ac = new AbortController();
-        if (this.signal.aborted) {
-          ac.abort(this.signal.reason);
-        } else {
-          let list = dependentControllerMap.get(this.signal);
-          if (list === void 0) {
-            list = /* @__PURE__ */ new Set();
-            dependentControllerMap.set(this.signal, list);
-          }
-          const acRef = new WeakRef(ac);
-          list.add(acRef);
-          util2.addAbortListener(
-            ac.signal,
-            buildAbort(acRef)
-          );
-        }
-        return fromInnerRequest(clonedRequest, this.#dispatcher, ac.signal, getHeadersGuard(this.#headers));
+        const signal = createDependentSignal(this.#signal);
+        return fromInnerRequest(clonedRequest, this.#dispatcher, signal, getHeadersGuard(this.#headers));
       }
       [nodeUtil.inspect.custom](depth, options) {
         if (options.depth === null) {
@@ -68190,7 +68459,12 @@ var require_request2 = __commonJS({
           request.#state = newState;
         };
         removeRequestAbortListener = (request) => {
-          request.#abortCleanup?.();
+          const state2 = requestSignals.get(request.#signal);
+          if (state2 !== void 0) {
+            requestSignals.delete(request.#signal);
+            requestFinalizer.unregister(state2.reference);
+            removeSignalFollower(state2.source, state2.reference);
+          }
         };
         webidl.is.Request = (arg) => {
           return arg != null && typeof arg === "object" && #state in arg;
@@ -68472,7 +68746,7 @@ var require_subresource_integrity = __commonJS({
     }
     function parseMetadata(metadata) {
       const result = [];
-      for (const item of metadata.split(" ")) {
+      for (const item of metadata.split(/[\t\n\f\r ]+/)) {
         const expressionAndOptions = item.split("?", 1);
         const algorithmExpression = expressionAndOptions[0];
         let base64Value = "";
@@ -68723,11 +68997,8 @@ var require_fetch = __commonJS({
           cleanupAbortListeners();
         },
         processResponse,
-        dispatcher: getRequestDispatcher(requestObject),
+        dispatcher: getRequestDispatcher(requestObject)
         // undici
-        // Keep requestObject alive to prevent its AbortController from being GC'd
-        // See https://github.com/nodejs/undici/issues/4627
-        requestObject
       });
       return p.promise;
     }
@@ -68795,10 +69066,8 @@ var require_fetch = __commonJS({
       processResponseEndOfBody,
       processResponseConsumeBody,
       useParallelQueue = false,
-      dispatcher = getGlobalDispatcher(),
+      dispatcher = getGlobalDispatcher()
       // undici
-      requestObject = null
-      // Keep alive to prevent AbortController GC, see #4627
     }) {
       assert(dispatcher);
       let taskDestination = null;
@@ -68821,9 +69090,7 @@ var require_fetch = __commonJS({
         processResponseConsumeBody,
         processResponseEndOfBody,
         taskDestination,
-        crossOriginIsolatedCapability,
-        // Keep requestObject alive to prevent its AbortController from being GC'd
-        requestObject
+        crossOriginIsolatedCapability
       };
       assert(!request.body || request.body.stream);
       if (request.window === "client") {
@@ -74122,7 +74389,7 @@ import dc from "node:diagnostics_channel";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
 import * as llm2 from "@deepseek-ai/dsh-llm";
-import { LlmError as LlmError14 } from "@deepseek-ai/dsh-llm";
+import { LlmError as LlmError13 } from "@deepseek-ai/dsh-llm";
 
 // src/adapter.ts
 init_models();
@@ -74178,6 +74445,14 @@ var openAIResponsesApi = () => lazyApi(() => Promise.resolve().then(() => (init_
 // src/catalog/index.ts
 import { attributionHeaders as attributionHeaders3, LlmError as LlmError4 } from "@deepseek-ai/dsh-llm";
 
+// src/llm-error.ts
+import { LlmError } from "@deepseek-ai/dsh-llm";
+function llmFailure(message, code, options) {
+  const raise = LlmError.fromFailure;
+  if (typeof raise === "function") return raise.call(LlmError, { message, code }, options);
+  return new LlmError(message, code, options);
+}
+
 // src/catalog/constants.ts
 var PROVIDER_ID = "opencode-go";
 var DISPLAY_NAME = "OpenCode Go";
@@ -74195,29 +74470,29 @@ var UNKNOWN_MODEL_PROBE_COOLDOWN_MS = 5 * 6e4;
 var MAX_CATALOG_STALENESS_MS = 24 * 60 * 6e4;
 
 // src/catalog/gateway.ts
-import { attributionHeaders, LlmError as LlmError2 } from "@deepseek-ai/dsh-llm";
+import { attributionHeaders, LlmError as LlmError3 } from "@deepseek-ai/dsh-llm";
 
 // src/catalog/json-response.ts
-import { LlmError } from "@deepseek-ai/dsh-llm";
+import { LlmError as LlmError2 } from "@deepseek-ai/dsh-llm";
 async function readBoundedJson(response, url, maxBytes) {
   const declared = Number(response.headers.get("content-length") ?? Number.NaN);
   if (Number.isFinite(declared) && declared > maxBytes) {
     await response.body?.cancel().catch(() => {
     });
-    throw new LlmError(`${url} declares ${declared} bytes, over the ${maxBytes}-byte cap`, "DISCOVERY_FAILED");
+    throw new LlmError2(`${url} declares ${declared} bytes, over the ${maxBytes}-byte cap`, "DISCOVERY_FAILED");
   }
   let text2;
   try {
     text2 = await readBoundedText(response, maxBytes);
   } catch (error) {
-    if (error instanceof LlmError) throw error;
+    if (error instanceof LlmError2) throw error;
     const detail = error instanceof Error ? error.message : String(error);
-    throw new LlmError(`could not read ${url}: ${detail}`, "DISCOVERY_FAILED", { cause: error });
+    throw new LlmError2(`could not read ${url}: ${detail}`, "DISCOVERY_FAILED", { cause: error });
   }
   try {
     return JSON.parse(text2);
   } catch (error) {
-    throw new LlmError(`${url} did not answer with JSON`, "DISCOVERY_FAILED", { cause: error });
+    throw new LlmError2(`${url} did not answer with JSON`, "DISCOVERY_FAILED", { cause: error });
   }
 }
 async function readBoundedText(response, maxBytes) {
@@ -74233,7 +74508,7 @@ async function readBoundedText(response, maxBytes) {
       if (total > maxBytes) {
         await reader.cancel().catch(() => {
         });
-        throw new LlmError(`response exceeds the ${maxBytes}-byte cap`, "DISCOVERY_FAILED");
+        throw new LlmError2(`response exceeds the ${maxBytes}-byte cap`, "DISCOVERY_FAILED");
       }
       chunks.push(value);
     }
@@ -74272,23 +74547,23 @@ async function fetchModelIds(baseURL, signal, request = globalThis.fetch) {
     headers: { ...attributionHeaders(), accept: "application/json", "cache-control": "no-cache" },
     signal: signal === void 0 ? timeout : AbortSignal.any([signal, timeout])
   }).catch((error) => {
-    throw new LlmError2(`could not reach ${url}`, "DISCOVERY_FAILED", { cause: error });
+    throw new LlmError3(`could not reach ${url}`, "DISCOVERY_FAILED", { cause: error });
   });
   if (!response.ok) {
     await response.body?.cancel().catch(() => {
     });
-    throw new LlmError2(`${url} answered HTTP ${response.status}`, "DISCOVERY_FAILED");
+    throw new LlmError3(`${url} answered HTTP ${response.status}`, "DISCOVERY_FAILED");
   }
   const body = await readBoundedJson(response, url, MODEL_LISTING_MAX_BYTES);
   try {
     return readModelIds(body);
   } catch (error) {
-    throw new LlmError2(`${url} returned an invalid model listing`, "DISCOVERY_FAILED", { cause: error });
+    throw new LlmError3(`${url} returned an invalid model listing`, "DISCOVERY_FAILED", { cause: error });
   }
 }
 
 // src/catalog/go-doc.ts
-import { attributionHeaders as attributionHeaders2, LlmError as LlmError3 } from "@deepseek-ai/dsh-llm";
+import { attributionHeaders as attributionHeaders2 } from "@deepseek-ai/dsh-llm";
 
 // src/catalog/go-doc-discovery.ts
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -74568,7 +74843,7 @@ async function fetchGoDocument(signal, options = {}) {
       }
     }
   }
-  throw new LlmError3(
+  throw llmFailure(
     `could not read the Go documentation (${failures.join("; ")})`,
     "DOCUMENT_UNAVAILABLE"
   );
@@ -75137,7 +75412,7 @@ var OpencodeGoCatalog = class {
     }
     const reason = snapshot2.unavailable.get(id);
     if (reason !== void 0) {
-      throw new LlmError4(
+      throw llmFailure(
         `opencode-go model "${id}" is advertised but cannot be configured: ${reason}; refresh the model list to retry`,
         "MODEL_METADATA_UNAVAILABLE"
       );
@@ -80336,7 +80611,7 @@ function createUpdateChecker(deps) {
 }
 
 // src/update/version.ts
-var PLUGIN_VERSION = true ? "0.1.92" : "0.0.0-dev";
+var PLUGIN_VERSION = true ? "0.1.94" : "0.0.0-dev";
 
 // src/update/service.ts
 import { TypertRemoteService as TypertRemoteService5 } from "@deepseek-ai/dsh-typert-protocol";
@@ -80365,7 +80640,7 @@ var OpencodeGoUpdateService = class extends TypertRemoteService5 {
 };
 
 // src/usage/windows.ts
-import { attributionHeaders as attributionHeaders6, LlmError as LlmError12 } from "@deepseek-ai/dsh-llm";
+import { attributionHeaders as attributionHeaders6 } from "@deepseek-ai/dsh-llm";
 var USAGE_MAX_BYTES = 1024 * 1024;
 var USAGE_TIMEOUT_MS = 1e4;
 function parseGoUsage(value) {
@@ -80383,7 +80658,7 @@ function parseGoUsage(value) {
 }
 async function readUsageWindows(options) {
   if (options.apiKey === void 0 || options.apiKey.length === 0) {
-    throw new LlmError12("dshopencodego: no credential is configured for the opencode-go route", "USAGE_UNAVAILABLE");
+    throw llmFailure("dshopencodego: no credential is configured for the opencode-go route", "USAGE_UNAVAILABLE");
   }
   const url = `${options.baseURL.replace(/\/+$/, "")}/usage`;
   const timeout = AbortSignal.timeout(USAGE_TIMEOUT_MS);
@@ -80400,12 +80675,12 @@ async function readUsageWindows(options) {
       signal: options.signal === void 0 ? timeout : AbortSignal.any([options.signal, timeout])
     });
   } catch (error) {
-    throw new LlmError12(`could not reach ${url}`, "USAGE_UNAVAILABLE", { cause: error });
+    throw llmFailure(`could not reach ${url}`, "USAGE_UNAVAILABLE", { cause: error });
   }
   if (!response.ok) {
     await response.body?.cancel().catch(() => {
     });
-    throw new LlmError12(`${url} answered HTTP ${response.status}`, "USAGE_UNAVAILABLE");
+    throw llmFailure(`${url} answered HTTP ${response.status}`, "USAGE_UNAVAILABLE");
   }
   const body = await readBoundedJson(response, url, USAGE_MAX_BYTES);
   try {
@@ -80414,16 +80689,16 @@ async function readUsageWindows(options) {
       ...options.source === void 0 ? {} : { source: options.source }
     };
   } catch (error) {
-    throw new LlmError12(`${url} returned an invalid usage document`, "USAGE_UNAVAILABLE", { cause: error });
+    throw llmFailure(`${url} returned an invalid usage document`, "USAGE_UNAVAILABLE", { cause: error });
   }
 }
 
 // src/usage/service.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { RemoteError as RemoteError2, TypertRemoteService as TypertRemoteService6 } from "@deepseek-ai/dsh-typert-protocol";
-import { LlmError as LlmError13 } from "@deepseek-ai/dsh-llm";
+import { LlmError as LlmError12 } from "@deepseek-ai/dsh-llm";
 function usageFailure(error, source) {
-  const missing = error instanceof LlmError13 && error.code === "MISSING_CREDENTIAL";
+  const missing = error instanceof LlmError12 && error.code === "MISSING_CREDENTIAL";
   return new RemoteError2(
     "dshopencodego/usage-unavailable",
     error instanceof Error ? error.message : "OpenCode Go usage is unavailable",
@@ -80450,7 +80725,7 @@ var OpencodeGoUsageService = class extends TypertRemoteService6 {
     }
     if (key === void 0 || key.length === 0) {
       this.identity = void 0;
-      throw usageFailure(new LlmError13("No OpenCode Go API key is configured", "MISSING_CREDENTIAL"), void 0);
+      throw usageFailure(new LlmError12("No OpenCode Go API key is configured", "MISSING_CREDENTIAL"), void 0);
     }
     if (this.identity?.baseURL !== baseURL || this.identity.key !== key) {
       this.identity = { baseURL, key, source: randomUUID3() };
@@ -80499,7 +80774,7 @@ function apply(ctx, raw) {
     const credentials = ctx.get("credentials");
     const hit = credentials !== void 0 ? (await credentials.resolve(credentialRef(ref)))?.value : launchEnvironmentOf(ctx).get(ref)?.value;
     if (hit !== void 0 && hit.length > 0) return llm2.assertUsableApiKey(hit, name, ref);
-    throw new LlmError14(
+    throw new LlmError13(
       `dshopencodego: no credential; the profile resolves ${ref}, which is not set \u2014 store ${ref} through the credentials service (the Web Models page writes it) or export it`,
       "MISSING_CREDENTIAL"
     );
@@ -80646,7 +80921,7 @@ function apply(ctx, raw) {
     settingsNs,
     async (request, signal) => {
       if (request.provider !== PROVIDER_ID && !(request.baseURL ?? "").includes("opencode.ai")) {
-        throw new LlmError14(
+        throw new LlmError13(
           "dshopencodego discovers only OpenCode Go/Console endpoints; enter this provider's models by hand",
           "DISCOVERY_UNSUPPORTED"
         );