@qwen-code/qwen-code 0.23.2-preview.0 → 0.23.3-nightly.20260910.c46cb85cf2

package/chunks/{chunk-VF6D6EGV.js → chunk-UKMWZ5NS.js}

@@ -1,32 +1,5 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  DASHSCOPE_PROXY_BASE_URL,
-  DEFAULT_DASHSCOPE_BASE_URL,
-  DEFAULT_MAX_RETRIES,
-  REASONING_EFFORT_TIERS,
-  clampReasoningEffort,
-  resolveRequestTimeout
-} from "./chunk-6YEOCHSE.js";
-import {
-  buildSessionAwareFetch
-} from "./chunk-NOO4QFXM.js";
-import {
-  isQwenFamilyWireModel,
-  isTieredEffortWireModel
-} from "./chunk-XBVNNDPK.js";
-import {
-  defaultOutputCeiling,
-  hasExplicitOutputLimit,
-  parsePositiveIntegerEnvValue,
-  tokenLimit
-} from "./chunk-FPGTNKCP.js";
-import {
-  buildRuntimeFetchOptions
-} from "./chunk-4HOEU2OR.js";
-import {
-  createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -34,6 +7,9 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// node_modules/openai/index.mjs
+init_esbuild_shims();
+
 // node_modules/openai/client.mjs
 init_esbuild_shims();
 
@@ -6878,849 +6854,140 @@ OpenAI.Responses = Responses;
 OpenAI.Evals = Evals;
 OpenAI.Containers = Containers;
 
-// node_modules/openai/index.mjs
-init_esbuild_shims();
-
 // node_modules/openai/azure.mjs
 init_esbuild_shims();
-
-// packages/core/src/core/openaiContentGenerator/provider/default.ts
-init_esbuild_shims();
-var debugLogger = createDebugLogger("DefaultOpenAICompatibleProvider");
-var OPENAI_COMPATIBLE_EFFORTS = [
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-function isQwen3Model(model) {
-  return model.toLowerCase().includes("qwen3");
-}
-__name(isQwen3Model, "isQwen3Model");
-function mirrorReasoningContentToReasoning(message) {
-  if (message.role !== "assistant") {
-    return message;
-  }
-  const assistant = message;
-  if (typeof assistant.reasoning_content !== "string" || assistant.reasoning_content.length === 0 || typeof assistant.reasoning === "string") {
-    return message;
-  }
-  return {
-    ...assistant,
-    reasoning: assistant.reasoning_content
-  };
-}
-__name(mirrorReasoningContentToReasoning, "mirrorReasoningContentToReasoning");
-var DefaultOpenAICompatibleProvider = class {
-  static {
-    __name(this, "DefaultOpenAICompatibleProvider");
-  }
-  contentGeneratorConfig;
-  cliConfig;
-  /**
-   * Latch so an effort-clamp warning fires once per provider lifetime. Shared
-   * with subclasses that clamp on their own wire shape (see DashScope) so one
-   * provider instance never repeats the notice.
-   */
-  effortClampWarned = false;
-  constructor(contentGeneratorConfig, cliConfig) {
-    this.cliConfig = cliConfig;
-    this.contentGeneratorConfig = contentGeneratorConfig;
-  }
-  buildHeaders() {
-    const version = this.cliConfig.getCliVersion() || "unknown";
-    const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
-    const { customHeaders } = this.contentGeneratorConfig;
-    const defaultHeaders = {
-      "User-Agent": userAgent
-    };
-    return customHeaders ? { ...defaultHeaders, ...customHeaders } : defaultHeaders;
-  }
-  buildClient() {
-    const {
-      apiKey,
-      baseUrl,
-      maxRetries = DEFAULT_MAX_RETRIES
-    } = this.contentGeneratorConfig;
-    const timeout = resolveRequestTimeout(this.contentGeneratorConfig.timeout);
-    const defaultHeaders = this.buildHeaders();
-    const runtimeOptions = buildRuntimeFetchOptions(
-      "openai",
-      this.cliConfig.getProxy()
-    );
-    return new OpenAI({
-      apiKey,
-      baseURL: baseUrl,
-      timeout,
-      maxRetries,
-      defaultHeaders,
-      ...runtimeOptions || {},
-      fetch: buildSessionAwareFetch(
-        runtimeOptions?.fetch,
-        this.cliConfig,
-        this.contentGeneratorConfig.customHeaders
-      )
-    });
-  }
-  /**
-   * Effort tiers this endpoint accepts for `model`. Takes the wire model
-   * rather than reading the configured one, because a request may override it
-   * (`pipeline.ts` resolves `request.model || contentGeneratorConfig.model`),
-   * and a capability answered for the wrong model is how an unaccepted tier
-   * reaches the wire. Override in a subclass whose endpoint takes `max`; the
-   * clamp calls it through `this`, so a subclass answer applies even on the
-   * `super.buildRequest` path.
-   */
-  supportedReasoningEffortsFor(_model) {
-    return OPENAI_COMPATIBLE_EFFORTS;
-  }
-  /**
-   * Cap the pipeline-injected `reasoning.effort` at what this endpoint accepts.
-   * The tier is configured once (`/effort`) and persisted, so an unaccepted
-   * value is not a one-off rejection: it 400s every later request in the
-   * session too.
-   *
-   * Only the pipeline-injected tier is capped. A `reasoning` object the user
-   * put in `samplingParams` ships verbatim (the pipeline hands those keys
-   * straight to the wire and skips the injection entirely), and `extra_body`
-   * merges after this, so both explicit overrides survive unchanged.
-   */
-  clampConfiguredReasoningEffort(request) {
-    if (this.contentGeneratorConfig.samplingParams?.["reasoning"] !== void 0) {
-      return request;
-    }
-    const loose = request;
-    const reasoning = loose["reasoning"];
-    const effort = reasoning?.effort;
-    if (typeof effort !== "string" || !REASONING_EFFORT_TIERS.includes(effort)) {
-      return request;
-    }
-    const clamped = clampReasoningEffort(
-      effort,
-      this.supportedReasoningEffortsFor(
-        loose["model"] ?? this.contentGeneratorConfig.model
-      )
-    );
-    if (clamped === effort) {
-      return request;
-    }
-    if (!this.effortClampWarned) {
-      debugLogger.warn(
-        `reasoning.effort='${effort}' is not accepted by this OpenAI-compatible endpoint; using '${clamped}'.`
-      );
-      this.effortClampWarned = true;
-    }
-    return {
-      ...loose,
-      reasoning: { ...reasoning, effort: clamped }
-    };
-  }
-  buildRequest(request, _userPromptId) {
-    const extraBody = this.contentGeneratorConfig.extra_body;
-    const requestWithTokenLimits = this.clampConfiguredReasoningEffort(
-      this.applyOutputTokenLimit(request)
-    );
-    const messages = isQwen3Model(request.model) ? requestWithTokenLimits.messages.map(mirrorReasoningContentToReasoning) : requestWithTokenLimits.messages;
-    return {
-      ...requestWithTokenLimits,
-      messages,
-      ...extraBody ? extraBody : {}
-    };
-  }
-  getDefaultGenerationConfig() {
-    return {};
-  }
-  getResponseParsingOptions(model) {
-    return {
-      contentOnlyThinkingTagLeaks: true,
-      ...model && isQwen3Model(model) ? { taggedThinkingTagsAfterReasoning: true } : {}
-    };
-  }
-  /**
-   * Apply output token limit to a request's max_tokens parameter.
-   *
-   * Purpose:
-   * Some APIs (e.g., OpenAI-compatible) default to a very small max_tokens value,
-   * which can cause responses to be truncated mid-output. This function ensures
-   * a reasonable default is set while respecting user configuration.
-   *
-   * Logic:
-   * 1. If user explicitly configured max_tokens:
-   *    - For known models (in OUTPUT_PATTERNS): use the user's value, but cap at
-   *      model's max output limit to avoid API errors
-   *      (input + max_output > contextWindowSize would cause 400 errors on some APIs)
-   *    - For unknown models (deployment aliases, self-hosted): respect user's
-   *      configured value entirely (backend may support larger limits)
-   * 2. If user didn't configure max_tokens:
-   *    - Check QWEN_CODE_MAX_OUTPUT_TOKENS env var first
-   *    - Otherwise use the model's output limit, clipped to
-   *      OUTPUT_TOKEN_CEILING (64K)
-   * 3. If model has no specific limit (tokenLimit returns default):
-   *    - Use DEFAULT_OUTPUT_TOKEN_LIMIT
-   *
-   * Examples:
-   * - User sets 4K, known model limit 64K → uses 4K (respects user preference)
-   * - User sets 100K, known model limit 64K → uses 64K (capped to avoid API error)
-   * - User sets 100K, unknown model → uses 100K (respects user, backend may support it)
-   * - User not set, model limit 64K → uses 64K
-   * - User not set, model limit 4K → uses 4K (model limit is lower)
-   * - User not set, env QWEN_CODE_MAX_OUTPUT_TOKENS=16000 -> uses 16K
-   *
-   * @param request - The chat completion request parameters
-   * @returns The request with max_tokens adjusted according to the logic
-   */
-  applyOutputTokenLimit(request) {
-    if (this.contentGeneratorConfig.samplingParams !== void 0) {
-      return request;
-    }
-    const userMaxTokens = request.max_tokens;
-    const modelLimit = tokenLimit(request.model, "output");
-    const isKnownModel = hasExplicitOutputLimit(request.model);
-    let effectiveMaxTokens;
-    if (userMaxTokens !== void 0 && userMaxTokens !== null) {
-      if (isKnownModel) {
-        effectiveMaxTokens = Math.min(userMaxTokens, modelLimit);
-      } else {
-        effectiveMaxTokens = userMaxTokens;
-      }
-    } else {
-      const envMaxTokens = parsePositiveIntegerEnvValue(
-        process.env["QWEN_CODE_MAX_OUTPUT_TOKENS"]
-      );
-      if (envMaxTokens !== void 0) {
-        effectiveMaxTokens = isKnownModel ? Math.min(envMaxTokens, modelLimit) : envMaxTokens;
-      } else {
-        effectiveMaxTokens = defaultOutputCeiling(request.model);
-      }
-    }
-    return {
-      ...request,
-      max_tokens: effectiveMaxTokens
-    };
-  }
-};
-
-// packages/core/src/core/openaiContentGenerator/provider/dashscope.ts
-init_esbuild_shims();
-var debugLogger2 = createDebugLogger("DashScopeOpenAICompatibleProvider");
-var DASHSCOPE_TIERED_EFFORTS = [
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-function selectDashScopeThinkingKnob(model, extraBody, samplingParams, reasoningEffort) {
-  if (!isTieredEffortWireModel((model ?? "").toLowerCase())) {
-    return void 0;
-  }
-  const selectFromLayer = /* @__PURE__ */ __name((source, layer) => {
-    if (layer?.["enable_thinking"] === false) {
-      return { source, field: "enable_thinking", value: false };
-    }
-    return selectValueFromLayer(source, layer) ?? selectOnSwitch(source, layer);
-  }, "selectFromLayer");
-  const selectValueFromLayer = /* @__PURE__ */ __name((source, layer) => {
-    if (layer?.["reasoning_effort"] != null) {
-      return {
-        source,
-        field: "reasoning_effort",
-        value: layer["reasoning_effort"]
-      };
-    }
-    if (layer?.["thinking_budget"] != null) {
-      return {
-        source,
-        field: "thinking_budget",
-        value: layer["thinking_budget"]
-      };
-    }
-    return void 0;
-  }, "selectValueFromLayer");
-  const selectOnSwitch = /* @__PURE__ */ __name((source, layer) => {
-    if (layer?.["enable_thinking"] === true) {
-      return { source, field: "enable_thinking", value: true };
-    }
-    return void 0;
-  }, "selectOnSwitch");
-  const reasoningSelection = reasoningEffort !== void 0 ? {
-    source: "reasoning",
-    field: "reasoning_effort",
-    value: reasoningEffort
-  } : void 0;
-  const extraBodySelection = selectFromLayer("extra_body", extraBody);
-  if (extraBodySelection?.field === "enable_thinking" && extraBodySelection.value === true) {
-    return selectValueFromLayer("samplingParams", samplingParams) ?? reasoningSelection ?? extraBodySelection;
-  }
-  if (extraBodySelection) {
-    return extraBodySelection;
-  }
-  const samplingSelection = selectFromLayer("samplingParams", samplingParams);
-  return samplingSelection?.field === "enable_thinking" && samplingSelection.value === true ? reasoningSelection ?? samplingSelection : samplingSelection ?? reasoningSelection;
-}
-__name(selectDashScopeThinkingKnob, "selectDashScopeThinkingKnob");
-function withoutNullishThinkingKnobs(layer) {
-  if (!layer) {
-    return void 0;
-  }
-  const hasNullishEnableThinking = "enable_thinking" in layer && layer["enable_thinking"] == null;
-  const hasNullishEffort = "reasoning_effort" in layer && layer["reasoning_effort"] == null;
-  const hasNullishBudget = "thinking_budget" in layer && layer["thinking_budget"] == null;
-  if (!hasNullishEnableThinking && !hasNullishEffort && !hasNullishBudget) {
-    return layer;
-  }
-  const sanitized = { ...layer };
-  if (hasNullishEnableThinking) {
-    delete sanitized["enable_thinking"];
-  }
-  if (hasNullishEffort) {
-    delete sanitized["reasoning_effort"];
-  }
-  if (hasNullishBudget) {
-    delete sanitized["thinking_budget"];
-  }
-  return sanitized;
-}
-__name(withoutNullishThinkingKnobs, "withoutNullishThinkingKnobs");
-var DASHSCOPE_REGIONAL_HOSTS = [
-  "dashscope.aliyuncs.com",
-  "dashscope-intl.aliyuncs.com",
-  "dashscope-us.aliyuncs.com"
-];
-var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider extends DefaultOpenAICompatibleProvider {
+var AzureOpenAI = class extends OpenAI {
   static {
-    __name(this, "DashScopeOpenAICompatibleProvider");
-  }
-  constructor(contentGeneratorConfig, cliConfig) {
-    super(contentGeneratorConfig, cliConfig);
-  }
-  /**
-   * Determines whether to use the DashScope-compatible provider.
-   * Covers the official regional hosts (DASHSCOPE_REGIONAL_HOSTS),
-   * Token Plan endpoints under token-plan.<region>.maas.aliyuncs.com,
-   * internal Alibaba domains (*.alibaba-inc.com, *.aliyun-inc.com),
-   * Alibaba Cloud API Gateway domains (*.alicloudapi.com),
-   * and proxy matches.
-   *
-   * Note: any *.alibaba-inc.com / *.aliyun-inc.com host is treated as a
-   * DashScope-compatible endpoint by design. Keep this generic and avoid
-   * embedding individual private gateway hostnames in provider detection.
-   */
-  static isDashScopeProvider(contentGeneratorConfig) {
-    const { authType, baseUrl } = contentGeneratorConfig;
-    if (authType === "qwen-oauth" /* QWEN_OAUTH */) return true;
-    if (!baseUrl) return true;
-    const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-    let hostname = null;
-    try {
-      hostname = new URL(normalizedBaseUrl).hostname.toLowerCase();
-    } catch {
-      hostname = null;
-    }
-    const isDashscopeOrigin = hostname !== null && DASHSCOPE_REGIONAL_HOSTS.some(
-      (host) => hostname === host || hostname.endsWith("." + host)
-    );
-    const isTokenPlanOrigin = hostname !== null && hostname.startsWith("token-plan.") && hostname.endsWith(".maas.aliyuncs.com");
-    const isInternalOrigin = hostname !== null && (hostname.endsWith(".alibaba-inc.com") || hostname.endsWith(".aliyun-inc.com"));
-    const isAliCloudApiOrigin = hostname !== null && hostname.endsWith(".alicloudapi.com");
-    const normalizedProxyUrl = DASHSCOPE_PROXY_BASE_URL?.endsWith("/") ? DASHSCOPE_PROXY_BASE_URL.slice(0, -1) : DASHSCOPE_PROXY_BASE_URL;
-    const isProxyMatch = Boolean(
-      normalizedProxyUrl && normalizedBaseUrl.toLowerCase() === normalizedProxyUrl.toLowerCase()
-    );
-    if (normalizedProxyUrl && !isDashscopeOrigin && !isTokenPlanOrigin && !isInternalOrigin && !isAliCloudApiOrigin && !isProxyMatch) {
-      debugLogger2.debug(
-        `DASHSCOPE_PROXY_BASE_URL is configured but the request baseUrl does not match. DashScope headers/cache control will be skipped.`
-      );
-    }
-    if (isInternalOrigin) {
-      debugLogger2.debug(
-        `DashScope provider activated via internal origin: ${hostname}`
-      );
-    }
-    if (isAliCloudApiOrigin) {
-      debugLogger2.debug(
-        `DashScope provider activated via alicloudapi origin: ${hostname}`
-      );
-    }
-    return isDashscopeOrigin || isTokenPlanOrigin || isInternalOrigin || isAliCloudApiOrigin || isProxyMatch;
-  }
-  buildHeaders() {
-    const version = this.cliConfig.getCliVersion() || "unknown";
-    const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
-    const { authType, customHeaders } = this.contentGeneratorConfig;
-    const defaultHeaders = {
-      "User-Agent": userAgent,
-      "X-DashScope-CacheControl": "enable",
-      "X-DashScope-UserAgent": userAgent,
-      "X-DashScope-AuthType": authType
-    };
-    return customHeaders ? { ...defaultHeaders, ...customHeaders } : defaultHeaders;
-  }
-  buildClient() {
-    const {
-      apiKey,
-      baseUrl = DEFAULT_DASHSCOPE_BASE_URL,
-      maxRetries = DEFAULT_MAX_RETRIES
-    } = this.contentGeneratorConfig;
-    const timeout = resolveRequestTimeout(this.contentGeneratorConfig.timeout);
-    const defaultHeaders = this.buildHeaders();
-    const runtimeOptions = buildRuntimeFetchOptions(
-      "openai",
-      this.cliConfig.getProxy()
-    );
-    return new OpenAI({
-      apiKey,
-      baseURL: baseUrl,
-      timeout,
-      maxRetries,
-      defaultHeaders,
-      ...runtimeOptions || {},
-      fetch: buildSessionAwareFetch(
-        runtimeOptions?.fetch,
-        this.cliConfig,
-        this.contentGeneratorConfig.customHeaders
-      )
-    });
+    __name(this, "AzureOpenAI");
   }
   /**
-   * Build and configure the request for DashScope API.
+   * API Client for interfacing with the Azure OpenAI API.
    *
-   * This method applies DashScope-specific configurations including:
-   * - Cache control for the system message, last tool message (when tools are configured),
-   *   and the latest history message
-   * - Output token limits based on model capabilities
-   * - Vision model specific parameters (vl_high_resolution_images)
-   * - Request metadata for session tracking
-   *
-   * @param request - The original chat completion request parameters
-   * @param userPromptId - Unique identifier for the user prompt for session tracking
-   * @returns Configured request with DashScope-specific parameters applied
-   */
-  buildRequest(request, userPromptId) {
-    let messages = request.messages;
-    let tools = request.tools;
-    const flattenPlainTextForGlm = this.isGlmModel(request.model) && !this.hasFunctionCallingContext(request);
-    if (flattenPlainTextForGlm) {
-      messages = this.flattenTextContent(messages);
-    } else if (this.shouldEnableCacheControl()) {
-      const { messages: updatedMessages, tools: updatedTools } = this.addDashScopeCacheControl(
-        request,
-        request.stream ? "all" : "system_only"
-      );
-      messages = updatedMessages;
-      tools = updatedTools;
-    }
-    const requestWithTokenLimits = this.applyOutputTokenLimit(request);
-    const isTieredQwenModel = isTieredEffortWireModel(
-      this.resolveWireModel(request.model)
-    );
-    const extraBody = isTieredQwenModel ? withoutNullishThinkingKnobs(this.contentGeneratorConfig.extra_body) : this.contentGeneratorConfig.extra_body;
-    const qwenEffortConfig = this.buildQwenEffortConfig(request.model);
-    const rawRequestParams = requestWithTokenLimits;
-    const requestParams = isTieredQwenModel ? withoutNullishThinkingKnobs(rawRequestParams) : rawRequestParams;
-    if ("reasoning_effort" in requestParams && "reasoning_effort" in qwenEffortConfig) {
-      qwenEffortConfig["reasoning_effort"] = requestParams["reasoning_effort"];
-    }
-    const hasQwenEffortConfig = Object.keys(qwenEffortConfig).length > 0;
-    const selectedThinkingKnob = isTieredQwenModel ? selectDashScopeThinkingKnob(
-      this.resolveWireModel(request.model),
-      extraBody,
-      requestParams,
-      qwenEffortConfig["reasoning_effort"]
-    ) : void 0;
-    if (this.isVisionModel(request.model)) {
-      const dashscopeExtras2 = {
-        vl_high_resolution_images: true,
-        preserve_thinking: true,
-        ...qwenEffortConfig
-      };
-      const visionResult = {
-        ...requestParams,
-        messages,
-        ...tools ? { tools } : {},
-        ...this.buildMetadata(userPromptId) || {},
-        ...dashscopeExtras2
-      };
-      if (hasQwenEffortConfig && "reasoning" in visionResult) {
-        delete visionResult["reasoning"];
-      }
-      return this.mergeExtraBodyAndResolveKnobs(
-        hasQwenEffortConfig ? visionResult : this.clampConfiguredReasoningEffort(visionResult),
-        extraBody,
-        request.model,
-        selectedThinkingKnob
-      );
-    }
-    const dashscopeExtras = {
-      preserve_thinking: true,
-      ...qwenEffortConfig
-    };
-    const result = {
-      ...requestParams,
-      // Preserve all original parameters including sampling params and adjusted max_tokens
-      messages,
-      ...tools ? { tools } : {},
-      ...this.buildMetadata(userPromptId) || {},
-      ...dashscopeExtras
-    };
-    if (hasQwenEffortConfig && "reasoning" in result) {
-      delete result["reasoning"];
-    }
-    return this.mergeExtraBodyAndResolveKnobs(
-      hasQwenEffortConfig ? result : this.clampConfiguredReasoningEffort(result),
-      extraBody,
-      request.model,
-      selectedThinkingKnob
-    );
-  }
-  /**
-   * Shared tail for the vision and text branches: merge user extra_body
-   * last, then resolve thinking-knob conflicts against the wire model.
-   */
-  mergeExtraBodyAndResolveKnobs(result, extraBody, model, selectedThinkingKnob) {
-    const merged = {
-      ...result,
-      ...extraBody ? extraBody : {}
-    };
-    const reasoningEffort = merged["reasoning_effort"];
-    const dropped = /* @__PURE__ */ new Set();
-    if (selectedThinkingKnob?.field === "thinking_budget") {
-      if (reasoningEffort !== void 0) {
-        dropped.add("reasoning_effort");
-      }
-      if (merged["enable_thinking"] === false) {
-        dropped.add("enable_thinking");
-      }
-    }
-    if (selectedThinkingKnob?.field === "reasoning_effort" && merged["thinking_budget"] !== void 0) {
-      dropped.add("thinking_budget");
-    }
-    for (const key of dropped) {
-      delete merged[key];
-    }
-    for (const key of this.dropConflictingThinkingKnobs(
-      model,
-      merged,
-      selectedThinkingKnob
-    )) {
-      dropped.add(key);
-    }
-    this.warnConflictingKnobDrop(model, reasoningEffort, [...dropped]);
-    return merged;
-  }
-  resolveWireModel(model) {
-    return (model ?? this.contentGeneratorConfig.model ?? "").toLowerCase();
-  }
-  /**
-   * Translate the unified reasoning effort into the wire shape the model
-   * accepts. The qwen3.8-max family takes the tiered `reasoning_effort`
-   * directly; older qwen hybrid models expose only the on/off
-   * `enable_thinking` switch, so the effort ladder collapses to on/off
-   * there. Gated to qwen-family wire models (mirroring the pipeline's
-   * disable gate) so the qwen-specific fields never leak to a non-qwen
-   * model sharing the DashScope endpoint.
+   * @param {string | undefined} [opts.apiVersion=process.env['OPENAI_API_VERSION'] ?? undefined]
+   * @param {string | undefined} [opts.endpoint=process.env['AZURE_OPENAI_ENDPOINT'] ?? undefined] - Your Azure endpoint, including the resource, e.g. `https://example-resource.azure.openai.com/`
+   * @param {string | undefined} [opts.apiKey=process.env['AZURE_OPENAI_API_KEY'] ?? undefined]
+   * @param {string | undefined} opts.deployment - A model deployment, if given, sets the base client URL to include `/deployments/{deployment}`.
+   * @param {string | null | undefined} [opts.organization=process.env['OPENAI_ORG_ID'] ?? null]
+   * @param {string} [opts.baseURL=process.env['OPENAI_BASE_URL']] - Sets the base URL for the API, e.g. `https://example-resource.azure.openai.com/openai/`.
+   * @param {number} [opts.timeout=10 minutes] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+   * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
+   * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+   * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+   * @param {Headers} opts.defaultHeaders - Default headers to include with every request to the API.
+   * @param {DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
+   * @param {boolean} [opts.dangerouslyAllowBrowser=false] - By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
    */
-  buildQwenEffortConfig(model) {
-    const reasoning = this.contentGeneratorConfig.reasoning;
-    if (!reasoning || reasoning.effort === void 0) {
-      return {};
+  constructor({ baseURL = readEnv("OPENAI_BASE_URL"), apiKey = readEnv("AZURE_OPENAI_API_KEY"), apiVersion = readEnv("OPENAI_API_VERSION"), endpoint, deployment, azureADTokenProvider, dangerouslyAllowBrowser, ...opts } = {}) {
+    if (!apiVersion) {
+      throw new OpenAIError("The OPENAI_API_VERSION environment variable is missing or empty; either provide it, or instantiate the AzureOpenAI client with an apiVersion option, like new AzureOpenAI({ apiVersion: 'My API Version' }).");
     }
-    const wireModel = this.resolveWireModel(model);
-    if (isTieredEffortWireModel(wireModel)) {
-      return { reasoning_effort: this.clampTieredEffort(reasoning.effort) };
+    if (typeof azureADTokenProvider === "function") {
+      dangerouslyAllowBrowser = true;
     }
-    if (isQwenFamilyWireModel(wireModel)) {
-      return { enable_thinking: true };
+    if (!azureADTokenProvider && !apiKey) {
+      throw new OpenAIError("Missing credentials. Please pass one of `apiKey` and `azureADTokenProvider`, or set the `AZURE_OPENAI_API_KEY` environment variable.");
     }
-    return {};
-  }
-  /**
-   * Cap a configured tier at what the qwen3.8-max family actually accepts.
-   * This family does not take `max`, and the rejection is a 400 on every
-   * subsequent request rather than a one-off, so the tier is clamped to the
-   * strongest supported tier and reported once. Only the
-   * configured `reasoning.effort` passes through here: an explicit
-   * `extra_body` / `samplingParams` `reasoning_effort` is a documented
-   * verbatim override and is merged after this, so it still ships unchanged.
-   */
-  clampTieredEffort(effort) {
-    const clamped = clampReasoningEffort(effort, DASHSCOPE_TIERED_EFFORTS);
-    if (clamped !== effort && !this.effortClampWarned) {
-      debugLogger2.warn(
-        `reasoning.effort='${effort}' is not accepted by the DashScope tiered-effort family; using '${clamped}'.`
-      );
-      this.effortClampWarned = true;
-    }
-    return clamped;
-  }
-  /**
-   * Resolve thinking knobs that conflict with a shipping `reasoning_effort`.
-   * Preset extra_body injects `enable_thinking` for models declared with
-   * enableThinking (provider-config.ts), and user extra_body merges last.
-   * Only the qwen3.8-max family reads `reasoning_effort` itself — there an
-   * effort tier ships alone: an `enable_thinking: true` alongside an effort
-   * tier is a second competing knob (the shape the nested-`reasoning` strip
-   * in buildRequest exists to prevent), and DashScope rejects
-   * `reasoning_effort` combined with `thinking_budget`. The `'none'`
-   * disable and a winning `thinking_budget` intentionally keep a co-present
-   * `enable_thinking: true`. Explicit same-layer effort/budget pairs retain
-   * reasoning_effort, matching the provider's behavior before cross-layer
-   * resolution. An explicit `enable_thinking: false` is the documented
-   * extra_body escape hatch winning over the config tier, so it is honoured
-   * as the family's canonical disable (`reasoning_effort: 'none'`, preserved
-   * by the pipeline's disable strip) rather than silently deleted; a
-   * higher-priority `enable_thinking: true` conversely keeps the shipping
-   * tier. Older qwen
-   * hybrids read `enable_thinking` / `thinking_budget`, not
-   * `reasoning_effort`, so when an opaque reasoning_effort override
-   * conflicts with a meaningful thinking_budget the inert field goes and
-   * the knobs the model reads survive. Non-qwen models treat
-   * `reasoning_effort` as an opaque sampling override and keep every knob.
-   */
-  dropConflictingThinkingKnobs(model, merged, selectedThinkingKnob) {
-    const wireModel = this.resolveWireModel(model);
-    if (!isQwenFamilyWireModel(wireModel)) {
-      return [];
+    if (azureADTokenProvider && apiKey) {
+      throw new OpenAIError("The `apiKey` and `azureADTokenProvider` arguments are mutually exclusive; only one can be passed at a time.");
     }
-    const isTieredEffortModel = isTieredEffortWireModel(wireModel);
-    if (isTieredEffortModel && selectedThinkingKnob?.field === "enable_thinking" && selectedThinkingKnob.value === false) {
-      merged["reasoning_effort"] = "none";
-      const dropped = ["enable_thinking"];
-      if (merged["thinking_budget"] !== void 0) {
-        dropped.push("thinking_budget");
+    apiKey ?? (apiKey = API_KEY_SENTINEL);
+    opts.defaultQuery = { ...opts.defaultQuery, "api-version": apiVersion };
+    if (!baseURL) {
+      if (!endpoint) {
+        endpoint = process.env["AZURE_OPENAI_ENDPOINT"];
       }
-      for (const key of dropped) {
-        delete merged[key];
+      if (!endpoint) {
+        throw new OpenAIError("Must provide one of the `baseURL` or `endpoint` arguments, or the `AZURE_OPENAI_ENDPOINT` environment variable");
       }
-      return dropped;
-    }
-    const effort = merged["reasoning_effort"];
-    if (typeof effort !== "string") {
-      return [];
-    }
-    if (isTieredEffortModel && effort === "none") {
-      if (merged["thinking_budget"] === void 0) {
-        return [];
-      }
-      delete merged["thinking_budget"];
-      return ["thinking_budget"];
-    }
-    if (isTieredEffortModel) {
-      if (selectedThinkingKnob?.field === "reasoning_effort" && "enable_thinking" in merged) {
-        delete merged["enable_thinking"];
-        return ["enable_thinking"];
+      baseURL = `${endpoint}/openai`;
+    } else {
+      if (endpoint) {
+        throw new OpenAIError("baseURL and endpoint are mutually exclusive");
       }
-      return [];
-    }
-    if (merged["thinking_budget"] === void 0) {
-      return [];
-    }
-    delete merged["reasoning_effort"];
-    return ["reasoning_effort"];
-  }
-  warnConflictingKnobDrop(model, reasoningEffort, dropped) {
-    if (dropped.length === 0) {
-      return;
-    }
-    if (!this.conflictingKnobDropWarned) {
-      this.conflictingKnobDropWarned = true;
-      debugLogger2.warn("DashScope: dropped conflicting thinking knobs", {
-        model: this.resolveWireModel(model),
-        reasoningEffort,
-        dropped
-      });
     }
+    super({
+      apiKey,
+      baseURL,
+      ...opts,
+      ...dangerouslyAllowBrowser !== void 0 ? { dangerouslyAllowBrowser } : {}
+    });
+    this.apiVersion = "";
+    this._azureADTokenProvider = azureADTokenProvider;
+    this.apiVersion = apiVersion;
+    this.deploymentName = deployment;
   }
-  conflictingKnobDropWarned = false;
-  buildMetadata(userPromptId) {
-    const channel = this.cliConfig.getChannel?.();
-    return {
-      metadata: {
-        sessionId: this.cliConfig.getSessionId?.(),
-        promptId: userPromptId,
-        ...channel ? { channel } : {}
+  async buildRequest(options, props = {}) {
+    if (_deployments_endpoints.has(options.path) && options.method === "post" && options.body !== void 0) {
+      if (!isObj(options.body)) {
+        throw new Error("Expected request body to be an object");
       }
-    };
-  }
-  getDefaultGenerationConfig() {
-    return {};
-  }
-  /**
-   * Add cache control flag to specified message(s) for DashScope providers
-   */
-  addDashScopeCacheControl(request, cacheControl) {
-    const messages = request.messages;
-    const systemIndex = messages.findIndex((msg) => msg.role === "system");
-    const lastIndex = messages.length - 1;
-    const updatedMessages = messages.length === 0 ? messages : messages.map((message, index) => {
-      const shouldAddCacheControl = Boolean(
-        index === systemIndex && systemIndex !== -1 || index === lastIndex && cacheControl === "all"
-      );
-      if (!shouldAddCacheControl || !("content" in message) || message.content === null || message.content === void 0) {
-        return message;
+      const model = this.deploymentName || options.body["model"] || options.__metadata?.["model"];
+      if (model !== void 0 && !this.baseURL.includes("/deployments")) {
+        options.path = `/deployments/${model}${options.path}`;
       }
-      return {
-        ...message,
-        content: this.addCacheControlToContent(message.content)
-      };
-    });
-    const updatedTools = cacheControl === "all" && request.tools?.length ? this.addCacheControlToTools(request.tools) : request.tools;
-    return {
-      messages: updatedMessages,
-      tools: updatedTools
-    };
-  }
-  addCacheControlToTools(tools) {
-    if (tools.length === 0) {
-      return tools;
-    }
-    const updatedTools = [...tools];
-    const lastToolIndex = tools.length - 1;
-    updatedTools[lastToolIndex] = {
-      ...updatedTools[lastToolIndex],
-      cache_control: { type: "ephemeral" }
-    };
-    return updatedTools;
-  }
-  /**
-   * Add cache control to message content, handling both string and array formats
-   */
-  addCacheControlToContent(content) {
-    const contentArray = this.normalizeContentToArray(content);
-    return this.addCacheControlToContentArray(contentArray);
-  }
-  /**
-   * Normalize content to array format
-   */
-  normalizeContentToArray(content) {
-    if (typeof content === "string") {
-      return [
-        {
-          type: "text",
-          text: content
-        }
-      ];
     }
-    return [...content];
+    return super.buildRequest(options, props);
   }
-  /**
-   * Add cache control to the content array
-   */
-  addCacheControlToContentArray(contentArray) {
-    if (contentArray.length === 0) {
-      return contentArray;
-    }
-    const lastItem = contentArray[contentArray.length - 1];
-    contentArray[contentArray.length - 1] = {
-      ...lastItem,
-      cache_control: { type: "ephemeral" }
-    };
-    return contentArray;
-  }
-  /**
-   * True for glm-* models (e.g. glm-4.5, glm-5.2). Uses the same `^glm-` prefix
-   * convention as the GLM matchers in tokenLimits.ts, keeping model detection
-   * consistent across the codebase.
-   */
-  isGlmModel(model) {
-    return !!model && model.toLowerCase().startsWith("glm-");
-  }
-  /**
-   * Whether the request is in "function-calling mode" — it declares `tools`, or
-   * its history already contains a tool result / assistant tool_call. glm needs
-   * one of these present to parse structured content-part arrays.
-   */
-  hasFunctionCallingContext(request) {
-    if (request.tools && request.tools.length > 0) {
-      return true;
-    }
-    return request.messages.some((message) => {
-      if (message.role === "tool") {
-        return true;
-      }
-      if (message.role === "assistant") {
-        const toolCalls = message.tool_calls;
-        return Array.isArray(toolCalls) && toolCalls.length > 0;
+  async _getAzureADToken() {
+    if (typeof this._azureADTokenProvider === "function") {
+      const token = await this._azureADTokenProvider();
+      if (!token || typeof token !== "string") {
+        throw new OpenAIError(`Expected 'azureADTokenProvider' argument to return a string but it returned ${token}`);
       }
-      return false;
-    });
+      return token;
+    }
+    return void 0;
   }
-  /**
-   * Collapse text-only content arrays back to a plain string, leaving
-   * media-bearing parts (image/audio/...) as arrays. Used for glm tool-less
-   * requests, where the array form would otherwise be dropped server-side.
-   * Multiple text parts are joined with a blank line, matching the DeepSeek
-   * provider's flattening (separate parts read as separate blocks).
-   * Only called on the flatten branch, which skips cache control, so no part
-   * here carries a `cache_control` marker.
-   */
-  flattenTextContent(messages) {
-    return messages.map((message) => {
-      if (!("content" in message) || !Array.isArray(message.content)) {
-        return message;
-      }
-      const parts = message.content;
-      if (parts.length === 0) {
-        return message;
-      }
-      const isTextOnly = parts.every((part) => part && part.type === "text");
-      if (!isTextOnly) {
-        return message;
-      }
-      const text = parts.map((part) => part.text ?? "").join("\n\n");
-      return {
-        ...message,
-        content: text
-      };
-    });
+  async authHeaders(opts) {
+    return;
   }
-  /**
-   * Vision-capable model patterns.
-   * Supports exact matches and prefix patterns for easy extension.
-   */
-  static VISION_MODEL_EXACT_MATCHES = /* @__PURE__ */ new Set(["coder-model"]);
-  static VISION_MODEL_PREFIX_PATTERNS = [
-    "qwen-vl",
-    // qwen-vl-max, qwen-vl-max-latest, etc.
-    "qwen3-vl-plus",
-    // qwen3-vl-plus variants
-    "qwen3.5-plus",
-    // qwen3.5-plus (has built-in vision capabilities)
-    "qwen3.6-plus",
-    // qwen3.6-plus (multimodal)
-    "qwen3.7-plus"
-    // qwen3.7-plus (multimodal)
-  ];
-  isVisionModel(model) {
-    if (!model) {
-      return false;
+  async prepareOptions(opts) {
+    opts.headers = buildHeaders([opts.headers]);
+    if (opts.headers.values.get("Authorization") || opts.headers.values.get("api-key")) {
+      return super.prepareOptions(opts);
     }
-    const normalized = model.toLowerCase();
-    if (_DashScopeOpenAICompatibleProvider.VISION_MODEL_EXACT_MATCHES.has(
-      normalized
-    )) {
-      return true;
-    }
-    for (const prefix of _DashScopeOpenAICompatibleProvider.VISION_MODEL_PREFIX_PATTERNS) {
-      if (normalized.startsWith(prefix)) {
-        return true;
-      }
+    const token = await this._getAzureADToken();
+    if (token) {
+      opts.headers.values.set("Authorization", `Bearer ${token}`);
+    } else if (this.apiKey !== API_KEY_SENTINEL) {
+      opts.headers.values.set("api-key", this.apiKey);
+    } else {
+      throw new OpenAIError("Unable to handle auth");
     }
-    return false;
-  }
-  /**
-   * Check if cache control should be disabled based on configuration.
-   *
-   * @returns true if cache control should be enabled, false otherwise
-   */
-  shouldEnableCacheControl() {
-    return this.cliConfig.getContentGeneratorConfig()?.enableCacheControl !== false;
+    return super.prepareOptions(opts);
   }
 };
+var _deployments_endpoints = /* @__PURE__ */ new Set([
+  "/completions",
+  "/chat/completions",
+  "/embeddings",
+  "/audio/transcriptions",
+  "/audio/translations",
+  "/audio/speech",
+  "/images/generations",
+  "/batches",
+  "/images/edits"
+]);
+var API_KEY_SENTINEL = "<Missing Key>";
 
 export {
+  OpenAIError,
+  APIError,
+  APIUserAbortError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  BadRequestError,
+  AuthenticationError,
+  PermissionDeniedError,
+  NotFoundError,
+  ConflictError,
+  UnprocessableEntityError,
+  RateLimitError,
+  InternalServerError,
+  InvalidWebhookSignatureError,
+  APIPromise,
+  PagePromise,
+  toFile,
   OpenAI,
-  DefaultOpenAICompatibleProvider,
-  selectDashScopeThinkingKnob,
-  DASHSCOPE_REGIONAL_HOSTS,
-  DashScopeOpenAICompatibleProvider
+  AzureOpenAI
 };