@qwen-code/qwen-code 0.22.0 → 0.22.2-preview.0

package/chunks/{chunk-NUGZAFR2.js → chunk-ZEADBZLO.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   isPrivateHost
-} from "./chunk-WRT324N6.js";
+} from "./chunk-FVDQ5E67.js";
 import {
   loadUndici
-} from "./chunk-PZRUV52H.js";
+} from "./chunk-GTUKW3I6.js";
 import {
   getErrorMessage
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -172,6 +172,8 @@ var PNG_SIGNATURE = Buffer.from([
   26,
   10
 ]);
+var MINIMAX_IMAGE_GENERATION_PATH = "/v1/image_generation";
+var MINIMAX_IMAGE_GENERATION_SUFFIX = "/image_generation";
 var ResponseSizeLimitError = class extends Error {
   static {
     __name(this, "ResponseSizeLimitError");
@@ -200,6 +202,9 @@ async function generateImage(request) {
       "Image generation baseUrl must be a valid HTTPS URL without credentials, query, or fragment."
     );
   }
+  if (isMiniMaxImageGenerationBaseUrl(baseUrl)) {
+    return generateMiniMaxImage({ ...request, baseUrl, fetchFn });
+  }
   const generationUrl = baseUrl.endsWith(
     "/services/aigc/multimodal-generation/generation"
   ) ? baseUrl : `${baseUrl}/services/aigc/multimodal-generation/generation`;
@@ -262,6 +267,75 @@ async function generateImage(request) {
   };
 }
 __name(generateImage, "generateImage");
+async function generateMiniMaxImage(request) {
+  const generationUrl = request.baseUrl.endsWith(MINIMAX_IMAGE_GENERATION_PATH) ? request.baseUrl : `${request.baseUrl}${MINIMAX_IMAGE_GENERATION_SUFFIX}`;
+  const body = {
+    model: request.model,
+    prompt: request.prompt,
+    n: 1,
+    prompt_optimizer: true,
+    response_format: "url"
+  };
+  const dimensions = parseImageSize(request.size);
+  if (dimensions) {
+    body["width"] = dimensions.width;
+    body["height"] = dimensions.height;
+  }
+  let response;
+  try {
+    response = await request.fetchFn(generationUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${request.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      redirect: "error",
+      signal: combineWithTimeout(request.signal, GENERATION_TIMEOUT_MS)
+    });
+  } catch (error) {
+    throw new Error(
+      `Image generation request failed: ${getErrorMessage(error)}`,
+      { cause: error }
+    );
+  }
+  if (!response.ok) {
+    let payload2 = {};
+    try {
+      payload2 = await readJsonResponse(response, MAX_API_RESPONSE_BYTES);
+    } catch {
+    }
+    throw new Error(formatImageGenerationError(response.status, payload2));
+  }
+  const payload = await readJsonResponse(response, MAX_API_RESPONSE_BYTES);
+  const baseResponse = isRecord(payload) ? payload["base_resp"] : void 0;
+  const statusCode = readStringOrNumber(baseResponse, "status_code");
+  if (statusCode && statusCode !== "0") {
+    throw new Error(formatImageGenerationError(response.status, payload));
+  }
+  const image = findMiniMaxGeneratedImage(payload);
+  if (!image) {
+    throw new Error("Image generation response did not contain an image URL.");
+  }
+  const requestId = readString(payload, "request_id", "requestId") ?? readString(
+    isRecord(payload) ? payload["base_resp"] : void 0,
+    "request_id"
+  );
+  if (image.kind === "base64") {
+    return {
+      bytes: decodePngBase64Image(image.value),
+      mimeType: "image/png",
+      ...requestId ? { requestId } : {}
+    };
+  }
+  const bytes = await downloadPng(image.value, request.fetchFn, request.signal);
+  return {
+    bytes,
+    mimeType: "image/png",
+    ...requestId ? { requestId } : {}
+  };
+}
+__name(generateMiniMaxImage, "generateMiniMaxImage");
 async function readJsonResponse(response, maxBytes) {
   const bytes = await readBoundedBody(response, maxBytes);
   if (bytes.length === 0) {
@@ -312,8 +386,9 @@ async function readBoundedBody(response, maxBytes) {
 }
 __name(readBoundedBody, "readBoundedBody");
 function formatImageGenerationError(status, payload) {
-  const code = readString(payload, "code");
-  const message = readString(payload, "message");
+  const baseResponse = isRecord(payload) ? payload["base_resp"] : void 0;
+  const code = readStringOrNumber(payload, "code") ?? readStringOrNumber(baseResponse, "status_code");
+  const message = readString(payload, "message") ?? readString(baseResponse, "status_msg");
   const suffix = [code, message].filter(Boolean).join(": ");
   if (status === 429 || /throttl|rate.?limit/i.test(`${code} ${message}`)) {
     return `Image generation rate limit reached${suffix ? ` (${suffix})` : ""}.`;
@@ -324,7 +399,8 @@ function formatImageGenerationError(status, payload) {
   if (/DataInspectionFailed/i.test(code ?? "")) {
     return `The image generation endpoint blocked the prompt during content moderation${message ? `: ${message}` : "."}`;
   }
-  return `Image generation failed with HTTP ${status}${suffix ? ` (${suffix})` : ""}.`;
+  const statusText = status >= 200 && status < 300 ? "" : ` with HTTP ${status}`;
+  return `Image generation failed${statusText}${suffix ? ` (${suffix})` : ""}.`;
 }
 __name(formatImageGenerationError, "formatImageGenerationError");
 function findGeneratedImageUrl(payload) {
@@ -346,6 +422,57 @@ function findGeneratedImageUrl(payload) {
   return void 0;
 }
 __name(findGeneratedImageUrl, "findGeneratedImageUrl");
+function isMiniMaxImageGenerationBaseUrl(baseUrl) {
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    return false;
+  }
+  const normalizedPath = parsed.pathname.replace(/\/+$/, "");
+  return (parsed.hostname === "api.minimax.io" || parsed.hostname === "api.minimaxi.com") && (normalizedPath === "/v1" || normalizedPath === MINIMAX_IMAGE_GENERATION_PATH);
+}
+__name(isMiniMaxImageGenerationBaseUrl, "isMiniMaxImageGenerationBaseUrl");
+function parseImageSize(value) {
+  const match = value?.trim().match(/^(\d+)\s*[*xX]\s*(\d+)$/);
+  if (!match) return void 0;
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height)) {
+    return void 0;
+  }
+  return { width, height };
+}
+__name(parseImageSize, "parseImageSize");
+function findMiniMaxGeneratedImage(payload) {
+  if (!isRecord(payload)) return void 0;
+  const data = payload["data"];
+  if (!isRecord(data)) return void 0;
+  const imageUrls = data["image_urls"];
+  if (!Array.isArray(imageUrls)) return void 0;
+  for (const candidate of imageUrls) {
+    if (typeof candidate !== "string" || !candidate.trim()) continue;
+    const value = candidate.trim();
+    if (/^https:\/\//i.test(value)) {
+      return { kind: "url", value };
+    }
+    return { kind: "base64", value };
+  }
+  return void 0;
+}
+__name(findMiniMaxGeneratedImage, "findMiniMaxGeneratedImage");
+function decodePngBase64Image(value) {
+  const match = value.match(/^data:image\/png;base64,(.+)$/i);
+  const base64 = (match?.[1] ?? value).trim();
+  const bytes = Buffer.from(base64, "base64");
+  if (bytes.length < PNG_SIGNATURE.length || !bytes.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) {
+    throw new Error(
+      "Image generation response did not contain a valid PNG image."
+    );
+  }
+  return bytes;
+}
+__name(decodePngBase64Image, "decodePngBase64Image");
 async function downloadPng(imageUrl, fetchFn, signal) {
   const combinedSignal = combineWithTimeout(signal, DOWNLOAD_TIMEOUT_MS);
   let currentTarget = await validateResultUrl(imageUrl, combinedSignal);
@@ -462,6 +589,20 @@ function readString(value, ...keys) {
   return void 0;
 }
 __name(readString, "readString");
+function readStringOrNumber(value, ...keys) {
+  if (!isRecord(value)) return void 0;
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return String(candidate);
+    }
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return void 0;
+}
+__name(readStringOrNumber, "readStringOrNumber");
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/chunks/chunk-ZELCTN6Y.js

@@ -0,0 +1,29 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  QWEN_SERVER_TOKEN_ENV
+} from "./chunk-GYTKQYDB.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/serve-token.ts
+init_esbuild_shims();
+function resolveServeToken(optionToken, environmentToken = process.env[QWEN_SERVER_TOKEN_ENV]) {
+  const selected = optionToken ?? environmentToken;
+  const trimmed = selected?.trim();
+  return trimmed ? trimmed : void 0;
+}
+__name(resolveServeToken, "resolveServeToken");
+
+export {
+  resolveServeToken
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-TQOF5KBL.js → chunk-ZEZKIS2K.js}

@@ -7,31 +7,6 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/cli/src/serve/loopback-binds.ts
-init_esbuild_shims();
-var LOOPBACK_BINDS = /* @__PURE__ */ new Set([
-  "127.0.0.1",
-  "localhost",
-  "::1",
-  "[::1]"
-]);
-function isIpv4Loopback(hostname) {
-  const octets = hostname.split(".");
-  if (octets.length !== 4) return false;
-  const [first, ...rest] = octets;
-  return first === "127" && rest.every((octet) => {
-    if (!/^\d+$/.test(octet)) return false;
-    const value = Number(octet);
-    return value >= 0 && value <= 255;
-  });
-}
-__name(isIpv4Loopback, "isIpv4Loopback");
-function isLoopbackBind(hostname) {
-  const normalized = hostname.toLowerCase();
-  return LOOPBACK_BINDS.has(normalized) || isIpv4Loopback(normalized);
-}
-__name(isLoopbackBind, "isLoopbackBind");
-
 // packages/cli/src/config/session-id.ts
 init_esbuild_shims();
 var INTERNAL_SESSION_ID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(-agent-[a-zA-Z0-9_.-]+)?$/i;
@@ -54,16 +29,10 @@ function parseCallerSuppliedSessionId(value) {
 __name(parseCallerSuppliedSessionId, "parseCallerSuppliedSessionId");
 
 export {
-  isLoopbackBind,
   isValidSessionId,
   normalizeSessionIdForLookup,
   parseCallerSuppliedSessionId
 };
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
 /**
  * @license
  * Copyright 2026 Qwen Team

package/chunks/{chunk-IOSEW6KP.js → chunk-ZJG323IA.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
-} from "./chunk-LURJYO2T.js";
+} from "./chunk-OZ6KS6KW.js";
 import {
   SessionNotFoundError
 } from "./chunk-624NHDGB.js";
 import {
   ChannelWorkerStartupError
-} from "./chunk-4F5WV4RF.js";
+} from "./chunk-PAJGKZAA.js";
 import {
   ChannelDeliveryError,
   ChannelWebhookEnqueueError
-} from "./chunk-ND7NOI4P.js";
+} from "./chunk-7CWEZQ6T.js";
 import {
   CHANNEL_LOOP_MCP_SERVER_NAME
-} from "./chunk-AW27A43Y.js";
+} from "./chunk-E55H6BZ7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -122,6 +122,7 @@ function createChannelWorkerGroup(opts) {
       cliEntryPath: opts.shared.cliEntryPath,
       daemonUrl: opts.shared.daemonUrl,
       ...opts.shared.daemonToken ? { daemonToken: opts.shared.daemonToken } : {},
+      ...opts.shared.workerTlsCaCertPath ? { tlsCaCertPath: opts.shared.workerTlsCaCertPath } : {},
       workspace: runtime.workspaceCwd,
       selection: group2.selection,
       // Multi-workspace runtimes expose a per-workspace env overlay; a

package/chunks/{chunk-VSNPOSDN.js → chunk-ZKAZP2ZG.js}

@@ -4,8 +4,10 @@ import {
   DASHSCOPE_PROXY_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
   DEFAULT_MAX_RETRIES,
+  REASONING_EFFORT_TIERS,
+  clampReasoningEffort,
   resolveRequestTimeout
-} from "./chunk-AXMWHKXA.js";
+} from "./chunk-2LD5U7Q3.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
@@ -18,10 +20,10 @@ import {
 } from "./chunk-FPGTNKCP.js";
 import {
   buildRuntimeFetchOptions
-} from "./chunk-PZRUV52H.js";
+} from "./chunk-GTUKW3I6.js";
 import {
   createDebugLogger
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -6881,6 +6883,13 @@ 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 shouldMirrorReasoningContentForQwen3(model) {
   return model.toLowerCase().includes("qwen3");
 }
@@ -6905,6 +6914,12 @@ var DefaultOpenAICompatibleProvider = class {
   }
   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;
@@ -6939,9 +6954,64 @@ var DefaultOpenAICompatibleProvider = class {
       ...runtimeOptions || {}
     });
   }
+  /**
+   * 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.applyOutputTokenLimit(request);
+    const requestWithTokenLimits = this.clampConfiguredReasoningEffort(
+      this.applyOutputTokenLimit(request)
+    );
     const messages = shouldMirrorReasoningContentForQwen3(request.model) ? requestWithTokenLimits.messages.map(mirrorReasoningContentToReasoning) : requestWithTokenLimits.messages;
     return {
       ...requestWithTokenLimits,
@@ -7021,7 +7091,13 @@ var DefaultOpenAICompatibleProvider = class {
 
 // packages/core/src/core/openaiContentGenerator/provider/dashscope.ts
 init_esbuild_shims();
-var debugLogger = createDebugLogger("DashScopeOpenAICompatibleProvider");
+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;
@@ -7140,17 +7216,17 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       normalizedProxyUrl && normalizedBaseUrl.toLowerCase() === normalizedProxyUrl.toLowerCase()
     );
     if (normalizedProxyUrl && !isDashscopeOrigin && !isTokenPlanOrigin && !isInternalOrigin && !isAliCloudApiOrigin && !isProxyMatch) {
-      debugLogger.debug(
+      debugLogger2.debug(
         `DASHSCOPE_PROXY_BASE_URL is configured but the request baseUrl does not match. DashScope headers/cache control will be skipped.`
       );
     }
     if (isInternalOrigin) {
-      debugLogger.debug(
+      debugLogger2.debug(
         `DashScope provider activated via internal origin: ${hostname}`
       );
     }
     if (isAliCloudApiOrigin) {
-      debugLogger.debug(
+      debugLogger2.debug(
         `DashScope provider activated via alicloudapi origin: ${hostname}`
       );
     }
@@ -7252,7 +7328,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
         delete visionResult["reasoning"];
       }
       return this.mergeExtraBodyAndResolveKnobs(
-        visionResult,
+        hasQwenEffortConfig ? visionResult : this.clampConfiguredReasoningEffort(visionResult),
         extraBody,
         request.model,
         selectedThinkingKnob
@@ -7274,7 +7350,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       delete result["reasoning"];
     }
     return this.mergeExtraBodyAndResolveKnobs(
-      result,
+      hasQwenEffortConfig ? result : this.clampConfiguredReasoningEffort(result),
       extraBody,
       request.model,
       selectedThinkingKnob
@@ -7334,13 +7410,32 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     }
     const wireModel = this.resolveWireModel(model);
     if (isTieredEffortWireModel(wireModel)) {
-      return { reasoning_effort: reasoning.effort };
+      return { reasoning_effort: this.clampTieredEffort(reasoning.effort) };
     }
     if (isQwenFamilyWireModel(wireModel)) {
       return { enable_thinking: true };
     }
     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
@@ -7412,7 +7507,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     }
     if (!this.conflictingKnobDropWarned) {
       this.conflictingKnobDropWarned = true;
-      debugLogger.warn("DashScope: dropped conflicting thinking knobs", {
+      debugLogger2.warn("DashScope: dropped conflicting thinking knobs", {
         model: this.resolveWireModel(model),
         reasoningEffort,
         dropped

package/chunks/{chunk-YMVFIYHV.js → chunk-ZLTEQYNC.js}

@@ -10,11 +10,11 @@ import {
 } from "./chunk-CPBF7KYF.js";
 import {
   atomicWriteJSON
-} from "./chunk-HDKCKCYO.js";
+} from "./chunk-7QGEJI7M.js";
 import {
   Storage,
   isNodeError
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-O5BDEWBC.js → chunk-ZWKGZB2K.js}

@@ -5,17 +5,17 @@ import {
 } from "./chunk-NAVJD2PQ.js";
 import {
   formatFetchErrorForUser
-} from "./chunk-WRT324N6.js";
+} from "./chunk-FVDQ5E67.js";
 import {
   combineAbortSignals
 } from "./chunk-DJ2GSRLV.js";
 import {
   atomicWriteFile
-} from "./chunk-HDKCKCYO.js";
+} from "./chunk-7QGEJI7M.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-ZYNTSXWK.js

@@ -0,0 +1,32 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/tool-call-arguments.ts
+init_esbuild_shims();
+function parseToolCallArguments(json) {
+  try {
+    const value = JSON.parse(json);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return { ok: false, reason: "NON_OBJECT" };
+    }
+    return { ok: true, value };
+  } catch {
+    return { ok: false, reason: "MALFORMED_JSON" };
+  }
+}
+__name(parseToolCallArguments, "parseToolCallArguments");
+
+export {
+  parseToolCallArguments
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */