@google/adk 0.1.0

package/dist/cjs/utils/deep_clone.js

@@ -0,0 +1,44 @@
+/**
+  * @license
+  * Copyright 2025 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 deep_clone_exports = {};
+__export(deep_clone_exports, {
+  deepClone: () => deepClone
+});
+module.exports = __toCommonJS(deep_clone_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function deepClone(obj) {
+  if (obj === void 0) {
+    return void 0;
+  }
+  return JSON.parse(JSON.stringify(obj));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deepClone
+});

package/dist/cjs/utils/env_aware_utils.js

@@ -0,0 +1,83 @@
+/**
+  * @license
+  * Copyright 2025 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,
+  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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base64Decode,
+  base64Encode,
+  isBase64Encoded,
+  isBrowser,
+  randomUUID
+});

package/dist/cjs/utils/gemini_schema_util.js

@@ -0,0 +1,88 @@
+/**
+  * @license
+  * Copyright 2025 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 gemini_schema_util_exports = {};
+__export(gemini_schema_util_exports, {
+  toGeminiSchema: () => toGeminiSchema
+});
+module.exports = __toCommonJS(gemini_schema_util_exports);
+var import_genai = require("@google/genai");
+var import_zod = require("zod");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const MCPToolSchema = import_zod.z.object({
+  type: import_zod.z.literal("object"),
+  properties: import_zod.z.record(import_zod.z.unknown()).optional(),
+  required: import_zod.z.string().array().optional()
+});
+function toGeminiType(mcpType) {
+  switch (mcpType.toLowerCase()) {
+    case "text":
+    case "string":
+      return import_genai.Type.STRING;
+    case "number":
+      return import_genai.Type.NUMBER;
+    case "boolean":
+      return import_genai.Type.BOOLEAN;
+    case "integer":
+      return import_genai.Type.INTEGER;
+    case "array":
+      return import_genai.Type.ARRAY;
+    case "object":
+      return import_genai.Type.OBJECT;
+    default:
+      return import_genai.Type.TYPE_UNSPECIFIED;
+  }
+}
+function toGeminiSchema(mcpSchema) {
+  if (!mcpSchema) {
+    return void 0;
+  }
+  function recursiveConvert(mcp) {
+    const geminiType = toGeminiType(mcp.type);
+    const geminiSchema = { type: geminiType, description: mcp.description };
+    if (geminiType === import_genai.Type.OBJECT) {
+      geminiSchema.properties = {};
+      if (mcp.properties) {
+        for (const name in mcp.properties) {
+          geminiSchema.properties[name] = recursiveConvert(mcp.properties[name]);
+        }
+      }
+      geminiSchema.required = mcp.required;
+    } else if (geminiType === import_genai.Type.ARRAY) {
+      if (mcp.items) {
+        geminiSchema.items = recursiveConvert(mcp.items);
+      }
+    }
+    return geminiSchema;
+  }
+  return recursiveConvert(mcpSchema);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toGeminiSchema
+});

package/dist/cjs/utils/logger.js

@@ -0,0 +1,121 @@
+/**
+  * @license
+  * Copyright 2025 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 logger_exports = {};
+__export(logger_exports, {
+  LogLevel: () => LogLevel,
+  logger: () => logger,
+  setLogLevel: () => setLogLevel
+});
+module.exports = __toCommonJS(logger_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+let logLevel = 1 /* INFO */;
+function setLogLevel(level) {
+  logLevel = level;
+}
+class SimpleLogger {
+  log(level, ...args) {
+    if (level < logLevel) {
+      return;
+    }
+    switch (level) {
+      case 0 /* DEBUG */:
+        this.debug(...args);
+        break;
+      case 1 /* INFO */:
+        this.info(...args);
+        break;
+      case 2 /* WARN */:
+        this.warn(...args);
+        break;
+      case 3 /* ERROR */:
+        this.error(...args);
+        break;
+      default:
+        throw new Error(`Unsupported log level: ${level}`);
+    }
+  }
+  debug(...args) {
+    if (logLevel > 0 /* DEBUG */) {
+      return;
+    }
+    console.debug(getColoredPrefix(0 /* DEBUG */), ...args);
+  }
+  info(...args) {
+    if (logLevel > 1 /* INFO */) {
+      return;
+    }
+    console.info(getColoredPrefix(1 /* INFO */), ...args);
+  }
+  warn(...args) {
+    if (logLevel > 2 /* WARN */) {
+      return;
+    }
+    console.warn(getColoredPrefix(2 /* WARN */), ...args);
+  }
+  error(...args) {
+    if (logLevel > 3 /* ERROR */) {
+      return;
+    }
+    console.error(getColoredPrefix(3 /* ERROR */), ...args);
+  }
+}
+const LOG_LEVEL_STR = {
+  [0 /* DEBUG */]: "DEBUG",
+  [1 /* INFO */]: "INFO",
+  [2 /* WARN */]: "WARN",
+  [3 /* ERROR */]: "ERROR"
+};
+const CONSOLE_COLOR_MAP = {
+  [0 /* DEBUG */]: "\x1B[34m",
+  // Blue
+  [1 /* INFO */]: "\x1B[32m",
+  // Green
+  [2 /* WARN */]: "\x1B[33m",
+  // Yellow
+  [3 /* ERROR */]: "\x1B[31m"
+  // Red
+};
+const RESET_COLOR = "\x1B[0m";
+function getColoredPrefix(level) {
+  return `${CONSOLE_COLOR_MAP[level]}[ADK ${LOG_LEVEL_STR[level]}]:${RESET_COLOR}`;
+}
+const logger = new SimpleLogger();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogLevel,
+  logger,
+  setLogLevel
+});

package/dist/cjs/utils/model_name.js

@@ -0,0 +1,64 @@
+/**
+  * @license
+  * Copyright 2025 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 model_name_exports = {};
+__export(model_name_exports, {
+  extractModelName: () => extractModelName,
+  isGemini1Model: () => isGemini1Model,
+  isGemini2Model: () => isGemini2Model,
+  isGeminiModel: () => isGeminiModel
+});
+module.exports = __toCommonJS(model_name_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const MODEL_NAME_PATTERN = "^projects/[^/]+/locations/[^/]+/publishers/[^/]+/models/(.+)$";
+function extractModelName(modelString) {
+  const match = modelString.match(MODEL_NAME_PATTERN);
+  if (match) {
+    return match[1];
+  }
+  return modelString;
+}
+function isGeminiModel(modelString) {
+  const modelName = extractModelName(modelString);
+  return modelName.startsWith("gemini-");
+}
+function isGemini1Model(modelString) {
+  const modelName = extractModelName(modelString);
+  return modelName.startsWith("gemini-1");
+}
+function isGemini2Model(modelString) {
+  const modelName = extractModelName(modelString);
+  return modelName.startsWith("gemini-2");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractModelName,
+  isGemini1Model,
+  isGemini2Model,
+  isGeminiModel
+});

package/dist/cjs/utils/simple_zod_to_json.js

@@ -0,0 +1,191 @@
+/**
+  * @license
+  * Copyright 2025 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 simple_zod_to_json_exports = {};
+__export(simple_zod_to_json_exports, {
+  isZodObject: () => isZodObject,
+  zodObjectToSchema: () => zodObjectToSchema
+});
+module.exports = __toCommonJS(simple_zod_to_json_exports);
+var import_genai = require("@google/genai");
+var import_zod = require("zod");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isZodObject(obj) {
+  var _a;
+  return obj !== null && typeof obj === "object" && ((_a = obj._def) == null ? void 0 : _a.typeName) === "ZodObject";
+}
+function parseZodType(zodType) {
+  const def = zodType._def;
+  if (!def) {
+    return {};
+  }
+  const description = def.description;
+  const result = {};
+  if (description) result.description = description;
+  const returnResult = (result2) => {
+    if (result2.description === void 0) {
+      delete result2.description;
+    }
+    return result2;
+  };
+  switch (def.typeName) {
+    case import_zod.z.ZodFirstPartyTypeKind.ZodString:
+      result.type = import_genai.Type.STRING;
+      for (const check of def.checks || []) {
+        if (check.kind === "min")
+          result.minLength = check.value.toString();
+        else if (check.kind === "max")
+          result.maxLength = check.value.toString();
+        else if (check.kind === "email")
+          result.format = "email";
+        else if (check.kind === "uuid")
+          result.format = "uuid";
+        else if (check.kind === "url")
+          result.format = "uri";
+        else if (check.kind === "regex")
+          result.pattern = check.regex.source;
+      }
+      return returnResult(result);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodNumber:
+      result.type = import_genai.Type.NUMBER;
+      for (const check of def.checks || []) {
+        if (check.kind === "min")
+          result.minimum = check.value;
+        else if (check.kind === "max")
+          result.maximum = check.value;
+        else if (check.kind === "int")
+          result.type = import_genai.Type.INTEGER;
+      }
+      return returnResult(result);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodBoolean:
+      result.type = import_genai.Type.BOOLEAN;
+      return returnResult(result);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodArray:
+      result.type = import_genai.Type.ARRAY;
+      result.items = parseZodType(def.type);
+      if (def.minLength) result.minItems = def.minLength.value.toString();
+      if (def.maxLength) result.maxItems = def.maxLength.value.toString();
+      return returnResult(result);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodObject: {
+      const nestedSchema = zodObjectToSchema(zodType);
+      return nestedSchema;
+    }
+    case import_zod.z.ZodFirstPartyTypeKind.ZodLiteral:
+      const literalType = typeof def.value;
+      result.enum = [def.value.toString()];
+      if (literalType === "string") {
+        result.type = import_genai.Type.STRING;
+      } else if (literalType === "number") {
+        result.type = import_genai.Type.NUMBER;
+      } else if (literalType === "boolean") {
+        result.type = import_genai.Type.BOOLEAN;
+      } else if (def.value === null) {
+        result.type = import_genai.Type.NULL;
+      } else {
+        throw new Error(`Unsupported ZodLiteral value type: ${literalType}`);
+      }
+      return returnResult(result);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodEnum:
+      result.type = import_genai.Type.STRING;
+      result.enum = def.values;
+      return returnResult(result);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodNativeEnum:
+      result.type = import_genai.Type.STRING;
+      result.enum = Object.values(def.values);
+      return returnResult(result);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodUnion:
+      result.anyOf = def.options.map(parseZodType);
+      return returnResult(result);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodOptional:
+      return parseZodType(def.innerType);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodNullable:
+      const nullableInner = parseZodType(def.innerType);
+      return nullableInner ? returnResult({
+        anyOf: [nullableInner, { type: import_genai.Type.NULL }],
+        ...description && { description }
+      }) : returnResult({ type: import_genai.Type.NULL, ...description && { description } });
+    case import_zod.z.ZodFirstPartyTypeKind.ZodDefault:
+      const defaultInner = parseZodType(def.innerType);
+      if (defaultInner) defaultInner.default = def.defaultValue();
+      return defaultInner;
+    case import_zod.z.ZodFirstPartyTypeKind.ZodBranded:
+      return parseZodType(def.type);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodReadonly:
+      return parseZodType(def.innerType);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodNull:
+      result.type = import_genai.Type.NULL;
+      return returnResult(result);
+    case import_zod.z.ZodFirstPartyTypeKind.ZodAny:
+    case import_zod.z.ZodFirstPartyTypeKind.ZodUnknown:
+      return returnResult({ ...description && { description } });
+    default:
+      throw new Error(`Unsupported Zod type: ${def.typeName}`);
+  }
+}
+function zodObjectToSchema(schema) {
+  if (schema._def.typeName !== import_zod.z.ZodFirstPartyTypeKind.ZodObject) {
+    throw new Error("Expected a ZodObject");
+  }
+  const shape = schema.shape;
+  const properties = {};
+  const required = [];
+  for (const key in shape) {
+    const fieldSchema = shape[key];
+    const parsedField = parseZodType(fieldSchema);
+    if (parsedField) {
+      properties[key] = parsedField;
+    }
+    let currentSchema = fieldSchema;
+    let isOptional = false;
+    while (currentSchema._def.typeName === import_zod.z.ZodFirstPartyTypeKind.ZodOptional || currentSchema._def.typeName === import_zod.z.ZodFirstPartyTypeKind.ZodDefault) {
+      isOptional = true;
+      currentSchema = currentSchema._def.innerType;
+    }
+    if (!isOptional) {
+      required.push(key);
+    }
+  }
+  const catchall = schema._def.catchall;
+  let additionalProperties = false;
+  if (catchall && catchall._def.typeName !== import_zod.z.ZodFirstPartyTypeKind.ZodNever) {
+    additionalProperties = parseZodType(catchall) || true;
+  } else {
+    additionalProperties = schema._def.unknownKeys === "passthrough";
+  }
+  return {
+    type: import_genai.Type.OBJECT,
+    properties,
+    required: required.length > 0 ? required : [],
+    ...schema._def.description ? { description: schema._def.description } : {}
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isZodObject,
+  zodObjectToSchema
+});

package/dist/cjs/utils/variant_utils.js

@@ -0,0 +1,55 @@
+/**
+  * @license
+  * Copyright 2025 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 variant_utils_exports = {};
+__export(variant_utils_exports, {
+  GoogleLLMVariant: () => GoogleLLMVariant,
+  getGoogleLlmVariant: () => getGoogleLlmVariant
+});
+module.exports = __toCommonJS(variant_utils_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var GoogleLLMVariant = /* @__PURE__ */ ((GoogleLLMVariant2) => {
+  GoogleLLMVariant2["VERTEX_AI"] = "VERTEX_AI";
+  GoogleLLMVariant2["GEMINI_API"] = "GEMINI_API";
+  return GoogleLLMVariant2;
+})(GoogleLLMVariant || {});
+function getGoogleLlmVariant() {
+  return getBooleanEnvVar("GOOGLE_GENAI_USE_VERTEXAI") ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
+}
+function getBooleanEnvVar(envVar) {
+  if (!process.env) {
+    return false;
+  }
+  const envVarValue = (process.env[envVar] || "").toLowerCase();
+  return ["true", "1"].includes(envVar.toLowerCase());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleLLMVariant,
+  getGoogleLlmVariant
+});

package/dist/cjs/version.js

@@ -0,0 +1,39 @@
+/**
+  * @license
+  * Copyright 2025 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 version_exports = {};
+__export(version_exports, {
+  version: () => version
+});
+module.exports = __toCommonJS(version_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const version = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  version
+});