@qwen-code/qwen-code 0.20.2-headless-image-routing.1 → 0.21.0

package/chunks/{chunk-QNLNLENL.js → chunk-5I2IWRSH.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-6X4GWOPW.js";
+} from "./chunk-A5L3JMUA.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-H24SOJIQ.js → chunk-5NBDS5S6.js}

@@ -2,9 +2,12 @@
 "use strict";
 import {
   CHANNEL_DAEMON_WORKER_SENTINEL,
+  CHANNEL_DELIVERY_IPC_TIMEOUT_MS,
   CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
   CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS,
+  ChannelDeliveryError,
   ChannelWebhookEnqueueError,
+  MAX_CHANNEL_DELIVERIES_IN_FLIGHT,
   MAX_CHANNEL_STARTUP_FAILURES,
   MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH,
   MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH,
@@ -13,26 +16,28 @@ import {
   QWEN_DAEMON_URL_ENV,
   QWEN_DAEMON_WORKSPACE_ENV,
   QWEN_SERVER_TOKEN_ENV,
+  createChannelDeliveryMessage,
   createChannelWebhookTaskMessage,
   createWorkerDiagnosticRedactor,
+  isChannelDeliveryResultMessage,
   isChannelStartupReportMessage,
   isChannelStartupReportType,
   isChannelWebhookEnqueueErrorCode,
   isChannelWebhookTaskResultMessage,
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-QKTHJXCS.js";
+} from "./chunk-LK7CHLVP.js";
 import {
   channelSelectionNames
-} from "./chunk-TJTKSVIV.js";
+} from "./chunk-JLU636DO.js";
+import {
+  sanitizeLogText
+} from "./chunk-RWTEFFPU.js";
 import {
   CHANNEL_WORKER_KILL_GRACE_MS,
   CHANNEL_WORKER_STARTUP_TIMEOUT_MS,
   CHANNEL_WORKER_STOP_GRACE_MS
 } from "./chunk-5HBA2Z7V.js";
-import {
-  sanitizeLogText
-} from "./chunk-RVLZCXEE.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -263,6 +268,7 @@ function createChannelWorkerSupervisor(opts) {
   let staleHeartbeatTimer;
   let restartAttemptTimes = [];
   const pendingWebhookTasks = /* @__PURE__ */ new Map();
+  const pendingChannelDeliveries = /* @__PURE__ */ new Map();
   let restarting;
   let disposed = false;
   const snapshotCopy = /* @__PURE__ */ __name(() => ({
@@ -273,7 +279,8 @@ function createChannelWorkerSupervisor(opts) {
       startupFailures: snapshot.startupFailures.map((failure) => ({
         ...failure
       }))
-    } : {}
+    } : {},
+    ...snapshot.adapters ? { adapters: snapshot.adapters.map((adapter) => ({ ...adapter })) } : {}
   }), "snapshotCopy");
   const clearRestartTimer = /* @__PURE__ */ __name(() => {
     if (restartTimer) {
@@ -325,6 +332,39 @@ function createChannelWorkerSupervisor(opts) {
     }
     return true;
   }, "settleWebhookTask");
+  const rejectPendingChannelDeliveries = /* @__PURE__ */ __name((code, message) => {
+    for (const pending of pendingChannelDeliveries.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new ChannelDeliveryError(code, message));
+    }
+    pendingChannelDeliveries.clear();
+  }, "rejectPendingChannelDeliveries");
+  const rejectPendingChannelDelivery = /* @__PURE__ */ __name((id, error) => {
+    const pending = pendingChannelDeliveries.get(id);
+    if (!pending) return;
+    pendingChannelDeliveries.delete(id);
+    clearTimeout(pending.timer);
+    pending.reject(error);
+  }, "rejectPendingChannelDelivery");
+  const settleChannelDelivery = /* @__PURE__ */ __name((message) => {
+    if (!isChannelDeliveryResultMessage(message)) return false;
+    const pending = pendingChannelDeliveries.get(message.id);
+    if (!pending) return true;
+    if (message.ok) {
+      pendingChannelDeliveries.delete(message.id);
+      clearTimeout(pending.timer);
+      pending.resolve({ delivered: true });
+    } else {
+      rejectPendingChannelDelivery(
+        message.id,
+        new ChannelDeliveryError(
+          message.code,
+          message.error || "Channel delivery failed."
+        )
+      );
+    }
+    return true;
+  }, "settleChannelDelivery");
   const pruneRestartAttempts = /* @__PURE__ */ __name((nowMs) => {
     restartAttemptTimes = restartAttemptTimes.filter(
       (attemptMs) => nowMs - attemptMs < restartPolicy.windowMs
@@ -432,6 +472,12 @@ function createChannelWorkerSupervisor(opts) {
       state: "starting",
       channels: channelSelectionNames(opts.selection),
       ...requestedChannels ? { requestedChannels } : {},
+      ...requestedChannels ? {
+        adapters: requestedChannels.map((name) => ({
+          name,
+          state: "starting"
+        }))
+      } : {},
       startedAt,
       restartCount: snapshot.restartCount ?? 0,
       ...snapshot.lastExitAt ? { lastExitAt: snapshot.lastExitAt } : {},
@@ -615,7 +661,14 @@ function createChannelWorkerSupervisor(opts) {
         };
         snapshot = {
           ...snapshot,
-          startupFailures: [...snapshot.startupFailures ?? [], failure]
+          startupFailures: [...snapshot.startupFailures ?? [], failure],
+          adapters: snapshot.adapters?.map(
+            (adapter) => adapter.name === failure.channel ? {
+              name: adapter.name,
+              state: "error",
+              error: failure.message
+            } : adapter
+          )
         };
         acknowledgeStartupReport();
       }, "handleStartupReport");
@@ -637,6 +690,22 @@ function createChannelWorkerSupervisor(opts) {
         if (message.requestedChannels?.length) {
           next.requestedChannels = [...message.requestedChannels];
         }
+        const adapterNames = message.requestedChannels?.length ? message.requestedChannels : next.requestedChannels ?? next.channels;
+        const connected = new Set(next.channels);
+        const failures = new Map(
+          next.startupFailures?.map((failure) => [failure.channel, failure])
+        );
+        next.adapters = adapterNames.map((name) => {
+          if (connected.has(name)) {
+            return { name, state: "connected" };
+          }
+          const failure = failures.get(name);
+          return {
+            name,
+            state: "error",
+            ...failure ? { error: failure.message } : {}
+          };
+        });
         snapshot = next;
         armStaleHeartbeatTimer(startedChild);
         notifyReady(opts.onReady, snapshotCopy());
@@ -656,6 +725,9 @@ function createChannelWorkerSupervisor(opts) {
       }, "handleHeartbeat");
       function handleMessage(message) {
         if (child !== startedChild) return;
+        if (settleChannelDelivery(message)) {
+          return;
+        }
         if (settleWebhookTask(message)) {
           return;
         }
@@ -684,6 +756,10 @@ function createChannelWorkerSupervisor(opts) {
           "channel_worker_unavailable",
           "Channel worker exited."
         );
+        rejectPendingChannelDeliveries(
+          "channel_worker_unavailable",
+          "Channel worker exited."
+        );
         child = void 0;
         if ((ready || kind === "restart") && !stopping) {
           scheduleRestart();
@@ -759,6 +835,10 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelDeliveries(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         child = void 0;
         snapshot = { ...snapshot, state: "stopped" };
@@ -803,6 +883,10 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelDeliveries(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         clearRestartTimer();
         clearStaleHeartbeatTimer();
@@ -825,6 +909,62 @@ function createChannelWorkerSupervisor(opts) {
     snapshot() {
       return snapshotCopy();
     },
+    async deliverChannelMessage(request) {
+      const startedChild = child;
+      if (!startedChild || snapshot.state !== "running") {
+        throw new ChannelDeliveryError(
+          "channel_worker_unavailable",
+          "Channel worker is not running."
+        );
+      }
+      const send = startedChild.send;
+      if (!send) {
+        throw new ChannelDeliveryError(
+          "channel_worker_unavailable",
+          "Channel worker IPC send failed."
+        );
+      }
+      if (pendingChannelDeliveries.size >= MAX_CHANNEL_DELIVERIES_IN_FLIGHT) {
+        throw new ChannelDeliveryError(
+          "channel_delivery_queue_full",
+          "Channel delivery queue is full."
+        );
+      }
+      const message = createChannelDeliveryMessage(request);
+      return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pendingChannelDeliveries.delete(message.id);
+          reject(
+            new ChannelDeliveryError(
+              "channel_delivery_timeout",
+              "Channel delivery IPC timed out."
+            )
+          );
+        }, CHANNEL_DELIVERY_IPC_TIMEOUT_MS);
+        timer.unref();
+        pendingChannelDeliveries.set(message.id, { resolve, reject, timer });
+        try {
+          send.call(startedChild, message, (error) => {
+            if (!error) return;
+            rejectPendingChannelDelivery(
+              message.id,
+              new ChannelDeliveryError(
+                "channel_worker_unavailable",
+                `Channel worker IPC send failed: ${error.message}`
+              )
+            );
+          });
+        } catch (error) {
+          rejectPendingChannelDelivery(
+            message.id,
+            new ChannelDeliveryError(
+              "channel_worker_unavailable",
+              `Channel worker IPC send failed: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+      });
+    },
     async enqueueWebhookTask(task) {
       const startedChild = child;
       if (!startedChild || snapshot.state !== "running") {

package/chunks/{chunk-E4IMU4Y5.js → chunk-63P4EL5V.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-6FGBXPWM.js

@@ -0,0 +1,293 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getErrorStatus
+} from "./chunk-NL7LTRLR.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/quotaErrorDetection.ts
+init_esbuild_shims();
+function isApiError(error) {
+  return typeof error === "object" && error !== null && "error" in error && typeof error.error === "object" && error.error !== null && "message" in error.error;
+}
+__name(isApiError, "isApiError");
+function isStructuredError(error) {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+__name(isStructuredError, "isStructuredError");
+function isProQuotaExceededError(error) {
+  const checkMessage = /* @__PURE__ */ __name((message) => message.includes("Quota exceeded for quota metric 'Gemini") && message.includes("Pro Requests'"), "checkMessage");
+  if (typeof error === "string") {
+    return checkMessage(error);
+  }
+  if (isStructuredError(error)) {
+    return checkMessage(error.message);
+  }
+  if (isApiError(error)) {
+    return checkMessage(error.error.message);
+  }
+  if (error && typeof error === "object" && "response" in error) {
+    const gaxiosError = error;
+    if (gaxiosError.response && gaxiosError.response.data) {
+      if (typeof gaxiosError.response.data === "string") {
+        return checkMessage(gaxiosError.response.data);
+      }
+      if (typeof gaxiosError.response.data === "object" && gaxiosError.response.data !== null && "error" in gaxiosError.response.data) {
+        const errorData = gaxiosError.response.data;
+        return checkMessage(errorData.error?.message || "");
+      }
+    }
+  }
+  return false;
+}
+__name(isProQuotaExceededError, "isProQuotaExceededError");
+function isGenericQuotaExceededError(error) {
+  if (typeof error === "string") {
+    return error.includes("Quota exceeded for quota metric");
+  }
+  if (isStructuredError(error)) {
+    return error.message.includes("Quota exceeded for quota metric");
+  }
+  if (isApiError(error)) {
+    return error.error.message.includes("Quota exceeded for quota metric");
+  }
+  return false;
+}
+__name(isGenericQuotaExceededError, "isGenericQuotaExceededError");
+function isQwenQuotaExceededError(error) {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const { status, code, message } = error;
+  return status === 429 && code === "insufficient_quota" && typeof message === "string" && message.toLowerCase().includes("free allocated quota exceeded");
+}
+__name(isQwenQuotaExceededError, "isQwenQuotaExceededError");
+
+// packages/core/src/utils/rateLimit.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/retryPolicy.ts
+init_esbuild_shims();
+var MAX_TIMEOUT_MS = 2147483647;
+function getRetryDelayMs(options) {
+  const normalizedAttempt = Math.max(1, options.attempt);
+  const delayCeilingMs = Math.min(options.maxDelayMs, MAX_TIMEOUT_MS);
+  const exponent = Math.min(normalizedAttempt - 1, 31);
+  const cappedExponentialDelayMs = Math.min(
+    options.initialDelayMs * Math.pow(2, exponent),
+    delayCeilingMs
+  );
+  const retryAfterMode = options.retryAfterMode ?? "ignore";
+  const retryAfterMs = retryAfterMode === "ignore" ? null : getRetryAfterDelayMs(options.error);
+  if (retryAfterMs !== null && retryAfterMs > 0) {
+    const retryAfterCapMs = Math.min(
+      options.retryAfterMaxDelayMs ?? options.maxDelayMs,
+      MAX_TIMEOUT_MS
+    );
+    const cappedRetryAfterMs = Math.min(retryAfterMs, retryAfterCapMs);
+    return Math.max(cappedExponentialDelayMs, cappedRetryAfterMs);
+  }
+  const jitterRatio = options.jitterRatio ?? 0;
+  if (jitterRatio <= 0) return cappedExponentialDelayMs;
+  const random = options.random ?? Math.random;
+  const jitter = cappedExponentialDelayMs * jitterRatio * (random() * 2 - 1);
+  return Math.min(
+    Math.max(0, cappedExponentialDelayMs + jitter),
+    delayCeilingMs
+  );
+}
+__name(getRetryDelayMs, "getRetryDelayMs");
+function getRetryAfterDelayMs(error) {
+  const value = getHeaderValue(error, "retry-after") ?? getResponseHeaderValue(error, "retry-after");
+  if (value === null) return null;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed)) {
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return Math.min(seconds * 1e3, MAX_TIMEOUT_MS);
+    }
+  }
+  const retryAtMs = Date.parse(trimmed);
+  if (!Number.isFinite(retryAtMs)) return null;
+  const delayMs = retryAtMs - Date.now();
+  return delayMs > 0 ? Math.min(delayMs, MAX_TIMEOUT_MS) : 0;
+}
+__name(getRetryAfterDelayMs, "getRetryAfterDelayMs");
+function getHeaderValue(error, headerName) {
+  if (!hasHeaders(error)) return null;
+  const { headers } = error;
+  if (typeof headers.get === "function") {
+    const value = headers.get(headerName);
+    return typeof value === "string" ? value : null;
+  }
+  if (typeof headers !== "object" || headers === null) return null;
+  const lowerHeaderName = headerName.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== lowerHeaderName) continue;
+    return typeof value === "string" ? value : null;
+  }
+  return null;
+}
+__name(getHeaderValue, "getHeaderValue");
+function getResponseHeaderValue(error, headerName) {
+  if (!hasResponseHeaders(error)) return null;
+  return getHeaderValue(error.response, headerName);
+}
+__name(getResponseHeaderValue, "getResponseHeaderValue");
+function hasHeaders(error) {
+  return typeof error === "object" && error !== null && "headers" in error && error.headers != null;
+}
+__name(hasHeaders, "hasHeaders");
+function hasResponseHeaders(error) {
+  return typeof error === "object" && error !== null && "response" in error && typeof error.response === "object" && error.response !== null && "headers" in error.response && error.response.headers != null;
+}
+__name(hasResponseHeaders, "hasResponseHeaders");
+
+// packages/core/src/utils/rateLimit.ts
+var RATE_LIMIT_ERROR_CODES = /* @__PURE__ */ new Set([429, 503, 1302, 1305]);
+function isRateLimitError(error, extraCodes) {
+  const code = getErrorCode(error);
+  if (code === null) return false;
+  if (RATE_LIMIT_ERROR_CODES.has(code)) return true;
+  if (extraCodes && extraCodes.includes(code)) return true;
+  return false;
+}
+__name(isRateLimitError, "isRateLimitError");
+function getRateLimitErrorDetails(error) {
+  const statusCode = getErrorStatus(error);
+  const payload = getProviderErrorPayload(error);
+  const message = getRawErrorMessage(error);
+  const transport = message?.includes("event:error") || message?.includes("HTTP_STATUS/") ? "sse" : statusCode !== void 0 ? "http" : "unknown";
+  return {
+    ...statusCode !== void 0 ? { statusCode } : {},
+    ...payload?.code !== void 0 ? { providerCode: String(payload.code) } : {},
+    ...payload?.message !== void 0 ? { providerMessage: payload.message } : {},
+    ...payload?.requestId !== void 0 ? { requestId: payload.requestId } : {},
+    transport
+  };
+}
+__name(getRateLimitErrorDetails, "getRateLimitErrorDetails");
+function getRateLimitRetryDelayMs(attempt, options) {
+  return getRetryDelayMs({
+    attempt,
+    initialDelayMs: options.initialDelayMs,
+    maxDelayMs: options.maxDelayMs,
+    retryAfterMode: "minimum",
+    retryAfterMaxDelayMs: options.maxDelayMs,
+    error: options.error
+  });
+}
+__name(getRateLimitRetryDelayMs, "getRateLimitRetryDelayMs");
+function getErrorCode(error) {
+  if (isApiError(error)) {
+    const n = Number(error.error.code);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  const msg = error instanceof Error ? error.message : typeof error === "string" ? error : null;
+  if (msg) {
+    const i = msg.indexOf("{");
+    if (i !== -1) {
+      try {
+        const p = JSON.parse(msg.substring(i));
+        if (isApiError(p)) {
+          const n = Number(p.error.code);
+          if (Number.isFinite(n) && n > 0) return n;
+        }
+      } catch {
+      }
+    }
+  }
+  if (isStructuredError(error) && typeof error.status === "number") {
+    return error.status;
+  }
+  if (error instanceof Error && "status" in error) {
+    const s = error.status;
+    if (typeof s === "number") return s;
+  }
+  return getErrorStatus(error) ?? null;
+}
+__name(getErrorCode, "getErrorCode");
+function getProviderErrorPayload(error) {
+  for (const payload of getJsonPayloads(error)) {
+    if (typeof payload !== "object" || payload === null) continue;
+    const direct = payload;
+    const nestedError = payload.error;
+    const nested = typeof nestedError === "object" && nestedError !== null ? nestedError : void 0;
+    const source = nested ?? direct;
+    const code = typeof source.code === "string" || typeof source.code === "number" ? source.code : void 0;
+    const message = typeof source.message === "string" ? source.message : void 0;
+    const requestId = typeof source.request_id === "string" ? source.request_id : typeof source.requestId === "string" ? source.requestId : typeof direct.request_id === "string" ? direct.request_id : typeof direct.requestId === "string" ? direct.requestId : void 0;
+    if (code !== void 0 || message !== void 0 || requestId !== void 0) {
+      return { code, message, requestId };
+    }
+  }
+  if (isApiError(error)) {
+    return {
+      code: error.error.code,
+      message: error.error.message
+    };
+  }
+  return null;
+}
+__name(getProviderErrorPayload, "getProviderErrorPayload");
+function getJsonPayloads(error) {
+  const message = getRawErrorMessage(error);
+  if (!message) return [];
+  const payloads = [];
+  for (const line of message.split(/\r?\n/)) {
+    if (!line.startsWith("data:")) continue;
+    const data = line.slice("data:".length).trim();
+    if (!data || data === "[DONE]") continue;
+    try {
+      payloads.push(JSON.parse(data));
+    } catch {
+    }
+  }
+  if (payloads.length > 0) return payloads;
+  const jsonStart = message.indexOf("{");
+  const jsonEnd = message.lastIndexOf("}");
+  if (jsonStart !== -1 && jsonEnd > jsonStart) {
+    try {
+      payloads.push(
+        JSON.parse(message.slice(jsonStart, jsonEnd + 1))
+      );
+    } catch {
+    }
+  }
+  return payloads;
+}
+__name(getJsonPayloads, "getJsonPayloads");
+function getRawErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return null;
+}
+__name(getRawErrorMessage, "getRawErrorMessage");
+
+export {
+  isApiError,
+  isStructuredError,
+  isProQuotaExceededError,
+  isGenericQuotaExceededError,
+  isQwenQuotaExceededError,
+  getRetryDelayMs,
+  getRetryAfterDelayMs,
+  isRateLimitError,
+  getRateLimitErrorDetails,
+  getRateLimitRetryDelayMs
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */