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

package/chunks/reactive-degrade-KWCJUHXH.js

@@ -0,0 +1,375 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  DashScopeUploader,
+  OSS_URL_PREFIX
+} from "./chunk-V2XJJTAB.js";
+import {
+  runFixedPolicies
+} from "./chunk-CQULG2GJ.js";
+import "./chunk-UXEI7POA.js";
+import {
+  MediaMemoryService
+} from "./chunk-SLHYLVRW.js";
+import "./chunk-YDERQ7ZV.js";
+import "./chunk-RSFNJ6UU.js";
+import {
+  DEFAULT_UPLOAD_CACHE_TTL_HOURS,
+  OmniUploadCache
+} from "./chunk-JYGESWZM.js";
+import "./chunk-TFDCK56Y.js";
+import {
+  OmniObjectStore
+} from "./chunk-FTKXJMQV.js";
+import {
+  extensionForMime,
+  hashFileSha256,
+  recognizeMediaFile
+} from "./chunk-S5BHLTHK.js";
+import "./chunk-KSEKRQJO.js";
+import {
+  isOmniDeliveryActive
+} from "./chunk-DBDJRURL.js";
+import "./chunk-MNU36NGH.js";
+import {
+  requireEffectiveOmniUploadConfig
+} from "./chunk-UQRDQCWF.js";
+import "./chunk-BQMSZSG6.js";
+import {
+  formatDisclosureText
+} from "./chunk-BKVPLSEI.js";
+import "./chunk-2VWXODMY.js";
+import "./chunk-366JNNY7.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-GW5SJ3II.js";
+import "./chunk-XZA32HII.js";
+import "./chunk-CA63HYHU.js";
+import "./chunk-SBP43AO6.js";
+import "./chunk-VPGRGNNH.js";
+import {
+  ToolNames
+} from "./chunk-ERIBG3BX.js";
+import {
+  createDebugLogger
+} from "./chunk-ZYDMQCQP.js";
+import "./chunk-S34QJ6IR.js";
+import "./chunk-TBWQLLFO.js";
+import "./chunk-UKMWZ5NS.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/omni/reactive-degrade.ts
+init_esbuild_shims();
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+var debugLogger = createDebugLogger("omni:reactive-degrade");
+var REACTIVE_LADDERS = {
+  video: {
+    toolName: ToolNames.OMNI_DOWNSCALE_VIDEO,
+    steps: [
+      { maxHeight: 480, fps: 2 },
+      { maxHeight: 360, fps: 0.5 },
+      { maxHeight: 360, fps: 0.25 }
+    ]
+  },
+  image: {
+    toolName: ToolNames.OMNI_DOWNSAMPLE_IMAGE,
+    steps: [
+      { maxDimension: 1024, quality: 70 },
+      { maxDimension: 640, quality: 60 },
+      { maxDimension: 448, quality: 50 }
+    ]
+  },
+  audio: {
+    toolName: ToolNames.OMNI_DOWNSAMPLE_AUDIO,
+    steps: [
+      { bitrateKbps: 32, sampleRateHz: 16e3, channels: 1 },
+      { bitrateKbps: 16, sampleRateHz: 16e3, channels: 1 },
+      { bitrateKbps: 12, sampleRateHz: 8e3, channels: 1 }
+    ]
+  }
+};
+var observedServerInputLimits = /* @__PURE__ */ new Map();
+function recordObservedServerInputLimit(model, limitTokens) {
+  if (!Number.isFinite(limitTokens) || limitTokens <= 0) return;
+  const prior = observedServerInputLimits.get(model);
+  if (prior === void 0 || limitTokens < prior) {
+    observedServerInputLimits.set(model, limitTokens);
+    debugLogger.info(
+      `observed server input limit for ${model}: ${limitTokens} tokens`
+    );
+  }
+}
+__name(recordObservedServerInputLimit, "recordObservedServerInputLimit");
+function getObservedServerInputLimit(model) {
+  return observedServerInputLimits.get(model);
+}
+__name(getObservedServerInputLimit, "getObservedServerInputLimit");
+function resetObservedServerInputLimitsForTests() {
+  observedServerInputLimits.clear();
+}
+__name(resetObservedServerInputLimitsForTests, "resetObservedServerInputLimitsForTests");
+function* iterateParts(content) {
+  for (const part of content.parts ?? []) {
+    yield part;
+    const nested = part.functionResponse?.parts;
+    if (Array.isArray(nested)) {
+      yield* nested;
+    }
+  }
+}
+__name(iterateParts, "iterateParts");
+function collectOssMediaRefs(contents) {
+  const byUri = /* @__PURE__ */ new Map();
+  for (const content of contents) {
+    for (const part of iterateParts(content)) {
+      const fileData = part.fileData;
+      if (!fileData?.fileUri?.startsWith(OSS_URL_PREFIX)) continue;
+      if (byUri.has(fileData.fileUri)) continue;
+      byUri.set(fileData.fileUri, {
+        fileUri: fileData.fileUri,
+        mimeType: fileData.mimeType ?? "",
+        displayName: fileData.displayName ?? path.basename(fileData.fileUri)
+      });
+    }
+  }
+  return [...byUri.values()];
+}
+__name(collectOssMediaRefs, "collectOssMediaRefs");
+function contentsHaveOssMedia(contents) {
+  return contents.some((content) => {
+    for (const part of iterateParts(content)) {
+      if (part.fileData?.fileUri?.startsWith(OSS_URL_PREFIX)) return true;
+    }
+    return false;
+  });
+}
+__name(contentsHaveOssMedia, "contentsHaveOssMedia");
+async function findObjectPath(store, sha256) {
+  const dir = path.join(store.getObjectsDir(), sha256.slice(0, 2));
+  let names;
+  try {
+    names = await fs.readdir(dir);
+  } catch {
+    return null;
+  }
+  const match = names.find((name) => name.startsWith(sha256));
+  return match ? path.join(dir, match) : null;
+}
+__name(findObjectPath, "findObjectPath");
+function buildLadderPolicy(base, modality, attempt) {
+  const ladder = REACTIVE_LADDERS[modality];
+  const rung = ladder.steps[Math.min(attempt, ladder.steps.length - 1)];
+  const args = base.toolName === ladder.toolName ? { ...base.arguments, ...rung } : base.arguments;
+  return {
+    ...base,
+    id: `${base.id}.reactive-${attempt}`,
+    when: void 0,
+    onConditionUnavailable: "run",
+    arguments: args,
+    maxRunsPerLineage: 1,
+    output: {
+      reprocessMedia: false,
+      source: "omit",
+      artifacts: { "*": "include" }
+    },
+    stage: "transport_guard"
+  };
+}
+__name(buildLadderPolicy, "buildLadderPolicy");
+function applyOssMediaReplacements(contents, replacements) {
+  let replacedParts = 0;
+  const swapInParts = /* @__PURE__ */ __name((parts) => {
+    const nextParts = [];
+    let changed = false;
+    for (const part of parts) {
+      const uri = part.fileData?.fileUri;
+      const replacement = uri ? replacements.get(uri) : void 0;
+      if (replacement && part.fileData) {
+        nextParts.push({ text: replacement.disclosureText });
+        nextParts.push({
+          fileData: {
+            ...part.fileData,
+            fileUri: replacement.fileUri,
+            mimeType: replacement.mimeType
+          }
+        });
+        replacedParts++;
+        changed = true;
+        continue;
+      }
+      const nested = part.functionResponse?.parts;
+      if (Array.isArray(nested)) {
+        const swappedNested = swapInParts(nested);
+        if (swappedNested) {
+          nextParts.push({
+            ...part,
+            functionResponse: {
+              ...part.functionResponse,
+              parts: swappedNested
+            }
+          });
+          changed = true;
+          continue;
+        }
+      }
+      nextParts.push(part);
+    }
+    return changed ? nextParts : null;
+  }, "swapInParts");
+  for (const content of contents) {
+    if (!content.parts?.length) continue;
+    const swapped = swapInParts(content.parts);
+    if (swapped) content.parts = swapped;
+  }
+  return replacedParts;
+}
+__name(applyOssMediaReplacements, "applyOssMediaReplacements");
+async function degradeOmniMediaAfterServerReject(config, contents, attempt, options) {
+  const none = {
+    replacedParts: 0,
+    degradedResources: 0
+  };
+  const signal = options?.signal;
+  if (!isOmniDeliveryActive(config)) return none;
+  const processingConfig = config.getOmniProcessingConfig?.();
+  if (!processingConfig) return none;
+  const refs = collectOssMediaRefs(contents);
+  if (refs.length === 0) return none;
+  const inferenceModel = config.getModel();
+  if (options?.observedLimitTokens !== void 0) {
+    recordObservedServerInputLimit(inferenceModel, options.observedLimitTokens);
+  }
+  const uploadConfig = requireEffectiveOmniUploadConfig(config);
+  const uploadModel = uploadConfig.model;
+  const store = new OmniObjectStore(config.storage.getQwenDir());
+  const cacheScope = createHash("sha256").update(`${uploadConfig.baseUrl}|${uploadConfig.apiKey}`).digest("hex").slice(0, 16);
+  const uploadCache = new OmniUploadCache(
+    store.getOmniRootDir(),
+    config.getOmniUploadUrlTtlHours?.() ?? DEFAULT_UPLOAD_CACHE_TTL_HOURS,
+    cacheScope
+  );
+  const memoryConfig = config.getOmniMemoryConfig?.();
+  const memoryService = memoryConfig ? new MediaMemoryService(store.getOmniRootDir(), {
+    maxInlineTextBytes: memoryConfig.collection.maxInlineTextBytes
+  }) : void 0;
+  const replacements = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    if (signal?.aborted) break;
+    try {
+      const sha256 = await uploadCache.findSha256ByUrl(ref.fileUri);
+      if (!sha256) {
+        debugLogger.debug(
+          `no upload-cache mapping for ${ref.fileUri}; skipping`
+        );
+        continue;
+      }
+      const objectPath = await findObjectPath(store, sha256);
+      if (!objectPath) {
+        debugLogger.debug(
+          `object ${sha256.slice(0, 12)}\u2026 not in store; skipping`
+        );
+        continue;
+      }
+      const recognized = await recognizeMediaFile(objectPath, { signal });
+      const basePolicy = processingConfig.transportGuardPolicies.find(
+        (p) => p.mediaTypes.includes(recognized.modality)
+      );
+      if (!basePolicy) continue;
+      const policy = buildLadderPolicy(
+        basePolicy,
+        recognized.modality,
+        attempt
+      );
+      const sourceBinding = memoryService ? await memoryService.findBindingBySha256(sha256) : void 0;
+      const { deliveries } = await runFixedPolicies(
+        config,
+        {
+          filePath: objectPath,
+          recognized,
+          displayName: ref.displayName,
+          origin: "user",
+          sha256
+        },
+        {
+          store,
+          policies: [policy],
+          signal,
+          limits: processingConfig.limits,
+          memory: memoryService && sourceBinding ? { service: memoryService, sourceBinding } : void 0
+        }
+      );
+      const delivery = deliveries[0];
+      if (!delivery || delivery.filePath === objectPath) {
+        debugLogger.debug(
+          `reactive rung ${attempt} made no progress on ${ref.displayName}`
+        );
+        continue;
+      }
+      const derivedSha = delivery.sha256 ?? await hashFileSha256(delivery.filePath, signal);
+      let fileUri = await uploadCache.get(derivedSha, uploadModel);
+      if (!fileUri) {
+        const { objectPath: derivedPath } = await store.putFile(
+          delivery.filePath,
+          derivedSha,
+          extensionForMime(delivery.recognized.detectedMimeType),
+          signal
+        );
+        const uploader = new DashScopeUploader({
+          apiKey: uploadConfig.apiKey,
+          baseUrl: uploadConfig.baseUrl
+        });
+        fileUri = await uploader.uploadFile({
+          filePath: derivedPath,
+          model: uploadModel,
+          mimeType: delivery.recognized.detectedMimeType,
+          signal
+        });
+        await uploadCache.put(derivedSha, uploadModel, fileUri);
+      }
+      if (fileUri === ref.fileUri) continue;
+      const disclosureText = formatDisclosureText(
+        ref.displayName,
+        `${delivery.disclosure ?? "\u5DF2\u8FDB\u4E00\u6B65\u964D\u8D28"}\uFF08\u670D\u52A1\u7AEF\u8F93\u5165\u8D85\u9650\uFF0C\u7B2C ${attempt + 1} \u6B21\u964D\u8D28\u91CD\u8BD5\uFF09`
+      );
+      replacements.set(ref.fileUri, {
+        fileUri,
+        mimeType: delivery.recognized.detectedMimeType,
+        disclosureText
+      });
+      debugLogger.info(
+        `reactive degrade rung ${attempt}: ${ref.displayName} ${sha256.slice(0, 12)}\u2026 \u2192 ${derivedSha.slice(0, 12)}\u2026 (${recognized.modality})`
+      );
+    } catch (err) {
+      if (signal?.aborted) throw err;
+      debugLogger.warn(
+        `reactive degrade failed for ${ref.displayName}; skipping`,
+        err
+      );
+    }
+  }
+  if (replacements.size === 0) return none;
+  const replacedParts = applyOssMediaReplacements(contents, replacements);
+  return { replacedParts, degradedResources: replacements.size };
+}
+__name(degradeOmniMediaAfterServerReject, "degradeOmniMediaAfterServerReject");
+export {
+  applyOssMediaReplacements,
+  buildLadderPolicy,
+  collectOssMediaRefs,
+  contentsHaveOssMedia,
+  degradeOmniMediaAfterServerReject,
+  getObservedServerInputLimit,
+  recordObservedServerInputLimit,
+  resetObservedServerInputLimitsForTests
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/read-file-ZQKBXJSH.js

@@ -0,0 +1,37 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  ReadFileTool,
+  buildReadFileDescription
+} from "./chunk-G3PBYAGM.js";
+import "./chunk-5ETULJLP.js";
+import "./chunk-VGC4I5JJ.js";
+import "./chunk-RVT5L74D.js";
+import "./chunk-HD7O6WLV.js";
+import "./chunk-25FMWESU.js";
+import "./chunk-CFMZLE3L.js";
+import "./chunk-43QUA4MC.js";
+import "./chunk-WZAD4ZNJ.js";
+import "./chunk-EKBQJ627.js";
+import "./chunk-GW5SJ3II.js";
+import "./chunk-XZA32HII.js";
+import "./chunk-CA63HYHU.js";
+import "./chunk-SBP43AO6.js";
+import "./chunk-HHJLM3WQ.js";
+import "./chunk-B3XJFEEH.js";
+import "./chunk-74TONY4F.js";
+import "./chunk-ZRQGTRHA.js";
+import "./chunk-VPGRGNNH.js";
+import "./chunk-ERIBG3BX.js";
+import "./chunk-ZYDMQCQP.js";
+import "./chunk-S34QJ6IR.js";
+import "./chunk-TBWQLLFO.js";
+import "./chunk-75DOP5OR.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
+import "./chunk-5O2XNYP6.js";
+import "./chunk-J2S4EL5Y.js";
+export {
+  ReadFileTool,
+  buildReadFileDescription
+};

package/chunks/{read-mcp-resource-LPSWXVOD.js → read-mcp-resource-INJIV3UC.js}

@@ -8,14 +8,18 @@ import {
 } from "./chunk-ZPJWUGCS.js";
 import {
   BaseDeclarativeTool,
-  BaseToolInvocation,
+  BaseToolInvocation
+} from "./chunk-VPGRGNNH.js";
+import {
   ToolDisplayNames,
   ToolNames
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-ERIBG3BX.js";
+import {
+  createDebugLogger
+} from "./chunk-ZYDMQCQP.js";
 import {
-  createDebugLogger,
   getErrorMessage
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-S34QJ6IR.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims

package/chunks/recall-media-memory-tool-PEE2BWRY.js

@@ -0,0 +1,198 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  createMediaMemoryRecallService
+} from "./chunk-DJYHML3Y.js";
+import {
+  MediaMemoryRecallRejection
+} from "./chunk-SLHYLVRW.js";
+import {
+  OMNI_MEMORY_RECALL_KINDS
+} from "./chunk-YDERQ7ZV.js";
+import "./chunk-TFDCK56Y.js";
+import "./chunk-FTKXJMQV.js";
+import "./chunk-S5BHLTHK.js";
+import "./chunk-KSEKRQJO.js";
+import {
+  resolveMediaReference
+} from "./chunk-MNU36NGH.js";
+import "./chunk-BQMSZSG6.js";
+import "./chunk-BKVPLSEI.js";
+import "./chunk-CA63HYHU.js";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation
+} from "./chunk-VPGRGNNH.js";
+import {
+  ToolDisplayNames,
+  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/recall-media-memory-tool.ts
+init_esbuild_shims();
+var OmniRecallMediaMemoryInvocation = class extends BaseToolInvocation {
+  constructor(config, params) {
+    super(params);
+    this.config = config;
+  }
+  static {
+    __name(this, "OmniRecallMediaMemoryInvocation");
+  }
+  getDescription() {
+    const handles = this.params.resourceIds.join(", ");
+    return `Recall media memory for ${handles}`;
+  }
+  async execute(_signal) {
+    const service = createMediaMemoryRecallService(this.config);
+    if (!service) {
+      return {
+        llmContent: "Media memory is not available in this session (omni memory is not configured).",
+        returnDisplay: "Media memory unavailable",
+        error: {
+          message: "omni memory is not configured",
+          type: "execution_failed" /* EXECUTION_FAILED */
+        }
+      };
+    }
+    try {
+      const result = await service.recall({
+        resourceIds: this.params.resourceIds,
+        query: this.params.query,
+        ...this.params.kinds !== void 0 ? { kinds: this.params.kinds } : {},
+        ...this.params.roles !== void 0 ? { roles: this.params.roles } : {},
+        ...this.params.includeHistoricalVersions !== void 0 ? {
+          includeHistoricalVersions: this.params.includeHistoricalVersions
+        } : {},
+        ...this.params.limit !== void 0 ? { limit: this.params.limit } : {}
+      });
+      return {
+        llmContent: JSON.stringify(result, null, 1),
+        returnDisplay: `Recall ${result.status}: ${result.entries.length} entr${result.entries.length === 1 ? "y" : "ies"}, ${result.gaps.length} gap${result.gaps.length === 1 ? "" : "s"}` + (result.nextPolicyActions?.length ? `, ${result.nextPolicyActions.length} suggested action${result.nextPolicyActions.length === 1 ? "" : "s"}` : "")
+      };
+    } catch (err) {
+      if (err instanceof MediaMemoryRecallRejection) {
+        return {
+          llmContent: `Recall request rejected (${err.reason}): ${err.message}`,
+          returnDisplay: `Recall rejected: ${err.reason}`,
+          error: {
+            message: err.message,
+            type: "invalid_tool_params" /* INVALID_TOOL_PARAMS */
+          }
+        };
+      }
+      throw err;
+    }
+  }
+};
+var OmniRecallMediaMemoryTool = class _OmniRecallMediaMemoryTool extends BaseDeclarativeTool {
+  constructor(config) {
+    super(
+      _OmniRecallMediaMemoryTool.Name,
+      ToolDisplayNames.OMNI_RECALL_MEDIA_MEMORY,
+      "Recalls what is already known about media resources delivered in this session: prior transcripts, extracted keyframes, technical metadata, and processing history persisted by earlier sessions. Pass the reference announced next to delivered media \u2014 the \u3010\u5A92\u4F53\u8DEF\u5F84\u3011<absolute path> of a local file you read, or the \u3010\u5A92\u4F53\u8D44\u6E90\u3011<resourceId> handle of path-less media (handles from recall results work too). Returns matching entries plus honest gaps \u2014 channels never processed or artifacts no longer available \u2014 and may suggest follow-up tool calls to gather missing evidence. Use this BEFORE reprocessing media: a transcript or keyframe set that already exists is returned instantly.",
+      "read" /* Read */,
+      {
+        type: "object",
+        properties: {
+          resourceIds: {
+            type: "array",
+            // maxLength admits a full absolute path (the path form), not just
+            // a ~16-char media-<n>-<hex> handle — an over-long bound would let
+            // Ajv reject the very path the annotation displayed, before
+            // resolution, with no shorter identifier to retry.
+            items: { type: "string", minLength: 1, maxLength: 4096 },
+            minItems: 1,
+            description: "Resource references to consult, each taken from a \u3010\u5A92\u4F53\u8DEF\u5F84\u3011 or \u3010\u5A92\u4F53\u8D44\u6E90\u3011 annotation or a prior recall result: the absolute path shown for a local file you read, or an opaque session handle. An unresolvable reference rejects the whole request."
+          },
+          query: {
+            type: "string",
+            minLength: 1,
+            maxLength: 2048,
+            description: "Free-text information need; orders results by relevance."
+          },
+          kinds: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: [...OMNI_MEMORY_RECALL_KINDS]
+            },
+            // An empty list would read as "restrict to nothing" and return a
+            // silent miss; omit the key instead to mean "all kinds".
+            minItems: 1,
+            uniqueItems: true,
+            description: "Restrict to entry kinds (default: all configured kinds)."
+          },
+          roles: {
+            type: "array",
+            items: { type: "string", minLength: 1, maxLength: 128 },
+            minItems: 1,
+            uniqueItems: true,
+            description: 'Restrict to artifact roles (e.g. "transcript", "keyframe").'
+          },
+          includeHistoricalVersions: {
+            type: "boolean",
+            description: "Also consult superseded file versions (default: only the current version)."
+          },
+          limit: {
+            type: "integer",
+            minimum: 1,
+            description: "Maximum entries to return (capped by session config)."
+          }
+        },
+        required: ["resourceIds", "query"],
+        additionalProperties: false
+      },
+      false,
+      // isOutputMarkdown — structured JSON payload
+      false,
+      // canUpdateOutput
+      true,
+      // shouldDefer — recall is an occasional lookup (matches web_fetch)
+      false,
+      // alwaysLoad
+      "recall media memory transcript keyframe history resource"
+    );
+    this.config = config;
+  }
+  static {
+    __name(this, "OmniRecallMediaMemoryTool");
+  }
+  static Name = ToolNames.OMNI_RECALL_MEDIA_MEMORY;
+  validateToolParamValues(params) {
+    const maxFiles = this.config.getOmniMemoryConfig()?.recall.active.maxFilesPerCall;
+    if (maxFiles === void 0) return null;
+    const registry = this.config.getOmniMediaResourceRegistry?.();
+    const resolved = /* @__PURE__ */ new Set();
+    const unresolvable = /* @__PURE__ */ new Set();
+    for (const reference of params.resourceIds) {
+      const binding = registry ? resolveMediaReference(registry, reference) : void 0;
+      if (binding) resolved.add(binding.resourceId);
+      else unresolvable.add(reference);
+    }
+    const distinct = resolved.size + unresolvable.size;
+    if (distinct > maxFiles) {
+      return `resourceIds resolves to ${distinct} distinct media files; at most ${maxFiles} may be consulted per call (omni.memory.recall.active.maxFilesPerCall). Split the request.`;
+    }
+    return null;
+  }
+  createInvocation(params) {
+    return new OmniRecallMediaMemoryInvocation(this.config, params);
+  }
+};
+export {
+  OmniRecallMediaMemoryTool
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{record-artifact-L3CFJOMA.js → record-artifact-KKW3AIMJ.js}

@@ -7,10 +7,12 @@ import {
   hasControlCharacter,
   hasUnsafeDisplayPayload,
   isRecordableDerivedChild
-} from "./chunk-TRZ22SG5.js";
-import "./chunk-5NUKK2DT.js";
-import "./chunk-RSWBT7AZ.js";
-import "./chunk-ZAFYHRVY.js";
+} from "./chunk-FXPP7VLM.js";
+import "./chunk-25FMWESU.js";
+import "./chunk-VPGRGNNH.js";
+import "./chunk-ERIBG3BX.js";
+import "./chunk-ZYDMQCQP.js";
+import "./chunk-S34QJ6IR.js";
 import "./chunk-TBWQLLFO.js";
 import "./chunk-5O2XNYP6.js";
 import "./chunk-J2S4EL5Y.js";

package/chunks/record-source-2VSQINX6.js

@@ -0,0 +1,24 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  RecordSourceTool
+} from "./chunk-QQPRTJOM.js";
+import "./chunk-ELRMZTPF.js";
+import "./chunk-GACWUBXV.js";
+import "./chunk-JX6XHPTX.js";
+import "./chunk-BXAU2UKM.js";
+import "./chunk-S6LOFUVP.js";
+import "./chunk-CTGMXP4A.js";
+import "./chunk-2GNZTJRK.js";
+import "./chunk-RMI3DKMV.js";
+import "./chunk-IITTKFWM.js";
+import "./chunk-VPGRGNNH.js";
+import "./chunk-ERIBG3BX.js";
+import "./chunk-ZYDMQCQP.js";
+import "./chunk-S34QJ6IR.js";
+import "./chunk-TBWQLLFO.js";
+import "./chunk-5O2XNYP6.js";
+import "./chunk-J2S4EL5Y.js";
+export {
+  RecordSourceTool
+};

package/chunks/{report-findings-LY5HQY4K.js → report-findings-OZSLWYAS.js}

@@ -13,11 +13,13 @@ import {
   ReportFindingsTool,
   SHORT_SUMMARY_MAX,
   compressFindingSummary
-} from "./chunk-X7AYIXC7.js";
-import "./chunk-TRZ22SG5.js";
-import "./chunk-5NUKK2DT.js";
-import "./chunk-RSWBT7AZ.js";
-import "./chunk-ZAFYHRVY.js";
+} from "./chunk-DJLCK66M.js";
+import "./chunk-FXPP7VLM.js";
+import "./chunk-25FMWESU.js";
+import "./chunk-VPGRGNNH.js";
+import "./chunk-ERIBG3BX.js";
+import "./chunk-ZYDMQCQP.js";
+import "./chunk-S34QJ6IR.js";
 import "./chunk-TBWQLLFO.js";
 import "./chunk-5O2XNYP6.js";
 import "./chunk-J2S4EL5Y.js";