@qwen-code/qwen-code 0.22.3-nightly.20260831.3a0c4c6108 → 0.23.0

package/chunks/{daemon-UCVUHPJD.js → daemon-RKDGBFLK.js}

@@ -210,6 +210,7 @@ __name(signalAbortError, "signalAbortError");
 // packages/sdk-typescript/src/daemon/session-pr.ts
 init_esbuild_shims();
 var MAX_SESSION_PR_URL_LENGTH = 2048;
+var MAX_SESSION_PR_ISSUES = 10;
 function hasControlCharacter(value) {
   return Array.from(value).some((character) => {
     const code = character.charCodeAt(0);
@@ -217,12 +218,20 @@ function hasControlCharacter(value) {
   });
 }
 __name(hasControlCharacter, "hasControlCharacter");
+function isBindingUrl(value) {
+  return typeof value === "string" && value.length <= MAX_SESSION_PR_URL_LENGTH && /^https?:\/\//i.test(value) && !hasControlCharacter(value);
+}
+__name(isBindingUrl, "isBindingUrl");
+function isDaemonSessionIssueInfo(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v["number"] === "number" && Number.isInteger(v["number"]) && v["number"] > 0 && isBindingUrl(v["url"]) && (v["state"] === void 0 || v["state"] === "open" || v["state"] === "completed" || v["state"] === "not_planned");
+}
+__name(isDaemonSessionIssueInfo, "isDaemonSessionIssueInfo");
 function isDaemonSessionPrInfo(value) {
   if (typeof value !== "object" || value === null) return false;
   const v = value;
-  return typeof v["number"] === "number" && Number.isInteger(v["number"]) && v["number"] > 0 && typeof v["url"] === "string" && v["url"].length <= MAX_SESSION_PR_URL_LENGTH && /^https?:\/\//i.test(v["url"]) && // The daemon interpolates the url into a stderr audit line — control
-  // characters would forge log lines downstream of this gate.
-  !hasControlCharacter(v["url"]) && (v["state"] === void 0 || v["state"] === "open" || v["state"] === "merged" || v["state"] === "closed");
+  return typeof v["number"] === "number" && Number.isInteger(v["number"]) && v["number"] > 0 && isBindingUrl(v["url"]) && (v["state"] === void 0 || v["state"] === "open" || v["state"] === "merged" || v["state"] === "closed") && (v["issues"] === void 0 || Array.isArray(v["issues"]) && v["issues"].length <= MAX_SESSION_PR_ISSUES && v["issues"].every(isDaemonSessionIssueInfo));
 }
 __name(isDaemonSessionPrInfo, "isDaemonSessionPrInfo");
 
@@ -629,6 +638,7 @@ var DAEMON_APPROVAL_MODES = PERMISSION_MODES;
 // packages/sdk-typescript/src/daemon/standalone-sessions.ts
 init_esbuild_shims();
 var STANDALONE_SESSIONS_CAPABILITY = "standalone_sessions_v1";
+var STANDALONE_SESSION_OPTIONS_CAPABILITY = "standalone_session_options_v1";
 var DaemonStandaloneProtocolError = class extends Error {
   constructor(route, detail) {
     super(`${route}: malformed standalone-session response (${detail})`);
@@ -720,6 +730,138 @@ function validateStandaloneFields(value, route) {
   validateWorkingDirectory(value["workingDirectory"], route);
 }
 __name(validateStandaloneFields, "validateStandaloneFields");
+function validateOptionalString(value, field, route) {
+  if (value[field] !== void 0 && typeof value[field] !== "string") {
+    throw new DaemonStandaloneProtocolError(route, `expected ${field} string`);
+  }
+}
+__name(validateOptionalString, "validateOptionalString");
+function validateStatusCell(value, route) {
+  requireString(value, "kind", route);
+  if (!["ok", "warning", "error", "disabled", "not_started", "unknown"].includes(
+    String(value["status"])
+  )) {
+    throw new DaemonStandaloneProtocolError(route, "invalid status");
+  }
+  for (const field of ["error", "hint"]) {
+    validateOptionalString(value, field, route);
+  }
+  if (value["errorKind"] !== void 0 && !DAEMON_ERROR_KINDS.includes(
+    value["errorKind"]
+  )) {
+    throw new DaemonStandaloneProtocolError(route, "invalid errorKind");
+  }
+}
+__name(validateStatusCell, "validateStatusCell");
+function validateProviderModel(value, route) {
+  const model = asRecord(value, route, "provider model");
+  requireString(model, "modelId", route);
+  requireString(model, "baseModelId", route);
+  requireString(model, "name", route, true);
+  if (model["description"] !== void 0 && model["description"] !== null && typeof model["description"] !== "string") {
+    throw new DaemonStandaloneProtocolError(route, "invalid description");
+  }
+  if (model["contextLimit"] !== void 0 && (typeof model["contextLimit"] !== "number" || !Number.isFinite(model["contextLimit"]) || model["contextLimit"] <= 0)) {
+    throw new DaemonStandaloneProtocolError(route, "invalid contextLimit");
+  }
+  for (const field of ["baseUrl", "envKey"]) {
+    validateOptionalString(model, field, route);
+  }
+  for (const field of ["isCurrent", "isRuntime"]) {
+    if (typeof model[field] !== "boolean") {
+      throw new DaemonStandaloneProtocolError(
+        route,
+        `expected ${field} boolean`
+      );
+    }
+  }
+  if (model["modalities"] !== void 0) {
+    const modalities = asRecord(model["modalities"], route, "modalities");
+    for (const field of ["image", "pdf", "audio", "video"]) {
+      if (modalities[field] !== void 0 && typeof modalities[field] !== "boolean") {
+        throw new DaemonStandaloneProtocolError(
+          route,
+          `expected modalities.${field} boolean`
+        );
+      }
+    }
+  }
+  if (model["configOptions"] !== void 0 && !Array.isArray(model["configOptions"])) {
+    throw new DaemonStandaloneProtocolError(route, "expected configOptions[]");
+  }
+}
+__name(validateProviderModel, "validateProviderModel");
+function parseStandaloneSessionOptions(value, route) {
+  const options = asRecord(value, route);
+  if (options["workspaceCwd"] !== void 0 || options["acpChannelLive"] !== void 0) {
+    throw new DaemonStandaloneProtocolError(
+      route,
+      "standalone options exposed workspace internals"
+    );
+  }
+  if (options["v"] !== 1) {
+    throw new DaemonStandaloneProtocolError(route, "expected v=1");
+  }
+  if (typeof options["initialized"] !== "boolean") {
+    throw new DaemonStandaloneProtocolError(
+      route,
+      "expected initialized boolean"
+    );
+  }
+  if (options["current"] !== void 0) {
+    const current = asRecord(options["current"], route, "current");
+    for (const field of [
+      "authType",
+      "modelId",
+      "baseUrl",
+      "fastModelId",
+      "visionModelId"
+    ]) {
+      validateOptionalString(current, field, route);
+    }
+  }
+  if (options["approvalMode"] !== void 0 && !DAEMON_APPROVAL_MODES.includes(
+    options["approvalMode"]
+  )) {
+    throw new DaemonStandaloneProtocolError(route, "invalid approvalMode");
+  }
+  if (!Array.isArray(options["providers"])) {
+    throw new DaemonStandaloneProtocolError(route, "expected providers[]");
+  }
+  for (const value2 of options["providers"]) {
+    const provider = asRecord(value2, route, "provider");
+    validateStatusCell(provider, route);
+    if (provider["kind"] !== "model_provider") {
+      throw new DaemonStandaloneProtocolError(
+        route,
+        "expected model_provider kind"
+      );
+    }
+    requireString(provider, "authType", route);
+    if (typeof provider["current"] !== "boolean") {
+      throw new DaemonStandaloneProtocolError(
+        route,
+        "expected provider current boolean"
+      );
+    }
+    if (!Array.isArray(provider["models"])) {
+      throw new DaemonStandaloneProtocolError(route, "expected models[]");
+    }
+    for (const model of provider["models"]) {
+      validateProviderModel(model, route);
+    }
+  }
+  if (options["errors"] !== void 0) {
+    if (!Array.isArray(options["errors"])) {
+      throw new DaemonStandaloneProtocolError(route, "expected errors[]");
+    }
+    for (const value2 of options["errors"]) {
+      validateStatusCell(asRecord(value2, route, "error"), route);
+    }
+  }
+  return options;
+}
+__name(parseStandaloneSessionOptions, "parseStandaloneSessionOptions");
 function parseStandaloneSession(value, route, expectedSessionId) {
   const session = asRecord(value, route);
   requireSessionId(session, route, expectedSessionId);
@@ -727,6 +869,12 @@ function parseStandaloneSession(value, route, expectedSessionId) {
   if (typeof session["attached"] !== "boolean") {
     throw new DaemonStandaloneProtocolError(route, "expected attached boolean");
   }
+  if (session["modelApplied"] !== void 0 && typeof session["modelApplied"] !== "boolean") {
+    throw new DaemonStandaloneProtocolError(
+      route,
+      "expected modelApplied boolean"
+    );
+  }
   validateStandaloneFields(session, route);
   return session;
 }
@@ -1323,6 +1471,31 @@ var DaemonClient = class {
       }
     );
   }
+  async setUserMcpServer(name, config) {
+    return await this.jsonRequest(
+      `/workspace/config/mcp/servers/${urlEncode(name)}`,
+      "PUT /workspace/config/mcp/servers/:name",
+      {
+        method: "PUT",
+        body: { scope: "user", config },
+        mode: "rest"
+      }
+    );
+  }
+  async removeUserMcpServer(name) {
+    return await this.jsonRequest(
+      `/workspace/config/mcp/servers/${urlEncode(name)}?scope=user`,
+      "DELETE /workspace/config/mcp/servers/:name",
+      { method: "DELETE", mode: "rest" }
+    );
+  }
+  async setUserMcpServerEnabled(name, enabled) {
+    return await this.jsonRequest(
+      `/workspace/config/mcp/${urlEncode(name)}/${enabled ? "enable" : "disable"}`,
+      "POST /workspace/config/mcp/:server/:action",
+      { method: "POST", body: {}, mode: "rest" }
+    );
+  }
   async initializeWorkspaceMcp() {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/workspace/mcp/initialize`,
@@ -1424,11 +1597,11 @@ var DaemonClient = class {
       { method: "POST", body: opts ?? {}, mode: "rest" }
     );
   }
-  async workspaceGitPull(opts) {
+  async workspaceGitPull(opts, timeoutMs) {
     return await this.jsonRequest(
       "/workspace/git/pull",
       "POST /workspace/git/pull",
-      { method: "POST", body: opts ?? {}, mode: "rest" }
+      { method: "POST", body: opts ?? {}, mode: "rest", timeoutMs }
     );
   }
   async workspaceGitCommit(message, opts) {
@@ -2415,6 +2588,16 @@ var DaemonClient = class {
     );
   }
   // -- Sessions ----------------------------------------------------------
+  async getStandaloneSessionOptions() {
+    await this.requireCapability(STANDALONE_SESSION_OPTIONS_CAPABILITY);
+    const route = "GET /standalone/session-options";
+    const response = await this.jsonRequest(
+      "/standalone/session-options",
+      route,
+      { mode: "rest" }
+    );
+    return parseStandaloneSessionOptions(response, route);
+  }
   async createStandaloneSession(options = {}) {
     await this.requireCapability(STANDALONE_SESSIONS_CAPABILITY);
     const { sessionId: requestedSessionId, ...request } = options;
@@ -2686,6 +2869,23 @@ var DaemonClient = class {
       "GET /workspace/sessions"
     );
   }
+  /**
+   * Search user/assistant message content across a workspace's persisted
+   * sessions via `GET /workspace/:id/sessions/search`. Returns one summary +
+   * snippet per matching session, most recently modified first. Requires a
+   * daemon new enough to serve the route — older daemons answer 404.
+   */
+  async searchWorkspaceSessions(workspaceCwd, queryText, options = {}) {
+    const query = new URLSearchParams({ q: queryText });
+    if (options.maxResults !== void 0) {
+      query.set("maxResults", String(options.maxResults));
+    }
+    return await this.jsonRequest(
+      `/workspace/${urlEncode(workspaceCwd)}/sessions/search?${query.toString()}`,
+      "GET /workspace/sessions/search",
+      { ...options.signal ? { signal: options.signal } : {} }
+    );
+  }
   /**
    * Read the memory-only live-state snapshot for a workspace via
    * `GET /workspaces/:workspace/sessions/live-state`: the complete set of
@@ -4178,11 +4378,20 @@ var DaemonClient = class {
       }
     );
   }
-  async setSessionConfigOption(sessionId, configId, value, clientId) {
+  async setSessionConfigOption(sessionId, configId, value, clientOrOptions) {
+    const options = typeof clientOrOptions === "string" ? { clientId: clientOrOptions } : clientOrOptions;
     return await this.jsonRequest(
       `/session/${urlEncode(sessionId)}/config-option`,
       "POST /session/:id/config-option",
-      { method: "POST", body: { configId, value }, clientId }
+      {
+        method: "POST",
+        body: {
+          configId,
+          value,
+          ...options?.persist !== void 0 ? { persist: options.persist } : {}
+        },
+        clientId: options?.clientId
+      }
     );
   }
   async setSessionLanguage(sessionId, language, opts) {
@@ -4207,6 +4416,26 @@ var DaemonClient = class {
       }
     );
   }
+  /**
+   * Sessionless user-level language sync (`POST /language`). Succeeds with
+   * zero sessions, so hosts can switch language before creating one.
+   * Pre-flight `caps.features.includes('user_language_sync')` — daemons that
+   * predate the route or were built without settings persistence 404.
+   */
+  async setUserLanguage(language, opts) {
+    return await this.jsonRequest(
+      "/language",
+      "POST /language",
+      {
+        method: "POST",
+        body: {
+          language,
+          syncOutputLanguage: opts?.syncOutputLanguage ?? false
+        },
+        clientId: opts?.clientId
+      }
+    );
+  }
   /**
    * Send a prompt to the agent. Supports both blocking (legacy 200)
    * and non-blocking (202 + SSE `turn_complete`) daemon responses.
@@ -4799,6 +5028,105 @@ var WorkspaceDaemonClient = class {
   workspaceMcp() {
     return this.get("/mcp", "GET /workspaces/:workspace/mcp");
   }
+  mcpConfig() {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/config/mcp/servers",
+      "GET /workspaces/:workspace/config/mcp/servers",
+      { mode: "rest" }
+    );
+  }
+  setMcpServer(name, config) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/config/mcp/servers/${urlEncode(name)}`,
+      "PUT /workspaces/:workspace/config/mcp/servers/:name",
+      {
+        method: "PUT",
+        body: { scope: "workspace", config },
+        mode: "rest"
+      }
+    );
+  }
+  removeMcpServer(name) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/config/mcp/servers/${urlEncode(name)}?scope=workspace`,
+      "DELETE /workspaces/:workspace/config/mcp/servers/:name",
+      { method: "DELETE", mode: "rest" }
+    );
+  }
+  setMcpServerEnabled(name, enabled) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/config/mcp/${urlEncode(name)}/${enabled ? "enable" : "disable"}`,
+      "POST /workspaces/:workspace/config/mcp/:server/:action",
+      { method: "POST", body: {}, mode: "rest" }
+    );
+  }
+  runtimeMcp() {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/runtime/mcp",
+      "GET /workspaces/:workspace/runtime/mcp",
+      { mode: "rest" }
+    );
+  }
+  runtimeMcpTools(serverName) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/runtime/mcp/${urlEncode(serverName)}/tools`,
+      "GET /workspaces/:workspace/runtime/mcp/:server/tools",
+      { mode: "rest" }
+    );
+  }
+  runtimeMcpResources(serverName) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/runtime/mcp/${urlEncode(serverName)}/resources`,
+      "GET /workspaces/:workspace/runtime/mcp/:server/resources",
+      { mode: "rest" }
+    );
+  }
+  reloadRuntimeMcp(options = {}) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/runtime/mcp/reload",
+      "POST /workspaces/:workspace/runtime/mcp/reload",
+      {
+        method: "POST",
+        body: options,
+        mode: "rest",
+        timeoutMs: MCP_RESTART_DEFAULT_TIMEOUT_MS
+      }
+    );
+  }
+  restartRuntimeMcpServer(serverName) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/runtime/mcp/${urlEncode(serverName)}/restart`,
+      "POST /workspaces/:workspace/runtime/mcp/:server/restart",
+      {
+        method: "POST",
+        body: {},
+        mode: "rest",
+        timeoutMs: MCP_RESTART_DEFAULT_TIMEOUT_MS
+      }
+    );
+  }
+  manageRuntimeMcpServer(serverName, action) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/runtime/mcp/${urlEncode(serverName)}/${action}`,
+      "POST /workspaces/:workspace/runtime/mcp/:server/:action",
+      {
+        method: "POST",
+        body: {},
+        mode: "rest",
+        timeoutMs: MCP_RESTART_DEFAULT_TIMEOUT_MS
+      }
+    );
+  }
   ensureRuntime() {
     return this.client.workspaceJsonRequest(
       this.workspaceSelector,
@@ -4819,6 +5147,34 @@ var WorkspaceDaemonClient = class {
       { mode: "rest" }
     );
   }
+  /**
+   * Ask the daemon host to open this workspace's directory in the host's OS
+   * file manager (Finder/Explorer/xdg-open). Only advertised via the
+   * `workspace_local_open` capability; on a headless host the daemon answers
+   * 501 `local_path_open_unavailable`.
+   */
+  async openLocally() {
+    await this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/open",
+      "POST /workspaces/:workspace/open",
+      { method: "POST", body: {}, mode: "rest" }
+    );
+  }
+  /**
+   * Ask the daemon host to open a terminal window in this workspace's
+   * directory (Terminal.app/wt.exe/a Linux terminal emulator). Only
+   * advertised via the `workspace_local_terminal` capability; on a headless
+   * host the daemon answers 501 `local_path_open_unavailable`.
+   */
+  async openTerminalLocally() {
+    await this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/open",
+      "POST /workspaces/:workspace/open",
+      { method: "POST", body: { target: "terminal" }, mode: "rest" }
+    );
+  }
   /**
    * Send text directly through this exact workspace's channel worker.
    * A successful capability pre-flight does not guarantee worker liveness;
@@ -5093,13 +5449,13 @@ var WorkspaceDaemonClient = class {
       { method: "POST", body: opts ?? {}, mode: "rest" }
     );
   }
-  workspaceGitPull(opts, cwd) {
+  workspaceGitPull(opts, cwd, timeoutMs) {
     const suffix = cwd != null ? `/git/pull?cwd=${urlEncode(cwd)}` : "/git/pull";
     return this.client.workspaceJsonRequest(
       this.workspaceSelector,
       suffix,
       "POST /workspaces/:workspace/git/pull",
-      { method: "POST", body: opts ?? {}, mode: "rest" }
+      { method: "POST", body: opts ?? {}, mode: "rest", timeoutMs }
     );
   }
   workspaceGitCommit(message, opts, cwd) {
@@ -5961,6 +6317,14 @@ var DaemonSessionClient = class _DaemonSessionClient {
   get branch() {
     return this.session.branch;
   }
+  /**
+   * Present when this client was created with a `modelServiceId`: `false`
+   * means the spawn-time model switch failed and the session is running on
+   * the agent default model.
+   */
+  get modelApplied() {
+    return this.session.modelApplied;
+  }
   get lastEventId() {
     return this.lastSeenEventId;
   }
@@ -6179,13 +6543,11 @@ var DaemonSessionClient = class _DaemonSessionClient {
   setModel(modelId) {
     return this.client.setSessionModel(this.sessionId, modelId, this.clientId);
   }
-  setConfigOption(configId, value) {
-    return this.client.setSessionConfigOption(
-      this.sessionId,
-      configId,
-      value,
-      this.clientId
-    );
+  setConfigOption(configId, value, opts) {
+    return this.client.setSessionConfigOption(this.sessionId, configId, value, {
+      clientId: this.clientId,
+      persist: opts?.persist
+    });
   }
   getRewindSnapshots() {
     return this.client.getRewindSnapshots(this.sessionId);
@@ -7502,7 +7864,7 @@ function isSessionClosedData(value) {
 }
 __name(isSessionClosedData, "isSessionClosedData");
 function isSessionMetadataUpdatedData(value) {
-  if (!isRecord(value) || !isNonEmptyString(value["sessionId"]) || !isOptionalStringOrNull(value["displayName"])) {
+  if (!isRecord(value) || !isNonEmptyString(value["sessionId"]) || !isOptionalStringOrNull(value["displayName"]) || value["titleSource"] !== void 0 && value["titleSource"] !== "manual" && value["titleSource"] !== "auto") {
     return false;
   }
   const prs = value["prs"];
@@ -8902,6 +9264,7 @@ function normalizePlanUpdate(update, base) {
   const stats = meta && isRecord2(meta["stats"]) ? meta["stats"] : void 0;
   const todoPlan = meta && isRecord2(meta["qwenTodoPlan"]) ? meta["qwenTodoPlan"] : void 0;
   const planId = getString2(todoPlan, "id");
+  const sessionWorkflow = meta?.["qwenSessionWorkflow"] === true;
   return {
     ...base,
     type: "tool.update",
@@ -8919,7 +9282,8 @@ function normalizePlanUpdate(update, base) {
     rawOutput: {
       entries,
       ...stats ? { stats } : {},
-      ...planId ? { plan: { id: planId, sourceCallId: planCallId } } : {}
+      ...planId ? { plan: { id: planId, sourceCallId: planCallId } } : {},
+      ...sessionWorkflow ? { sessionWorkflow: true } : {}
     }
   };
 }
@@ -10747,7 +11111,8 @@ function compactTaskExecutionOutput(rawOutput, retainSubagentBlocks) {
     "executionMode",
     "terminateReason",
     "tokenCount",
-    "executionSummary"
+    "executionSummary",
+    "skills"
   ]) {
     if (rawOutput[key] !== void 0) compact[key] = rawOutput[key];
   }
@@ -12964,6 +13329,7 @@ export {
   PENDING_PROMPT_COMPLETED_EVENT,
   PENDING_PROMPT_STARTED_EVENT,
   STANDALONE_SESSIONS_CAPABILITY,
+  STANDALONE_SESSION_OPTIONS_CAPABILITY,
   SseFramingError,
   UNRECOGNIZED_DIAGNOSTICS_LIMIT,
   WorkspaceDaemonClient,