@qwen-code/qwen-code 0.23.3 → 0.23.4-nightly.20260914.f024b37689

package/chunks/chunk-INGBUYL6.js

@@ -0,0 +1,230 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  external_exports
+} from "./chunk-CQ35AJ4Z.js";
+import {
+  AuthType
+} from "./chunk-ERU3SDXT.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/acpModelUtils.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+var ACP_ROUTE_ID_PREFIX = "qwen-route:v1:";
+function publicProviderBaseUrl(baseUrl) {
+  if (!/^https?:\/\//i.test(baseUrl.trim())) return void 0;
+  try {
+    const url = new URL(baseUrl);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.href;
+  } catch {
+    return void 0;
+  }
+}
+__name(publicProviderBaseUrl, "publicProviderBaseUrl");
+function getRouteEndpointIdentity(baseUrl) {
+  if (!baseUrl) return null;
+  try {
+    const url = new URL(baseUrl);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.href;
+  } catch {
+    return sanitizeProviderBaseUrl(baseUrl).split(/[?#]/, 1)[0] ?? null;
+  }
+}
+__name(getRouteEndpointIdentity, "getRouteEndpointIdentity");
+function formatAcpModelId(modelId, authType) {
+  return `${modelId}(${authType})`;
+}
+__name(formatAcpModelId, "formatAcpModelId");
+function buildAcpModelOptions(models) {
+  const candidates = models.filter(
+    (model) => model.fastOnly !== true && model.voiceOnly !== true && model.imageOnly !== true
+  ).map((model) => {
+    const effectiveModelId = model.isRuntimeModel && model.runtimeSnapshotId ? model.runtimeSnapshotId : model.id;
+    return {
+      model,
+      effectiveModelId,
+      legacyModelId: formatAcpModelId(effectiveModelId, model.authType)
+    };
+  });
+  const counts = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    counts.set(
+      candidate.legacyModelId,
+      (counts.get(candidate.legacyModelId) ?? 0) + 1
+    );
+  }
+  const discriminators = /* @__PURE__ */ new Set();
+  return candidates.map(({ model, effectiveModelId, legacyModelId }) => {
+    const discriminator = [
+      legacyModelId,
+      model.label,
+      model.envKey ?? null,
+      model.registryBaseUrl === void 0,
+      getRouteEndpointIdentity(model.registryBaseUrl ?? model.baseUrl)
+    ];
+    const discriminatorKey = JSON.stringify(discriminator);
+    if (counts.get(legacyModelId) !== 1 && discriminators.has(discriminatorKey)) {
+      throw new Error(
+        `ACP model routes for "${legacyModelId}" need distinct names, envKey values, or public endpoints.`
+      );
+    }
+    discriminators.add(discriminatorKey);
+    return {
+      model,
+      effectiveModelId,
+      modelId: counts.get(legacyModelId) === 1 ? legacyModelId : `${ACP_ROUTE_ID_PREFIX}${createHash("sha256").update(discriminatorKey).digest("base64url").slice(0, 16)}`
+    };
+  });
+}
+__name(buildAcpModelOptions, "buildAcpModelOptions");
+function resolveAcpModelOption(input, models) {
+  const matched = buildAcpModelOptions(models).find(
+    (option) => option.modelId === input.trim()
+  );
+  if (!matched) return null;
+  return {
+    modelId: matched.effectiveModelId,
+    authType: matched.model.authType,
+    ...matched.model.registryBaseUrl !== void 0 ? { baseUrl: matched.model.registryBaseUrl } : {},
+    ...!matched.model.isRuntimeModel ? { registryBaseUrl: matched.model.registryBaseUrl ?? null } : {},
+    isRuntime: matched.model.isRuntimeModel === true
+  };
+}
+__name(resolveAcpModelOption, "resolveAcpModelOption");
+function getCurrentAcpModelId(options, modelId, authType, registryBaseUrl) {
+  if (!modelId || !authType) return modelId;
+  const matching = options.filter(
+    (option) => option.effectiveModelId === modelId && option.model.authType === authType
+  );
+  if (matching[0]?.model.isRuntimeModel) return matching[0].modelId;
+  if (registryBaseUrl !== void 0) {
+    const exact = matching.find(
+      (option) => (option.model.registryBaseUrl ?? null) === registryBaseUrl
+    );
+    return exact?.modelId ?? modelId;
+  }
+  return matching.length === 1 ? matching[0].modelId : formatAcpModelId(modelId, authType);
+}
+__name(getCurrentAcpModelId, "getCurrentAcpModelId");
+function sanitizeProviderBaseUrl(baseUrl) {
+  const scheme = baseUrl.match(/^[A-Za-z][A-Za-z\d+.-]*:\/\//);
+  if (!scheme) {
+    return baseUrl;
+  }
+  const authorityStart = scheme[0].length;
+  const stripAt = /* @__PURE__ */ __name((at) => `${baseUrl.slice(0, authorityStart)}${baseUrl.slice(at + 1)}`, "stripAt");
+  const authorityEnd = findAuthorityEnd(baseUrl, authorityStart);
+  const authorityAt = baseUrl.slice(authorityStart, authorityEnd).lastIndexOf("@");
+  const authorityAtIndex = authorityAt === -1 ? -1 : authorityStart + authorityAt;
+  try {
+    const parsed = new URL(baseUrl);
+    if (parsed.username || parsed.password) {
+      return authorityAtIndex >= authorityStart ? stripAt(authorityAtIndex) : baseUrl;
+    }
+    return baseUrl;
+  } catch {
+    if (authorityAtIndex >= authorityStart) {
+      return stripAt(authorityAtIndex);
+    }
+    const fallbackAt = findUnescapedUserInfoFallbackAt(
+      baseUrl,
+      authorityStart,
+      authorityEnd
+    );
+    return fallbackAt === -1 ? baseUrl : stripAt(fallbackAt);
+  }
+}
+__name(sanitizeProviderBaseUrl, "sanitizeProviderBaseUrl");
+function findUnescapedUserInfoFallbackAt(baseUrl, authorityStart, authorityEnd) {
+  const at = baseUrl.lastIndexOf("@");
+  if (at < authorityStart || authorityEnd >= at) {
+    return -1;
+  }
+  const colon = baseUrl.indexOf(":", authorityStart);
+  if (colon === -1 || colon > authorityEnd) {
+    return -1;
+  }
+  const portCandidate = baseUrl.slice(colon + 1, authorityEnd);
+  return /^\d+$/.test(portCandidate) ? -1 : at;
+}
+__name(findUnescapedUserInfoFallbackAt, "findUnescapedUserInfoFallbackAt");
+function findAuthorityEnd(baseUrl, authorityStart) {
+  const slash = baseUrl.indexOf("/", authorityStart);
+  const query = baseUrl.indexOf("?", authorityStart);
+  const hash = baseUrl.indexOf("#", authorityStart);
+  let end = baseUrl.length;
+  if (slash !== -1) end = Math.min(end, slash);
+  if (query !== -1) end = Math.min(end, query);
+  if (hash !== -1) end = Math.min(end, hash);
+  return end;
+}
+__name(findAuthorityEnd, "findAuthorityEnd");
+function parseAcpBaseModelId(value) {
+  const trimmed = value.trim();
+  const closeIdx = trimmed.lastIndexOf(")");
+  const openIdx = trimmed.lastIndexOf("(");
+  if (openIdx >= 0 && closeIdx === trimmed.length - 1 && openIdx < closeIdx) {
+    return trimmed.slice(0, openIdx);
+  }
+  return trimmed;
+}
+__name(parseAcpBaseModelId, "parseAcpBaseModelId");
+function parseAcpModelOption(input) {
+  const trimmed = input.trim();
+  const closeIdx = trimmed.lastIndexOf(")");
+  const openIdx = trimmed.lastIndexOf("(");
+  if (openIdx >= 0 && closeIdx === trimmed.length - 1 && openIdx < closeIdx) {
+    const maybeModelId = trimmed.slice(0, openIdx);
+    const maybeAuthType = trimmed.slice(openIdx + 1, closeIdx);
+    const parsedAuthType = external_exports.nativeEnum(AuthType).safeParse(maybeAuthType);
+    if (parsedAuthType.success) {
+      return { modelId: maybeModelId, authType: parsedAuthType.data };
+    }
+  }
+  return { modelId: trimmed };
+}
+__name(parseAcpModelOption, "parseAcpModelOption");
+function isInlineModelOverrideAllowed(config, modelId) {
+  const contentGeneratorConfig = config.getContentGeneratorConfig();
+  const authType = contentGeneratorConfig?.authType;
+  if (!authType) {
+    return false;
+  }
+  const activeBaseUrl = contentGeneratorConfig.baseUrl;
+  const activeEnvKey = contentGeneratorConfig.apiKeyEnvKey;
+  return config.getAvailableModelsForAuthType(authType).filter((m) => !m.fastOnly && !m.voiceOnly && !m.imageOnly).some(
+    (m) => m.id === modelId && (m.baseUrl ?? void 0) === (activeBaseUrl ?? void 0) && (m.envKey ?? void 0) === (activeEnvKey ?? void 0)
+  );
+}
+__name(isInlineModelOverrideAllowed, "isInlineModelOverrideAllowed");
+
+export {
+  ACP_ROUTE_ID_PREFIX,
+  publicProviderBaseUrl,
+  buildAcpModelOptions,
+  resolveAcpModelOption,
+  getCurrentAcpModelId,
+  sanitizeProviderBaseUrl,
+  parseAcpBaseModelId,
+  parseAcpModelOption,
+  isInlineModelOverrideAllowed
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-7ICHPMBQ.js → chunk-IVUKJRSD.js}

@@ -2,18 +2,18 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-DYFOSJHU.js";
+} from "./chunk-LCYVZFMV.js";
 import {
   assembleMcpServers,
   getPendingGatedMcpServers,
   getPromptableMcpServers
-} from "./chunk-2ZN3O5FT.js";
+} from "./chunk-YAC6S4ZF.js";
 import {
   getMCPServerStatus
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-DQLYJFK2.js";
 import {
   require_fast_deep_equal
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";

package/chunks/{chunk-NRXWJXJ4.js → chunk-IYSXQ5I4.js}

@@ -1,33 +1,33 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  MAX_CHILD_HEAP_MB,
-  MIN_CHILD_HEAP_MB,
-  recommendedChildShareMb
-} from "./chunk-UXEO7E3V.js";
+  formatHostForAuthority,
+  isLoopbackBind
+} from "./chunk-DMEUXLSS.js";
 import {
   CLIENT_ID_RE,
   MAX_CLIENT_ID_LENGTH
 } from "./chunk-LAUEEBDL.js";
-import {
-  isPreAuthWebShellRequest
-} from "./chunk-SVWWF5TZ.js";
-import {
-  formatHostForAuthority,
-  isLoopbackBind
-} from "./chunk-DMEUXLSS.js";
 import {
   isInternalWorkspaceRuntime
 } from "./chunk-NYWWQ437.js";
+import {
+  isPreAuthWebShellRequest
+} from "./chunk-SVWWF5TZ.js";
 import {
   conversationRuntimeUnavailableError
-} from "./chunk-2Z3T52OC.js";
+} from "./chunk-Y5TM7SBV.js";
 import {
-  CLIENT_MCP_OVER_WS_CONFIG_FLAG
-} from "./chunk-PSPAM24S.js";
+  MAX_CHILD_HEAP_MB,
+  MIN_CHILD_HEAP_MB,
+  recommendedChildShareMb
+} from "./chunk-LYD3T3H7.js";
 import {
   MAX_REGISTERED_WORKSPACES
-} from "./chunk-SBRX4BDI.js";
+} from "./chunk-74NZLSCZ.js";
+import {
+  CLIENT_MCP_OVER_WS_CONFIG_FLAG
+} from "./chunk-TBSCTWKF.js";
 import {
   parseToolWriteOriginMeta
 } from "./chunk-GELRJXE2.js";

package/chunks/{chunk-XGYHNWL3.js → chunk-J7LBAKDH.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
-} from "./chunk-PSPAM24S.js";
+} from "./chunk-TBSCTWKF.js";
 import {
   SessionNotFoundError
 } from "./chunk-FAWTMDX7.js";
 import {
   ChannelWorkerStartupError
-} from "./chunk-EDMXGXAK.js";
+} from "./chunk-IBRQG2MP.js";
 import {
   ChannelWebhookEnqueueError
 } from "./chunk-STUJ7IMZ.js";
@@ -20,7 +20,7 @@ import {
 } from "./chunk-CJ3DHN5I.js";
 import {
   CHANNEL_LOOP_MCP_SERVER_NAME
-} from "./chunk-7QYWGTHB.js";
+} from "./chunk-EPVEPTI3.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-3BTSSIJO.js → chunk-JDKY7O5J.js}

@@ -4,22 +4,23 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-MOS5OAOG.js";
+} from "./chunk-SROLVJFY.js";
 import {
   applyOfficialOpenAIPromptCaching,
-  isOfficialOpenAIEndpoint
-} from "./chunk-SAH4BD2J.js";
+  isOfficialOpenAIEndpoint,
+  trailingReattachPartCount
+} from "./chunk-WFNEY5G7.js";
 import {
   DashScopeOpenAICompatibleProvider,
   DefaultOpenAICompatibleProvider,
   isOpenRouterHostname
-} from "./chunk-CXTPVBFA.js";
+} from "./chunk-GSS4SZNG.js";
 import {
   getCurrentAgentId
-} from "./chunk-U7O65WKL.js";
+} from "./chunk-BW2SMO6L.js";
 import {
   isInForkExecution
-} from "./chunk-FN3JNDRU.js";
+} from "./chunk-VVI7MK3V.js";
 import {
   extractTextFromContents
 } from "./chunk-AYEJOTIU.js";
@@ -36,8 +37,9 @@ import {
 } from "./chunk-VNOVK4I7.js";
 import {
   InvalidStreamError,
-  getToolCallPreparations
-} from "./chunk-CFKIH3D3.js";
+  getToolCallPreparations,
+  markFlushedToolCallPark
+} from "./chunk-S7UQ3V2H.js";
 import {
   safeJsonParse
 } from "./chunk-GSKX53AN.js";
@@ -47,7 +49,7 @@ import {
 import {
   getRateLimitErrorDetails,
   getTransportCode
-} from "./chunk-4ALNJDHL.js";
+} from "./chunk-ZKIAGIGH.js";
 import {
   reportOpenAiChunk,
   reportOpenAiRequest,
@@ -56,17 +58,17 @@ import {
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-DQLYJFK2.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
-} from "./chunk-ZHKTKHMO.js";
+} from "./chunk-7MIBD3LG.js";
 import {
   REASONING_EFFORT_TIERS,
   getGptReasoningCapabilities,
   isReasoningEffortPlaceholder,
   parseModelReasoningCapabilities
-} from "./chunk-3FPYT6QC.js";
+} from "./chunk-ARDHE6MM.js";
 import {
   reconcileMaxTokens
 } from "./chunk-FPGTNKCP.js";
@@ -476,6 +478,49 @@ var CerebrasOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProv
   }
 };
 
+// packages/core/src/core/openaiContentGenerator/provider/fireworks.ts
+init_esbuild_shims();
+var FIREWORKS_API_HOST = "api.fireworks.ai";
+function isFireworksProvider(config) {
+  const baseUrl = config.baseUrl ?? "";
+  if (!baseUrl) return false;
+  try {
+    const hostname = new URL(baseUrl).hostname.toLowerCase();
+    return hostname === FIREWORKS_API_HOST || hostname.endsWith(`.${FIREWORKS_API_HOST}`);
+  } catch {
+    return false;
+  }
+}
+__name(isFireworksProvider, "isFireworksProvider");
+var FireworksOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProvider {
+  static {
+    __name(this, "FireworksOpenAICompatibleProvider");
+  }
+  static isFireworksProvider = isFireworksProvider;
+  buildRequest(request, userPromptId) {
+    const baseRequest = super.buildRequest(request, userPromptId);
+    return {
+      ...baseRequest,
+      messages: baseRequest.messages.map(unmirrorReasoningField)
+    };
+  }
+};
+function unmirrorReasoningField(message) {
+  if (message.role !== "assistant") {
+    return message;
+  }
+  const assistant = message;
+  if (assistant.reasoning !== assistant.reasoning_content) {
+    return message;
+  }
+  if (typeof assistant.reasoning !== "string") {
+    return message;
+  }
+  const { reasoning: _drop, ...rest } = assistant;
+  return rest;
+}
+__name(unmirrorReasoningField, "unmirrorReasoningField");
+
 // packages/core/src/core/openaiContentGenerator/provider/mimo.ts
 init_esbuild_shims();
 function isMiMoProvider(contentGeneratorConfig) {
@@ -1118,6 +1163,14 @@ function isSSECompatibleContentType(contentType) {
   return mediaType === "text/event-stream" || mediaType === "application/x-ndjson" || mediaType === "application/stream+json";
 }
 __name(isSSECompatibleContentType, "isSSECompatibleContentType");
+function hasNonThoughtCandidateParts(response) {
+  return Boolean(
+    response.candidates?.some(
+      (candidate) => candidate.content?.parts?.some((part) => !part.thought)
+    )
+  );
+}
+__name(hasNonThoughtCandidateParts, "hasNonThoughtCandidateParts");
 var NonSSEResponseError = class extends Error {
   constructor(contentType, httpStatus, bodyPrefix, requestId) {
     const preview = bodyPrefix.length > 0 ? ` Body prefix: ${bodyPrefix}` : "";
@@ -1293,6 +1346,7 @@ var ContentGenerationPipeline = class {
   async *processStreamWithLogging(stream, context, request, userPromptId, telemetryAttempt) {
     let pendingFinishResponse = null;
     let finishYielded = false;
+    let contentYielded = request.continuationInFlight === true;
     let pendingFinishProtocolTagSanitized;
     const logPendingProtocolTagSanitized = /* @__PURE__ */ __name((response, sanitization) => {
       if (!sanitization) return;
@@ -1364,9 +1418,10 @@ var ContentGenerationPipeline = class {
               pendingFinishResponse,
               pendingFinishProtocolTagSanitized
             );
-            yield pendingFinishResponse;
             finishYielded = true;
+            yield pendingFinishResponse;
           } else {
+            contentYielded ||= hasNonThoughtCandidateParts(response);
             logPendingProtocolTagSanitized(response, sanitization);
             yield response;
           }
@@ -1384,6 +1439,7 @@ var ContentGenerationPipeline = class {
               index: 0
             }
           ];
+          contentYielded ||= hasNonThoughtCandidateParts(response);
           yield response;
         }
       } else if (context.pendingThinkingTagCandidate || context.responseParsingOptions?.taggedThinkingTagsAfterReasoning && context.taggedThinkingParser?.hasUnclosedThought()) {
@@ -1397,12 +1453,33 @@ var ContentGenerationPipeline = class {
           pendingFinishResponse,
           pendingFinishProtocolTagSanitized
         );
+        finishYielded = true;
         yield pendingFinishResponse;
       }
     } catch (error) {
       if (error instanceof InvalidStreamError) {
         throw error;
       }
+      const parked = pendingFinishResponse;
+      const parkedHasToolCall = parked?.candidates?.some(
+        (candidate) => candidate.content?.parts?.some((part) => part.functionCall)
+      );
+      if (pendingFinishResponse && !finishYielded && // A cancellation is not a stream failure to recover from: synthesising
+      // a delivery here hands the consumer a finish it was never shown, and
+      // cancellation persistence keeps whatever the consumer received.
+      // Spelled exactly as the PROTOCOL_TAG_LEAK branch below spells it, so
+      // one catch does not hold two notions of "aborted".
+      request.config?.abortSignal?.aborted !== true && (!parkedHasToolCall || contentYielded)) {
+        logPendingProtocolTagSanitized(
+          pendingFinishResponse,
+          pendingFinishProtocolTagSanitized
+        );
+        if (parkedHasToolCall) {
+          markFlushedToolCallPark(pendingFinishResponse);
+        }
+        yield pendingFinishResponse;
+        finishYielded = true;
+      }
       if (error instanceof StreamContentError) {
         throw redactProxyError(error);
       }
@@ -1528,7 +1605,8 @@ var ContentGenerationPipeline = class {
     }
     let providerRequest = this.config.provider.buildRequest(
       baseRequest,
-      userPromptId
+      userPromptId,
+      trailingReattachPartCount(request.contents)
     );
     if (this.contentGeneratorConfig.enableCacheControl !== false && isOfficialOpenAIEndpoint(this.contentGeneratorConfig)) {
       providerRequest = applyOfficialOpenAIPromptCaching(
@@ -2018,6 +2096,12 @@ function determineProvider(contentGeneratorConfig, cliConfig) {
       cliConfig
     );
   }
+  if (FireworksOpenAICompatibleProvider.isFireworksProvider(config)) {
+    return new FireworksOpenAICompatibleProvider(
+      contentGeneratorConfig,
+      cliConfig
+    );
+  }
   return new DefaultOpenAICompatibleProvider(contentGeneratorConfig, cliConfig);
 }
 __name(determineProvider, "determineProvider");
@@ -2027,6 +2111,7 @@ export {
   MiniMaxOpenAICompatibleProvider,
   MistralOpenAICompatibleProvider,
   CerebrasOpenAICompatibleProvider,
+  FireworksOpenAICompatibleProvider,
   MiMoOpenAICompatibleProvider,
   ContentGenerationPipeline,
   EnhancedErrorHandler,