@qwen-code/qwen-code 0.22.2-preview.1 → 0.22.3

package/chunks/chunk-U54AYGEC.js

@@ -0,0 +1,337 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/conversation-directory-identity.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import { lstat, mkdir, realpath } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+function hasVerifiableInode(ino) {
+  return Number(ino) !== 0;
+}
+__name(hasVerifiableInode, "hasVerifiableInode");
+var ConversationDirectoryIdentityError = class extends Error {
+  constructor(scope, reason, cause) {
+    super(
+      `Conversation ${scope} identity validation failed: ${reason}`,
+      cause !== void 0 ? { cause } : void 0
+    );
+    this.scope = scope;
+    this.reason = reason;
+  }
+  static {
+    __name(this, "ConversationDirectoryIdentityError");
+  }
+  name = "ConversationDirectoryIdentityError";
+};
+function throwIdentityIoError(scope, cause) {
+  throw new ConversationDirectoryIdentityError(scope, "io_error", cause);
+}
+__name(throwIdentityIoError, "throwIdentityIoError");
+var isSameConversationPath = /* @__PURE__ */ __name((left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right, "isSameConversationPath");
+function getConversationDirectoryName(storageSessionId) {
+  if (storageSessionId.length === 0 || storageSessionId.length > 256) {
+    throw new ConversationDirectoryIdentityError("child", "invalid_session_id");
+  }
+  return `conversation-${createHash("sha256").update(storageSessionId).digest("hex")}`;
+}
+__name(getConversationDirectoryName, "getConversationDirectoryName");
+function getConversationStagedDirectoryName(storageSessionId) {
+  return `${getConversationDirectoryName(storageSessionId)}.deleting`;
+}
+__name(getConversationStagedDirectoryName, "getConversationStagedDirectoryName");
+function validateDirectoryStats(stats, scope) {
+  if (stats.isSymbolicLink() || !stats.isDirectory()) {
+    throw new ConversationDirectoryIdentityError(scope, "not_directory");
+  }
+  if (process.platform !== "win32" && typeof process.getuid === "function" && stats.uid !== process.getuid()) {
+    throw new ConversationDirectoryIdentityError(scope, "wrong_owner");
+  }
+  if (process.platform !== "win32" && (stats.mode & 63) !== 0) {
+    throw new ConversationDirectoryIdentityError(scope, "wrong_mode");
+  }
+}
+__name(validateDirectoryStats, "validateDirectoryStats");
+function hasRootIdentity(stats, root) {
+  if (!root.inodeVerifiable) return stats.dev === root.device;
+  return hasVerifiableInode(stats.ino) && stats.dev === root.device && stats.ino === root.inode;
+}
+__name(hasRootIdentity, "hasRootIdentity");
+function isSameDirectoryIdentity(before, after) {
+  if (!hasVerifiableInode(before.ino) || !hasVerifiableInode(after.ino)) {
+    return before.dev === after.dev;
+  }
+  return before.dev === after.dev && before.ino === after.ino;
+}
+__name(isSameDirectoryIdentity, "isSameDirectoryIdentity");
+function hasExpectedDirectoryIdentity(identity, expected) {
+  const identityInodeVerifiable = hasVerifiableInode(identity.inode);
+  const expectedInodeVerifiable = hasVerifiableInode(expected.inode);
+  return identity.storageSessionId === expected.storageSessionId && identity.name === expected.name && isSameConversationPath(identity.canonicalPath, expected.canonicalPath) && identity.device === expected.device && identityInodeVerifiable === expectedInodeVerifiable && (!identityInodeVerifiable || identity.inode === expected.inode) && isSameConversationPath(
+    identity.root.configuredRoot,
+    expected.root.configuredRoot
+  ) && isSameConversationPath(
+    identity.root.canonicalRoot,
+    expected.root.canonicalRoot
+  ) && identity.root.device === expected.root.device && identity.root.inodeVerifiable === expected.root.inodeVerifiable && (!identity.root.inodeVerifiable || identity.root.inode === expected.root.inode);
+}
+__name(hasExpectedDirectoryIdentity, "hasExpectedDirectoryIdentity");
+async function createConversationRootIdentity(configuredRoot) {
+  try {
+    await mkdir(configuredRoot, { recursive: true, mode: 448 });
+  } catch (error) {
+    let existing;
+    try {
+      existing = await lstat(configuredRoot);
+    } catch {
+      throwIdentityIoError("root", error);
+    }
+    validateDirectoryStats(existing, "root");
+    throwIdentityIoError("root", error);
+  }
+  let before;
+  try {
+    before = await lstat(configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(before, "root");
+  let canonicalRoot;
+  let after;
+  try {
+    canonicalRoot = await realpath(configuredRoot);
+    after = await lstat(canonicalRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(after, "root");
+  if (!isSameDirectoryIdentity(before, after)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  return {
+    configuredRoot,
+    canonicalRoot,
+    device: after.dev,
+    inode: after.ino,
+    inodeVerifiable: hasVerifiableInode(after.ino)
+  };
+}
+__name(createConversationRootIdentity, "createConversationRootIdentity");
+async function revalidateConversationRootIdentity(root) {
+  let configuredStats;
+  try {
+    configuredStats = await lstat(root.configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(configuredStats, "root");
+  if (!hasRootIdentity(configuredStats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  let canonical;
+  try {
+    canonical = await realpath(root.configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  if (!isSameConversationPath(canonical, root.canonicalRoot)) {
+    throw new ConversationDirectoryIdentityError(
+      "root",
+      "canonical_path_changed"
+    );
+  }
+  let canonicalStats;
+  try {
+    canonicalStats = await lstat(root.canonicalRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(canonicalStats, "root");
+  if (!hasRootIdentity(canonicalStats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  return root;
+}
+__name(revalidateConversationRootIdentity, "revalidateConversationRootIdentity");
+async function assertExactConversationRootIdentity(root, candidate) {
+  await revalidateConversationRootIdentity(root);
+  const resolvedCandidate = resolve(candidate);
+  if (!isSameConversationPath(resolvedCandidate, root.configuredRoot) && !isSameConversationPath(resolvedCandidate, root.canonicalRoot)) {
+    throw new ConversationDirectoryIdentityError("root", "unexpected_identity");
+  }
+  let stats;
+  let canonical;
+  try {
+    stats = await lstat(resolvedCandidate);
+    validateDirectoryStats(stats, "root");
+    canonical = await realpath(resolvedCandidate);
+  } catch (error) {
+    if (error instanceof ConversationDirectoryIdentityError) throw error;
+    throwIdentityIoError("root", error);
+  }
+  if (!isSameConversationPath(canonical, root.canonicalRoot) || !hasRootIdentity(stats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "unexpected_identity");
+  }
+  return root;
+}
+__name(assertExactConversationRootIdentity, "assertExactConversationRootIdentity");
+async function inspectConversationNamedDirectoryIdentity(root, storageSessionId, name, expected) {
+  await revalidateConversationRootIdentity(root);
+  const candidate = join(root.canonicalRoot, name);
+  let before;
+  try {
+    before = await lstat(candidate);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throwIdentityIoError("child", error);
+  }
+  validateDirectoryStats(before, "child");
+  let canonical;
+  let after;
+  try {
+    canonical = await realpath(candidate);
+    after = await lstat(canonical);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throwIdentityIoError("child", error);
+  }
+  validateDirectoryStats(after, "child");
+  const child = relative(root.canonicalRoot, canonical);
+  if (child !== name || child.includes(sep) || child.startsWith("..") || isAbsolute(child)) {
+    throw new ConversationDirectoryIdentityError("child", "not_direct_child");
+  }
+  if (!isSameDirectoryIdentity(before, after)) {
+    throw new ConversationDirectoryIdentityError("child", "identity_changed");
+  }
+  await revalidateConversationRootIdentity(root);
+  const identity = {
+    root,
+    storageSessionId,
+    name,
+    canonicalPath: canonical,
+    device: after.dev,
+    inode: after.ino
+  };
+  if (expected && !hasExpectedDirectoryIdentity(identity, expected)) {
+    throw new ConversationDirectoryIdentityError(
+      "child",
+      "unexpected_identity"
+    );
+  }
+  return identity;
+}
+__name(inspectConversationNamedDirectoryIdentity, "inspectConversationNamedDirectoryIdentity");
+async function inspectConversationDirectoryIdentity(root, storageSessionId, expected) {
+  return inspectConversationNamedDirectoryIdentity(
+    root,
+    storageSessionId,
+    getConversationDirectoryName(storageSessionId),
+    expected
+  );
+}
+__name(inspectConversationDirectoryIdentity, "inspectConversationDirectoryIdentity");
+async function inspectConversationStagedDirectoryIdentity(root, storageSessionId) {
+  return inspectConversationNamedDirectoryIdentity(
+    root,
+    storageSessionId,
+    getConversationStagedDirectoryName(storageSessionId)
+  );
+}
+__name(inspectConversationStagedDirectoryIdentity, "inspectConversationStagedDirectoryIdentity");
+function isSameConversationDirectoryObject(identity, expected) {
+  const identityInodeVerifiable = hasVerifiableInode(identity.inode);
+  const expectedInodeVerifiable = hasVerifiableInode(expected.inode);
+  return identity.storageSessionId === expected.storageSessionId && identity.device === expected.device && identityInodeVerifiable === expectedInodeVerifiable && (!identityInodeVerifiable || identity.inode === expected.inode) && isSameConversationPath(
+    identity.root.canonicalRoot,
+    expected.root.canonicalRoot
+  ) && identity.root.device === expected.root.device && identity.root.inodeVerifiable === expected.root.inodeVerifiable && (!identity.root.inodeVerifiable || identity.root.inode === expected.root.inode);
+}
+__name(isSameConversationDirectoryObject, "isSameConversationDirectoryObject");
+async function materializeConversationDirectoryIdentity(root, storageSessionId) {
+  await revalidateConversationRootIdentity(root);
+  const name = getConversationDirectoryName(storageSessionId);
+  const candidate = join(root.canonicalRoot, name);
+  let created = false;
+  try {
+    await mkdir(candidate, { mode: 448 });
+    created = true;
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throwIdentityIoError("child", error);
+    }
+  }
+  const identity = await inspectConversationDirectoryIdentity(
+    root,
+    storageSessionId
+  );
+  if (!identity) {
+    throw new ConversationDirectoryIdentityError("child", "identity_changed");
+  }
+  return { identity, created };
+}
+__name(materializeConversationDirectoryIdentity, "materializeConversationDirectoryIdentity");
+
+// packages/core/dist/src/services/tool-write-origin.js
+init_esbuild_shims();
+var TOOL_WRITE_ORIGIN_META_KEY = "qwen-code/tool-write-origin";
+var TOOL_WRITE_ORIGINS = [
+  "write_file",
+  "edit",
+  "notebook_edit",
+  "shell_sed_edit"
+];
+var TOOL_WRITE_ORIGIN_SET = new Set(TOOL_WRITE_ORIGINS);
+function buildToolWriteOriginMeta(meta, source) {
+  const sanitized = { ...meta };
+  delete sanitized[TOOL_WRITE_ORIGIN_META_KEY];
+  if (source !== void 0) {
+    sanitized[TOOL_WRITE_ORIGIN_META_KEY] = { version: 1, source };
+  }
+  return Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+__name(buildToolWriteOriginMeta, "buildToolWriteOriginMeta");
+function parseToolWriteOriginMeta(meta) {
+  const marker = meta?.[TOOL_WRITE_ORIGIN_META_KEY];
+  if (typeof marker !== "object" || marker === null || Array.isArray(marker)) {
+    return void 0;
+  }
+  const keys = Object.keys(marker);
+  if (keys.length !== 2 || !Object.hasOwn(marker, "version") || !Object.hasOwn(marker, "source")) {
+    return void 0;
+  }
+  const record = marker;
+  return record["version"] === 1 && typeof record["source"] === "string" && TOOL_WRITE_ORIGIN_SET.has(record["source"]) ? record["source"] : void 0;
+}
+__name(parseToolWriteOriginMeta, "parseToolWriteOriginMeta");
+
+export {
+  buildToolWriteOriginMeta,
+  parseToolWriteOriginMeta,
+  ConversationDirectoryIdentityError,
+  isSameConversationPath,
+  getConversationDirectoryName,
+  getConversationStagedDirectoryName,
+  createConversationRootIdentity,
+  revalidateConversationRootIdentity,
+  assertExactConversationRootIdentity,
+  inspectConversationDirectoryIdentity,
+  inspectConversationStagedDirectoryIdentity,
+  isSameConversationDirectoryObject,
+  materializeConversationDirectoryIdentity
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-2NNTE2ED.js → chunk-UHQFIS7N.js}

@@ -1108,6 +1108,21 @@ var Storage = class _Storage {
   getWorkflowRunsDir() {
     return path2.join(this.getProjectDir(), "workflows");
   }
+  /**
+   * Generated-workflow scripts directory: `<projectDir>/workflows/generated`.
+   * A trusted root for `Workflow({scriptPath})` / `workflow({scriptPath})`
+   * that is NOT a saved-workflow scope: scripts here are never listed as
+   * `/<name>` slash commands and cannot be reached by `workflow('<name>')`.
+   * It exists for tooling that emits a script for one run (a CLI subcommand
+   * generating a fan-out for the model to dispatch) — such a script has no
+   * business in the user's command namespace, and the runtime dir keeps it
+   * out of the project tree. Layout below the root is the writer's; the
+   * loader trusts the whole subtree. A subprocess reaches it as
+   * `$QWEN_CODE_PROJECT_DIR/workflows/generated`.
+   */
+  getGeneratedWorkflowsDir() {
+    return path2.join(this.getWorkflowRunsDir(), "generated");
+  }
   /**
    * Path to the persisted snapshot of a completed workflow run.
    */

package/chunks/{chunk-76WGY6LW.js → chunk-URE3QBBB.js}

@@ -5,14 +5,14 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-2MHGD7EE.js";
+} from "./chunk-A3LWD5MK.js";
 import {
   resolvePath
-} from "./chunk-2SERYG4T.js";
+} from "./chunk-YTDVNSUQ.js";
 import {
   createDebugLogger,
   isSubpath
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-KOJ6MHD5.js → chunk-UTLCH2FK.js}

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

package/chunks/{chunk-7DPKPBOQ.js → chunk-V2NDP3I4.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   isGitRepository
-} from "./chunk-DEYPMJPD.js";
+} from "./chunk-SMPR7SPO.js";
 import {
   createDebugLogger
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-FJWICLG7.js → chunk-V4264FEG.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -716,7 +716,7 @@ function anthropicTools(value) {
   return result;
 }
 __name(anthropicTools, "anthropicTools");
-function geminiTools(value) {
+function llmTools(value) {
   if (!Array.isArray(value)) return void 0;
   const result = [];
   for (const wrapper of value) {
@@ -734,7 +734,7 @@ function geminiTools(value) {
   }
   return result;
 }
-__name(geminiTools, "geminiTools");
+__name(llmTools, "llmTools");
 function extractOpenAiContent(request) {
   const value = request;
   return {
@@ -756,7 +756,7 @@ function extractAnthropicContent(request) {
   };
 }
 __name(extractAnthropicContent, "extractAnthropicContent");
-function extractGeminiContent(request) {
+function extractLlmContent(request) {
   const value = request;
   const config = record(value["config"]);
   return {
@@ -766,10 +766,10 @@ function extractGeminiContent(request) {
       (role) => role === "model" ? "assistant" : role
     ) : void 0,
     systemInstructions: config && Object.hasOwn(config, "systemInstruction") ? systemParts(config["systemInstruction"], geminiPart) : void 0,
-    toolDefinitions: config && Object.hasOwn(config, "tools") ? geminiTools(config["tools"]) : void 0
+    toolDefinitions: config && Object.hasOwn(config, "tools") ? llmTools(config["tools"]) : void 0
   };
 }
-__name(extractGeminiContent, "extractGeminiContent");
+__name(extractLlmContent, "extractLlmContent");
 function stringifyGenAiJson(value, maxLength, requireObject = false) {
   const converted = jsonValue(value);
   if (converted === void 0 || requireObject && (converted === null || Array.isArray(converted) || typeof converted !== "object")) {
@@ -1032,7 +1032,7 @@ var GenAiOutputAccumulator = class {
       if (finishReason) candidate.finishReason = finishReason;
     }
   }
-  recordGeminiResponse(response) {
+  recordLlmResponse(response) {
     const candidates = response["candidates"];
     if (!Array.isArray(candidates)) return;
     this.observedResponse = true;
@@ -1061,7 +1061,7 @@ var GenAiOutputAccumulator = class {
       if (finishReason) outputCandidate.finishReason = finishReason;
     }
   }
-  recordGeminiChunk(chunk) {
+  recordLlmChunk(chunk) {
     const candidates = chunk["candidates"];
     if (!Array.isArray(candidates)) return;
     this.observedResponse = true;
@@ -1241,7 +1241,7 @@ var GenAiOutputAccumulator = class {
 export {
   extractOpenAiContent,
   extractAnthropicContent,
-  extractGeminiContent,
+  extractLlmContent,
   stringifyGenAiJson,
   GenAiOutputAccumulator
 };

package/chunks/{chunk-XR7OIAQF.js → chunk-V5J4J5TP.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   getCurrentAgentId
-} from "./chunk-U45D46O5.js";
+} from "./chunk-CMHFCLBU.js";
 import {
   getTeammateContext,
   isTeammate
 } from "./chunk-S6LOFUVP.js";
 import {
   ToolNames
-} from "./chunk-KOJ6MHD5.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7UJTY5V3.js → chunk-V7EESTJV.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   parseRule
-} from "./chunk-XIRDDFRS.js";
+} from "./chunk-PZ66FRIC.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-Z6L3C4VF.js → chunk-VBCPNIQD.js}

@@ -7,10 +7,10 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-BQBUZDDH.js";
+} from "./chunk-DJECZIJX.js";
 import {
   safeJsonParse
-} from "./chunk-E4I5MVBR.js";
+} from "./chunk-ABS25QER.js";
 import {
   runtimeDiagnostics
 } from "./chunk-VNOVK4I7.js";
@@ -18,18 +18,22 @@ import {
   reportOpenAiChunk,
   reportOpenAiRequest,
   reportOpenAiResponse
-} from "./chunk-5T4LWWNX.js";
+} from "./chunk-KYWTPLBJ.js";
 import {
   applyOfficialOpenAIPromptCaching,
   isOfficialOpenAIEndpoint
-} from "./chunk-SAH4BD2J.js";
+} from "./chunk-PQEISIKS.js";
 import {
   DashScopeOpenAICompatibleProvider,
   DefaultOpenAICompatibleProvider
-} from "./chunk-ZKAZP2ZG.js";
+} from "./chunk-EB6QRGHM.js";
 import {
   getCurrentAgentId
-} from "./chunk-U45D46O5.js";
+} from "./chunk-CMHFCLBU.js";
+import {
+  InvalidStreamError,
+  getToolCallPreparations
+} from "./chunk-CFKIH3D3.js";
 import {
   DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   DEFAULT_STREAM_MAX_LIFETIME_MS,
@@ -42,39 +46,33 @@ import {
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
 import {
+  getRateLimitErrorDetails,
   getTransportCode
-} from "./chunk-I6VVOZDK.js";
-import {
-  InvalidStreamError,
-  getToolCallPreparations
-} from "./chunk-CFKIH3D3.js";
-import {
-  getRateLimitErrorDetails
-} from "./chunk-EB4VDXNI.js";
+} from "./chunk-DYXFD5RO.js";
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-OF2DPXUS.js";
+} from "./chunk-QYMAKPY5.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
-} from "./chunk-YRLW2MSX.js";
+} from "./chunk-XBVNNDPK.js";
 import {
   reconcileMaxTokens
 } from "./chunk-FPGTNKCP.js";
 import {
   redactProxyError
-} from "./chunk-GTUKW3I6.js";
+} from "./chunk-PPKZ7JOE.js";
 import {
   isInForkExecution
-} from "./chunk-7OBH4AM2.js";
+} from "./chunk-CAJTKR6W.js";
 import {
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   getErrorType,
   isAbortError
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   GenerateContentResponse
 } from "./chunk-64REQJJ2.js";
@@ -190,16 +188,17 @@ var DeepSeekOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProv
     return isDeepSeekHostname(this.contentGeneratorConfig) ? REASONING_EFFORT_TIERS : super.supportedReasoningEffortsFor(model);
   }
   /**
-   * DeepSeek's API requires message content to be a plain string, not an
-   * array of content parts. Flatten any text-part arrays into joined
-   * strings; non-text parts (image_url, audio, …) are replaced with a
-   * `[Unsupported content type: <type>]` placeholder so the request still
-   * goes through with a textual breadcrumb rather than silently dropping
-   * the part or raising mid-conversation. Also translate the standard
-   * `reasoning.effort` config into DeepSeek's flat `reasoning_effort`
-   * body parameter — but only on actual DeepSeek hostnames, since the
-   * model-name fallback above can match self-hosted/strict OpenAI-compat
-   * backends that don't accept the DeepSeek extension.
+   * Text-only DeepSeek APIs require message content to be a plain string, not
+   * an array of content parts. Flatten text-only request arrays into joined
+   * strings; non-text parts (image_url, audio, …) are replaced with an
+   * `[Unsupported content type: <type>]` placeholder so the request still goes
+   * through with a textual breadcrumb rather than silently dropping the part
+   * or raising mid-conversation. Models that explicitly declare image input
+   * retain multipart content for compatible gateways. Also translate the
+   * standard `reasoning.effort` config into DeepSeek's flat `reasoning_effort`
+   * body parameter — but only on actual DeepSeek hostnames, since the model-name
+   * fallback above can match self-hosted/strict OpenAI-compat backends that
+   * don't accept the DeepSeek extension.
    */
   buildRequest(request, userPromptId) {
     const baseRequest = super.buildRequest(request, userPromptId);
@@ -207,10 +206,11 @@ var DeepSeekOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProv
     if (!reshaped.messages?.length) {
       return reshaped;
     }
-    const messages = reshaped.messages.map((message) => {
-      const flattened = flattenContentParts(message);
-      return ensureReasoningContentOnAssistantMessage(flattened);
-    });
+    const messages = reshaped.messages.map(
+      (message) => ensureReasoningContentOnAssistantMessage(
+        this.contentGeneratorConfig.modalities?.image ? message : flattenContentParts(message)
+      )
+    );
     return {
       ...reshaped,
       messages
@@ -1061,7 +1061,7 @@ var StreamContentError = class extends Error {
 var StreamInactivityTimeoutError = class extends Error {
   constructor(idleMs, chunksReceived, streamLifetimeMs) {
     super(
-      `No stream activity for ${idleMs}ms after ${chunksReceived} chunks (stream lifetime: ${streamLifetimeMs}ms). Set ${QWEN_STREAM_IDLE_TIMEOUT_MS_ENV} to increase this window (or 0 to disable it).`
+      `No stream activity for ${idleMs}ms after ${chunksReceived} chunks (stream lifetime: ${streamLifetimeMs}ms). For provider-backed models, increase modelProviders[providerId][].generationConfig.streamIdleTimeoutMs; provider configuration takes precedence, so model.generationConfig is ignored for those models. For runtime models, increase model.generationConfig.streamIdleTimeoutMs. Built-in Qwen OAuth models cannot be overridden via settings. Use ${QWEN_STREAM_IDLE_TIMEOUT_MS_ENV} for them or whenever no explicit value is active. Set the active value to 0 to disable it.`
     );
     this.idleMs = idleMs;
     this.chunksReceived = chunksReceived;
@@ -1299,11 +1299,11 @@ var ContentGenerationPipeline = class {
             }
           );
           reportOpenAiResponse(telemetryAttempt, openaiResponse);
-          const geminiResponse = OpenAIContentConverter.convertOpenAIResponseToGemini(
+          const llmResponse = OpenAIContentConverter.convertOpenAIResponseToLlm(
             openaiResponse,
             context
           );
-          return geminiResponse;
+          return llmResponse;
         } finally {
           perRequestAc?.abort();
         }
@@ -1424,7 +1424,7 @@ var ContentGenerationPipeline = class {
           const errorContent = chunk.choices?.[0]?.delta?.content?.trim() || "Unknown stream error";
           throw new StreamContentError(errorContent);
         }
-        const response = OpenAIContentConverter.convertOpenAIChunkToGemini(
+        const response = OpenAIContentConverter.convertOpenAIChunkToLlm(
           chunk,
           context
         );
@@ -1583,7 +1583,7 @@ var ContentGenerationPipeline = class {
     return true;
   }
   async buildRequest(request, userPromptId, context, isStreaming) {
-    const messages = OpenAIContentConverter.convertGeminiRequestToOpenAI(
+    const messages = OpenAIContentConverter.convertLlmRequestToOpenAI(
       request,
       context
     );
@@ -1600,7 +1600,7 @@ var ContentGenerationPipeline = class {
       baseRequest.stream = false;
     }
     if (request.config?.tools && request.config.tools.length > 0) {
-      baseRequest.tools = await OpenAIContentConverter.convertGeminiToolsToOpenAI(
+      baseRequest.tools = await OpenAIContentConverter.convertLlmToolsToOpenAI(
         request.config.tools,
         this.contentGeneratorConfig.schemaCompliance ?? "auto"
       );