@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260710.205430235

package/chunks/{daemon-F3I2RXP6.js → daemon-NNUYIBWA.js}

@@ -686,6 +686,47 @@ var DaemonClient = class {
       opts.timeoutMs
     );
   }
+  /** @internal */
+  async workspaceJsonRequest(workspaceSelector, path, label, opts = {}) {
+    return await this.jsonRequest(
+      `/workspaces/${workspaceSelector}${path}`,
+      label,
+      opts
+    );
+  }
+  /** @internal */
+  async workspaceNoContentRequest(workspaceSelector, path, label, opts = {}) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspaces/${workspaceSelector}${path}`,
+      {
+        ...opts.method ? { method: opts.method } : {},
+        headers: this.headers({}, opts.clientId)
+      },
+      async (res) => {
+        if (res.status === 204) {
+          try {
+            await res.body?.cancel();
+          } catch {
+          }
+          return;
+        }
+        if (res.status === 404 && opts.okNotFoundCode) {
+          const err = await this.failOnError(res, label);
+          const body = err.body;
+          if (body?.code === opts.okNotFoundCode) return;
+          throw err;
+        }
+        throw await this.failOnError(res, label);
+      },
+      opts.timeoutMs
+    );
+  }
+  workspaceById(workspaceId) {
+    return new WorkspaceDaemonClient(this, urlEncode(workspaceId));
+  }
+  workspaceByCwd(workspaceCwd) {
+    return new WorkspaceDaemonClient(this, urlEncode(workspaceCwd));
+  }
   // -- Lifecycle / discovery ---------------------------------------------
   async health() {
     return await this.fetchWithTimeout(
@@ -787,6 +828,33 @@ var DaemonClient = class {
       }
     );
   }
+  async workspaceAcpPreheat(timeoutMs) {
+    const serverBudgetMs = timeoutMs ?? 5e3;
+    const suffix = timeoutMs !== void 0 ? `?timeoutMs=${encodeURIComponent(timeoutMs)}` : "";
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/acp/preheat${suffix}`,
+      { method: "POST", headers: this.headers() },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "POST /workspace/acp/preheat");
+        }
+        return await res.json();
+      },
+      serverBudgetMs + 2e3
+    );
+  }
+  async workspaceAcpStatus() {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/acp/status`,
+      { headers: this.headers() },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "GET /workspace/acp/status");
+        }
+        return await res.json();
+      }
+    );
+  }
   async workspaceProviders() {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/workspace/providers`,
@@ -2047,6 +2115,32 @@ var DaemonClient = class {
       opts?.timeoutMs
     );
   }
+  /**
+   * Reload the daemon-managed channel worker: the daemon stops and relaunches
+   * it so it re-reads settings.json (channels / proxy / per-channel model).
+   * Requires the daemon to have been started with `--channel`; otherwise the
+   * route responds 409. Pre-flight the `channel_reload` capability.
+   */
+  async reloadChannelWorker(opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/channel/reload`,
+      {
+        method: "POST",
+        headers: this.headers(
+          { "Content-Type": "application/json" },
+          opts?.clientId
+        ),
+        body: "{}"
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "POST /workspace/channel/reload");
+        }
+        return await res.json();
+      },
+      opts?.timeoutMs
+    );
+  }
   async manageMcpServer(serverName, action, opts) {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/workspace/mcp/${urlEncode(serverName)}/${urlEncode(action)}`,
@@ -2714,6 +2808,324 @@ var DaemonClient = class {
     );
   }
 };
+var WorkspaceDaemonClient = class {
+  constructor(client, workspaceSelector) {
+    this.client = client;
+    this.workspaceSelector = workspaceSelector;
+  }
+  static {
+    __name(this, "WorkspaceDaemonClient");
+  }
+  workspaceMcp() {
+    return this.get("/mcp", "GET /workspaces/:workspace/mcp");
+  }
+  workspaceSkills() {
+    return this.get("/skills", "GET /workspaces/:workspace/skills");
+  }
+  workspaceProviders() {
+    return this.get("/providers", "GET /workspaces/:workspace/providers");
+  }
+  workspaceHooks() {
+    return this.get("/hooks", "GET /workspaces/:workspace/hooks");
+  }
+  workspaceEnv() {
+    return this.get("/env", "GET /workspaces/:workspace/env");
+  }
+  workspacePreflight() {
+    return this.get("/preflight", "GET /workspaces/:workspace/preflight");
+  }
+  workspaceTools() {
+    return this.get("/tools", "GET /workspaces/:workspace/tools");
+  }
+  workspaceMemory() {
+    return this.get("/memory", "GET /workspaces/:workspace/memory");
+  }
+  writeWorkspaceMemory(req, clientId) {
+    return this.post(
+      "/memory",
+      "POST /workspaces/:workspace/memory",
+      { ...req, scope: "workspace" },
+      clientId
+    );
+  }
+  listWorkspaceAgents() {
+    return this.get("/agents", "GET /workspaces/:workspace/agents");
+  }
+  createWorkspaceAgent(req, clientId) {
+    return this.post(
+      "/agents",
+      "POST /workspaces/:workspace/agents",
+      { ...req, scope: req.scope ?? "workspace" },
+      clientId
+    );
+  }
+  getWorkspaceAgent(agentType) {
+    return this.get(
+      `/agents/${urlEncode(agentType)}`,
+      "GET /workspaces/:workspace/agents/:agentType"
+    );
+  }
+  updateWorkspaceAgent(agentType, req, opts = {}) {
+    const query = opts.scope ? `?scope=${urlEncode(opts.scope)}` : "";
+    return this.post(
+      `/agents/${urlEncode(agentType)}${query}`,
+      "POST /workspaces/:workspace/agents/:agentType",
+      req,
+      opts.clientId
+    );
+  }
+  async deleteWorkspaceAgent(agentType, opts = {}) {
+    const query = opts.scope ? `?scope=${urlEncode(opts.scope)}` : "";
+    return await this.client.workspaceNoContentRequest(
+      this.workspaceSelector,
+      `/agents/${urlEncode(agentType)}${query}`,
+      "DELETE /workspaces/:workspace/agents/:agentType",
+      {
+        method: "DELETE",
+        clientId: opts.clientId,
+        okNotFoundCode: "agent_not_found"
+      }
+    );
+  }
+  listWorkspaceSessionsPage(options) {
+    const requestedPageSize = options?.pageSize ?? DEFAULT_SESSION_LIST_PAGE_SIZE;
+    const pageSize = Math.max(
+      1,
+      Math.min(
+        1e3,
+        Math.round(
+          Number.isFinite(requestedPageSize) ? requestedPageSize : DEFAULT_SESSION_LIST_PAGE_SIZE
+        )
+      )
+    );
+    const query = new URLSearchParams({ size: String(pageSize) });
+    if (options?.cursor !== void 0) query.set("cursor", options.cursor);
+    if (options?.archiveState !== void 0) {
+      query.set("archiveState", options.archiveState);
+    }
+    if (options?.view !== void 0) query.set("view", options.view);
+    if (options?.group !== void 0) query.set("group", options.group);
+    return this.get(
+      `/sessions?${query.toString()}`,
+      "GET /workspaces/:workspace/sessions"
+    );
+  }
+  async listWorkspaceSessions(options) {
+    const page = await this.listWorkspaceSessionsPage(options);
+    return page.sessions;
+  }
+  listSessionGroups() {
+    return this.get(
+      "/session-groups",
+      "GET /workspaces/:workspace/session-groups"
+    );
+  }
+  async createSessionGroup(input) {
+    const body = await this.post(
+      "/session-groups",
+      "POST /workspaces/:workspace/session-groups",
+      input
+    );
+    return body.group;
+  }
+  async updateSessionGroup(groupId, update) {
+    const body = await this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/session-groups/${urlEncode(groupId)}`,
+      "PATCH /workspaces/:workspace/session-groups/:groupId",
+      { method: "PATCH", body: update }
+    );
+    return body.group;
+  }
+  deleteSessionGroup(groupId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/session-groups/${urlEncode(groupId)}`,
+      "DELETE /workspaces/:workspace/session-groups/:groupId",
+      { method: "DELETE" }
+    );
+  }
+  deleteSessionsData(sessionIds, clientId) {
+    return this.post(
+      "/sessions/delete",
+      "POST /workspaces/:workspace/sessions/delete",
+      { sessionIds },
+      clientId
+    );
+  }
+  archiveSessionsData(sessionIds, clientId) {
+    return this.post(
+      "/sessions/archive",
+      "POST /workspaces/:workspace/sessions/archive",
+      { sessionIds },
+      clientId
+    );
+  }
+  unarchiveSessionsData(sessionIds, clientId) {
+    return this.post(
+      "/sessions/unarchive",
+      "POST /workspaces/:workspace/sessions/unarchive",
+      { sessionIds },
+      clientId
+    );
+  }
+  readWorkspaceFile(filePath, opts = {}, clientId) {
+    const query = new URLSearchParams({ path: filePath });
+    if (opts.maxBytes !== void 0)
+      query.set("maxBytes", String(opts.maxBytes));
+    if (opts.line !== void 0) query.set("line", String(opts.line));
+    if (opts.limit !== void 0) query.set("limit", String(opts.limit));
+    return this.get(
+      `/file?${query.toString()}`,
+      "GET /workspaces/:workspace/file",
+      clientId
+    );
+  }
+  readWorkspaceFileBytes(filePath, opts = {}, clientId) {
+    const query = new URLSearchParams({ path: filePath });
+    if (opts.offset !== void 0) query.set("offset", String(opts.offset));
+    if (opts.maxBytes !== void 0)
+      query.set("maxBytes", String(opts.maxBytes));
+    return this.get(
+      `/file/bytes?${query.toString()}`,
+      "GET /workspaces/:workspace/file/bytes",
+      clientId
+    );
+  }
+  fileStat(filePath) {
+    const query = new URLSearchParams({ path: filePath });
+    return this.get(
+      `/stat?${query.toString()}`,
+      "GET /workspaces/:workspace/stat"
+    );
+  }
+  dirList(dirPath) {
+    const query = new URLSearchParams({ path: dirPath });
+    return this.get(
+      `/list?${query.toString()}`,
+      "GET /workspaces/:workspace/list"
+    );
+  }
+  glob(pattern) {
+    const query = new URLSearchParams({ pattern });
+    return this.get(
+      `/glob?${query.toString()}`,
+      "GET /workspaces/:workspace/glob"
+    );
+  }
+  writeWorkspaceFile(req, clientId) {
+    return this.post(
+      "/file/write",
+      "POST /workspaces/:workspace/file/write",
+      req,
+      clientId
+    );
+  }
+  editWorkspaceFile(req, clientId) {
+    return this.post(
+      "/file/edit",
+      "POST /workspaces/:workspace/file/edit",
+      req,
+      clientId
+    );
+  }
+  workspaceSettings(opts) {
+    return this.get(
+      "/settings",
+      "GET /workspaces/:workspace/settings",
+      opts?.clientId
+    );
+  }
+  setWorkspaceSetting(scope, key, value, opts) {
+    return this.post(
+      "/settings",
+      "POST /workspaces/:workspace/settings",
+      { scope, key, value },
+      opts?.clientId
+    );
+  }
+  workspaceTrust(opts) {
+    return this.get(
+      "/trust",
+      "GET /workspaces/:workspace/trust",
+      opts?.clientId
+    );
+  }
+  requestWorkspaceTrustChange(request, clientId) {
+    return this.post(
+      "/trust/request",
+      "POST /workspaces/:workspace/trust/request",
+      request,
+      clientId
+    );
+  }
+  workspacePermissions(opts) {
+    return this.get(
+      "/permissions",
+      "GET /workspaces/:workspace/permissions",
+      opts?.clientId
+    );
+  }
+  setWorkspacePermissionRules(ruleType, rules, opts) {
+    return this.post(
+      "/permissions",
+      "POST /workspaces/:workspace/permissions",
+      { scope: "workspace", ruleType, rules: [...rules] },
+      opts?.clientId
+    );
+  }
+  setWorkspaceToolEnabled(toolName, enabled, opts) {
+    return this.post(
+      `/tools/${urlEncode(toolName)}/enable`,
+      "POST /workspaces/:workspace/tools/:name/enable",
+      { enabled },
+      opts?.clientId
+    );
+  }
+  restartMcpServer(serverName, opts) {
+    const query = opts?.entryIndex === void 0 ? "" : `?entryIndex=${urlEncode(String(opts.entryIndex))}`;
+    return this.post(
+      `/mcp/${urlEncode(serverName)}/restart${query}`,
+      "POST /workspaces/:workspace/mcp/:server/restart",
+      {},
+      opts?.clientId,
+      opts?.timeoutMs ?? MCP_RESTART_DEFAULT_TIMEOUT_MS
+    );
+  }
+  reload(opts) {
+    return this.post(
+      "/reload",
+      "POST /workspaces/:workspace/reload",
+      {},
+      opts?.clientId,
+      opts?.timeoutMs
+    );
+  }
+  initWorkspace(opts) {
+    return this.post(
+      "/init",
+      "POST /workspaces/:workspace/init",
+      opts?.force === true ? { force: true } : {},
+      opts?.clientId
+    );
+  }
+  get(path, label, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      path,
+      label,
+      { clientId }
+    );
+  }
+  post(path, label, body, clientId, timeoutMs) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      path,
+      label,
+      { method: "POST", body, clientId, timeoutMs }
+    );
+  }
+};
 function composeAbortSignals2(signals) {
   const anyFn = AbortSignal.any;
   if (typeof anyFn === "function") return anyFn.call(AbortSignal, signals);
@@ -3322,6 +3734,11 @@ var DAEMON_KNOWN_EVENT_TYPE_VALUES = [
   // reseeds state. Synthetic (no `id`) so it doesn't burn a slot
   // in the per-session monotonic sequence.
   "state_resync_required",
+  // Synthetic marker prepended to a bounded `/session/:id/load` replay
+  // snapshot when older replay history was dropped from the daemon's
+  // in-memory window. This is NOT a resync request: consumers should render
+  // it as transcript status and continue applying the retained snapshot.
+  "history_truncated",
   // MCP guardrail push events. See `mcp_guardrail_events` capability
   // tag. Both fire on the per-session SSE bus; consumers should
   // pre-flight `caps.features.includes('mcp_guardrail_events')`
@@ -3418,6 +3835,7 @@ var MAX_PENDING_PER_SESSION = 64;
 var MAX_FORBIDDEN_VOTES_PER_SESSION = 32;
 var RESYNC_PASSTHROUGH_TYPES = /* @__PURE__ */ new Set([
   "state_resync_required",
+  "history_truncated",
   "session_died",
   "session_closed",
   "client_evicted",
@@ -3475,6 +3893,8 @@ function createDaemonSessionViewState(seed = {}) {
     awaitingResync: seed.awaitingResync ?? false,
     resyncRequiredCount: seed.resyncRequiredCount ?? 0,
     lastResyncRequired: seed.lastResyncRequired,
+    historyTruncatedCount: seed.historyTruncatedCount ?? 0,
+    lastHistoryTruncated: seed.lastHistoryTruncated,
     lastFollowupSuggestion: seed.lastFollowupSuggestion,
     rewindCount: seed.rewindCount ?? 0,
     lastRewind: seed.lastRewind,
@@ -3537,6 +3957,8 @@ function asKnownDaemonEvent(event) {
       return isStreamErrorData(event.data) ? event : void 0;
     case "state_resync_required":
       return isStateResyncRequiredData(event.data) ? event : void 0;
+    case "history_truncated":
+      return isHistoryTruncatedData(event.data) ? event : void 0;
     case "mcp_budget_warning":
       return isMcpBudgetWarningData(event.data) ? event : void 0;
     case "mcp_child_refused_batch":
@@ -3773,6 +4195,12 @@ function reduceDaemonSessionEvent(state, rawEvent) {
         resyncRequiredCount: base.resyncRequiredCount + 1,
         lastResyncRequired: event.data
       };
+    case "history_truncated":
+      return {
+        ...base,
+        historyTruncatedCount: base.historyTruncatedCount + 1,
+        lastHistoryTruncated: event.data
+      };
     case "mcp_budget_warning":
       return {
         ...base,
@@ -4136,6 +4564,14 @@ function isStateResyncRequiredData(value) {
   return isRecord(value) && isNonEmptyString(value["reason"]) && isFiniteNumber(value["lastDeliveredId"]) && isFiniteNumber(value["earliestAvailableId"]);
 }
 __name(isStateResyncRequiredData, "isStateResyncRequiredData");
+function isHistoryTruncatedData(value) {
+  if (!isRecord(value) || value["reason"] !== "replay_window_exceeded" || !isFiniteNumber(value["truncatedEvents"]) || !isFiniteNumber(value["retainedEvents"]) || !isFiniteNumber(value["maxBytes"]) || value["fullTranscriptAvailable"] !== false) {
+    return false;
+  }
+  const truncatedTurns = value["truncatedTurns"];
+  return isNonNegativeInteger(value["truncatedEvents"]) && isNonNegativeInteger(value["retainedEvents"]) && isNonNegativeInteger(value["maxBytes"]) && (truncatedTurns === void 0 || isNonNegativeInteger(truncatedTurns));
+}
+__name(isHistoryTruncatedData, "isHistoryTruncatedData");
 function isSlowClientWarningData(value) {
   if (!isRecord(value)) return false;
   const threshold = value["threshold"];
@@ -4372,6 +4808,10 @@ function isOptionalNumberOrNull(value) {
   return value === void 0 || value === null || isFiniteNumber(value);
 }
 __name(isOptionalNumberOrNull, "isOptionalNumberOrNull");
+function isNonNegativeInteger(value) {
+  return isFiniteNumber(value) && Number.isInteger(value) && value >= 0;
+}
+__name(isNonNegativeInteger, "isNonNegativeInteger");
 function isOptionalStringOrNull(value) {
   return value === void 0 || value === null || typeof value === "string";
 }
@@ -4780,6 +5220,8 @@ function normalizeDaemonEvent(event, opts = {}) {
     }
     case "state_resync_required":
       return normalizeStateResyncRequired(event, base);
+    case "history_truncated":
+      return normalizeHistoryTruncated(event, base);
     case "session_rewound":
       return normalizeSessionRewound(event, base);
     case "session_branched":
@@ -4905,6 +5347,24 @@ function normalizeStateResyncRequired(event, base) {
   ];
 }
 __name(normalizeStateResyncRequired, "normalizeStateResyncRequired");
+function normalizeHistoryTruncated(event, base) {
+  const reason = getString2(event.data, "reason");
+  const truncatedEvents = numberField(event.data, "truncatedEvents");
+  const retainedEvents = numberField(event.data, "retainedEvents");
+  const maxBytes = numberField(event.data, "maxBytes");
+  if (reason !== "replay_window_exceeded" || truncatedEvents === void 0 || retainedEvents === void 0 || maxBytes === void 0 || isRecord2(event.data) && event.data["fullTranscriptAvailable"] !== false) {
+    return fallbackDebug(event, base, "malformed history_truncated payload");
+  }
+  return [
+    {
+      ...base,
+      type: "status",
+      text: `History truncated: retained ${retainedEvents}, dropped ${truncatedEvents} (window ${maxBytes} bytes).`,
+      source: "history_truncated"
+    }
+  ];
+}
+__name(normalizeHistoryTruncated, "normalizeHistoryTruncated");
 function normalizeSessionRewound(event, base) {
   const promptId = getString2(event.data, "promptId");
   const targetTurnIndex = numberField(event.data, "targetTurnIndex");
@@ -8643,6 +9103,7 @@ export {
   PENDING_PROMPT_COMPLETED_EVENT,
   PENDING_PROMPT_STARTED_EVENT,
   SseFramingError,
+  WorkspaceDaemonClient,
   appendLocalUserTranscriptMessage,
   asKnownDaemonEvent,
   createDaemonAuthState,

package/chunks/{daemon-status-provider-XSAFKVDS.js → daemon-status-provider-3EPG6BXX.js}

@@ -2,59 +2,61 @@
 "use strict";
 import {
   createDaemonStatusProvider
-} from "./chunk-7JGISHHZ.js";
-import "./chunk-24XYI5EI.js";
+} from "./chunk-HDEUQRAR.js";
+import "./chunk-TERKDCOZ.js";
 import "./chunk-KHDZHZMH.js";
-import "./chunk-U4FRHCLA.js";
+import "./chunk-DDKUYKHA.js";
 import "./chunk-P7M4GA57.js";
-import "./chunk-B34OV7K2.js";
+import "./chunk-GGQQA4JW.js";
 import "./chunk-AGHU5VRK.js";
 import "./chunk-ER3BKOLB.js";
-import "./chunk-G7ZG7CA6.js";
-import "./chunk-VRDMOSQS.js";
-import "./chunk-AJBEAUIS.js";
+import "./chunk-3UP777ZS.js";
+import "./chunk-GLE2YUPU.js";
+import "./chunk-MG2TNCRX.js";
 import "./chunk-EXPMGZZV.js";
-import "./chunk-JF7DFPQ5.js";
+import "./chunk-PCWSPWXZ.js";
+import "./chunk-I3MBKL6Z.js";
+import "./chunk-VRDMOSQS.js";
 import "./chunk-HLKG6CZN.js";
-import "./chunk-GD236YPV.js";
+import "./chunk-4ONWIT5C.js";
 import "./chunk-43W4YSO6.js";
-import "./chunk-YEGT55NW.js";
+import "./chunk-ZDAZSR2O.js";
 import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
 import "./chunk-K5PGHDBN.js";
-import "./chunk-3B26UVCX.js";
+import "./chunk-2GUVUHJY.js";
 import "./chunk-W7EEOR7D.js";
 import "./chunk-42XGFRJS.js";
 import "./chunk-X2XNQQJI.js";
-import "./chunk-VZ7HY3YU.js";
+import "./chunk-IAMRWMFU.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-FV7425LN.js";
+import "./chunk-2SZOMGOR.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-E5A7LHNN.js";
-import "./chunk-VEB3NYSO.js";
+import "./chunk-ZJQBTFJ6.js";
 import "./chunk-GO6LNQXT.js";
 import "./chunk-NQKLOAVJ.js";
 import "./chunk-WMPVYQ4P.js";
 import "./chunk-TLWA7TPR.js";
 import "./chunk-QYNNN7BK.js";
-import "./chunk-GMOWQOQQ.js";
+import "./chunk-5ZVIYNLN.js";
 import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
-import "./chunk-4KJ2BPIT.js";
+import "./chunk-OACJLMLD.js";
 import "./chunk-SUAKHHK7.js";
-import "./chunk-FEJ2FZ3U.js";
-import "./chunk-X3YGAX7V.js";
+import "./chunk-NY2ZOFMM.js";
+import "./chunk-KS2FRTYI.js";
 import "./chunk-IJRL2S3D.js";
 import "./chunk-AHNJGLFV.js";
 import "./chunk-22IFUCVR.js";
 import "./chunk-7LTB54MK.js";
 import "./chunk-SIUQ3YYX.js";
 import "./chunk-HW4N45EE.js";
-import "./chunk-CCGOFQV3.js";
+import "./chunk-SS5P6JM6.js";
 import "./chunk-IRJWHZWU.js";
 import "./chunk-SYCJMSIJ.js";
 import "./chunk-55ZMG67I.js";