@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-preview.0

package/chunks/{chunk-LTCI6ZOJ.js → chunk-45ROPFQY.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-65GHQ4FX.js";
+} from "./chunk-XVTCSVBK.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-W4LL5RZO.js → chunk-4ALNJDHL.js}

@@ -146,12 +146,49 @@ init_esbuild_shims();
 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 (code === null) return isStatuslessThrottle(error);
   if (RATE_LIMIT_ERROR_CODES.has(code)) return true;
   if (extraCodes && extraCodes.includes(code)) return true;
   return false;
 }
 __name(isRateLimitError, "isRateLimitError");
+function isStatuslessThrottle(error) {
+  for (const payload of [error, ...getJsonPayloads(error)]) {
+    const selected = providerErrorSource(payload);
+    if (!selected) continue;
+    const { source } = selected;
+    const { type, message } = source;
+    if (type === "rate_limit_error" || type === "overloaded_error") return true;
+    if (type !== "invalid_request_error" || typeof message !== "string")
+      continue;
+    const detail = decodeProviderMessage(message)?.["message"] ?? message;
+    if (typeof detail === "string" && /^too many requests\b/i.test(detail.trim()) && /\b(?:wait|try(?:ing)? again)\b/i.test(detail)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(isStatuslessThrottle, "isStatuslessThrottle");
+function providerErrorSource(payload) {
+  if (typeof payload !== "object" || payload === null) return null;
+  const direct = payload;
+  const nested = direct["error"];
+  const source = typeof nested === "object" && nested !== null ? nested : direct;
+  return { source, direct };
+}
+__name(providerErrorSource, "providerErrorSource");
+function decodeProviderMessage(message) {
+  try {
+    const selected = providerErrorSource(JSON.parse(message));
+    if (!selected || typeof selected.source["message"] !== "string") {
+      return null;
+    }
+    return { ...selected.direct, ...selected.source };
+  } catch {
+    return null;
+  }
+}
+__name(decodeProviderMessage, "decodeProviderMessage");
 function getRateLimitErrorDetails(error) {
   const statusCode = getErrorStatus(error);
   const payload = getProviderErrorPayload(error);
@@ -159,7 +196,7 @@ function getRateLimitErrorDetails(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?.code !== void 0 || payload?.type !== void 0 ? { providerCode: String(payload.code ?? payload.type) } : {},
     ...payload?.message !== void 0 ? { providerMessage: payload.message } : {},
     ...payload?.requestId !== void 0 ? { requestId: payload.requestId } : {},
     transport
@@ -208,22 +245,24 @@ function getErrorCode(error) {
 __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 };
+    const selected = providerErrorSource(payload);
+    if (!selected) continue;
+    const { source, direct } = selected;
+    const decoded = typeof source["message"] === "string" ? decodeProviderMessage(source["message"]) : null;
+    const code = typeof source["code"] === "string" || typeof source["code"] === "number" ? source["code"] : typeof decoded?.["code"] === "string" || typeof decoded?.["code"] === "number" ? decoded["code"] : void 0;
+    const type = typeof source["type"] === "string" ? source["type"] : typeof decoded?.["type"] === "string" ? decoded["type"] : void 0;
+    const message = typeof decoded?.["message"] === "string" ? decoded["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"] : typeof decoded?.["request_id"] === "string" ? decoded["request_id"] : typeof decoded?.["requestId"] === "string" ? decoded["requestId"] : void 0;
+    if (code !== void 0 || type !== void 0 || message !== void 0 || requestId !== void 0) {
+      return { code, type, message, requestId };
     }
   }
   if (isApiError(error)) {
+    const decoded = decodeProviderMessage(error.error.message);
     return {
       code: error.error.code,
-      message: error.error.message
+      ...typeof decoded?.["type"] === "string" ? { type: decoded["type"] } : {},
+      message: typeof decoded?.["message"] === "string" ? decoded["message"] : error.error.message
     };
   }
   return null;

package/chunks/{chunk-RRCNEW2A.js → chunk-4BLTSTF6.js}

@@ -2,20 +2,21 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-VMFPZXRT.js";
+} from "./chunk-ODBNTMZW.js";
 import {
   observeHeadlessToolResultProjection,
   observeHeadlessToolResultWire,
   projectJsonStringToByteBudget
-} from "./chunk-PMGWY6ZP.js";
+} from "./chunk-UULHYZ4W.js";
 import {
+  createNotStartedToolErrorResponse,
   parseAndFormatApiError,
   toolResultBoundaryArtifact
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-WQBR7LN5.js";
+} from "./chunk-OIPUQE3S.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -378,6 +379,49 @@ var BaseJsonOutputAdapter = class {
   startAssistantMessage() {
     this.startAssistantMessageInternal(this.mainAgentMessageState);
   }
+  /**
+   * Starts a replacement provider attempt. Continuation retries keep the
+   * already-delivered text; fresh retries and fallbacks discard the pending
+   * assistant state. Streaming adapters override this to pair any tool_use
+   * frames that are already on the wire before resetting.
+   */
+  restartAttempt(preserveText, discardedToolCalls) {
+    if (preserveText) {
+      const discardedIds = new Set(
+        discardedToolCalls.map((request) => request.callId)
+      );
+      if (discardedIds.size > 0) {
+        const state = this.mainAgentMessageState;
+        const retainedBlocks = [];
+        const retainedOpenBlocks = /* @__PURE__ */ new Set();
+        for (const [index, block] of state.blocks.entries()) {
+          if (block.type === "tool_use" && discardedIds.has(block.id)) {
+            continue;
+          }
+          const retainedIndex = retainedBlocks.length;
+          retainedBlocks.push(block);
+          if (state.openBlocks.has(index)) {
+            retainedOpenBlocks.add(retainedIndex);
+          }
+        }
+        state.blocks = retainedBlocks;
+        state.openBlocks = retainedOpenBlocks;
+        state.currentBlockType = retainedBlocks.at(-1)?.type ?? null;
+        state.messageStarted = retainedBlocks.length > 0;
+      }
+      return;
+    }
+    this.startAssistantMessageInternal(this.mainAgentMessageState);
+  }
+  emitDiscardedAttemptToolResults(discardedToolCalls) {
+    const message = "Skipped because the provider attempt was retried before execution.";
+    for (const request of discardedToolCalls) {
+      this.emitToolResult(
+        request,
+        createNotStartedToolErrorResponse(request, message)
+      );
+    }
+  }
   /**
    * Processes an LLM stream event.
    * This is a shared implementation used by both streaming and non-streaming adapters.
@@ -1072,6 +1116,16 @@ var StreamJsonOutputAdapter = class extends BaseJsonOutputAdapter {
     this.mainTurnMessageStartEmitted = false;
     super.startAssistantMessage();
   }
+  restartAttempt(preserveText, discardedToolCalls) {
+    if (preserveText && discardedToolCalls.length === 0) {
+      return;
+    }
+    if (this.mainAgentMessageState.messageStarted && !this.mainAgentMessageState.finalized) {
+      this.finalizeAssistantMessage();
+    }
+    this.emitDiscardedAttemptToolResults(discardedToolCalls);
+    super.restartAttempt(false, discardedToolCalls);
+  }
   finalizeAssistantMessage() {
     const message = this.finalizeAssistantMessageInternal(
       this.mainAgentMessageState,

package/chunks/{chunk-3RMVM33U.js → chunk-4JKLPTV6.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   getExtensionManager
-} from "./chunk-2C3XDBGL.js";
+} from "./chunk-ORREXWOM.js";
 import {
   parseChannelConfig
-} from "./chunk-BNWIX6BM.js";
+} from "./chunk-UXDVUFKU.js";
 import {
   getPlugin,
   registerPlugin
-} from "./chunk-RGAQDQ3Z.js";
+} from "./chunk-UHUT4IDM.js";
 import {
   sanitizeLogText
-} from "./chunk-65GHQ4FX.js";
+} from "./chunk-XVTCSVBK.js";
 import {
   loadSettings
-} from "./chunk-RUMSY4ES.js";
+} from "./chunk-Q2F43WTJ.js";
 import {
   hashDaemonWorkspace
 } from "./chunk-7OCIQNKX.js";

package/chunks/{chunk-ZRVFHLLK.js → chunk-5DQ4YTIZ.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-N6VQ37ZZ.js";
 import {
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   getPackageJson
 } from "./chunk-W3N5XAZ6.js";

package/chunks/{chunk-AWDF462I.js → chunk-5GD7LYOH.js}

@@ -16,7 +16,7 @@ import {
   MODIFIER_SHIFT_BIT,
   MODIFIER_SUPER_BIT,
   clipboardHasImage
-} from "./chunk-HY3DXYZK.js";
+} from "./chunk-UYDQYDW2.js";
 import {
   noteInteraction
 } from "./chunk-KW7NOTN6.js";
@@ -33,7 +33,7 @@ import {
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-WQBR7LN5.js";
+} from "./chunk-OIPUQE3S.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";

package/chunks/{chunk-HZS3JRQW.js → chunk-5VZFJTL2.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-RRCNEW2A.js";
+} from "./chunk-4BLTSTF6.js";
 import {
   observeHeadlessJsonToolResultWire
-} from "./chunk-PMGWY6ZP.js";
+} from "./chunk-UULHYZ4W.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -20,6 +20,8 @@ var JsonOutputAdapter = class extends BaseJsonOutputAdapter {
     __name(this, "JsonOutputAdapter");
   }
   messages = [];
+  attemptMessageCheckpoint = 0;
+  lastAssistantMessageAtAttemptStart = null;
   constructor(config) {
     super(config);
   }
@@ -39,6 +41,42 @@ var JsonOutputAdapter = class extends BaseJsonOutputAdapter {
   shouldEmitStreamEvents() {
     return false;
   }
+  startAssistantMessage() {
+    this.attemptMessageCheckpoint = this.messages.length;
+    this.lastAssistantMessageAtAttemptStart = this.lastAssistantMessage;
+    super.startAssistantMessage();
+  }
+  restartAttempt(preserveText, discardedToolCalls) {
+    if (preserveText) {
+      const discardedIds = new Set(
+        discardedToolCalls.map((request) => request.callId)
+      );
+      if (discardedIds.size > 0) {
+        const retained = this.messages.slice(this.attemptMessageCheckpoint).filter(
+          (message) => message.type !== "assistant" || !message.message.content.some(
+            (block) => block.type === "tool_use" && discardedIds.has(block.id)
+          )
+        );
+        this.messages.splice(
+          this.attemptMessageCheckpoint,
+          this.messages.length - this.attemptMessageCheckpoint,
+          ...retained
+        );
+        this.lastAssistantMessage = this.messages.findLast(
+          (message) => message.type === "assistant"
+        ) ?? this.lastAssistantMessageAtAttemptStart;
+      }
+    } else {
+      const retained = this.messages.slice(this.attemptMessageCheckpoint).filter((message) => message.type !== "assistant");
+      this.messages.splice(
+        this.attemptMessageCheckpoint,
+        this.messages.length - this.attemptMessageCheckpoint,
+        ...retained
+      );
+      this.lastAssistantMessage = this.lastAssistantMessageAtAttemptStart;
+    }
+    super.restartAttempt(preserveText, discardedToolCalls);
+  }
   finalizeAssistantMessage() {
     return this.finalizeAssistantMessageInternal(
       this.mainAgentMessageState,

package/chunks/{chunk-537SQ2AI.js → chunk-5WC2ECUK.js}

@@ -3012,6 +3012,62 @@ var DaemonClient = class {
   async resumeSession(sessionId, req = {}, clientId) {
     return this.restoreSession("resume", sessionId, req, clientId);
   }
+  /**
+   * Transfer a worktree session's checkout ownership to a fresh replacement
+   * session (`POST /session/:id/worktree-reset`, capability
+   * `session_worktree_reset_v1`). Resolves 200 with the replacement
+   * session's create-shape response. The route never reads a caller-supplied
+   * client id, so this method takes none — but the response is not
+   * registration-free: a fresh transfer mints an owner-style `clientId` for
+   * the spawn it performs, registers it on the replacement, and returns it in
+   * the body, while an idempotent resume of a committed transfer returns
+   * none. That registration is not an attachment (the replacement's attach
+   * count is unaffected), and nothing detaches it for you — pass a minted id
+   * you do not keep using to `detachSession`, or the replacement never
+   * reaches the daemon's idle cleanup. Typed 409 bodies carry the reset
+   * taxonomy: `worktree_reset_unsupported` (not a worktree session),
+   * `worktree_reset_active` (a session involved is busy), and
+   * `worktree_reset_invalid_state` (corrupt or ambiguous ownership state; a
+   * partial transfer this request started is rolled back, while a
+   * pre-existing interrupted state is left untouched for operator repair).
+   * A crashed transfer whose sidecar links agree is self-healed here: a
+   * pre-commit one (the marker still names this session, or is absent while
+   * the replacement is dormant) is rolled back and re-run in the same
+   * request, and a committed one (the marker names the replacement) is
+   * finished idempotently. Every other interrupted shape — disagreeing links,
+   * an invalid marker, a marker naming a third session, a replacement still
+   * live with no marker — is reported as `worktree_reset_invalid_state` (or
+   * `worktree_reset_active` when the committed replacement is busy) and left
+   * untouched: a retry re-reads the same state and returns the same 409, so
+   * it does not converge and needs operator repair rather than a retry loop.
+   * `worktree_reset_interrupted`, `worktree_session_superseded`, and
+   * `worktree_marker_missing` belong to the restore surface (`loadSession` /
+   * `resumeSession`) instead; for `worktree_reset_interrupted` — the
+   * agreeing-links shape — retrying this reset against the superseded session
+   * is the repair.
+   */
+  async resetWorktreeSession(sessionId, req = {}) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/worktree-reset`,
+      {
+        method: "POST",
+        headers: this.headers({ "Content-Type": "application/json" }),
+        body: JSON.stringify({
+          ...req.workspaceCwd !== void 0 ? { cwd: req.workspaceCwd } : {},
+          ...req.modelServiceId !== void 0 ? { modelServiceId: req.modelServiceId } : {},
+          ...req.approvalMode !== void 0 ? { approvalMode: req.approvalMode } : {},
+          ...req.sourceType !== void 0 ? { sourceType: req.sourceType } : {},
+          ...req.sourceId !== void 0 ? { sourceId: req.sourceId } : {}
+        })
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "POST /session/:id/worktree-reset");
+        }
+        return await res.json();
+      }
+    );
+  }
   async branchSession(sessionId, req = {}, clientId) {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/session/${urlEncode(sessionId)}/branch`,
@@ -6437,6 +6493,36 @@ var DaemonSessionClient = class _DaemonSessionClient {
       eventEpoch
     });
   }
+  /**
+   * Transfer a worktree session's checkout ownership to a fresh replacement
+   * session and return a client bound to the replacement's identity. That
+   * client carries whatever `clientId` the response had: a fresh transfer
+   * mints and registers an owner-style one for the spawn it performs, while
+   * an idempotent resume of a committed transfer returns none. The
+   * registration is not an attachment (the replacement's attach count is
+   * unaffected), but it is a client registration, and a non-empty one is what
+   * holds the daemon's idle cleanup off — so detach a minted id you do not
+   * keep using, or the replacement stays live indefinitely. A registered
+   * attachment still requires the normal restore surface: load or resume the
+   * replacement, passing the minted id to reuse that registration instead of
+   * adding a second one. The replacement is a brand-new conversation; the
+   * superseded session keeps its transcript on the daemon and is never
+   * restored again (its restore surfaces `worktree_session_superseded`). The
+   * existing reattach identity guard applies to the replacement client
+   * unchanged.
+   */
+  static async resetWorktree(client, sessionId, req = {}) {
+    const session = await client.resetWorktreeSession(sessionId, req);
+    return new _DaemonSessionClient({
+      client,
+      session,
+      hasActivePrompt: session.hasActivePrompt,
+      // The replacement is freshly created: seed from the start of its bus
+      // so events fired during the transfer window are not skipped.
+      lastEventId: 0,
+      eventEpoch: session.eventEpoch
+    });
+  }
   static async createStandalone(client, options = {}) {
     const session = await client.createStandaloneSession(options);
     return new _DaemonSessionClient({
@@ -6672,16 +6758,21 @@ var DaemonSessionClient = class _DaemonSessionClient {
     });
     this.reattaching = resume.then(async (session) => {
       if (this.session.worktreeState === "persisted-v1") {
-        const sameWorktree = session.worktreeState === "persisted-v1" && session.worktree?.path === this.session.worktree?.path;
-        if (!sameWorktree) {
-          await this.client.detachSession(session.sessionId, session.clientId).catch(() => {
-          });
-          throw new Error(
-            `Daemon lost durable worktree identity for session ${this.sessionId}`
-          );
+        if (!session.worktree) {
+          this.session.worktree = void 0;
+          this.session.worktreeState = void 0;
+        } else {
+          const sameWorktree = session.worktreeState === "persisted-v1" && session.worktree.path === this.session.worktree?.path;
+          if (!sameWorktree) {
+            await this.client.detachSession(session.sessionId, session.clientId).catch(() => {
+            });
+            throw new Error(
+              `Daemon lost durable worktree identity for session ${this.sessionId}`
+            );
+          }
+          this.session.worktree = session.worktree;
+          this.session.worktreeState = session.worktreeState;
         }
-        this.session.worktree = session.worktree;
-        this.session.worktreeState = session.worktreeState;
       }
       this.session.clientId = session.clientId;
     });
@@ -9369,13 +9460,10 @@ function normalizeDaemonEvent(event, opts = {}) {
         }
       ];
     case "slow_client_warning":
-      return [
-        {
-          ...base,
-          type: "status",
-          text: "SSE stream is lagging"
-        }
-      ];
+      if (typeof console !== "undefined") {
+        console.warn?.("[daemon-ui] SSE stream is lagging", event.data);
+      }
+      return [];
     case "stream_error": {
       const errorKind = asDaemonErrorKind(getString2(event.data, "errorKind"));
       return [