@qwen-code/qwen-code 0.19.7-nightly.20260708.394c1a289 → 0.19.8

package/chunks/chunk-BOBRZZKD.js

@@ -0,0 +1,468 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  DEFAULT_EXCLUDED_ENV_VARS,
+  HOME_ENV_BOOTSTRAP_KEYS,
+  PROJECT_ENV_HARDCODED_EXCLUSIONS
+} from "./chunk-Z3I3QJK3.js";
+import {
+  isWorkspaceTrusted
+} from "./chunk-DICGXFAI.js";
+import {
+  require_main
+} from "./chunk-SKAZWEV5.js";
+import {
+  QWEN_DIR,
+  Storage,
+  getErrorMessage
+} from "./chunk-22MNNNXE.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/environment.ts
+init_esbuild_shims();
+var dotenv = __toESM(require_main(), 1);
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+var SETTINGS_DIRECTORY_NAME = QWEN_DIR;
+var RELOAD_EXCLUDED_KEYS = /* @__PURE__ */ new Set([
+  ...PROJECT_ENV_HARDCODED_EXCLUSIONS,
+  "QWEN_SERVER_TOKEN",
+  "QWEN_CLI_ENTRY",
+  "NODE_OPTIONS",
+  "NODE_PATH",
+  "NODE_TLS_REJECT_UNAUTHORIZED",
+  "LD_PRELOAD",
+  "LD_AUDIT",
+  "LD_LIBRARY_PATH",
+  "DYLD_INSERT_LIBRARIES",
+  "DYLD_LIBRARY_PATH",
+  "BASH_ENV",
+  "ENV",
+  "PATH",
+  "HOME",
+  "TMPDIR",
+  "TMP",
+  "TEMP"
+]);
+var dotEnvSourcedKeys = /* @__PURE__ */ new Set();
+var settingsEnvSourcedKeys = /* @__PURE__ */ new Set();
+var lastReloadSnapshot = /* @__PURE__ */ new Map();
+var lastReloadSnapshotSeeded = false;
+function getUserLevelEnvPaths() {
+  const homeDir = os.homedir();
+  const globalQwenDir = Storage.getGlobalQwenDir();
+  const paths = /* @__PURE__ */ new Set([
+    path.normalize(path.join(homeDir, ".env")),
+    path.normalize(path.join(globalQwenDir, ".env"))
+  ]);
+  const legacyQwenEnv = path.normalize(path.join(homeDir, QWEN_DIR, ".env"));
+  paths.add(legacyQwenEnv);
+  return paths;
+}
+__name(getUserLevelEnvPaths, "getUserLevelEnvPaths");
+var homeEnvBootstrapped = false;
+function preResolveHomeEnvOverrides() {
+  if (homeEnvBootstrapped) {
+    return;
+  }
+  homeEnvBootstrapped = true;
+  if (HOME_ENV_BOOTSTRAP_KEYS.every((key) => process.env[key])) {
+    return;
+  }
+  const initialQwenHome = process.env["QWEN_HOME"];
+  const initialQwenDir = Storage.getGlobalQwenDir();
+  const candidates = [path.join(initialQwenDir, ".env")];
+  if (!initialQwenHome) {
+    candidates.push(path.join(path.dirname(initialQwenDir), ".env"));
+  }
+  for (const candidate of candidates) {
+    readHomeEnvInto(candidate);
+  }
+  const discoveredQwenHome = process.env["QWEN_HOME"];
+  if (discoveredQwenHome && discoveredQwenHome !== initialQwenHome) {
+    const discoveredDir = Storage.getGlobalQwenDir();
+    if (discoveredDir !== initialQwenDir) {
+      readHomeEnvInto(path.join(discoveredDir, ".env"));
+    }
+  }
+}
+__name(preResolveHomeEnvOverrides, "preResolveHomeEnvOverrides");
+function readHomeEnvInto(file) {
+  if (!fs.existsSync(file)) {
+    return;
+  }
+  try {
+    const parsed = dotenv.parse(fs.readFileSync(file, "utf-8"));
+    for (const key of PROJECT_ENV_HARDCODED_EXCLUSIONS) {
+      if (parsed[key] && !Object.hasOwn(process.env, key)) {
+        process.env[key] = parsed[key];
+      }
+    }
+  } catch (_e) {
+  }
+}
+__name(readHomeEnvInto, "readHomeEnvInto");
+function resetHomeEnvBootstrapForTesting() {
+  homeEnvBootstrapped = false;
+}
+__name(resetHomeEnvBootstrapForTesting, "resetHomeEnvBootstrapForTesting");
+function resetEnvironmentTrackingForTesting() {
+  dotEnvSourcedKeys.clear();
+  settingsEnvSourcedKeys.clear();
+  lastReloadSnapshot.clear();
+  lastReloadSnapshotSeeded = false;
+}
+__name(resetEnvironmentTrackingForTesting, "resetEnvironmentTrackingForTesting");
+function getHomeEnvFallbackVars(onReadError) {
+  const globalQwenDir = Storage.getGlobalQwenDir();
+  const candidates = [path.join(globalQwenDir, ".env")];
+  if (!process.env["QWEN_HOME"]) {
+    candidates.push(path.join(path.dirname(globalQwenDir), ".env"));
+  }
+  const result = {};
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) {
+      continue;
+    }
+    try {
+      const parsed = dotenv.parse(fs.readFileSync(candidate, "utf-8"));
+      for (const key in parsed) {
+        if (Object.hasOwn(parsed, key) && !Object.hasOwn(process.env, key)) {
+          result[key] ??= parsed[key];
+        }
+      }
+    } catch (e) {
+      onReadError?.(
+        `Failed to read home .env candidate ${candidate}: ${getErrorMessage(e)}`
+      );
+    }
+  }
+  return result;
+}
+__name(getHomeEnvFallbackVars, "getHomeEnvFallbackVars");
+function findEnvFiles(settings, startDir, userLevelPaths = getUserLevelEnvPaths()) {
+  const homeDir = os.homedir();
+  let realStartDir = path.resolve(startDir);
+  try {
+    realStartDir = fs.realpathSync(realStartDir);
+  } catch {
+  }
+  const isTrusted = isWorkspaceTrusted(
+    settings,
+    void 0,
+    realStartDir
+  ).isTrusted;
+  const globalQwenDir = Storage.getGlobalQwenDir();
+  const legacyQwenDir = path.normalize(path.join(homeDir, QWEN_DIR));
+  const hasCustomConfigDir = path.normalize(globalQwenDir) !== legacyQwenDir;
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const canUseEnvFile = /* @__PURE__ */ __name((filePath) => isTrusted !== false || userLevelPaths.has(path.normalize(filePath)), "canUseEnvFile");
+  const pushCandidate = /* @__PURE__ */ __name((filePath) => {
+    const normalized = path.normalize(filePath);
+    if (!seen.has(normalized) && fs.existsSync(filePath) && canUseEnvFile(filePath)) {
+      seen.add(normalized);
+      found.push(filePath);
+      return true;
+    }
+    return false;
+  }, "pushCandidate");
+  const pushHomeCandidates = /* @__PURE__ */ __name(() => {
+    const candidates = [path.join(globalQwenDir, ".env")];
+    if (hasCustomConfigDir) {
+      candidates.push(path.join(legacyQwenDir, ".env"));
+    }
+    candidates.push(path.join(homeDir, ".env"));
+    for (const candidate of candidates) {
+      pushCandidate(candidate);
+    }
+  }, "pushHomeCandidates");
+  let currentDir = realStartDir;
+  let visitedHomeDir = false;
+  while (true) {
+    if (currentDir === homeDir) {
+      visitedHomeDir = true;
+      pushHomeCandidates();
+      return found;
+    } else {
+      const geminiEnvPath = path.join(currentDir, QWEN_DIR, ".env");
+      if (pushCandidate(geminiEnvPath)) {
+        pushHomeCandidates();
+        return found;
+      }
+      const envPath = path.join(currentDir, ".env");
+      if (pushCandidate(envPath)) {
+        pushHomeCandidates();
+        return found;
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir || !parentDir) {
+      if (!visitedHomeDir) {
+        pushHomeCandidates();
+      }
+      return found;
+    }
+    currentDir = parentDir;
+  }
+}
+__name(findEnvFiles, "findEnvFiles");
+function setUpCloudShellEnvironment(envFilePath) {
+  if (envFilePath && fs.existsSync(envFilePath)) {
+    const envFileContent = fs.readFileSync(envFilePath);
+    const parsedEnv = dotenv.parse(envFileContent);
+    if (parsedEnv["GOOGLE_CLOUD_PROJECT"]) {
+      process.env["GOOGLE_CLOUD_PROJECT"] = parsedEnv["GOOGLE_CLOUD_PROJECT"];
+    } else {
+      process.env["GOOGLE_CLOUD_PROJECT"] = "cloudshell-gca";
+    }
+  } else {
+    process.env["GOOGLE_CLOUD_PROJECT"] = "cloudshell-gca";
+  }
+}
+__name(setUpCloudShellEnvironment, "setUpCloudShellEnvironment");
+function setUpCloudShellEnvironmentInEnv(env, envFiles) {
+  for (const envFile of envFiles) {
+    if (envFile.parsedEnv["GOOGLE_CLOUD_PROJECT"]) {
+      env["GOOGLE_CLOUD_PROJECT"] = envFile.parsedEnv["GOOGLE_CLOUD_PROJECT"];
+      return;
+    }
+  }
+  env["GOOGLE_CLOUD_PROJECT"] = "cloudshell-gca";
+}
+__name(setUpCloudShellEnvironmentInEnv, "setUpCloudShellEnvironmentInEnv");
+function parseEnvFiles(envFilePaths, userLevelPaths) {
+  const files = [];
+  const readFailures = [];
+  for (const envFilePath of envFilePaths) {
+    try {
+      const envFileContent = fs.readFileSync(envFilePath, "utf-8");
+      const parsedEnv = dotenv.parse(envFileContent);
+      const normalizedEnvFilePath = path.normalize(envFilePath);
+      const isHomeScopedEnvFile = userLevelPaths.has(normalizedEnvFilePath);
+      const isQwenScopedEnvFile = isHomeScopedEnvFile || path.basename(path.dirname(normalizedEnvFilePath)) === QWEN_DIR;
+      files.push({
+        parsedEnv,
+        isHomeScopedEnvFile,
+        isQwenScopedEnvFile
+      });
+    } catch (err) {
+      readFailures.push({
+        path: envFilePath,
+        error: getErrorMessage(err)
+      });
+    }
+  }
+  return { files, readFailed: readFailures.length > 0, readFailures };
+}
+__name(parseEnvFiles, "parseEnvFiles");
+function canApplyParsedEnvKey(envFile, key, excludedVars, options = {}) {
+  if (!Object.hasOwn(envFile.parsedEnv, key)) return false;
+  if (options.reload && RELOAD_EXCLUDED_KEYS.has(key)) return false;
+  if (!envFile.isHomeScopedEnvFile && PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
+    return false;
+  }
+  return envFile.isQwenScopedEnvFile || !excludedVars.includes(key);
+}
+__name(canApplyParsedEnvKey, "canApplyParsedEnvKey");
+function isEffectivelyUnset(env, key) {
+  const existingValue = env[key];
+  return !Object.hasOwn(env, key) || existingValue === "";
+}
+__name(isEffectivelyUnset, "isEffectivelyUnset");
+function setRuntimeEnvIfUnset(env, key, value) {
+  if (isEffectivelyUnset(env, key)) {
+    env[key] = value;
+  }
+}
+__name(setRuntimeEnvIfUnset, "setRuntimeEnvIfUnset");
+function buildRuntimeEnvironment(settings, startDir = process.cwd(), baseEnv = process.env) {
+  const userLevelPaths = getUserLevelEnvPaths();
+  const envFilePaths = findEnvFiles(settings, startDir, userLevelPaths);
+  const parsedEnvFiles = parseEnvFiles(envFilePaths, userLevelPaths);
+  const effectiveEnv = { ...baseEnv };
+  if (baseEnv["CLOUD_SHELL"] === "true") {
+    setUpCloudShellEnvironmentInEnv(effectiveEnv, parsedEnvFiles.files);
+  }
+  for (const envFile of parsedEnvFiles.files) {
+    const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
+    for (const key in envFile.parsedEnv) {
+      if (!canApplyParsedEnvKey(envFile, key, excludedVars, { reload: true })) {
+        continue;
+      }
+      setRuntimeEnvIfUnset(effectiveEnv, key, envFile.parsedEnv[key]);
+    }
+  }
+  if (settings.env) {
+    const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
+    for (const [key, value] of Object.entries(settings.env)) {
+      if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
+      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) continue;
+      if (excludedVars.includes(key)) continue;
+      if (typeof value !== "string") continue;
+      setRuntimeEnvIfUnset(effectiveEnv, key, value);
+    }
+  }
+  const overlayKeys = Object.keys(effectiveEnv).filter((key) => effectiveEnv[key] !== baseEnv[key]).sort();
+  return {
+    effectiveEnv: Object.freeze({ ...effectiveEnv }),
+    overlayKeys: Object.freeze(overlayKeys),
+    envFilePaths: Object.freeze([...envFilePaths]),
+    envFileReadFailed: parsedEnvFiles.readFailed,
+    envFileReadFailures: Object.freeze([...parsedEnvFiles.readFailures])
+  };
+}
+__name(buildRuntimeEnvironment, "buildRuntimeEnvironment");
+function loadEnvironment(settings, startDir = process.cwd()) {
+  const userLevelPaths = getUserLevelEnvPaths();
+  const envFilePaths = findEnvFiles(settings, startDir, userLevelPaths);
+  const parsedEnvFiles = parseEnvFiles(envFilePaths, userLevelPaths);
+  if (process.env["CLOUD_SHELL"] === "true") {
+    setUpCloudShellEnvironmentInEnv(process.env, parsedEnvFiles.files);
+  }
+  for (const envFile of parsedEnvFiles.files) {
+    const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
+    for (const key in envFile.parsedEnv) {
+      if (!canApplyParsedEnvKey(envFile, key, excludedVars)) continue;
+      const existingValue = process.env[key];
+      const isEffectivelyUnset2 = !Object.hasOwn(process.env, key) || existingValue === "";
+      if (isEffectivelyUnset2) {
+        process.env[key] = envFile.parsedEnv[key];
+        dotEnvSourcedKeys.add(key);
+      }
+      if (!lastReloadSnapshotSeeded && !lastReloadSnapshot.has(key)) {
+        lastReloadSnapshot.set(key, envFile.parsedEnv[key]);
+      }
+    }
+  }
+  if (settings.env) {
+    for (const [key, value] of Object.entries(settings.env)) {
+      if (RELOAD_EXCLUDED_KEYS.has(key)) {
+        continue;
+      }
+      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
+        continue;
+      }
+      const existingValue = process.env[key];
+      const isEffectivelyUnset2 = !Object.hasOwn(process.env, key) || existingValue === "";
+      if (isEffectivelyUnset2 && typeof value === "string") {
+        process.env[key] = value;
+        settingsEnvSourcedKeys.add(key);
+      }
+      if (!lastReloadSnapshotSeeded && typeof value === "string" && !lastReloadSnapshot.has(key)) {
+        lastReloadSnapshot.set(key, value);
+      }
+    }
+  }
+  lastReloadSnapshotSeeded = true;
+}
+__name(loadEnvironment, "loadEnvironment");
+function reloadEnvironment(settings, workspaceCwd) {
+  const userLevelPaths = getUserLevelEnvPaths();
+  const envFilePaths = findEnvFiles(settings, workspaceCwd, userLevelPaths);
+  const parsedEnvFiles = parseEnvFiles(envFilePaths, userLevelPaths);
+  if (process.env["CLOUD_SHELL"] === "true") {
+    setUpCloudShellEnvironmentInEnv(process.env, parsedEnvFiles.files);
+  }
+  const dotEnvReadFailed = parsedEnvFiles.readFailed;
+  const newDotEnvKeys = /* @__PURE__ */ new Map();
+  const newSettingsEnvKeys = /* @__PURE__ */ new Map();
+  for (const envFile of parsedEnvFiles.files) {
+    const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
+    for (const key in envFile.parsedEnv) {
+      if (!canApplyParsedEnvKey(envFile, key, excludedVars, { reload: true })) {
+        continue;
+      }
+      if (!newDotEnvKeys.has(key)) {
+        newDotEnvKeys.set(key, envFile.parsedEnv[key]);
+      }
+    }
+  }
+  if (settings.env) {
+    for (const [key, value] of Object.entries(settings.env)) {
+      if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
+      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) continue;
+      if (typeof value !== "string") continue;
+      const dotEnvValue = newDotEnvKeys.get(key);
+      if (dotEnvValue !== void 0 && dotEnvValue !== "") continue;
+      if (dotEnvReadFailed && lastReloadSnapshot.has(key)) continue;
+      newSettingsEnvKeys.set(key, value);
+    }
+  }
+  const allNewKeys = /* @__PURE__ */ new Set([
+    ...newDotEnvKeys.keys(),
+    ...newSettingsEnvKeys.keys()
+  ]);
+  const updatedKeys = [];
+  const removedKeys = [];
+  if (!dotEnvReadFailed) {
+    const previouslyKnown = /* @__PURE__ */ new Set([
+      ...lastReloadSnapshot.keys(),
+      ...dotEnvSourcedKeys,
+      ...settingsEnvSourcedKeys
+    ]);
+    for (const key of previouslyKnown) {
+      if (!allNewKeys.has(key) && !RELOAD_EXCLUDED_KEYS.has(key)) {
+        delete process.env[key];
+        removedKeys.push(key);
+      }
+    }
+  }
+  for (const [key, value] of newDotEnvKeys) {
+    if (value === "" && newSettingsEnvKeys.has(key)) continue;
+    if (process.env[key] !== value) {
+      updatedKeys.push(key);
+    }
+    process.env[key] = value;
+  }
+  for (const [key, value] of newSettingsEnvKeys) {
+    if (process.env[key] !== value) {
+      updatedKeys.push(key);
+    }
+    process.env[key] = value;
+  }
+  if (!dotEnvReadFailed) {
+    dotEnvSourcedKeys.clear();
+    for (const key of newDotEnvKeys.keys()) {
+      dotEnvSourcedKeys.add(key);
+    }
+    lastReloadSnapshot.clear();
+    for (const [key, value] of newDotEnvKeys) {
+      lastReloadSnapshot.set(key, value);
+    }
+    for (const [key, value] of newSettingsEnvKeys) {
+      lastReloadSnapshot.set(key, value);
+    }
+  }
+  settingsEnvSourcedKeys.clear();
+  for (const key of newSettingsEnvKeys.keys()) {
+    settingsEnvSourcedKeys.add(key);
+  }
+  return { updatedKeys, removedKeys };
+}
+__name(reloadEnvironment, "reloadEnvironment");
+
+export {
+  SETTINGS_DIRECTORY_NAME,
+  preResolveHomeEnvOverrides,
+  resetHomeEnvBootstrapForTesting,
+  resetEnvironmentTrackingForTesting,
+  getHomeEnvFallbackVars,
+  findEnvFiles,
+  setUpCloudShellEnvironment,
+  buildRuntimeEnvironment,
+  loadEnvironment,
+  reloadEnvironment
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-7I4MGFBN.js → chunk-BUZ6HGL4.js}

@@ -23,7 +23,7 @@ import {
 } from "./chunk-OMX7CUOE.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-4KJ2BPIT.js";
+} from "./chunk-OACJLMLD.js";
 import {
   InstallationManager
 } from "./chunk-SUAKHHK7.js";
@@ -69870,11 +69870,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   let baseGenerator;
   try {
     if (authType === "openai" /* USE_OPENAI */) {
-      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-5LJ5A7YY.js");
+      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-YE42PKCY.js");
       baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
       const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-ZV7YLMND.js");
-      const { QwenContentGenerator } = await import("./qwenContentGenerator-E2JSB4FJ.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-NX2E7PB7.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -69892,10 +69892,10 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
         throw new Error(error instanceof Error ? error.message : String(error));
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
-      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-AKYPSZIV.js");
+      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-CPF22MA7.js");
       baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-WCH4GWD3.js");
+      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-CDUNEJQE.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(

package/chunks/{chunk-FK77ILF5.js → chunk-BVYU3ZTI.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-Y6Z2O3WR.js";
 import {
   getActiveGoal
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   ToolNames
 } from "./chunk-X3YGAX7V.js";
@@ -1603,7 +1603,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./src-NLEX4CUC.js");
+    const { getGitRepoName } = await import("./src-BBQSM46M.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;

package/chunks/{chunk-TBAZMRW3.js → chunk-CD6USWHZ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-2NPS2UDH.js";
+} from "./chunk-IBY3Q3HG.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-PVXPDMGP.js → chunk-CHB5SLZZ.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-KKWO4IX2.js";
+} from "./chunk-2EM7ECZD.js";
 import {
   parseAndFormatApiError
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-SJHAUELE.js → chunk-DCZWC4PF.js}

@@ -6,7 +6,7 @@ import {
 import {
   JsonFormatter,
   parseAndFormatApiError
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
@@ -15,7 +15,7 @@ import {
 } from "./chunk-22MNNNXE.js";
 import {
   runExitCleanup
-} from "./chunk-QCSLZO6J.js";
+} from "./chunk-JCH35JB3.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-YYU6H66M.js → chunk-DHOLNQLC.js}

@@ -1,14 +1,14 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  handleAtCommand
+} from "./chunk-RMLZAUWH.js";
 import {
   JsonOutputAdapter
-} from "./chunk-XQ2GVLNJ.js";
+} from "./chunk-EEN2TKST.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-PVXPDMGP.js";
-import {
-  handleAtCommand
-} from "./chunk-5OSSOBZC.js";
+} from "./chunk-CHB5SLZZ.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -20,10 +20,10 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-KKWO4IX2.js";
+} from "./chunk-2EM7ECZD.js";
 import {
   RunBudgetEnforcer
-} from "./chunk-YMWIKAEE.js";
+} from "./chunk-YDOXPLYL.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -31,10 +31,10 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-SJHAUELE.js";
+} from "./chunk-DCZWC4PF.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-KT3SI3CQ.js";
+} from "./chunk-DIWVZ3VM.js";
 import {
   ORPHAN_TOOL_USE_REPAIR_REASON,
   buildSyntheticToolResponseParts,
@@ -49,12 +49,12 @@ import {
   parseAndFormatApiError,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry,
   uiTelemetryService
-} from "./chunk-7I4MGFBN.js";
+} from "./chunk-BUZ6HGL4.js";
 import {
   ToolNames
 } from "./chunk-X3YGAX7V.js";

package/chunks/{chunk-MOQOAH7N.js → chunk-DICGXFAI.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-QYUE6W3T.js";
 import {
   ideContextStore
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   atomicWriteFileSync
 } from "./chunk-7LTB54MK.js";

package/chunks/{chunk-KT3SI3CQ.js → chunk-DIWVZ3VM.js}

@@ -4,14 +4,14 @@ import {
   resolveModelConfig,
   resolveProviderProtocol,
   stripRuntimeSnapshotPrefix
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-7I4MGFBN.js";
+} from "./chunk-BUZ6HGL4.js";
 import {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort
@@ -214,20 +214,20 @@ function buildIgnoredTopLevelGenerationConfigWarning(providerId, modelProvider,
   return `Warning: ${fieldList} ${verb} ignored for provider model "${modelProvider.id}" from modelProviders.${providerId}. Move ${fieldReference} to modelProviders.${providerId}[].generationConfig for that model if you want ${pronoun} to apply.`;
 }
 __name(buildIgnoredTopLevelGenerationConfigWarning, "buildIgnoredTopLevelGenerationConfigWarning");
-function getAuthTypeFromEnv() {
-  if (process.env["QWEN_OAUTH"]) {
+function getAuthTypeFromEnv(env = process.env) {
+  if (env["QWEN_OAUTH"]) {
     return "qwen-oauth" /* QWEN_OAUTH */;
   }
-  if (process.env["OPENAI_API_KEY"] && (process.env["OPENAI_MODEL"] || process.env["QWEN_MODEL"]) && process.env["OPENAI_BASE_URL"]) {
+  if (env["OPENAI_API_KEY"] && (env["OPENAI_MODEL"] || env["QWEN_MODEL"]) && env["OPENAI_BASE_URL"]) {
     return "openai" /* USE_OPENAI */;
   }
-  if (process.env["GEMINI_API_KEY"] && process.env["GEMINI_MODEL"]) {
+  if (env["GEMINI_API_KEY"] && env["GEMINI_MODEL"]) {
     return "gemini" /* USE_GEMINI */;
   }
-  if (process.env["GOOGLE_API_KEY"] && process.env["GOOGLE_MODEL"]) {
+  if (env["GOOGLE_API_KEY"] && env["GOOGLE_MODEL"]) {
     return "vertex-ai" /* USE_VERTEX_AI */;
   }
-  if (process.env["ANTHROPIC_API_KEY"] && process.env["ANTHROPIC_MODEL"] && process.env["ANTHROPIC_BASE_URL"]) {
+  if (env["ANTHROPIC_API_KEY"] && env["ANTHROPIC_MODEL"] && env["ANTHROPIC_BASE_URL"]) {
     return "anthropic" /* USE_ANTHROPIC */;
   }
   return void 0;

package/chunks/{chunk-2DYY5XUZ.js → chunk-E7EMCSUG.js}

@@ -24,7 +24,7 @@ import {
   ansi_regex_exports,
   init_ansi_regex,
   stripAnsi
-} from "./chunk-E7HM76PR.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   require_graceful_fs
 } from "./chunk-X2XNQQJI.js";