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

package/chunks/chunk-KSEKRQJO.js

@@ -0,0 +1,253 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  FatalConfigError
+} from "./chunk-S34QJ6IR.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/omni/ffmpeg.ts
+init_esbuild_shims();
+import { execFile } from "node:child_process";
+import path from "node:path";
+function execCommand(command, args, options = {}) {
+  return new Promise((resolve) => {
+    execFile(
+      command,
+      args,
+      { encoding: "utf8", ...options },
+      (error, stdout, stderr) => {
+        if (error) {
+          resolve({
+            stdout: String(stdout ?? ""),
+            stderr: String(stderr ?? ""),
+            code: typeof error.code === "number" ? error.code : 1
+          });
+          return;
+        }
+        resolve({
+          stdout: String(stdout ?? ""),
+          stderr: String(stderr ?? ""),
+          code: 0
+        });
+      }
+    );
+  });
+}
+__name(execCommand, "execCommand");
+var availabilityCache = /* @__PURE__ */ new Map();
+async function probeBinary(binary) {
+  const cached = availabilityCache.get(binary);
+  if (typeof cached === "boolean") return cached;
+  if (cached) return cached;
+  const probe = (async () => {
+    try {
+      const { code } = await execCommand(binary, ["-version"], {
+        timeout: 5e3
+      });
+      return code === 0;
+    } catch {
+      return false;
+    }
+  })().then(
+    (result) => {
+      availabilityCache.set(binary, result);
+      return result;
+    },
+    () => {
+      availabilityCache.delete(binary);
+      return false;
+    }
+  );
+  availabilityCache.set(binary, probe);
+  return probe;
+}
+__name(probeBinary, "probeBinary");
+async function isFfmpegAvailable() {
+  return probeBinary("ffmpeg");
+}
+__name(isFfmpegAvailable, "isFfmpegAvailable");
+async function isFfprobeAvailable() {
+  return probeBinary("ffprobe");
+}
+__name(isFfprobeAvailable, "isFfprobeAvailable");
+function resetFfmpegCachesForTests() {
+  availabilityCache.clear();
+}
+__name(resetFfmpegCachesForTests, "resetFfmpegCachesForTests");
+async function assertOmniRuntimeDependencies() {
+  const [ffmpeg, ffprobe] = await Promise.all([
+    isFfmpegAvailable(),
+    isFfprobeAvailable()
+  ]);
+  if (ffmpeg && ffprobe) return;
+  const missing = [
+    ...ffmpeg ? [] : ["ffmpeg"],
+    ...ffprobe ? [] : ["ffprobe"]
+  ].join(" and ");
+  throw new FatalConfigError(
+    `Omni multimodal support is enabled (omni.enabled / QWEN_CODE_ENABLE_OMNI=1) but ${missing} was not found on PATH. Install ffmpeg (e.g. "brew install ffmpeg" on macOS, "apt-get install ffmpeg" on Debian/Ubuntu) or disable omni support.`
+  );
+}
+__name(assertOmniRuntimeDependencies, "assertOmniRuntimeDependencies");
+async function runFfmpeg(args, options) {
+  const { code, stderr } = await execCommand("ffmpeg", args, {
+    // Transcodes are long-running; stderr carries progress lines, so give
+    // it more headroom than the probe calls.
+    maxBuffer: 16 * 1024 * 1024,
+    ...options?.timeoutMs !== void 0 && { timeout: options.timeoutMs },
+    ...options?.signal && { signal: options.signal }
+  });
+  return { code, stderr };
+}
+__name(runFfmpeg, "runFfmpeg");
+function parseFrameRate(raw) {
+  if (!raw) return void 0;
+  const parts = raw.split("/");
+  const num = Number(parts[0]);
+  const den = parts.length > 1 ? Number(parts[1]) : 1;
+  if (!Number.isFinite(num) || !Number.isFinite(den) || den === 0) {
+    return void 0;
+  }
+  const fps = num / den;
+  return Number.isFinite(fps) && fps > 0 ? fps : void 0;
+}
+__name(parseFrameRate, "parseFrameRate");
+function isAnimationCapableImage(formatName, codecName) {
+  const tokens = /* @__PURE__ */ new Set([
+    ...formatName?.split(",").map((t) => t.trim()) ?? [],
+    ...codecName ? [codecName] : []
+  ]);
+  return ["gif", "webp", "png", "apng"].some((t) => tokens.has(t));
+}
+__name(isAnimationCapableImage, "isAnimationCapableImage");
+async function countImageFrames(filePath, signal) {
+  try {
+    const { stdout, code } = await execCommand(
+      "ffprobe",
+      [
+        "-v",
+        "error",
+        "-count_frames",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=nb_read_frames",
+        "-print_format",
+        "json",
+        filePath
+      ],
+      {
+        timeout: 15e3,
+        maxBuffer: 4 * 1024 * 1024,
+        ...signal && { signal }
+      }
+    );
+    if (signal?.aborted || code !== 0) return NaN;
+    const parsed = JSON.parse(stdout);
+    return Number(parsed.streams?.[0]?.nb_read_frames);
+  } catch {
+    return NaN;
+  }
+}
+__name(countImageFrames, "countImageFrames");
+async function probeMediaMetadata(filePath, modality, signal) {
+  const { stdout, code, stderr } = await execCommand(
+    "ffprobe",
+    [
+      "-v",
+      "error",
+      "-print_format",
+      "json",
+      "-show_format",
+      "-show_streams",
+      filePath
+    ],
+    { timeout: 15e3, maxBuffer: 4 * 1024 * 1024, ...signal && { signal } }
+  );
+  if (signal?.aborted) {
+    throw new Error(`ffprobe aborted for ${path.basename(filePath)}`);
+  }
+  if (code !== 0) {
+    throw new Error(
+      `ffprobe failed (exit ${code}) for ${path.basename(filePath)}: ${stderr.slice(0, 300)}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new Error(
+      `ffprobe produced unparseable output for ${path.basename(filePath)}`
+    );
+  }
+  const videoStream = parsed.streams?.find((s) => s.codec_type === "video");
+  const audioStream = parsed.streams?.find((s) => s.codec_type === "audio");
+  const durationSeconds = Number(parsed.format?.duration);
+  const durationMs = Number.isFinite(durationSeconds) && durationSeconds >= 0 ? Math.round(durationSeconds * 1e3) : void 0;
+  const parsePositiveInt = /* @__PURE__ */ __name((raw) => {
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? Math.round(n) : void 0;
+  }, "parsePositiveInt");
+  const bitRateFor = /* @__PURE__ */ __name((stream) => parsePositiveInt(parsed.format?.bit_rate) ?? parsePositiveInt(stream?.bit_rate), "bitRateFor");
+  const base = { formatName: parsed.format?.format_name };
+  switch (modality) {
+    case "image": {
+      let nbFrames = Number(videoStream?.nb_frames);
+      if (!(Number.isFinite(nbFrames) && nbFrames > 0) && isAnimationCapableImage(
+        parsed.format?.format_name,
+        videoStream?.codec_name
+      )) {
+        nbFrames = await countImageFrames(filePath, signal);
+      }
+      return {
+        ...base,
+        width: videoStream?.width,
+        height: videoStream?.height,
+        codec: videoStream?.codec_name,
+        ...Number.isFinite(nbFrames) && nbFrames > 0 ? { frameCount: nbFrames } : {}
+      };
+    }
+    case "audio": {
+      const channels = audioStream?.channels;
+      return {
+        ...base,
+        durationMs,
+        codec: audioStream?.codec_name,
+        bitRate: bitRateFor(audioStream),
+        sampleRateHz: parsePositiveInt(audioStream?.sample_rate),
+        ...typeof channels === "number" && channels > 0 ? { channels } : {}
+      };
+    }
+    case "video":
+    default:
+      return {
+        ...base,
+        durationMs,
+        width: videoStream?.width,
+        height: videoStream?.height,
+        frameRate: parseFrameRate(videoStream?.avg_frame_rate) ?? parseFrameRate(videoStream?.r_frame_rate),
+        codec: videoStream?.codec_name,
+        bitRate: bitRateFor(videoStream)
+      };
+  }
+}
+__name(probeMediaMetadata, "probeMediaMetadata");
+
+export {
+  isFfmpegAvailable,
+  isFfprobeAvailable,
+  resetFfmpegCachesForTests,
+  assertOmniRuntimeDependencies,
+  runFfmpeg,
+  probeMediaMetadata
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-P42KMMU6.js → chunk-KWTLCPYY.js}

@@ -5,14 +5,14 @@ import {
 } from "./chunk-MLXTMF7H.js";
 import {
   stringifyGenAiJson
-} from "./chunk-KFFCDLKV.js";
+} from "./chunk-QE36VXWP.js";
 import {
   GOAL_STATE_EVENT_CAUSES,
   makeGoalStateEvent
-} from "./chunk-CDDP4ONL.js";
+} from "./chunk-G3PBYAGM.js";
 import {
   atomicWriteJSON
-} from "./chunk-XFFRI3WM.js";
+} from "./chunk-CA63HYHU.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT,
@@ -20,12 +20,14 @@ import {
   getMeter,
   isTelemetrySdkInitialized,
   isValidSensitiveSpanAttributeMaxLength
-} from "./chunk-6USYH3EU.js";
+} from "./chunk-B3XJFEEH.js";
 import {
-  FatalConfigError,
   QWEN_DIR,
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
+import {
+  FatalConfigError
+} from "./chunk-S34QJ6IR.js";
 import {
   ValueType,
   diag,
@@ -7854,6 +7856,16 @@ __name(goalPauseReasonForRunBudget, "goalPauseReasonForRunBudget");
 
 // packages/core/src/goals/goal-reducer.ts
 var MAX_BLOCKED_AUDIT_COUNT = 3;
+function reduceGoalSpend(goal, tokens, now) {
+  if (!Number.isFinite(tokens) || tokens <= 0) return goal;
+  return {
+    ...goal,
+    tokensUsed: goal.tokensUsed + tokens,
+    activeTimeMs: elapsedActiveTime(goal, now),
+    updatedAt: now
+  };
+}
+__name(reduceGoalSpend, "reduceGoalSpend");
 var GoalConflictError = class extends Error {
   constructor(current) {
     super("Goal version does not match the current session Goal");
@@ -10412,6 +10424,7 @@ export {
   goalPauseReasonForFailure,
   goalPauseReasonForHeadlessFailure,
   goalPauseReasonForRunBudget,
+  reduceGoalSpend,
   GoalConflictError,
   GoalInvalidTransitionError,
   elapsedActiveTime,

package/chunks/{chunk-U4AASWUQ.js → chunk-L4GF4IK2.js}

@@ -258,12 +258,12 @@ function ensureBuiltins() {
   if (!builtinsPromise) {
     builtinsPromise = (async () => {
       const labelled = [
-        { name: "telegram", promise: import("./dist-G5UMXIGF.js") },
+        { name: "telegram", promise: import("./dist-I6D6XOWV.js") },
         { name: "weixin", promise: import("./dist-VA4LREAQ.js") },
-        { name: "dingtalk", promise: import("./dist-BNW423XT.js") },
+        { name: "dingtalk", promise: import("./dist-CXDHIHN4.js") },
         { name: "dws", promise: import("./dist-4P3ZJYGI.js") },
         { name: "wecom", promise: import("./dist-XDRTR4QP.js") },
-        { name: "feishu", promise: import("./dist-UXVNLQHG.js") },
+        { name: "feishu", promise: import("./dist-VIKOMAGG.js") },
         { name: "qqbot", promise: import("./dist-CESMUYGN.js") },
         { name: "github", promise: import("./dist-DBBOFWSC.js") },
         { name: "gitlab", promise: import("./dist-7MGRENQ5.js") }

package/chunks/{chunk-5FK4MSHB.js → chunk-LADOQIYQ.js}

@@ -2,20 +2,22 @@
 "use strict";
 import {
   createTask
-} from "./chunk-WK6DEH3Q.js";
+} from "./chunk-PQQV3OBW.js";
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-AEWCOE64.js";
+} from "./chunk-GACWUBXV.js";
 import {
   resolveActiveTeamName
 } from "./chunk-S6LOFUVP.js";
 import {
   BaseDeclarativeTool,
-  BaseToolInvocation,
+  BaseToolInvocation
+} from "./chunk-VPGRGNNH.js";
+import {
   ToolDisplayNames,
   ToolNames
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-ERIBG3BX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-DJXSOEFB.js → chunk-LAE6RY3L.js}

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

package/chunks/{chunk-CQPM66MG.js → chunk-LG475XAV.js}

@@ -3,17 +3,17 @@
 import {
   getGitVersion,
   getNpmVersion
-} from "./chunk-FX6PZBOV.js";
+} from "./chunk-BJ2TJY7V.js";
 import {
   buildEnvStatusFromEnv,
   snapshotProcessEnv
-} from "./chunk-XICCGDWF.js";
+} from "./chunk-3WIPATJX.js";
 import {
   mapDomainErrorToErrorKind
-} from "./chunk-M23GFJ5B.js";
+} from "./chunk-EHMLJKF5.js";
 import {
   canUseRipgrep
-} from "./chunk-BTICBRPL.js";
+} from "./chunk-IWMYX5LB.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-3BZI5GDP.js → chunk-M5YIHMXP.js}

@@ -2,14 +2,16 @@
 "use strict";
 import {
   readRuntimeStatus
-} from "./chunk-CXONOVBN.js";
+} from "./chunk-KS6F6LZQ.js";
 import {
   atomicWriteJSON
-} from "./chunk-XFFRI3WM.js";
+} from "./chunk-CA63HYHU.js";
+import {
+  Storage
+} from "./chunk-ZYDMQCQP.js";
 import {
-  Storage,
   isNodeError
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-S34QJ6IR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-6WXVEDT2.js → chunk-MC2RYJMU.js}

@@ -6,13 +6,15 @@ import {
 import {
   MAX_CRON_TASK_ROUTING_ID_LENGTH,
   isValidCronTaskRoutingId
-} from "./chunk-3LMDSCLU.js";
+} from "./chunk-C4FISGDN.js";
 import {
   BaseDeclarativeTool,
-  BaseToolInvocation,
+  BaseToolInvocation
+} from "./chunk-VPGRGNNH.js";
+import {
   ToolDisplayNames,
   ToolNames
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-ERIBG3BX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-MNU36NGH.js

@@ -0,0 +1,233 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isPlainRecord
+} from "./chunk-BQMSZSG6.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/services/media-memory/registry.ts
+init_esbuild_shims();
+import { randomBytes } from "node:crypto";
+var MediaResourceRegistry = class {
+  static {
+    __name(this, "MediaResourceRegistry");
+  }
+  byResourceId = /* @__PURE__ */ new Map();
+  byVersionId = /* @__PURE__ */ new Map();
+  counter = 0;
+  /** Bind (or return the existing binding of) one file version. */
+  bind(input) {
+    const existing = this.byVersionId.get(input.fileVersionId);
+    if (existing) {
+      this.byVersionId.delete(input.fileVersionId);
+      this.byVersionId.set(input.fileVersionId, existing);
+      return existing;
+    }
+    const resourceId = `media-${++this.counter}-${randomBytes(4).toString("hex")}`;
+    const binding = { resourceId, ...input };
+    this.byResourceId.set(resourceId, binding);
+    this.byVersionId.set(input.fileVersionId, binding);
+    return binding;
+  }
+  /** Resolve a model-supplied handle. Undefined = never issued in this
+   * session (an unauthorized or fabricated id — callers must reject). */
+  resolve(resourceId) {
+    return this.byResourceId.get(resourceId);
+  }
+  /** Look up the binding already issued for a version, if any. */
+  resolveVersion(fileVersionId) {
+    return this.byVersionId.get(fileVersionId);
+  }
+  /** Look up a binding by its harness-side locator. Lets collection paths
+   * that only hold a resolved `inputPath` (a gated model call, where the
+   * gate already turned the handle back into a path) recover the memory
+   * identity without re-hashing the file, and lets recall reverse a
+   * path-form annotation back to its handle.
+   *
+   * When the same locator has been bound more than once this session (the
+   * same file re-read after its bytes changed, minting a distinct version),
+   * the LATEST-DELIVERED binding wins: a path names "the file at this path",
+   * and the most recently delivered version is the one the model is
+   * currently looking at — including after a revert to previously-seen bytes,
+   * because `bind` refreshes a re-delivered version's position. A path cannot
+   * name an older version — that ambiguity is the price of showing the path
+   * instead of the version-specific handle, and two path annotations for two
+   * versions in ONE request collapse to the latest. */
+  resolveByFileRef(fileRef) {
+    let latest;
+    for (const binding of this.byVersionId.values()) {
+      if (binding.fileRef === fileRef) latest = binding;
+    }
+    return latest;
+  }
+  /** Every locator this session currently has a handle for. GC treats
+   * these as roots alongside the memory snapshot: a resource delivered
+   * THIS turn may be bound here before its memory commit lands, and the
+   * sweep must not win that race. */
+  activeFileRefs() {
+    const refs = /* @__PURE__ */ new Set();
+    for (const binding of this.byVersionId.values()) {
+      refs.add(binding.fileRef);
+    }
+    return [...refs];
+  }
+};
+function resolveMediaReference(registry, reference) {
+  return registry.resolve(reference) ?? registry.resolveByFileRef(reference);
+}
+__name(resolveMediaReference, "resolveMediaReference");
+
+// packages/core/src/omni/policy/model-access.ts
+init_esbuild_shims();
+function resolveMediaPolicyModelAccess(config, toolName) {
+  const entry = config.getOmniPolicyToolsSettings?.()?.[toolName];
+  const modelAccess = isPlainRecord(entry) && isPlainRecord(entry["modelAccess"]) ? entry["modelAccess"] : void 0;
+  return {
+    enabled: modelAccess?.enabled === true,
+    defaultArguments: isPlainRecord(modelAccess?.defaultArguments) ? modelAccess.defaultArguments : {},
+    lockedArguments: isPlainRecord(modelAccess?.lockedArguments) ? modelAccess.lockedArguments : {},
+    description: typeof modelAccess?.description === "string" && modelAccess.description !== "" ? modelAccess.description : void 0,
+    parameterSchema: isPlainRecord(modelAccess?.parameterSchema) ? modelAccess.parameterSchema : void 0
+  };
+}
+__name(resolveMediaPolicyModelAccess, "resolveMediaPolicyModelAccess");
+function projectMediaPolicyToolDeclaration(config, native) {
+  const access = resolveMediaPolicyModelAccess(config, native.name);
+  const description = access.description ?? native.description;
+  const schema = isPlainRecord(native.parametersJsonSchema) ? native.parametersJsonSchema : void 0;
+  const nativeProps = schema && isPlainRecord(schema["properties"]) ? schema["properties"] : void 0;
+  if (!schema || !nativeProps) {
+    return {
+      name: native.name,
+      description,
+      parametersJsonSchema: native.parametersJsonSchema
+    };
+  }
+  const lockedKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(access.lockedArguments),
+    ...native.operatorOnlyParams ?? []
+  ]);
+  const narrowProps = access.parameterSchema && isPlainRecord(access.parameterSchema["properties"]) ? access.parameterSchema["properties"] : void 0;
+  const properties = {};
+  for (const [key, value] of Object.entries(nativeProps)) {
+    if (lockedKeys.has(key)) continue;
+    if (narrowProps && !(key in narrowProps)) continue;
+    const override = narrowProps?.[key];
+    properties[key] = isPlainRecord(override) && isPlainRecord(value) ? { ...value, ...override } : value;
+  }
+  const required = Array.isArray(schema["required"]) ? schema["required"].filter(
+    (key) => typeof key === "string" && key in properties
+  ) : void 0;
+  return {
+    name: native.name,
+    description,
+    parametersJsonSchema: {
+      ...schema,
+      properties,
+      ...required !== void 0 ? { required } : {}
+    }
+  };
+}
+__name(projectMediaPolicyToolDeclaration, "projectMediaPolicyToolDeclaration");
+function isMediaPolicyToolHiddenFromModel(config, tool) {
+  if (!tool.mediaPolicyDescriptor) return false;
+  return !resolveMediaPolicyModelAccess(config, tool.name).enabled;
+}
+__name(isMediaPolicyToolHiddenFromModel, "isMediaPolicyToolHiddenFromModel");
+function evaluateMediaPolicyToolCall(params) {
+  const { config, tool } = params;
+  let args = params.args;
+  const origin = params.executionOrigin ?? { kind: "model" };
+  if (origin.kind === "fixed_policy") {
+    if (!tool.mediaPolicyDescriptor) {
+      return {
+        outcome: "reject",
+        reason: "execution_denied",
+        message: `Tool "${tool.name}" cannot run with a fixed-policy execution origin: it is not a media policy tool.`
+      };
+    }
+    return { outcome: "pass", args };
+  }
+  if (!tool.mediaPolicyDescriptor) {
+    return { outcome: "pass", args };
+  }
+  const access = resolveMediaPolicyModelAccess(config, tool.name);
+  if (!access.enabled) {
+    return {
+      outcome: "reject",
+      reason: "execution_denied",
+      message: `Tool "${tool.name}" is an omni media policy tool reserved for fixed-policy orchestration. Direct calls require "omni.processing.policyTools.${tool.name}.modelAccess.enabled": true.`
+    };
+  }
+  if (typeof args["resourceId"] === "string") {
+    if (args["inputPath"] !== void 0) {
+      return {
+        outcome: "reject",
+        reason: "invalid_params",
+        message: `Invalid parameters for tool "${tool.name}": provide exactly one of "inputPath" or "resourceId", not both.`
+      };
+    }
+    const registry = config.getOmniMediaResourceRegistry?.();
+    const binding = registry ? resolveMediaReference(registry, args["resourceId"]) : void 0;
+    if (!binding) {
+      return {
+        outcome: "reject",
+        reason: "invalid_params",
+        message: `Invalid parameters for tool "${tool.name}": resourceId "${args["resourceId"]}" matches no media delivered this session. Use a handle or the absolute path from a \u3010\u5A92\u4F53\u8D44\u6E90\u3011 annotation or a recall result.`
+      };
+    }
+    const accepted = tool.mediaPolicyDescriptor.inputMediaTypes;
+    if (accepted !== void 0 && !accepted.includes(binding.mediaType)) {
+      return {
+        outcome: "reject",
+        reason: "invalid_params",
+        message: `Invalid parameters for tool "${tool.name}": resourceId "${args["resourceId"]}" names ${binding.mediaType} media, but this tool accepts ${accepted.join(", ")}. Pass a handle whose media type matches.`
+      };
+    }
+    const { resourceId: _resourceId, ...rest } = args;
+    args = { ...rest, inputPath: binding.fileRef };
+  }
+  const lockedKeys = Object.keys(access.lockedArguments);
+  const violations = lockedKeys.filter(
+    (key) => Object.prototype.hasOwnProperty.call(args, key)
+  );
+  if (violations.length > 0) {
+    return {
+      outcome: "reject",
+      reason: "invalid_params",
+      message: `Invalid parameters for tool "${tool.name}": ${violations.map((k) => `"${k}"`).join(", ")} ${violations.length === 1 ? "is" : "are"} locked by configuration and must not be provided. Remove ${violations.length === 1 ? "it" : "them"} and retry.`
+    };
+  }
+  const operatorViolations = (tool.mediaPolicyDescriptor.operatorOnlyParams ?? []).filter((key) => Object.prototype.hasOwnProperty.call(args, key));
+  if (operatorViolations.length > 0) {
+    return {
+      outcome: "reject",
+      reason: "invalid_params",
+      message: `Invalid parameters for tool "${tool.name}": ${operatorViolations.map((k) => `"${k}"`).join(", ")} ${operatorViolations.length === 1 ? "is" : "are"} operator-only (set via omni.processing.policyTools.${tool.name} configuration) and must not be provided by the caller. Remove ${operatorViolations.length === 1 ? "it" : "them"} and retry.`
+    };
+  }
+  return {
+    outcome: "pass",
+    args: { ...access.defaultArguments, ...args, ...access.lockedArguments }
+  };
+}
+__name(evaluateMediaPolicyToolCall, "evaluateMediaPolicyToolCall");
+
+export {
+  MediaResourceRegistry,
+  resolveMediaReference,
+  resolveMediaPolicyModelAccess,
+  projectMediaPolicyToolDeclaration,
+  isMediaPolicyToolHiddenFromModel,
+  evaluateMediaPolicyToolCall
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-M4U2LTD2.js → chunk-MS4SXNJ6.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   redactProxyCredentials
-} from "./chunk-7O5PYQ3M.js";
+} from "./chunk-SBP43AO6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";