@qwen-code/qwen-code 0.21.1-simplify-system-prompt.0 → 0.21.2

package/chunks/{chunk-FNQ6T3CV.js → chunk-TEGJSJDF.js}

@@ -5,11 +5,11 @@ import {
 } from "./chunk-VGC4I5JJ.js";
 import {
   atomicWriteJSON
-} from "./chunk-A5L3JMUA.js";
+} from "./chunk-HC45LTEN.js";
 import {
   Storage,
   getProjectHash
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -104,10 +104,14 @@ async function readCronTasks(projectRoot) {
   return parsed;
 }
 __name(readCronTasks, "readCronTasks");
-async function writeCronTasks(projectRoot, tasks) {
+async function writeCronTasks(projectRoot, tasks, options = {}) {
   const filePath = getCronFilePath(projectRoot);
+  options.assertCanCommit?.();
   await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await atomicWriteJSON(filePath, tasks, { noFollow: true });
+  await atomicWriteJSON(filePath, tasks, {
+    noFollow: true,
+    assertCanCommit: options.assertCanCommit
+  });
 }
 __name(writeCronTasks, "writeCronTasks");
 async function acquireUpdateLock(filePath) {
@@ -154,7 +158,7 @@ async function acquireUpdateLock(filePath) {
   }
 }
 __name(acquireUpdateLock, "acquireUpdateLock");
-async function updateCronTasks(projectRoot, mutate) {
+async function updateCronTasks(projectRoot, mutate, options = {}) {
   const filePath = getCronFilePath(projectRoot);
   return getUpdateMutex(filePath).runExclusive(async () => {
     const release = await acquireUpdateLock(filePath);
@@ -162,7 +166,7 @@ async function updateCronTasks(projectRoot, mutate) {
       const tasks = await readCronTasks(projectRoot);
       const next = mutate(tasks);
       if (next !== tasks) {
-        await writeCronTasks(projectRoot, next);
+        await writeCronTasks(projectRoot, next, options);
       }
     } finally {
       await release();
@@ -230,7 +234,6 @@ function isValidTask(value) {
 __name(isValidTask, "isValidTask");
 
 export {
-  MAX_TASK_RUNS,
   MAX_CHANNEL_DELIVERY_NAME_LENGTH,
   MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH,
   appendCronRun,

package/chunks/{chunk-OHNBB4XR.js → chunk-THVU3RNH.js}

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

package/chunks/{record-artifact-RQKFYO5B.js → chunk-TIRRPCFS.js}

@@ -5,9 +5,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-PR75REBZ.js";
-import "./chunk-NL7LTRLR.js";
-import "./chunk-TARRHLLG.js";
+} from "./chunk-MM7TH7ZM.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -18,9 +16,11 @@ import {
 // packages/core/src/tools/record-artifact.ts
 init_esbuild_shims();
 import path from "node:path";
-var DESCRIPTION = `Registers a session artifact so clients can show it in an artifacts panel. Use it after creating a useful file, URL, image, report, notebook, or other intermediate result that the user may want to open later.
+var DESCRIPTION = `Registers a session artifact so clients can show it in an artifacts panel. Use it after creating a useful file, URL, image, report, notebook, or other intermediate result that the user may want to open later, unless the producing tool already returned artifact metadata. For example, write_file automatically records HTML, image, PDF, and notebook files it writes inside the workspace, so do not call record_artifact again for the same workspacePath; still call it for other formats such as Markdown, CSV, JSON, and plain text, and for files produced outside write_file.
 
 This tool only records metadata. It does not publish, upload, read, write, or verify the referenced resource. Provide exactly one locator: workspacePath, managedId, or url. Use the Artifact tool, not record_artifact, for published interactive HTML artifacts.`;
+var ARTIFACT_TITLE_MAX_LENGTH = 200;
+var ARTIFACT_WORKSPACE_PATH_MAX_LENGTH = 500;
 var RecordArtifactInvocation = class extends BaseToolInvocation {
   static {
     __name(this, "RecordArtifactInvocation");
@@ -135,7 +135,12 @@ var RecordArtifactTool = class _RecordArtifactTool extends BaseDeclarativeTool {
   }
   validateToolParamValues(params) {
     params.title = (params.title ?? "").trim();
-    const titleError = validateString(params.title, "title", 200, true);
+    const titleError = validateString(
+      params.title,
+      "title",
+      ARTIFACT_TITLE_MAX_LENGTH,
+      true
+    );
     if (titleError) {
       return titleError;
     }
@@ -282,7 +287,12 @@ function hasUnsafeDisplayPayload(value) {
 __name(hasUnsafeDisplayPayload, "hasUnsafeDisplayPayload");
 function validateWorkspacePath(value) {
   const trimmed = value.trim();
-  const stringError = validateString(trimmed, "workspacePath", 500, true);
+  const stringError = validateString(
+    trimmed,
+    "workspacePath",
+    ARTIFACT_WORKSPACE_PATH_MAX_LENGTH,
+    true
+  );
   if (stringError) {
     return stringError;
   }
@@ -333,8 +343,13 @@ function isArtifactKind(kind) {
   return kind === "file" || kind === "link" || kind === "html" || kind === "image" || kind === "video" || kind === "audio" || kind === "pdf" || kind === "notebook" || kind === "other";
 }
 __name(isArtifactKind, "isArtifactKind");
+
 export {
-  RecordArtifactTool
+  ARTIFACT_TITLE_MAX_LENGTH,
+  ARTIFACT_WORKSPACE_PATH_MAX_LENGTH,
+  RecordArtifactTool,
+  hasControlCharacter,
+  hasUnsafeDisplayPayload
 };
 /**
  * @license

package/chunks/chunk-TTJZAIFP.js

@@ -0,0 +1,319 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getUserSettingsPath,
+  v1ToV2Migration
+} from "./chunk-W3UKBMSI.js";
+import {
+  getSystemDefaultsPath,
+  getSystemSettingsPath
+} from "./chunk-IDS7MSUP.js";
+import {
+  LoadedTrustedFolders,
+  TrustLevel,
+  getTrustedFoldersPath
+} from "./chunk-P755N4CS.js";
+import {
+  require_strip_json_comments
+} from "./chunk-ALGGS7UH.js";
+import {
+  arePathsEquivalent
+} from "./chunk-MR3PXB6E.js";
+import {
+  ideContextStore
+} from "./chunk-54YCNSK5.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/daemon-trust-policy.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+var import_strip_json_comments = __toESM(require_strip_json_comments(), 1);
+var MAX_TRUSTED_FOLDERS_BYTES = 1024 * 1024;
+var MAX_SETTINGS_BYTES = 4 * 1024 * 1024;
+function policyError(code, filePath, error) {
+  return {
+    code,
+    path: filePath,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+__name(policyError, "policyError");
+async function readJsonObject(filePath, maxBytes, requireRegularFile, retryMissing = false) {
+  const delays = [0, 50, 200];
+  let result = {};
+  for (const delay of delays) {
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    result = await readJsonObjectOnce(filePath, maxBytes, requireRegularFile);
+    if (!result.error && (!result.missing || !retryMissing)) return result;
+  }
+  return result;
+}
+__name(readJsonObject, "readJsonObject");
+async function readJsonObjectOnce(filePath, maxBytes, requireRegularFile) {
+  let stat2;
+  try {
+    stat2 = await fs.lstat(filePath);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { value: {}, missing: true };
+    }
+    return {
+      error: policyError("trust_policy_unreadable", filePath, error)
+    };
+  }
+  if (!requireRegularFile && stat2.isSymbolicLink()) {
+    try {
+      stat2 = await fs.stat(filePath);
+    } catch (error) {
+      return {
+        error: policyError("trust_policy_unreadable", filePath, error)
+      };
+    }
+  }
+  if (requireRegularFile && stat2.isSymbolicLink() || !stat2.isFile()) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("Trust policy input must be a regular file.")
+      )
+    };
+  }
+  if (stat2.size > maxBytes) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error(`Trust policy input exceeds ${maxBytes} bytes.`)
+      )
+    };
+  }
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse((0, import_strip_json_comments.default)(raw));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Trust policy input must contain a JSON object.");
+    }
+    return { value: parsed };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { value: {}, missing: true };
+    }
+    return { error: policyError("trust_policy_invalid", filePath, error) };
+  }
+}
+__name(readJsonObjectOnce, "readJsonObjectOnce");
+function migrateFolderTrustSettings(value, scope) {
+  if (!value || !v1ToV2Migration.shouldMigrate(value)) return value;
+  return v1ToV2Migration.migrate(value, scope).settings;
+}
+__name(migrateFolderTrustSettings, "migrateFolderTrustSettings");
+function folderTrustSetting(value, filePath) {
+  if (!value || !("security" in value)) return {};
+  const security = value?.["security"];
+  if (typeof security !== "object" || security === null || Array.isArray(security)) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("`security` must be an object.")
+      )
+    };
+  }
+  if (!("folderTrust" in security)) return {};
+  const folderTrust = security["folderTrust"];
+  if (typeof folderTrust !== "object" || folderTrust === null || Array.isArray(folderTrust)) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("`security.folderTrust` must be an object.")
+      )
+    };
+  }
+  if (!("enabled" in folderTrust)) return {};
+  const enabled = folderTrust["enabled"];
+  if (typeof enabled === "boolean") return { value: enabled };
+  return {
+    error: policyError(
+      "trust_policy_invalid",
+      filePath,
+      new Error("`security.folderTrust.enabled` must be a boolean.")
+    )
+  };
+}
+__name(folderTrustSetting, "folderTrustSetting");
+function parseTrustedFolders(value, filePath) {
+  const config = {};
+  for (const [rulePath, rawLevel] of Object.entries(value ?? {})) {
+    if (!Object.values(TrustLevel).includes(rawLevel)) {
+      return {
+        config: {},
+        error: policyError(
+          "trust_policy_invalid",
+          filePath,
+          new Error(`Invalid trust level for ${JSON.stringify(rulePath)}.`)
+        )
+      };
+    }
+    config[rulePath] = rawLevel;
+  }
+  return { config };
+}
+__name(parseTrustedFolders, "parseTrustedFolders");
+function semanticRevision(input) {
+  const sortedRules = Object.entries(input.trustedFolders).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return createHash("sha256").update(
+    JSON.stringify({
+      folderTrustEnabled: input.folderTrustEnabled,
+      ideTrust: input.ideTrust ?? null,
+      trustedFolders: sortedRules,
+      settingsError: input.settingsError?.code ?? null,
+      trustedFoldersError: input.trustedFoldersError?.code ?? null
+    })
+  ).digest("hex");
+}
+__name(semanticRevision, "semanticRevision");
+async function readDaemonTrustPolicySnapshot() {
+  const [user, system, systemDefaults] = await Promise.all([
+    readJsonObject(getUserSettingsPath(), MAX_SETTINGS_BYTES, false),
+    readJsonObject(getSystemSettingsPath(), MAX_SETTINGS_BYTES, false),
+    readJsonObject(getSystemDefaultsPath(), MAX_SETTINGS_BYTES, false)
+  ]);
+  const systemFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(system.value, "System"),
+    getSystemSettingsPath()
+  );
+  const userFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(user.value, "User"),
+    getUserSettingsPath()
+  );
+  const defaultsFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(systemDefaults.value, "SystemDefaults"),
+    getSystemDefaultsPath()
+  );
+  const settingsError = system.error ?? systemFolderTrust.error ?? user.error ?? userFolderTrust.error ?? systemDefaults.error ?? defaultsFolderTrust.error;
+  const folderTrustEnabled = systemFolderTrust.value ?? userFolderTrust.value ?? defaultsFolderTrust.value ?? false;
+  const trustedFoldersFile = await readJsonObject(
+    getTrustedFoldersPath(),
+    MAX_TRUSTED_FOLDERS_BYTES,
+    true,
+    folderTrustEnabled
+  );
+  const parsedTrustedFolders = parseTrustedFolders(
+    trustedFoldersFile.value,
+    getTrustedFoldersPath()
+  );
+  const trustedFoldersError = trustedFoldersFile.error ?? parsedTrustedFolders.error;
+  const ideTrust = ideContextStore.get()?.workspaceState?.isTrusted;
+  const revision = semanticRevision({
+    folderTrustEnabled,
+    ideTrust,
+    trustedFolders: parsedTrustedFolders.config,
+    ...settingsError ? { settingsError } : {},
+    ...trustedFoldersError ? { trustedFoldersError } : {}
+  });
+  return {
+    revision,
+    folderTrustEnabled,
+    ideTrust,
+    trustedFolders: Object.freeze({ ...parsedTrustedFolders.config }),
+    ...settingsError ? { settingsError } : {},
+    ...trustedFoldersError ? { trustedFoldersError } : {}
+  };
+}
+__name(readDaemonTrustPolicySnapshot, "readDaemonTrustPolicySnapshot");
+function explicitTrustLevel(snapshot, workspaceCwd) {
+  const folders = new LoadedTrustedFolders(
+    {
+      path: getTrustedFoldersPath(),
+      config: { ...snapshot.trustedFolders }
+    },
+    []
+  );
+  const effective = folders.isPathTrusted(workspaceCwd);
+  if (effective === void 0) return null;
+  for (const [rulePath, trustLevel] of Object.entries(
+    snapshot.trustedFolders
+  )) {
+    const preview = new LoadedTrustedFolders(
+      { path: getTrustedFoldersPath(), config: { [rulePath]: trustLevel } },
+      []
+    ).isPathTrusted(workspaceCwd);
+    if (preview === effective) return trustLevel;
+  }
+  return null;
+}
+__name(explicitTrustLevel, "explicitTrustLevel");
+function evaluateDaemonWorkspaceTrust(snapshot, workspaceCwd, processCwd = process.cwd()) {
+  if (snapshot.settingsError) {
+    return {
+      state: "error",
+      targetTrusted: false,
+      source: "none",
+      explicitTrustLevel: null,
+      error: snapshot.settingsError
+    };
+  }
+  if (!snapshot.folderTrustEnabled) {
+    return {
+      state: "trusted",
+      targetTrusted: true,
+      source: "disabled",
+      explicitTrustLevel: null
+    };
+  }
+  if (snapshot.ideTrust !== void 0 && arePathsEquivalent(workspaceCwd, processCwd)) {
+    return {
+      state: snapshot.ideTrust ? "trusted" : "untrusted",
+      targetTrusted: snapshot.ideTrust,
+      source: "ide",
+      explicitTrustLevel: null
+    };
+  }
+  if (snapshot.trustedFoldersError) {
+    return {
+      state: "error",
+      targetTrusted: false,
+      source: "none",
+      explicitTrustLevel: null,
+      error: snapshot.trustedFoldersError
+    };
+  }
+  const folders = new LoadedTrustedFolders(
+    {
+      path: getTrustedFoldersPath(),
+      config: { ...snapshot.trustedFolders }
+    },
+    []
+  );
+  const trusted = folders.isPathTrusted(workspaceCwd);
+  return {
+    state: trusted === true ? "trusted" : trusted === false ? "untrusted" : "unknown",
+    targetTrusted: trusted === true,
+    source: trusted === void 0 ? "none" : "file",
+    explicitTrustLevel: explicitTrustLevel(snapshot, workspaceCwd)
+  };
+}
+__name(evaluateDaemonWorkspaceTrust, "evaluateDaemonWorkspaceTrust");
+
+export {
+  readDaemonTrustPolicySnapshot,
+  evaluateDaemonWorkspaceTrust
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

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

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

package/chunks/{chunk-52O2CIUL.js → chunk-UV6KF7T3.js}

@@ -2,15 +2,15 @@
 "use strict";
 import {
   sanitizeFilenameForDisplay
-} from "./chunk-IPUUTYMV.js";
+} from "./chunk-YDLJGZHL.js";
 import {
   t
-} from "./chunk-VV6XU5L7.js";
+} from "./chunk-3F2WDAV6.js";
 import {
   fetchGitDiff,
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-DM4Q4JJH.js";
+} from "./chunk-54YCNSK5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -274,6 +274,115 @@ var diffCommand = {
   action: diffAction
 };
 
+// packages/cli/src/ui/utils/inline-math.ts
+init_esbuild_shims();
+var INLINE_MATH_MAX_CHARS = 1024;
+var INLINE_CODE_SPAN_PATTERN_SOURCE = String.raw`(?<!\`)(?<inlineCodeFence>\`+)(?!\`).+?(?<!\`)\k<inlineCodeFence>(?!\`)`;
+var INLINE_CODE_SPAN_RE = new RegExp(INLINE_CODE_SPAN_PATTERN_SOURCE, "g");
+function isEscapedAt(text, index) {
+  let slashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor -= 1) {
+    slashCount += 1;
+  }
+  return slashCount % 2 === 1;
+}
+__name(isEscapedAt, "isEscapedAt");
+function isUnescapedDollarAt(text, index) {
+  return text[index] === "$" && !isEscapedAt(text, index);
+}
+__name(isUnescapedDollarAt, "isUnescapedDollarAt");
+function unescapeMarkdownDollars(text) {
+  return text.replace(
+    /(\\+)\$/g,
+    (_match, slashes) => `${"\\".repeat(Math.floor(slashes.length / 2))}$`
+  );
+}
+__name(unescapeMarkdownDollars, "unescapeMarkdownDollars");
+function unescapeMarkdownBeforeMath(text) {
+  return unescapeMarkdownDollars(`${text}$`).slice(0, -1);
+}
+__name(unescapeMarkdownBeforeMath, "unescapeMarkdownBeforeMath");
+function readInlineMathSpan(text, index) {
+  if (!isUnescapedDollarAt(text, index)) {
+    return null;
+  }
+  const previous = text[index - 1] ?? "";
+  const next = text[index + 1] ?? "";
+  if (/\w/.test(previous) || isUnescapedDollarAt(text, index - 1) || !next || /[\s\d$]/.test(next)) {
+    return null;
+  }
+  let closingIndex = index + 1;
+  while (closingIndex < text.length && text[closingIndex] !== "\n" && closingIndex - index - 1 <= INLINE_MATH_MAX_CHARS && !isUnescapedDollarAt(text, closingIndex)) {
+    closingIndex += 1;
+  }
+  if (!isUnescapedDollarAt(text, closingIndex)) {
+    return null;
+  }
+  const content = text.slice(index + 1, closingIndex);
+  const following = text[closingIndex + 1] ?? "";
+  if (content.length > INLINE_MATH_MAX_CHARS || /\s$/.test(content) || /[\w$]/.test(following)) {
+    return null;
+  }
+  return {
+    content,
+    index,
+    raw: text.slice(index, closingIndex + 1)
+  };
+}
+__name(readInlineMathSpan, "readInlineMathSpan");
+function findNextInlineMath(text, fromIndex = 0) {
+  for (let index = fromIndex; index < text.length; index += 1) {
+    const span = readInlineMathSpan(text, index);
+    if (span) {
+      return span;
+    }
+  }
+  return null;
+}
+__name(findNextInlineMath, "findNextInlineMath");
+function* mergeInlineMathMatches(text, markupRegex, enableInlineMath = true) {
+  markupRegex.lastIndex = 0;
+  const markupMatches = text.matchAll(markupRegex);
+  let nextMarkup = markupMatches.next();
+  let nextMath = enableInlineMath ? findNextInlineMath(text) : null;
+  let cursor = 0;
+  while (!nextMarkup.done || nextMath) {
+    while (!nextMarkup.done && (nextMarkup.value.index ?? 0) < cursor) {
+      nextMarkup = markupMatches.next();
+    }
+    if (nextMath && nextMath.index < cursor) {
+      nextMath = findNextInlineMath(text, cursor);
+    }
+    const markupIndex = nextMarkup.done ? Number.POSITIVE_INFINITY : nextMarkup.value.index ?? 0;
+    const mathIndex = nextMath?.index ?? Number.POSITIVE_INFINITY;
+    if (!nextMarkup.done && markupIndex <= mathIndex) {
+      const match = nextMarkup.value;
+      yield { kind: "markup", match };
+      cursor = markupIndex + match[0].length;
+      nextMarkup = markupMatches.next();
+    } else if (nextMath) {
+      yield { kind: "math", span: nextMath };
+      cursor = mathIndex + nextMath.raw.length;
+      nextMath = findNextInlineMath(text, cursor);
+    }
+  }
+}
+__name(mergeInlineMathMatches, "mergeInlineMathMatches");
+function findInlineMathExpressions(text) {
+  const expressions = [];
+  for (const token of mergeInlineMathMatches(text, INLINE_CODE_SPAN_RE)) {
+    if (token.kind === "math") {
+      expressions.push(token.span.content);
+    }
+  }
+  return expressions;
+}
+__name(findInlineMathExpressions, "findInlineMathExpressions");
+function readInlineMathSpanAt(text, index) {
+  return readInlineMathSpan(text, index)?.raw ?? null;
+}
+__name(readInlineMathSpanAt, "readInlineMathSpanAt");
+
 // packages/cli/src/utils/systemInfoFields.ts
 init_esbuild_shims();
 function getSystemInfoFields(info) {
@@ -390,10 +499,15 @@ init_esbuild_shims();
 function calculateCost(args) {
   const { inputTokens, outputTokens, pricing } = args;
   if (!pricing) return null;
+  if (pricing.inputPerMillionTokens == null && pricing.outputPerMillionTokens == null) {
+    return null;
+  }
+  if (inputTokens <= 0 && outputTokens <= 0) {
+    return null;
+  }
   const inputCost = pricing.inputPerMillionTokens != null ? inputTokens / 1e6 * pricing.inputPerMillionTokens : 0;
   const outputCost = pricing.outputPerMillionTokens != null ? outputTokens / 1e6 * pricing.outputPerMillionTokens : 0;
-  const total = inputCost + outputCost;
-  return total > 0 ? total : null;
+  return inputCost + outputCost;
 }
 __name(calculateCost, "calculateCost");
 
@@ -418,6 +532,12 @@ function levelLabel(level) {
 __name(levelLabel, "levelLabel");
 
 export {
+  INLINE_CODE_SPAN_PATTERN_SOURCE,
+  unescapeMarkdownDollars,
+  unescapeMarkdownBeforeMath,
+  mergeInlineMathMatches,
+  findInlineMathExpressions,
+  readInlineMathSpanAt,
   getSystemInfoFields,
   calculateErrorRate,
   calculateAverageLatency,
@@ -435,6 +555,11 @@ export {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen

package/chunks/{chunk-QPDRAXDJ.js → chunk-V25K5ID7.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-P5V4T7NK.js";
+} from "./chunk-JJPKFJBT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";