@qwen-code/qwen-code 0.16.0-preview.0 → 0.16.1

package/chunks/{chunk-EDYSNFEM.js → chunk-L5E26RN6.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   ToolNames
-} from "./chunk-FZIUV27X.js";
+} from "./chunk-PVVL5Q3W.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -85,7 +85,7 @@ async function checkPriorRead(cache, filePath, verb, options = {}) {
   }
   if (status.state === "fresh" && status.entry.lastReadAt !== void 0 && !status.entry.lastReadCacheable) {
     const verbBare2 = verb === "editing" ? "edit" : "overwrite";
-    const raw2 = `File ${filePath} is a binary / image / audio / video / PDF / notebook payload that the ${ToolNames.READ_FILE} tool returns as a structured value rather than as plain text. The Edit / WriteFile tools cannot mutate that payload safely \u2014 re-reading it would not change this. Use a different mechanism (e.g. shell tool with a binary-aware writer) if you need to ${verbBare2} it.`;
+    const raw2 = `File ${filePath} is a binary / image / audio / video / PDF / notebook payload that the ${ToolNames.READ_FILE} tool returns as a structured value rather than as plain text. The Edit / WriteFile tools cannot mutate that payload safely \u2014 re-reading it would not change this. If this is a Jupyter notebook (.ipynb), use the ${ToolNames.NOTEBOOK_EDIT} tool for cell-level edits after reading it. For other non-text files, use a different mechanism (e.g. shell tool with an appropriate writer) if you need to ${verbBare2} it.`;
     return {
       ok: false,
       type: "edit_requires_prior_read" /* EDIT_REQUIRES_PRIOR_READ */,

package/chunks/{chunk-CW44BRRA.js → chunk-MAY32HXD.js}

@@ -10,6 +10,371 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// packages/core/src/utils/runtimeDiagnostics.ts
+init_esbuild_shims();
+var RUNTIME_PROFILE_ENV = "QWEN_CODE_PROFILE_RUNTIME";
+function isRuntimeDiagnosticsEnabled(env = process.env) {
+  return env[RUNTIME_PROFILE_ENV] === "1";
+}
+__name(isRuntimeDiagnosticsEnabled, "isRuntimeDiagnosticsEnabled");
+var RuntimeDiagnosticsCollector = class {
+  static {
+    __name(this, "RuntimeDiagnosticsCollector");
+  }
+  enabled;
+  now;
+  startedAt;
+  requestIndex = 0;
+  openAIWireRequestIndex = 0;
+  anthropicWireRequestIndex = 0;
+  requests = [];
+  openaiWireRequests = [];
+  anthropicWireRequests = [];
+  tools = createInitialToolDiagnostics();
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? isRuntimeDiagnosticsEnabled();
+    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.startedAt = this.now();
+  }
+  reset(options = {}) {
+    this.enabled = options.enabled ?? isRuntimeDiagnosticsEnabled();
+    this.startedAt = this.now();
+    this.requestIndex = 0;
+    this.openAIWireRequestIndex = 0;
+    this.anthropicWireRequestIndex = 0;
+    this.requests = [];
+    this.openaiWireRequests = [];
+    this.anthropicWireRequests = [];
+    this.tools = createInitialToolDiagnostics();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  recordGenerateContentRequest(request, options) {
+    if (!this.enabled) {
+      return;
+    }
+    this.requestIndex += 1;
+    this.requests.push({
+      index: this.requestIndex,
+      timestamp: this.now(),
+      source: options.source,
+      model: request.model,
+      stream: options.stream,
+      serializedBytes: utf8Bytes(toJsonSafeRequest(request)),
+      contents: summarizeContents(request.contents),
+      systemInstructionBytes: summarizeContentTextBytes(
+        request.config?.systemInstruction
+      ),
+      generationConfigBytes: utf8Bytes(toJsonSafeConfig(request.config)),
+      tools: summarizeToolSchemas(request.config?.tools)
+    });
+  }
+  recordOpenAIWireRequest(request) {
+    if (!this.enabled) {
+      return;
+    }
+    this.openAIWireRequestIndex += 1;
+    this.openaiWireRequests.push({
+      index: this.openAIWireRequestIndex,
+      timestamp: this.now(),
+      ...summarizeOpenAIWireRequest(request)
+    });
+  }
+  recordAnthropicWireRequest(request) {
+    if (!this.enabled) {
+      return;
+    }
+    this.anthropicWireRequestIndex += 1;
+    this.anthropicWireRequests.push({
+      index: this.anthropicWireRequestIndex,
+      timestamp: this.now(),
+      ...summarizeAnthropicWireRequest(request)
+    });
+  }
+  recordToolUse(name, args) {
+    if (!this.enabled) {
+      return;
+    }
+    const argBytes = utf8Bytes(args);
+    const tool = this.getToolNameDiagnostics(name);
+    tool.uses += 1;
+    tool.argBytes += argBytes;
+    tool.maxArgBytes = Math.max(tool.maxArgBytes, argBytes);
+    this.tools.toolUseCount += 1;
+    this.tools.totalToolUseArgBytes += argBytes;
+    this.tools.maxToolUseArgBytes = Math.max(
+      this.tools.maxToolUseArgBytes,
+      argBytes
+    );
+  }
+  recordToolResult(record) {
+    if (!this.enabled) {
+      return;
+    }
+    const tool = this.getToolNameDiagnostics(record.name);
+    tool.results += 1;
+    tool.resultBytes += record.resultBytes;
+    tool.maxResultBytes = Math.max(tool.maxResultBytes, record.resultBytes);
+    if (record.isError) {
+      tool.errors += 1;
+      this.tools.toolResultErrorCount += 1;
+    }
+    this.tools.toolResultCount += 1;
+    this.tools.totalToolResultBytes += record.resultBytes;
+    this.tools.maxToolResultBytes = Math.max(
+      this.tools.maxToolResultBytes,
+      record.resultBytes
+    );
+  }
+  snapshot() {
+    return {
+      enabled: this.enabled,
+      startedAt: this.startedAt,
+      requests: this.requests.map((request) => ({
+        ...request,
+        contents: {
+          ...request.contents,
+          roleCounts: { ...request.contents.roleCounts }
+        },
+        tools: { ...request.tools }
+      })),
+      openaiWireRequests: this.openaiWireRequests.map((request) => ({
+        ...request,
+        messageBytesByRole: { ...request.messageBytesByRole },
+        topLevelKeys: [...request.topLevelKeys]
+      })),
+      anthropicWireRequests: this.anthropicWireRequests.map((request) => ({
+        ...request,
+        messageBytesByRole: { ...request.messageBytesByRole },
+        topLevelKeys: [...request.topLevelKeys]
+      })),
+      tools: {
+        ...this.tools,
+        byName: Object.fromEntries(
+          Object.entries(this.tools.byName).map(([name, value]) => [
+            name,
+            { ...value }
+          ])
+        )
+      }
+    };
+  }
+  getToolNameDiagnostics(name) {
+    const existing = this.tools.byName[name];
+    if (existing) {
+      return existing;
+    }
+    const created = createInitialToolNameDiagnostics();
+    this.tools.byName[name] = created;
+    return created;
+  }
+};
+var runtimeDiagnostics = new RuntimeDiagnosticsCollector();
+function summarizeOpenAIWireRequest(request) {
+  const requestRecord = asRecord(request);
+  const messages = Array.isArray(requestRecord["messages"]) ? requestRecord["messages"] : [];
+  const tools = Array.isArray(requestRecord["tools"]) ? requestRecord["tools"] : [];
+  const messageBytesByRole = {};
+  for (const message of messages) {
+    const messageRecord = asRecord(message);
+    const role = typeof messageRecord["role"] === "string" ? messageRecord["role"] : "unknown";
+    messageBytesByRole[role] = (messageBytesByRole[role] ?? 0) + utf8Bytes(messageRecord["content"]);
+  }
+  return {
+    model: typeof requestRecord["model"] === "string" ? requestRecord["model"] : "unknown",
+    stream: requestRecord["stream"] === true,
+    bodyBytes: utf8Bytes(request),
+    messageCount: messages.length,
+    messageBytesByRole,
+    toolsCount: tools.length,
+    toolSchemaBytes: utf8Bytes(tools),
+    topLevelKeys: Object.keys(requestRecord).sort()
+  };
+}
+__name(summarizeOpenAIWireRequest, "summarizeOpenAIWireRequest");
+function summarizeAnthropicWireRequest(request) {
+  const requestRecord = asRecord(request);
+  const messages = Array.isArray(requestRecord["messages"]) ? requestRecord["messages"] : [];
+  const tools = Array.isArray(requestRecord["tools"]) ? requestRecord["tools"] : [];
+  const messageBytesByRole = {};
+  for (const message of messages) {
+    const messageRecord = asRecord(message);
+    const role = typeof messageRecord["role"] === "string" ? messageRecord["role"] : "unknown";
+    messageBytesByRole[role] = (messageBytesByRole[role] ?? 0) + utf8Bytes(messageRecord["content"]);
+  }
+  return {
+    model: typeof requestRecord["model"] === "string" ? requestRecord["model"] : "unknown",
+    stream: requestRecord["stream"] === true,
+    bodyBytes: utf8Bytes(request),
+    messageCount: messages.length,
+    messageBytesByRole,
+    systemBytes: utf8Bytes(requestRecord["system"]),
+    toolsCount: tools.length,
+    toolSchemaBytes: utf8Bytes(tools),
+    topLevelKeys: Object.keys(requestRecord).sort()
+  };
+}
+__name(summarizeAnthropicWireRequest, "summarizeAnthropicWireRequest");
+function createInitialToolDiagnostics() {
+  return {
+    toolUseCount: 0,
+    toolResultCount: 0,
+    toolResultErrorCount: 0,
+    totalToolUseArgBytes: 0,
+    maxToolUseArgBytes: 0,
+    totalToolResultBytes: 0,
+    maxToolResultBytes: 0,
+    byName: /* @__PURE__ */ Object.create(null)
+  };
+}
+__name(createInitialToolDiagnostics, "createInitialToolDiagnostics");
+function createInitialToolNameDiagnostics() {
+  return {
+    uses: 0,
+    argBytes: 0,
+    maxArgBytes: 0,
+    results: 0,
+    errors: 0,
+    resultBytes: 0,
+    maxResultBytes: 0
+  };
+}
+__name(createInitialToolNameDiagnostics, "createInitialToolNameDiagnostics");
+function summarizeContents(contents) {
+  const summary = {
+    count: 0,
+    roleCounts: {},
+    partCount: 0,
+    textBytes: 0,
+    functionCallCount: 0,
+    functionCallArgBytes: 0,
+    functionResponseCount: 0,
+    functionResponseBytes: 0,
+    inlineDataCount: 0,
+    inlineDataBytes: 0,
+    fileDataCount: 0
+  };
+  const contentItems = Array.isArray(contents) ? contents : contents === void 0 || contents === null ? [] : [contents];
+  for (const content of contentItems) {
+    summary.count += 1;
+    if (typeof content === "string") {
+      summary.roleCounts["user"] = (summary.roleCounts["user"] ?? 0) + 1;
+      summary.partCount += 1;
+      summary.textBytes += utf8Bytes(content);
+      continue;
+    }
+    const contentRecord = asRecord(content);
+    const role = typeof contentRecord["role"] === "string" ? contentRecord["role"] : "unknown";
+    summary.roleCounts[role] = (summary.roleCounts[role] ?? 0) + 1;
+    const parts = Array.isArray(contentRecord["parts"]) ? contentRecord["parts"] : [];
+    summarizeParts(parts, summary);
+  }
+  return summary;
+}
+__name(summarizeContents, "summarizeContents");
+function summarizeContentTextBytes(content) {
+  const summary = summarizeContents(content);
+  return summary.textBytes;
+}
+__name(summarizeContentTextBytes, "summarizeContentTextBytes");
+function summarizeParts(parts, summary) {
+  for (const part of parts) {
+    summary.partCount += 1;
+    if (typeof part === "string") {
+      summary.textBytes += utf8Bytes(part);
+      continue;
+    }
+    const partRecord = asRecord(part);
+    if (typeof partRecord["text"] === "string") {
+      summary.textBytes += utf8Bytes(partRecord["text"]);
+    }
+    const functionCall = asOptionalRecord(partRecord["functionCall"]);
+    if (functionCall) {
+      summary.functionCallCount += 1;
+      summary.functionCallArgBytes += utf8Bytes(functionCall["args"]);
+    }
+    const functionResponse = asOptionalRecord(partRecord["functionResponse"]);
+    if (functionResponse) {
+      summary.functionResponseCount += 1;
+      summary.functionResponseBytes += utf8Bytes(functionResponse["response"]) + utf8Bytes(functionResponse["parts"]);
+    }
+    const inlineData = asOptionalRecord(partRecord["inlineData"]);
+    if (inlineData) {
+      summary.inlineDataCount += 1;
+      summary.inlineDataBytes += utf8Bytes(inlineData["data"]);
+    }
+    if (partRecord["fileData"]) {
+      summary.fileDataCount += 1;
+    }
+  }
+}
+__name(summarizeParts, "summarizeParts");
+function summarizeToolSchemas(tools) {
+  const toolList = Array.isArray(tools) ? tools : [];
+  let functionDeclarationCount = 0;
+  for (const tool of toolList) {
+    const toolRecord = asRecord(tool);
+    const declarations = Array.isArray(toolRecord["functionDeclarations"]) ? toolRecord["functionDeclarations"] : [];
+    functionDeclarationCount += declarations.length;
+  }
+  return {
+    count: toolList.length,
+    functionDeclarationCount,
+    schemaBytes: utf8Bytes(toolList)
+  };
+}
+__name(summarizeToolSchemas, "summarizeToolSchemas");
+function toJsonSafeRequest(request) {
+  return {
+    model: request.model,
+    contents: request.contents,
+    config: toJsonSafeConfig(request.config)
+  };
+}
+__name(toJsonSafeRequest, "toJsonSafeRequest");
+function toJsonSafeConfig(config) {
+  if (!config) {
+    return void 0;
+  }
+  const configRecord = asRecord(config);
+  const safeConfig = {};
+  for (const [key, value] of Object.entries(configRecord)) {
+    if (key === "abortSignal") {
+      continue;
+    }
+    safeConfig[key] = value;
+  }
+  return safeConfig;
+}
+__name(toJsonSafeConfig, "toJsonSafeConfig");
+function utf8Bytes(value) {
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  if (typeof value === "string") {
+    return Buffer.byteLength(value, "utf8");
+  }
+  return Buffer.byteLength(safeStringify(value), "utf8");
+}
+__name(utf8Bytes, "utf8Bytes");
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "[unserializable]";
+  }
+}
+__name(safeStringify, "safeStringify");
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+__name(asRecord, "asRecord");
+function asOptionalRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+__name(asOptionalRecord, "asOptionalRecord");
+
 // packages/core/src/core/tokenLimits.ts
 init_esbuild_shims();
 var DEFAULT_TOKEN_LIMIT = 131072;
@@ -1012,6 +1377,11 @@ __name(toOpenAPI30, "toOpenAPI30");
 export {
   safeJsonParse,
   convertSchema,
+  isRuntimeDiagnosticsEnabled,
+  RuntimeDiagnosticsCollector,
+  runtimeDiagnostics,
+  summarizeOpenAIWireRequest,
+  summarizeAnthropicWireRequest,
   DEFAULT_TOKEN_LIMIT,
   DEFAULT_OUTPUT_TOKEN_LIMIT,
   CAPPED_DEFAULT_MAX_TOKENS,
@@ -1026,6 +1396,11 @@ export {
   DEFAULT_DASHSCOPE_BASE_URL,
   DASHSCOPE_PROXY_BASE_URL
 };
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen

package/chunks/{chunk-7QXHXMC6.js → chunk-N6GSJHZ4.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   RequestTokenizer
-} from "./chunk-NAID3ZWF.js";
+} from "./chunk-DMIMF3CG.js";
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-VTPOO6GV.js";
+} from "./chunk-CSWBPY3P.js";
 import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-C3LHPHN2.js";
+} from "./chunk-JCR2WRXZ.js";
 import {
   CAPPED_DEFAULT_MAX_TOKENS,
   DASHSCOPE_PROXY_BASE_URL,
@@ -19,9 +19,10 @@ import {
   DEFAULT_MAX_RETRIES,
   DEFAULT_TIMEOUT,
   hasExplicitOutputLimit,
+  runtimeDiagnostics,
   safeJsonParse,
   tokenLimit
-} from "./chunk-CW44BRRA.js";
+} from "./chunk-MAY32HXD.js";
 import {
   GenerateContentResponse
 } from "./chunk-T4VD6OJ4.js";
@@ -6902,6 +6903,24 @@ OpenAI.Containers = Containers;
 init_esbuild_shims();
 
 // packages/core/src/core/openaiContentGenerator/provider/default.ts
+function shouldMirrorReasoningContentForQwen3(model) {
+  return model.toLowerCase().includes("qwen3");
+}
+__name(shouldMirrorReasoningContentForQwen3, "shouldMirrorReasoningContentForQwen3");
+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");
@@ -6945,8 +6964,10 @@ var DefaultOpenAICompatibleProvider = class {
   buildRequest(request, _userPromptId) {
     const extraBody = this.contentGeneratorConfig.extra_body;
     const requestWithTokenLimits = this.applyOutputTokenLimit(request);
+    const messages = shouldMirrorReasoningContentForQwen3(request.model) ? requestWithTokenLimits.messages.map(mirrorReasoningContentToReasoning) : requestWithTokenLimits.messages;
     return {
       ...requestWithTokenLimits,
+      messages,
       ...extraBody ? extraBody : {}
     };
   }
@@ -7296,6 +7317,25 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
 
 // packages/core/src/core/openaiContentGenerator/provider/deepseek.ts
 init_esbuild_shims();
+
+// packages/core/src/core/openaiContentGenerator/provider/utils.ts
+init_esbuild_shims();
+function ensureReasoningContentOnAssistantMessage(message) {
+  if (message.role !== "assistant") {
+    return message;
+  }
+  const assistant = message;
+  if (typeof assistant.reasoning_content === "string") {
+    return message;
+  }
+  return {
+    ...assistant,
+    reasoning_content: ""
+  };
+}
+__name(ensureReasoningContentOnAssistantMessage, "ensureReasoningContentOnAssistantMessage");
+
+// packages/core/src/core/openaiContentGenerator/provider/deepseek.ts
 function isDeepSeekHostname(contentGeneratorConfig) {
   const baseUrl = contentGeneratorConfig.baseUrl ?? "";
   if (!baseUrl) return false;
@@ -7347,7 +7387,7 @@ var DeepSeekOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProv
     }
     const messages = reshaped.messages.map((message) => {
       const flattened = flattenContentParts(message);
-      return ensureReasoningContentOnToolCalls(flattened);
+      return ensureReasoningContentOnAssistantMessage(flattened);
     });
     return {
       ...reshaped,
@@ -7409,20 +7449,6 @@ function translateReasoningEffort(request) {
   return next;
 }
 __name(translateReasoningEffort, "translateReasoningEffort");
-function ensureReasoningContentOnToolCalls(message) {
-  if (message.role !== "assistant") {
-    return message;
-  }
-  const extended = message;
-  if (typeof extended.reasoning_content === "string" && extended.reasoning_content.length > 0) {
-    return message;
-  }
-  return {
-    ...extended,
-    reasoning_content: ""
-  };
-}
-__name(ensureReasoningContentOnToolCalls, "ensureReasoningContentOnToolCalls");
 
 // packages/core/src/core/openaiContentGenerator/provider/openrouter.ts
 init_esbuild_shims();
@@ -7524,6 +7550,50 @@ function stripReasoningContent(message) {
 }
 __name(stripReasoningContent, "stripReasoningContent");
 
+// packages/core/src/core/openaiContentGenerator/provider/mimo.ts
+init_esbuild_shims();
+function isMiMoProvider(contentGeneratorConfig) {
+  const baseUrl = contentGeneratorConfig.baseUrl ?? "";
+  if (baseUrl) {
+    try {
+      const hostname = new URL(baseUrl).hostname.toLowerCase();
+      if (hostname === "xiaomimimo.com" || hostname.endsWith(".xiaomimimo.com")) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  const model = contentGeneratorConfig.model ?? "";
+  return model.toLowerCase().startsWith("mimo-");
+}
+__name(isMiMoProvider, "isMiMoProvider");
+var MiMoOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProvider {
+  static {
+    __name(this, "MiMoOpenAICompatibleProvider");
+  }
+  constructor(contentGeneratorConfig, cliConfig) {
+    super(contentGeneratorConfig, cliConfig);
+  }
+  static isMiMoProvider = isMiMoProvider;
+  buildRequest(request, userPromptId) {
+    const baseRequest = super.buildRequest(request, userPromptId);
+    if (!baseRequest.messages?.length) {
+      return baseRequest;
+    }
+    return {
+      ...baseRequest,
+      messages: baseRequest.messages.map(
+        ensureReasoningContentOnAssistantMessage
+      )
+    };
+  }
+  getRequestContextOverrides() {
+    return {
+      splitToolMedia: this.contentGeneratorConfig.splitToolMedia ?? true
+    };
+  }
+};
+
 // packages/core/src/core/openaiContentGenerator/pipeline.ts
 init_esbuild_shims();
 import { setMaxListeners } from "node:events";
@@ -8120,6 +8190,7 @@ var ContentGenerationPipeline = class {
         isStreaming
       );
       openaiRequestCaptureContext.getStore()?.(openaiRequest);
+      runtimeDiagnostics.recordOpenAIWireRequest(openaiRequest);
       const result = await executor(openaiRequest, context);
       return result;
     } catch (error) {
@@ -8138,6 +8209,7 @@ var ContentGenerationPipeline = class {
    */
   createRequestContext(request, isStreaming) {
     const effectiveModel = request.model || this.contentGeneratorConfig.model;
+    const providerOverrides = this.config.provider.getRequestContextOverrides?.() ?? {};
     const toolCallParser = isStreaming ? new StreamingToolCallParser() : void 0;
     const responseParsingOptions = this.config.provider.getResponseParsingOptions?.();
     const taggedThinkingParser = isStreaming && responseParsingOptions?.taggedThinkingTags ? new TaggedThinkingParser() : void 0;
@@ -8145,7 +8217,7 @@ var ContentGenerationPipeline = class {
       model: effectiveModel,
       modalities: this.contentGeneratorConfig.modalities ?? {},
       startTime: Date.now(),
-      splitToolMedia: this.contentGeneratorConfig.splitToolMedia ?? false,
+      splitToolMedia: providerOverrides.splitToolMedia ?? this.contentGeneratorConfig.splitToolMedia ?? false,
       ...toolCallParser ? { toolCallParser } : {},
       ...responseParsingOptions ? { responseParsingOptions } : {},
       ...taggedThinkingParser ? { taggedThinkingParser } : {}
@@ -8337,6 +8409,9 @@ function determineProvider(contentGeneratorConfig, cliConfig) {
       cliConfig
     );
   }
+  if (MiMoOpenAICompatibleProvider.isMiMoProvider(config)) {
+    return new MiMoOpenAICompatibleProvider(contentGeneratorConfig, cliConfig);
+  }
   if (OpenRouterOpenAICompatibleProvider.isOpenRouterProvider(config)) {
     return new OpenRouterOpenAICompatibleProvider(
       contentGeneratorConfig,
@@ -8371,6 +8446,7 @@ export {
   OpenRouterOpenAICompatibleProvider,
   MiniMaxOpenAICompatibleProvider,
   MistralOpenAICompatibleProvider,
+  MiMoOpenAICompatibleProvider,
   ContentGenerationPipeline,
   EnhancedErrorHandler,
   OpenAIContentGenerator,

package/chunks/{chunk-FZIUV27X.js → chunk-PVVL5Q3W.js}

@@ -14155,6 +14155,10 @@ var ToolErrorType = /* @__PURE__ */ ((ToolErrorType2) => {
   ToolErrorType2["EDIT_REQUIRES_PRIOR_READ"] = "edit_requires_prior_read";
   ToolErrorType2["FILE_CHANGED_SINCE_READ"] = "file_changed_since_read";
   ToolErrorType2["PRIOR_READ_VERIFICATION_FAILED"] = "prior_read_verification_failed";
+  ToolErrorType2["TARGET_NOT_REGULAR_FILE"] = "target_not_regular_file";
+  ToolErrorType2["NOTEBOOK_EDIT_FAILURE"] = "notebook_edit_failure";
+  ToolErrorType2["NOTEBOOK_INVALID_JSON"] = "notebook_invalid_json";
+  ToolErrorType2["NOTEBOOK_CELL_NOT_FOUND"] = "notebook_cell_not_found";
   ToolErrorType2["GLOB_EXECUTION_ERROR"] = "glob_execution_error";
   ToolErrorType2["GREP_EXECUTION_ERROR"] = "grep_execution_error";
   ToolErrorType2["LS_EXECUTION_ERROR"] = "ls_execution_error";
@@ -14608,6 +14612,31 @@ var DeclarativeTool = class {
       parametersJsonSchema: this.parameterSchema
     };
   }
+  /**
+   * Projects tool params for the AUTO approval mode classifier.
+   *
+   * Tools with security-relevant parameters (file paths, shell commands,
+   * URLs) should override this to redact voluminous or sensitive fields
+   * (full content, secrets) while exposing enough for the classifier to
+   * judge safety.
+   *
+   * Returns:
+   *   - object: projected params to send to the classifier
+   *   - empty string: signals "no security relevance" — the classifier
+   *     transcript will record only the tool name
+   *   - undefined: fall back to raw params (only safe when the tool is
+   *     known to have no sensitive params)
+   *
+   * Default is the empty-string sentinel — fail-closed: a third-party
+   * MCP tool (or any tool that has not opted in) does not leak its raw
+   * parameters (potentially containing API keys, tokens, file contents)
+   * into the classifier LLM prompt. Tools that want their args inspected
+   * by the classifier for safety judgement should override this and
+   * return an object with only the security-relevant fields.
+   */
+  toAutoClassifierInput(_params) {
+    return "";
+  }
   /**
    * Validates the raw tool parameters.
    * Subclasses should override this to add custom validation logic
@@ -14832,6 +14861,7 @@ var ToolNames = {
   SEND_MESSAGE: "send_message",
   STRUCTURED_OUTPUT: "structured_output",
   MONITOR: "monitor",
+  NOTEBOOK_EDIT: "notebook_edit",
   TOOL_SEARCH: "tool_search",
   ENTER_WORKTREE: "enter_worktree",
   EXIT_WORKTREE: "exit_worktree"
@@ -14859,6 +14889,7 @@ var ToolDisplayNames = {
   SEND_MESSAGE: "SendMessage",
   STRUCTURED_OUTPUT: "StructuredOutput",
   MONITOR: "Monitor",
+  NOTEBOOK_EDIT: "NotebookEdit",
   TOOL_SEARCH: "ToolSearch",
   ENTER_WORKTREE: "EnterWorktree",
   EXIT_WORKTREE: "ExitWorktree"

package/chunks/{chunk-YHEAJFCI.js → chunk-USE2VQ5P.js}

@@ -1005,6 +1005,9 @@ var AcpBridge = class extends EventEmitter {
   }
 };
 
+// packages/channels/base/dist/DaemonChannelBridge.js
+init_esbuild_shims();
+
 export {
   resolvePath,
   getGlobalQwenDir,