@qwen-code/qwen-code 0.23.5-preview.0 → 0.24.0

package/chunks/{chunk-ZAFYHRVY.js → chunk-ZYDMQCQP.js}

@@ -1,5 +1,9 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  FatalConfigError,
+  isNodeError
+} from "./chunk-S34QJ6IR.js";
 import {
   createContextKey,
   init_esm,
@@ -13,266 +17,6 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/core/src/utils/errors.ts
-init_esbuild_shims();
-var MAX_STRINGIFIED_ERROR_MESSAGE_LENGTH = 1e3;
-function isNodeError(error) {
-  return error instanceof Error && "code" in error;
-}
-__name(isNodeError, "isNodeError");
-function isAbortError(error) {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  if (error instanceof Error && error.name === "AbortError") {
-    return true;
-  }
-  if (isNodeError(error) && error.code === "ABORT_ERR") {
-    return true;
-  }
-  if (error instanceof Error && error.constructor?.name === "APIUserAbortError") {
-    return true;
-  }
-  return false;
-}
-__name(isAbortError, "isAbortError");
-function describeErrorCause(cause) {
-  if (cause == null) return void 0;
-  return describeCodedCause(cause, 0, /* @__PURE__ */ new Set()) ?? describeCauseFallback(cause);
-}
-__name(describeErrorCause, "describeErrorCause");
-function describeCauseFallback(cause) {
-  if (cause instanceof AggregateError && Array.isArray(cause.errors)) {
-    const inner = cause.errors.map((error) => describeSingleError(error)).filter((detail) => Boolean(detail));
-    if (inner.length > 0) {
-      return [...new Set(inner)].join("; ");
-    }
-  }
-  return describeSingleError(cause);
-}
-__name(describeCauseFallback, "describeCauseFallback");
-function describeCodedCause(cause, depth, visited) {
-  if (cause == null || depth >= 8 || typeof cause !== "object" || visited.has(cause)) {
-    return void 0;
-  }
-  visited.add(cause);
-  if (cause instanceof AggregateError && Array.isArray(cause.errors)) {
-    const inner = cause.errors.map((error) => describeCodedCause(error, depth + 1, visited)).filter((detail) => Boolean(detail));
-    if (inner.length > 0) {
-      return [...new Set(inner)].join("; ");
-    }
-  }
-  const nested = describeCodedCause(
-    cause.cause,
-    depth + 1,
-    visited
-  );
-  if (nested) {
-    return nested;
-  }
-  const code = cause.code;
-  return typeof code === "string" && code ? describeSingleError(cause) : void 0;
-}
-__name(describeCodedCause, "describeCodedCause");
-function describeSingleError(err) {
-  if (err instanceof Error) {
-    const code = err.code;
-    const codeStr = typeof code === "string" ? code : void 0;
-    const msg = err.message?.trim();
-    if (msg && codeStr && !msg.includes(codeStr)) {
-      return `${codeStr}: ${msg}`;
-    }
-    return msg || codeStr || (err.name !== "Error" ? err.name : void 0);
-  }
-  if (err && typeof err === "object" && !Array.isArray(err)) {
-    const rec = err;
-    const code = rec["code"];
-    const codeStr = typeof code === "string" && code ? code : typeof code === "number" ? String(code) : void 0;
-    const message = rec["message"];
-    const msg = typeof message === "string" && message.trim() ? message.trim() : void 0;
-    if (msg && codeStr && !msg.includes(codeStr)) {
-      return `${codeStr}: ${msg}`;
-    }
-    return msg || codeStr;
-  }
-  const str = String(err);
-  return str && str !== "[object Object]" ? str : void 0;
-}
-__name(describeSingleError, "describeSingleError");
-function truncateStringifiedErrorMessage(message) {
-  if (message.length <= MAX_STRINGIFIED_ERROR_MESSAGE_LENGTH) {
-    return message;
-  }
-  return `${message.slice(0, MAX_STRINGIFIED_ERROR_MESSAGE_LENGTH - 3)}...`;
-}
-__name(truncateStringifiedErrorMessage, "truncateStringifiedErrorMessage");
-function getErrorMessage(error) {
-  if (error instanceof Error) {
-    const detail = describeErrorCause(error.cause);
-    if (detail && detail !== error.message) {
-      return truncateStringifiedErrorMessage(
-        `${error.message} (cause: ${detail})`
-      );
-    }
-    return truncateStringifiedErrorMessage(error.message);
-  }
-  if (error !== null && typeof error === "object" && !Array.isArray(error)) {
-    const { message, cause } = error;
-    if (typeof message === "string" && message.trim()) {
-      const detail = describeErrorCause(cause);
-      const result = detail && detail !== message ? `${message} (cause: ${detail})` : message;
-      return truncateStringifiedErrorMessage(result);
-    }
-    try {
-      const serialized = JSON.stringify(error);
-      return serialized ? truncateStringifiedErrorMessage(serialized) : String(error);
-    } catch {
-      const detail = describeSingleError(error);
-      return detail ? truncateStringifiedErrorMessage(detail) : String(error);
-    }
-  }
-  try {
-    return String(error);
-  } catch {
-    return "Failed to get error details";
-  }
-}
-__name(getErrorMessage, "getErrorMessage");
-function getErrorStatus(error) {
-  if (typeof error !== "object" || error === null) {
-    return void 0;
-  }
-  const err = error;
-  const value = err.status ?? err.statusCode ?? err.response?.status ?? err.error?.code;
-  if (typeof value === "number" && value >= 100 && value <= 599) {
-    return value;
-  }
-  if (typeof err.message === "string") {
-    const match = err.message.match(/HTTP_STATUS\/(\d{3})\b/);
-    if (match) {
-      const parsed = Number(match[1]);
-      if (parsed >= 100 && parsed <= 599) {
-        return parsed;
-      }
-    }
-  }
-  return void 0;
-}
-__name(getErrorStatus, "getErrorStatus");
-function getErrorType(error) {
-  if (typeof error !== "object" || error === null) {
-    return "unknown";
-  }
-  const constructorName = error instanceof Error && error.constructor.name !== "Error" ? error.constructor.name : void 0;
-  const sdkType = error.type;
-  const baseType = constructorName ?? sdkType ?? (error instanceof Error ? error.name : "unknown");
-  const cause = error instanceof Error ? error.cause : void 0;
-  const causeCode = cause && typeof cause === "object" && "code" in cause ? cause.code : void 0;
-  return causeCode ? `${baseType}:${causeCode}` : baseType;
-}
-__name(getErrorType, "getErrorType");
-var FatalError = class extends Error {
-  constructor(message, exitCode) {
-    super(message);
-    this.exitCode = exitCode;
-  }
-  static {
-    __name(this, "FatalError");
-  }
-};
-var FatalInputError = class extends FatalError {
-  static {
-    __name(this, "FatalInputError");
-  }
-  constructor(message) {
-    super(message, 42);
-  }
-};
-var FatalSandboxError = class extends FatalError {
-  static {
-    __name(this, "FatalSandboxError");
-  }
-  constructor(message) {
-    super(message, 44);
-  }
-};
-var FatalConfigError = class extends FatalError {
-  static {
-    __name(this, "FatalConfigError");
-  }
-  constructor(message) {
-    super(message, 52);
-  }
-};
-var FatalTurnLimitedError = class extends FatalError {
-  static {
-    __name(this, "FatalTurnLimitedError");
-  }
-  constructor(message) {
-    super(message, 53);
-  }
-};
-var FatalBudgetExceededError = class extends FatalError {
-  static {
-    __name(this, "FatalBudgetExceededError");
-  }
-  constructor(message) {
-    super(message, 55);
-  }
-};
-var FatalCancellationError = class extends FatalError {
-  static {
-    __name(this, "FatalCancellationError");
-  }
-  constructor(message) {
-    super(message, 130);
-  }
-};
-var ForbiddenError = class extends Error {
-  static {
-    __name(this, "ForbiddenError");
-  }
-  status = 403;
-};
-var UnauthorizedError = class extends Error {
-  static {
-    __name(this, "UnauthorizedError");
-  }
-  status = 401;
-};
-var BadRequestError = class extends Error {
-  static {
-    __name(this, "BadRequestError");
-  }
-  status = 400;
-};
-function toFriendlyError(error) {
-  if (error && typeof error === "object" && "response" in error) {
-    const gaxiosError = error;
-    const data = parseResponseData(gaxiosError);
-    if (data.error && data.error.message && data.error.code) {
-      switch (data.error.code) {
-        case 400:
-          return new BadRequestError(data.error.message);
-        case 401:
-          return new UnauthorizedError(data.error.message);
-        case 403:
-          return new ForbiddenError(data.error.message);
-        default:
-      }
-    }
-  }
-  return error;
-}
-__name(toFriendlyError, "toFriendlyError");
-function parseResponseData(error) {
-  if (typeof error.response?.data === "string") {
-    return JSON.parse(error.response?.data);
-  }
-  return error.response?.data;
-}
-__name(parseResponseData, "parseResponseData");
-
 // packages/core/src/utils/paths.ts
 init_esbuild_shims();
 import fs from "node:fs";
@@ -1508,20 +1252,6 @@ function createDebugLogger(tag) {
 __name(createDebugLogger, "createDebugLogger");
 
 export {
-  isNodeError,
-  isAbortError,
-  getErrorMessage,
-  getErrorStatus,
-  getErrorType,
-  FatalError,
-  FatalInputError,
-  FatalSandboxError,
-  FatalConfigError,
-  FatalTurnLimitedError,
-  FatalBudgetExceededError,
-  FatalCancellationError,
-  UnauthorizedError,
-  toFriendlyError,
   QWEN_DIR,
   PATH_ARG_KEYS,
   tildeifyPath,

package/chunks/clip-audio-SH4L7AEY.js

@@ -0,0 +1,255 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  BaseMediaPolicyTool,
+  BaseMediaPolicyToolInvocation,
+  MEDIA_POLICY_IO_SCHEMA_PROPERTIES,
+  assertMediaPolicyIo,
+  ffmpegFailureMessage,
+  mediaPolicyToolError,
+  mediaPolicyToolFailure,
+  mediaPolicyToolSuccess,
+  policyOutputFileName,
+  resolvePolicyToolTimeoutMs
+} from "./chunk-UXEI7POA.js";
+import {
+  probeMediaMetadata,
+  runFfmpeg
+} from "./chunk-KSEKRQJO.js";
+import "./chunk-MNU36NGH.js";
+import "./chunk-BQMSZSG6.js";
+import "./chunk-VPGRGNNH.js";
+import {
+  ToolNames
+} from "./chunk-ERIBG3BX.js";
+import "./chunk-ZYDMQCQP.js";
+import "./chunk-S34QJ6IR.js";
+import "./chunk-TBWQLLFO.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/omni/policy/tools/clip-audio.ts
+init_esbuild_shims();
+import fs from "node:fs/promises";
+import path from "node:path";
+var OMNI_CLIP_AUDIO_TOOL_NAME = ToolNames.OMNI_CLIP_AUDIO;
+var CLIP_AUDIO_DEFAULTS = {
+  bitrateKbps: 128
+};
+var OUTPUT_FORMATS = {
+  wav: {
+    extension: ".wav",
+    mimeType: "audio/wav",
+    label: "WAV",
+    codecArgs: /* @__PURE__ */ __name(() => ["-c:a", "pcm_s16le"], "codecArgs")
+  },
+  mp3: {
+    extension: ".mp3",
+    mimeType: "audio/mpeg",
+    label: "MP3",
+    codecArgs: /* @__PURE__ */ __name((kbps) => ["-c:a", "libmp3lame", "-b:a", `${kbps}k`], "codecArgs")
+  },
+  m4a: {
+    extension: ".m4a",
+    mimeType: "audio/mp4",
+    label: "M4A",
+    codecArgs: /* @__PURE__ */ __name((kbps) => ["-c:a", "aac", "-b:a", `${kbps}k`], "codecArgs")
+  }
+};
+var MIN_DURATION_MS = 1e3;
+var TUNABLE_SCHEMA_PROPERTIES = {
+  startMs: {
+    type: "number",
+    description: "Clip start position in milliseconds. Default 0.",
+    minimum: 0
+  },
+  durationMs: {
+    type: "number",
+    description: "Clip duration in milliseconds (minimum 1000). Default: from startMs to the end.",
+    exclusiveMinimum: 0
+  },
+  format: {
+    type: "string",
+    enum: ["wav", "mp3", "m4a"],
+    description: "Output format: 'wav' (16-bit PCM), 'mp3', or 'm4a' (AAC). Default 'm4a'."
+  },
+  bitrateKbps: {
+    type: "number",
+    description: "Output bit rate in kbit/s for mp3/m4a (ignored for wav). Default 128.",
+    minimum: 8
+  }
+};
+var DESCRIPTOR = {
+  kind: "media_policy",
+  // Same versioning rationale as omni_clip_video '2': outputs carry
+  // `metadata.omniRole: 'clip'` → memory maps them to `partial` coverage.
+  version: "1",
+  inputMediaTypes: ["audio"],
+  outputs: [
+    {
+      kind: "media",
+      mimeTypes: ["audio/wav", "audio/mpeg", "audio/mp4"],
+      required: true,
+      lossy: true
+    },
+    { kind: "text", role: "disclosure", required: true }
+  ],
+  settingsSchema: {
+    type: "object",
+    properties: TUNABLE_SCHEMA_PROPERTIES,
+    additionalProperties: false
+  }
+};
+function formatMs(ms) {
+  return `${Math.round(ms / 100) / 10}s`;
+}
+__name(formatMs, "formatMs");
+var ClipAudioInvocation = class extends BaseMediaPolicyToolInvocation {
+  constructor(params, timeoutMs) {
+    super(params);
+    this.timeoutMs = timeoutMs;
+  }
+  static {
+    __name(this, "ClipAudioInvocation");
+  }
+  getDescription() {
+    const start = this.params.startMs ?? 0;
+    const span = this.params.durationMs !== void 0 ? `${formatMs(start)}\u2013${formatMs(start + this.params.durationMs)}` : `${formatMs(start)}\u2013end`;
+    return `Clip ${path.basename(this.params.inputPath)} to [${span}]`;
+  }
+  async execute(signal) {
+    const startMs = this.params.startMs ?? 0;
+    const durationMs = this.params.durationMs;
+    const format = this.params.format ?? "m4a";
+    const bitrateKbps = this.params.bitrateKbps ?? CLIP_AUDIO_DEFAULTS.bitrateKbps;
+    const output = OUTPUT_FORMATS[format];
+    try {
+      await assertMediaPolicyIo(this.params);
+      const probe = await probeMediaMetadata(
+        this.params.inputPath,
+        "audio",
+        signal
+      );
+      const totalMs = probe.durationMs;
+      if (totalMs !== void 0 && startMs >= totalMs) {
+        return mediaPolicyToolError(
+          `startMs (${formatMs(startMs)}) is at or beyond the end of the audio (${formatMs(totalMs)})`
+        );
+      }
+      if (totalMs !== void 0 && startMs === 0 && durationMs !== void 0 && durationMs >= totalMs) {
+        return mediaPolicyToolError(
+          `the requested span [0\u2013${formatMs(durationMs)}] covers the entire audio (${formatMs(totalMs)}) \u2014 a no-op clip that would only re-encode (and damage) the input`
+        );
+      }
+      const outputFileName = policyOutputFileName({
+        inputPath: this.params.inputPath,
+        operation: "clip",
+        variant: durationMs !== void 0 ? `${Math.round(startMs)}ms+${Math.round(durationMs)}ms` : `${Math.round(startMs)}ms-end`,
+        extension: output.extension
+      });
+      const outputPath = path.join(this.params.outputDir, outputFileName);
+      const run = await runFfmpeg(
+        [
+          "-y",
+          "-ss",
+          (startMs / 1e3).toFixed(3),
+          ...durationMs !== void 0 ? ["-t", (durationMs / 1e3).toFixed(3)] : [],
+          "-i",
+          this.params.inputPath,
+          "-vn",
+          ...output.codecArgs(bitrateKbps),
+          outputPath
+        ],
+        { signal, timeoutMs: this.timeoutMs }
+      );
+      if (signal.aborted) {
+        return mediaPolicyToolError("audio clipping aborted");
+      }
+      if (run.code !== 0) {
+        return mediaPolicyToolError(
+          ffmpegFailureMessage(run, "clipping", this.params.inputPath)
+        );
+      }
+      const outputSizeBytes = (await fs.stat(outputPath)).size;
+      const endMs = durationMs !== void 0 ? totalMs !== void 0 ? Math.min(startMs + durationMs, totalMs) : startMs + durationMs : totalMs;
+      const original = totalMs !== void 0 ? formatMs(totalMs) : "\u672A\u77E5\u65F6\u957F";
+      const endText = endMs !== void 0 ? formatMs(endMs) : "\u7ED3\u5C3E";
+      const spanText = endMs !== void 0 ? ` ${formatMs(endMs - startMs)}` : "";
+      const disclosure = `\u539F ${original} \u2192 \u7247\u6BB5 [${formatMs(startMs)}\u2013${endText}]${spanText} ${output.label}\uFF0C\u7247\u6BB5\u5916\u5185\u5BB9\u5168\u90E8\u4E22\u5F03`;
+      return mediaPolicyToolSuccess({
+        outputDir: this.params.outputDir,
+        outputFileName,
+        artifactKind: "audio",
+        title: "Clipped audio",
+        mimeType: output.mimeType,
+        sizeBytes: outputSizeBytes,
+        disclosure,
+        // Marks the artifact as a temporal excerpt for downstream role
+        // consumers (output routing selectors, memory coverage).
+        role: "clip"
+      });
+    } catch (error) {
+      return mediaPolicyToolFailure(error);
+    }
+  }
+};
+var OmniClipAudioTool = class extends BaseMediaPolicyTool {
+  static {
+    __name(this, "OmniClipAudioTool");
+  }
+  constructor(config) {
+    super(
+      OMNI_CLIP_AUDIO_TOOL_NAME,
+      "ClipAudio",
+      "Cuts a time span out of an audio file (sample-accurate re-encode), discarding everything outside the span, with a disclosure of the cut.",
+      "other" /* Other */,
+      {
+        type: "object",
+        properties: {
+          ...MEDIA_POLICY_IO_SCHEMA_PROPERTIES,
+          ...TUNABLE_SCHEMA_PROPERTIES
+        },
+        required: ["outputDir"],
+        additionalProperties: false
+      },
+      config
+    );
+  }
+  get mediaPolicyDescriptor() {
+    return DESCRIPTOR;
+  }
+  validateToolParamValues(params) {
+    const ioError = super.validateToolParamValues(params);
+    if (ioError) return ioError;
+    if (params.startMs === void 0 && params.durationMs === void 0) {
+      return "at least one of startMs / durationMs must be provided";
+    }
+    if (params.startMs === 0 && params.durationMs === void 0) {
+      return "startMs: 0 without durationMs selects the whole audio \u2014 a no-op clip that would only re-encode (and damage) the input";
+    }
+    if (params.durationMs !== void 0 && params.durationMs < MIN_DURATION_MS) {
+      return `durationMs must be at least ${MIN_DURATION_MS} (got ${params.durationMs})`;
+    }
+    return null;
+  }
+  createInvocation(params) {
+    return new ClipAudioInvocation(
+      params,
+      resolvePolicyToolTimeoutMs(this.configView, this.name)
+    );
+  }
+};
+export {
+  CLIP_AUDIO_DEFAULTS,
+  OMNI_CLIP_AUDIO_TOOL_NAME,
+  OmniClipAudioTool
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */