@softactivate/adk 1.1.0

package/dist/cjs/tools/vertex_ai_search_tool.js

@@ -0,0 +1,127 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vertex_ai_search_tool_exports = {};
+__export(vertex_ai_search_tool_exports, {
+  VertexAiSearchTool: () => VertexAiSearchTool
+});
+module.exports = __toCommonJS(vertex_ai_search_tool_exports);
+var import_logger = require("../utils/logger.js");
+var import_model_name = require("../utils/model_name.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = (0, import_logger.getLogger)();
+class VertexAiSearchTool extends import_base_tool.BaseTool {
+  constructor(params) {
+    super({ name: "vertex_ai_search", description: "vertex_ai_search" });
+    const {
+      dataStoreId,
+      dataStoreSpecs,
+      searchEngineId,
+      filter,
+      maxResults,
+      bypassMultiToolsLimit = false
+    } = params;
+    if (dataStoreId === void 0 && searchEngineId === void 0 || dataStoreId !== void 0 && searchEngineId !== void 0) {
+      throw new Error(
+        "Either dataStoreId or searchEngineId must be specified."
+      );
+    }
+    if (dataStoreSpecs !== void 0 && searchEngineId === void 0) {
+      throw new Error(
+        "searchEngineId must be specified if dataStoreSpecs is specified."
+      );
+    }
+    this.dataStoreId = dataStoreId;
+    this.dataStoreSpecs = dataStoreSpecs;
+    this.searchEngineId = searchEngineId;
+    this.filter = filter;
+    this.maxResults = maxResults;
+    this.bypassMultiToolsLimit = bypassMultiToolsLimit;
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  /**
+   * Builds the VertexAISearch configuration.
+   *
+   * Override this method in a subclass to dynamically customize the search
+   * configuration based on the context (e.g., set filter based on session
+   * state).
+   */
+  buildVertexAiSearchConfig(_readonlyContext) {
+    return {
+      datastore: this.dataStoreId,
+      dataStoreSpecs: this.dataStoreSpecs,
+      engine: this.searchEngineId,
+      filter: this.filter,
+      maxResults: this.maxResults
+    };
+  }
+  async processLlmRequest({
+    toolContext,
+    llmRequest
+  }) {
+    if (!llmRequest.model) {
+      return;
+    }
+    const modelCheckDisabled = (0, import_model_name.isGeminiModelIdCheckDisabled)();
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    if (!(0, import_model_name.isGeminiModel)(llmRequest.model) && !modelCheckDisabled) {
+      throw new Error(
+        `Vertex AI search tool is not supported for model ${llmRequest.model}`
+      );
+    }
+    if ((0, import_model_name.isGemini1Model)(llmRequest.model) && llmRequest.config.tools.length > 0 && !this.bypassMultiToolsLimit) {
+      throw new Error(
+        "Vertex AI search tool cannot be used with other tools in Gemini 1.x."
+      );
+    }
+    const vertexAiSearchConfig = this.buildVertexAiSearchConfig(toolContext);
+    let specsInfo;
+    if (vertexAiSearchConfig.dataStoreSpecs) {
+      const specIds = vertexAiSearchConfig.dataStoreSpecs.map(
+        (spec) => spec.dataStore ? spec.dataStore.split("/").pop() : "unnamed"
+      );
+      specsInfo = `${vertexAiSearchConfig.dataStoreSpecs.length} spec(s): [${specIds.join(", ")}]`;
+    }
+    logger.debug(
+      `Adding Vertex AI Search tool config to LLM request: datastore=${vertexAiSearchConfig.datastore}, engine=${vertexAiSearchConfig.engine}, filter=${vertexAiSearchConfig.filter}, maxResults=${vertexAiSearchConfig.maxResults}, dataStoreSpecs=${specsInfo}`
+    );
+    llmRequest.config.tools.push({
+      retrieval: {
+        vertexAiSearch: vertexAiSearchConfig
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VertexAiSearchTool
+});

package/dist/cjs/tools/vertex_rag_retrieval_tool.js

@@ -0,0 +1,64 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vertex_rag_retrieval_tool_exports = {};
+__export(vertex_rag_retrieval_tool_exports, {
+  VertexRagRetrievalTool: () => VertexRagRetrievalTool
+});
+module.exports = __toCommonJS(vertex_rag_retrieval_tool_exports);
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class VertexRagRetrievalTool extends import_base_tool.BaseTool {
+  constructor(config) {
+    super({
+      name: "vertex_rag_retrieval",
+      description: "Vertex AI RAG Retrieval Tool"
+    });
+    this.vertexRagStore = config;
+  }
+  /**
+   * This tool is executed server-side by the Vertex AI RAG Engine.
+   * Local execution is not required.
+   */
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    llmRequest.config.tools.push({
+      retrieval: { vertexRagStore: this.vertexRagStore }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VertexRagRetrievalTool
+});

package/dist/cjs/utils/client_labels.js

@@ -0,0 +1,56 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_labels_exports = {};
+__export(client_labels_exports, {
+  getClientLabels: () => getClientLabels
+});
+module.exports = __toCommonJS(client_labels_exports);
+var import_version = require("../version.js");
+var import_env_aware_utils = require("./env_aware_utils.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const ADK_LABEL = "google-adk";
+const LANGUAGE_LABEL = "gl-typescript";
+const AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
+const AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
+function _getDefaultLabels() {
+  let frameworkLabel = `${ADK_LABEL}/${import_version.version}`;
+  if (!(0, import_env_aware_utils.isBrowser)() && process.env[AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME]) {
+    frameworkLabel = `${frameworkLabel}+${AGENT_ENGINE_TELEMETRY_TAG}`;
+  }
+  const languageLabel = `${LANGUAGE_LABEL}/${(0, import_env_aware_utils.isBrowser)() ? window.navigator.userAgent : process.version}`;
+  return [frameworkLabel, languageLabel];
+}
+function getClientLabels() {
+  const labels = _getDefaultLabels();
+  return labels;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getClientLabels
+});

package/dist/cjs/utils/env_aware_utils.js

@@ -0,0 +1,92 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var env_aware_utils_exports = {};
+__export(env_aware_utils_exports, {
+  base64Decode: () => base64Decode,
+  base64Encode: () => base64Encode,
+  getBooleanEnvVar: () => getBooleanEnvVar,
+  isBase64Encoded: () => isBase64Encoded,
+  isBrowser: () => isBrowser,
+  randomUUID: () => randomUUID
+});
+module.exports = __toCommonJS(env_aware_utils_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+const UUID_MASK = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+function randomUUID() {
+  let uuid = "";
+  for (let i = 0; i < UUID_MASK.length; i++) {
+    const randomValue = Math.random() * 16 | 0;
+    if (UUID_MASK[i] === "x") {
+      uuid += randomValue.toString(16);
+    } else if (UUID_MASK[i] === "y") {
+      uuid += (randomValue & 3 | 8).toString(16);
+    } else {
+      uuid += UUID_MASK[i];
+    }
+  }
+  return uuid;
+}
+function base64Encode(data) {
+  if (isBrowser()) {
+    return window.btoa(data);
+  }
+  return Buffer.from(data).toString("base64");
+}
+function base64Decode(data) {
+  if (isBrowser()) {
+    return window.atob(data);
+  }
+  return Buffer.from(data, "base64").toString();
+}
+function isBase64Encoded(data) {
+  try {
+    return base64Encode(base64Decode(data)) === data;
+  } catch (_e) {
+    return false;
+  }
+}
+function getBooleanEnvVar(envVar) {
+  if (!process.env) {
+    return false;
+  }
+  const envVarValue = (process.env[envVar] || "").toLowerCase();
+  return ["true", "1"].includes(envVarValue);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base64Decode,
+  base64Encode,
+  getBooleanEnvVar,
+  isBase64Encoded,
+  isBrowser,
+  randomUUID
+});

package/dist/cjs/utils/experimental.js

@@ -0,0 +1,74 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var experimental_exports = {};
+__export(experimental_exports, {
+  experimental: () => experimental
+});
+module.exports = __toCommonJS(experimental_exports);
+var import_logger = require("./logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const warnedItems = /* @__PURE__ */ new Set();
+function experimental(target, propertyKey, descriptor) {
+  if (propertyKey === void 0) {
+    const className = target.name;
+    const newConstructor = class extends target {
+      constructor(...args) {
+        if (!warnedItems.has(className)) {
+          import_logger.logger.warn(
+            `Class ${className} is experimental and may change in the future.`
+          );
+          warnedItems.add(className);
+        }
+        super(...args);
+      }
+    };
+    return newConstructor;
+  }
+  if (propertyKey !== void 0 && descriptor !== void 0) {
+    const className = typeof target === "function" ? target.name : target.constructor.name;
+    const methodName = String(propertyKey);
+    const identifier = `${className}.${methodName}`;
+    const originalMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      if (!warnedItems.has(identifier)) {
+        import_logger.logger.warn(
+          `Method ${identifier} is experimental and may change in the future.`
+        );
+        warnedItems.add(identifier);
+      }
+      return originalMethod.apply(this, args);
+    };
+    return descriptor;
+  }
+  throw new Error("Invalid decorator usage");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  experimental
+});

package/dist/cjs/utils/failover_utils.js

@@ -0,0 +1,93 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var failover_utils_exports = {};
+__export(failover_utils_exports, {
+  runWithRouting: () => runWithRouting
+});
+module.exports = __toCommonJS(failover_utils_exports);
+var import_logger = require("./logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+async function* runWithRouting(items, context, router, runFn) {
+  const initialKey = await router(items, context);
+  if (!initialKey) {
+    throw new Error("Initial routing failed, no item selected.");
+  }
+  let selectedKey = initialKey;
+  import_logger.logger.debug(`Router selected initial key: ${selectedKey}`);
+  let selectedItem = items[selectedKey];
+  if (!selectedItem) {
+    throw new Error(`Item not found for key: ${selectedKey}`);
+  }
+  const triedKeys = /* @__PURE__ */ new Set([selectedKey]);
+  while (true) {
+    const generatorOrPromise = runFn(selectedItem);
+    let firstYielded = false;
+    try {
+      if (isAsyncGenerator(generatorOrPromise)) {
+        for await (const result2 of generatorOrPromise) {
+          yield result2;
+          firstYielded = true;
+        }
+        return;
+      }
+      const result = await generatorOrPromise;
+      yield result;
+      return;
+    } catch (error) {
+      if (!firstYielded) {
+        const nextKey = await router(items, context, {
+          failedKeys: triedKeys,
+          lastError: error
+        });
+        import_logger.logger.debug(`Router selected next key: ${nextKey}`);
+        if (nextKey === void 0) {
+          throw error;
+        }
+        if (triedKeys.has(nextKey)) {
+          throw error;
+        }
+        selectedKey = nextKey;
+        selectedItem = items[selectedKey];
+        if (!selectedItem) {
+          throw new Error(`Item not found for key: ${selectedKey}`);
+        }
+        triedKeys.add(selectedKey);
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+function isAsyncGenerator(obj) {
+  return typeof obj === "object" && typeof obj[Symbol.asyncIterator] === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runWithRouting
+});

package/dist/cjs/utils/file_extension_utils.js

@@ -0,0 +1,77 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_extension_utils_exports = {};
+__export(file_extension_utils_exports, {
+  getMimeTypeAndEncoding: () => getMimeTypeAndEncoding,
+  getScriptLanguageByExtension: () => getScriptLanguageByExtension
+});
+module.exports = __toCommonJS(file_extension_utils_exports);
+var import_code_execution_utils = require("../code_executors/code_execution_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const MIME_TYPE_MAP = {
+  ".js": { mimeType: "text/javascript", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".py": { mimeType: "text/x-python", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".md": { mimeType: "text/markdown", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".txt": { mimeType: "text/plain", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".html": { mimeType: "text/html", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".css": { mimeType: "text/css", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".json": { mimeType: "application/json", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".csv": { mimeType: "text/csv", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".svg": { mimeType: "image/svg+xml", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".xml": { mimeType: "application/xml", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".yaml": { mimeType: "text/yaml", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".yml": { mimeType: "text/yaml", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".png": { mimeType: "image/png", encoding: import_code_execution_utils.FileContentEncoding.BASE64 },
+  ".jpg": { mimeType: "image/jpeg", encoding: import_code_execution_utils.FileContentEncoding.BASE64 },
+  ".jpeg": { mimeType: "image/jpeg", encoding: import_code_execution_utils.FileContentEncoding.BASE64 },
+  ".pdf": { mimeType: "application/pdf", encoding: import_code_execution_utils.FileContentEncoding.BASE64 }
+};
+const EXTENSION_TO_LANGUAGE = {
+  ".js": import_code_execution_utils.CodeExecutionLanguage.JAVASCRIPT,
+  ".ts": import_code_execution_utils.CodeExecutionLanguage.TYPESCRIPT,
+  ".py": import_code_execution_utils.CodeExecutionLanguage.PYTHON,
+  ".bat": import_code_execution_utils.CodeExecutionLanguage.WINDOWS_CMD,
+  ".cmd": import_code_execution_utils.CodeExecutionLanguage.WINDOWS_CMD,
+  ".ps1": import_code_execution_utils.CodeExecutionLanguage.POWERSHELL,
+  ".sh": import_code_execution_utils.CodeExecutionLanguage.SHELL
+};
+function getMimeTypeAndEncoding(ext) {
+  return MIME_TYPE_MAP[ext.toLowerCase()] || {
+    mimeType: "application/octet-stream",
+    encoding: import_code_execution_utils.FileContentEncoding.BASE64
+  };
+}
+function getScriptLanguageByExtension(ext) {
+  return EXTENSION_TO_LANGUAGE[ext.toLowerCase()] || import_code_execution_utils.CodeExecutionLanguage.UNSPECIFIED;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMimeTypeAndEncoding,
+  getScriptLanguageByExtension
+});

package/dist/cjs/utils/file_utils.js

@@ -0,0 +1,94 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_utils_exports = {};
+__export(file_utils_exports, {
+  materializeFiles: () => materializeFiles
+});
+module.exports = __toCommonJS(file_utils_exports);
+var fs = __toESM(require("node:fs/promises"), 1);
+var path = __toESM(require("node:path"), 1);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+async function materializeFiles(files, dir = process.cwd()) {
+  const resolvedBaseDir = path.resolve(dir);
+  const createdFiles = [];
+  for (const file of files) {
+    const fullPath = path.resolve(dir, file.name);
+    if (!fullPath.startsWith(resolvedBaseDir)) {
+      throw new Error(
+        `Path traversal detected: ${file.name} resolves outside of ${dir}`
+      );
+    }
+    const ext = path.extname(fullPath);
+    const dirName = path.dirname(fullPath);
+    const base = path.basename(fullPath, ext);
+    let finalPath = fullPath;
+    let counter = 2;
+    while (true) {
+      try {
+        await fs.access(finalPath);
+        const newName = `${base}_${counter}${ext}`;
+        finalPath = path.join(dirName, newName);
+        const originalDir = path.dirname(file.name);
+        file.name = originalDir === "." ? newName : path.join(originalDir, newName);
+        counter++;
+      } catch {
+        break;
+      }
+    }
+    if (!finalPath.startsWith(resolvedBaseDir)) {
+      throw new Error(
+        `Path traversal detected: ${file.name} resolves outside of ${dir}`
+      );
+    }
+    await fs.mkdir(path.dirname(finalPath), { recursive: true });
+    await fs.writeFile(
+      finalPath,
+      Buffer.from(file.content, file.contentEncoding)
+    );
+    createdFiles.push({
+      ...file,
+      name: path.relative(dir, finalPath)
+    });
+  }
+  return createdFiles;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  materializeFiles
+});