@google/adk 0.2.4 → 0.3.0

package/dist/cjs/tools/base_tool.js

@@ -24,7 +24,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var base_tool_exports = {};
 __export(base_tool_exports, {
-  BaseTool: () => BaseTool
+  BaseTool: () => BaseTool,
+  isBaseTool: () => isBaseTool
 });
 module.exports = __toCommonJS(base_tool_exports);
 var import_variant_utils = require("../utils/variant_utils.js");
@@ -33,6 +34,12 @@ var import_variant_utils = require("../utils/variant_utils.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
+const BASE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseTool");
+function isBaseTool(obj) {
+  return typeof obj === "object" && obj !== null && BASE_TOOL_SIGNATURE_SYMBOL in obj && obj[BASE_TOOL_SIGNATURE_SYMBOL] === true;
+}
+_a = BASE_TOOL_SIGNATURE_SYMBOL;
 class BaseTool {
   /**
    * Base constructor for a tool.
@@ -40,10 +47,12 @@ class BaseTool {
    * @param params The parameters for `BaseTool`.
    */
   constructor(params) {
-    var _a;
+    /** A unique symbol to identify ADK base tool class. */
+    this[_a] = true;
+    var _a2;
     this.name = params.name;
     this.description = params.description;
-    this.isLongRunning = (_a = params.isLongRunning) != null ? _a : false;
+    this.isLongRunning = (_a2 = params.isLongRunning) != null ? _a2 : false;
   }
   /**
    * Gets the OpenAPI specification of this tool in the form of a
@@ -70,7 +79,7 @@ class BaseTool {
    *
    * @param request The request to process the LLM request.
    */
-  async processLlmRequest({ toolContext, llmRequest }) {
+  async processLlmRequest({ llmRequest }) {
     const functionDeclaration = this._getDeclaration();
     if (!functionDeclaration) {
       return;
@@ -98,10 +107,13 @@ class BaseTool {
   }
 }
 function findToolWithFunctionDeclarations(llmRequest) {
-  var _a;
-  return (((_a = llmRequest.config) == null ? void 0 : _a.tools) || []).find((tool) => "functionDeclarations" in tool);
+  var _a2;
+  return (((_a2 = llmRequest.config) == null ? void 0 : _a2.tools) || []).find(
+    (tool) => "functionDeclarations" in tool
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BaseTool
+  BaseTool,
+  isBaseTool
 });

package/dist/cjs/tools/forwarding_artifact_service.js

@@ -45,7 +45,7 @@ class ForwardingArtifactService {
   async loadArtifact(request) {
     return this.toolContext.loadArtifact(request.filename, request.version);
   }
-  async listArtifactKeys(request) {
+  async listArtifactKeys() {
     return this.toolContext.listArtifacts();
   }
   async deleteArtifact(request) {

package/dist/cjs/tools/function_tool.js

@@ -24,11 +24,11 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var function_tool_exports = {};
 __export(function_tool_exports, {
-  FunctionTool: () => FunctionTool
+  FunctionTool: () => FunctionTool,
+  isFunctionTool: () => isFunctionTool
 });
 module.exports = __toCommonJS(function_tool_exports);
 var import_genai = require("@google/genai");
-var import_zod = require("zod");
 var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
 var import_base_tool = require("./base_tool.js");
 /**
@@ -36,6 +36,7 @@ var import_base_tool = require("./base_tool.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a, _b;
 function toSchema(parameters) {
   if (parameters === void 0) {
     return { type: import_genai.Type.OBJECT, properties: {} };
@@ -45,14 +46,18 @@ function toSchema(parameters) {
   }
   return parameters;
 }
-class FunctionTool extends import_base_tool.BaseTool {
+const FUNCTION_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.functionTool");
+function isFunctionTool(obj) {
+  return typeof obj === "object" && obj !== null && FUNCTION_TOOL_SIGNATURE_SYMBOL in obj && obj[FUNCTION_TOOL_SIGNATURE_SYMBOL] === true;
+}
+class FunctionTool extends (_b = import_base_tool.BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL, _b) {
   /**
    * The constructor acts as the user-friendly factory.
    * @param options The configuration for the tool.
    */
   constructor(options) {
-    var _a;
-    const name = (_a = options.name) != null ? _a : options.execute.name;
+    var _a2;
+    const name = (_a2 = options.name) != null ? _a2 : options.execute.name;
     if (!name) {
       throw new Error(
         "Tool name cannot be empty. Either name the `execute` function or provide a `name`."
@@ -63,6 +68,8 @@ class FunctionTool extends import_base_tool.BaseTool {
       description: options.description,
       isLongRunning: options.isLongRunning
     });
+    /** A unique symbol to identify ADK function tool class. */
+    this[_a] = true;
     this.execute = options.execute;
     this.parameters = options.parameters;
   }
@@ -82,7 +89,7 @@ class FunctionTool extends import_base_tool.BaseTool {
   async runAsync(req) {
     try {
       let validatedArgs = req.args;
-      if (this.parameters instanceof import_zod.ZodObject) {
+      if ((0, import_simple_zod_to_json.isZodObject)(this.parameters)) {
         validatedArgs = this.parameters.parse(req.args);
       }
       return await this.execute(
@@ -97,5 +104,6 @@ class FunctionTool extends import_base_tool.BaseTool {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  FunctionTool
+  FunctionTool,
+  isFunctionTool
 });

package/dist/cjs/tools/google_search_tool.js

@@ -24,7 +24,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var google_search_tool_exports = {};
 __export(google_search_tool_exports, {
-  GOOGLE_SEARCH: () => GOOGLE_SEARCH
+  GOOGLE_SEARCH: () => GOOGLE_SEARCH,
+  GoogleSearchTool: () => GoogleSearchTool
 });
 module.exports = __toCommonJS(google_search_tool_exports);
 var import_model_name = require("../utils/model_name.js");
@@ -38,10 +39,12 @@ class GoogleSearchTool extends import_base_tool.BaseTool {
   constructor() {
     super({ name: "google_search", description: "Google Search Tool" });
   }
-  runAsync(request) {
+  runAsync() {
     return Promise.resolve();
   }
-  async processLlmRequest({ toolContext, llmRequest }) {
+  async processLlmRequest({
+    llmRequest
+  }) {
     if (!llmRequest.model) {
       return;
     }
@@ -72,5 +75,6 @@ class GoogleSearchTool extends import_base_tool.BaseTool {
 const GOOGLE_SEARCH = new GoogleSearchTool();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  GOOGLE_SEARCH
+  GOOGLE_SEARCH,
+  GoogleSearchTool
 });

package/dist/cjs/tools/mcp/mcp_session_manager.js

@@ -40,6 +40,7 @@ class MCPSessionManager {
     this.connectionParams = connectionParams;
   }
   async createSession() {
+    var _a;
     const client = new import_client.Client({ name: "MCPClient", version: "1.0.0" });
     switch (this.connectionParams.type) {
       case "StdioConnectionParams":
@@ -47,20 +48,25 @@ class MCPSessionManager {
           new import_stdio.StdioClientTransport(this.connectionParams.serverParams)
         );
         break;
-      case "StreamableHTTPConnectionParams":
-        const transportOptions = this.connectionParams.header ? {
-          requestInit: {
+      case "StreamableHTTPConnectionParams": {
+        const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
+        if (!options.requestInit && this.connectionParams.header !== void 0) {
+          options.requestInit = {
             headers: this.connectionParams.header
-          }
-        } : void 0;
-        await client.connect(new import_streamableHttp.StreamableHTTPClientTransport(
-          new URL(this.connectionParams.url),
-          transportOptions
-        ));
+          };
+        }
+        await client.connect(
+          new import_streamableHttp.StreamableHTTPClientTransport(
+            new URL(this.connectionParams.url),
+            options
+          )
+        );
         break;
-      default:
+      }
+      default: {
         const _exhaustiveCheck = this.connectionParams;
         break;
+      }
     }
     return client;
   }

package/dist/cjs/tools/mcp/mcp_tool.js

@@ -41,8 +41,7 @@ class MCPTool extends import_base_tool.BaseTool {
     this.mcpSessionManager = mcpSessionManager;
   }
   _getDeclaration() {
-    let declaration;
-    declaration = {
+    return {
       name: this.mcpTool.name,
       description: this.mcpTool.description,
       parameters: (0, import_gemini_schema_util.toGeminiSchema)(this.mcpTool.inputSchema),
@@ -50,7 +49,6 @@ class MCPTool extends import_base_tool.BaseTool {
       // https://modelcontextprotocol.io/specification/2025-06-18/server/tools#tool-result
       response: (0, import_gemini_schema_util.toGeminiSchema)(this.mcpTool.outputSchema)
     };
-    return declaration;
   }
   async runAsync(request) {
     const session = await this.mcpSessionManager.createSession();

package/dist/cjs/tools/mcp/mcp_toolset.js

@@ -41,7 +41,7 @@ class MCPToolset extends import_base_toolset.BaseToolset {
     super(toolFilter);
     this.mcpSessionManager = new import_mcp_session_manager.MCPSessionManager(connectionParams);
   }
-  async getTools(context) {
+  async getTools() {
     const session = await this.mcpSessionManager.createSession();
     const listResult = await session.listTools();
     import_logger.logger.debug(`number of tools: ${listResult.tools.length}`);

package/dist/cjs/tools/tool_context.js

@@ -47,15 +47,10 @@ class ToolContext extends import_callback_context.CallbackContext {
    * @param params.toolConfirmation The tool confirmation of the current tool
    *     call.
    */
-  constructor({
-    invocationContext,
-    eventActions,
-    functionCallId,
-    toolConfirmation
-  }) {
-    super({ invocationContext, eventActions });
-    this.functionCallId = functionCallId;
-    this.toolConfirmation = toolConfirmation;
+  constructor(params) {
+    super(params);
+    this.functionCallId = params.functionCallId;
+    this.toolConfirmation = params.toolConfirmation;
   }
   get actions() {
     return this.eventActions;

package/dist/cjs/utils/env_aware_utils.js

@@ -69,7 +69,7 @@ function base64Decode(data) {
 function isBase64Encoded(data) {
   try {
     return base64Encode(base64Decode(data)) === data;
-  } catch (e) {
+  } catch (_e) {
     return false;
   }
 }

package/dist/cjs/utils/gemini_schema_util.js

@@ -34,12 +34,13 @@ var import_zod = require("zod");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const MCPToolSchema = import_zod.z.object({
+const MCPToolSchemaObject = import_zod.z.object({
   type: import_zod.z.literal("object"),
-  properties: import_zod.z.record(import_zod.z.unknown()).optional(),
+  properties: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
   required: import_zod.z.string().array().optional()
 });
 function toGeminiType(mcpType) {
+  if (!mcpType) return import_genai.Type.TYPE_UNSPECIFIED;
   switch (mcpType.toLowerCase()) {
     case "text":
     case "string":
@@ -80,12 +81,17 @@ function toGeminiSchema(mcpSchema) {
       }
     }
     const geminiType = toGeminiType(mcp.type);
-    const geminiSchema = { type: geminiType, description: mcp.description };
+    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.properties[name] = recursiveConvert(
+            mcp.properties[name]
+          );
         }
       }
       geminiSchema.required = mcp.required;

package/dist/cjs/utils/logger.js

@@ -25,8 +25,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var logger_exports = {};
 __export(logger_exports, {
   LogLevel: () => LogLevel,
+  getLogger: () => getLogger,
   logger: () => logger,
-  setLogLevel: () => setLogLevel
+  resetLogger: () => resetLogger,
+  setLogLevel: () => setLogLevel,
+  setLogger: () => setLogger
 });
 module.exports = __toCommonJS(logger_exports);
 /**
@@ -92,6 +95,18 @@ class SimpleLogger {
     console.error(getColoredPrefix(3 /* ERROR */), ...args);
   }
 }
+class NoOpLogger {
+  log(_level, ..._args) {
+  }
+  debug(..._args) {
+  }
+  info(..._args) {
+  }
+  warn(..._args) {
+  }
+  error(..._args) {
+  }
+}
 const LOG_LEVEL_STR = {
   [0 /* DEBUG */]: "DEBUG",
   [1 /* INFO */]: "INFO",
@@ -112,10 +127,39 @@ const RESET_COLOR = "\x1B[0m";
 function getColoredPrefix(level) {
   return `${CONSOLE_COLOR_MAP[level]}[ADK ${LOG_LEVEL_STR[level]}]:${RESET_COLOR}`;
 }
-const logger = new SimpleLogger();
+let currentLogger = new SimpleLogger();
+function setLogger(customLogger) {
+  currentLogger = customLogger != null ? customLogger : new NoOpLogger();
+}
+function getLogger() {
+  return currentLogger;
+}
+function resetLogger() {
+  currentLogger = new SimpleLogger();
+}
+const logger = {
+  log(level, ...args) {
+    currentLogger.log(level, ...args);
+  },
+  debug(...args) {
+    currentLogger.debug(...args);
+  },
+  info(...args) {
+    currentLogger.info(...args);
+  },
+  warn(...args) {
+    currentLogger.warn(...args);
+  },
+  error(...args) {
+    currentLogger.error(...args);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LogLevel,
+  getLogger,
   logger,
-  setLogLevel
+  resetLogger,
+  setLogLevel,
+  setLogger
 });

package/dist/cjs/utils/simple_zod_to_json.js

@@ -29,160 +29,119 @@ __export(simple_zod_to_json_exports, {
 });
 module.exports = __toCommonJS(simple_zod_to_json_exports);
 var import_genai = require("@google/genai");
-var import_zod = require("zod");
+var import_zod_to_json_schema = require("zod-to-json-schema");
+var import_v4 = require("zod/v4");
 /**
  * @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 isZodSchema(obj) {
+  return obj !== null && typeof obj === "object" && "parse" in obj && typeof obj.parse === "function" && "safeParse" in obj && typeof obj.safeParse === "function";
+}
+function isZodV3Schema(obj) {
+  return isZodSchema(obj) && !("_zod" in obj);
+}
+function isZodV4Schema(obj) {
+  return isZodSchema(obj) && "_zod" in obj;
 }
-function parseZodType(zodType) {
-  const def = zodType._def;
-  if (!def) {
-    return {};
+function getZodTypeName(schema) {
+  var _a, _b;
+  const schemaAny = schema;
+  if ((_a = schemaAny._def) == null ? void 0 : _a.typeName) {
+    return schemaAny._def.typeName;
   }
-  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}`);
+  const zod4Type = (_b = schemaAny._def) == null ? void 0 : _b.type;
+  if (typeof zod4Type === "string" && zod4Type) {
+    return "Zod" + zod4Type.charAt(0).toUpperCase() + zod4Type.slice(1);
   }
+  return void 0;
+}
+function isZodObject(obj) {
+  return isZodSchema(obj) && getZodTypeName(obj) === "ZodObject";
 }
 function zodObjectToSchema(schema) {
-  if (schema._def.typeName !== import_zod.z.ZodFirstPartyTypeKind.ZodObject) {
-    throw new Error("Expected a ZodObject");
+  if (!isZodObject(schema)) {
+    throw new Error("Expected a Zod Object");
   }
-  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);
-    }
+  if (isZodV4Schema(schema)) {
+    return (0, import_v4.toJSONSchema)(schema, {
+      target: "openapi-3.0",
+      io: "input",
+      override: (ctx) => {
+        var _a;
+        const { jsonSchema } = ctx;
+        if (jsonSchema.additionalProperties !== void 0) {
+          delete jsonSchema.additionalProperties;
+        }
+        if (jsonSchema.readOnly !== void 0) {
+          delete jsonSchema.readOnly;
+        }
+        if (jsonSchema.maxItems !== void 0) {
+          jsonSchema.maxItems = jsonSchema.maxItems.toString();
+        }
+        if (jsonSchema.format === "email" || jsonSchema.format === "uuid") {
+          delete jsonSchema.pattern;
+        }
+        if (jsonSchema.minItems !== void 0) {
+          jsonSchema.minItems = jsonSchema.minItems.toString();
+        }
+        if (jsonSchema.minLength !== void 0) {
+          jsonSchema.minLength = jsonSchema.minLength.toString();
+        }
+        if (jsonSchema.maxLength !== void 0) {
+          jsonSchema.maxLength = jsonSchema.maxLength.toString();
+        }
+        if (((_a = jsonSchema.enum) == null ? void 0 : _a.length) === 1 && jsonSchema.enum[0] === null) {
+          jsonSchema.type = import_genai.Type.NULL;
+          delete jsonSchema.enum;
+        }
+        if (jsonSchema.type !== void 0) {
+          jsonSchema.type = jsonSchema.type.toUpperCase();
+        }
+      }
+    });
   }
-  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";
+  if (isZodV3Schema(schema)) {
+    return (0, import_zod_to_json_schema.zodToJsonSchema)(schema, {
+      target: "openApi3",
+      emailStrategy: "format:email",
+      postProcess: (jsonSchema) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!jsonSchema) {
+          return;
+        }
+        if (jsonSchema.additionalProperties !== void 0) {
+          delete jsonSchema.additionalProperties;
+        }
+        if (jsonSchema.maxItems !== void 0) {
+          jsonSchema.maxItems = (_a = jsonSchema.maxItems) == null ? void 0 : _a.toString();
+        }
+        if (jsonSchema.minItems !== void 0) {
+          jsonSchema.minItems = (_b = jsonSchema.minItems) == null ? void 0 : _b.toString();
+        }
+        if (jsonSchema.minLength !== void 0) {
+          jsonSchema.minLength = (_c = jsonSchema.minLength) == null ? void 0 : _c.toString();
+        }
+        if (jsonSchema.maxLength !== void 0) {
+          jsonSchema.maxLength = (_d = jsonSchema.maxLength) == null ? void 0 : _d.toString();
+        }
+        if (((_e = jsonSchema.enum) == null ? void 0 : _e.length) === 1 && jsonSchema.enum[0] === "null") {
+          jsonSchema.type = import_genai.Type.NULL;
+          delete jsonSchema.enum;
+        }
+        if (jsonSchema.type === "integer" && jsonSchema.format !== "int64") {
+          (_f = jsonSchema.minimum) != null ? _f : jsonSchema.minimum = Number.MIN_SAFE_INTEGER;
+          (_g = jsonSchema.maximum) != null ? _g : jsonSchema.maximum = Number.MAX_SAFE_INTEGER;
+        }
+        if (jsonSchema.type !== void 0) {
+          jsonSchema.type = jsonSchema.type.toUpperCase();
+        }
+        return jsonSchema;
+      }
+    });
   }
-  return {
-    type: import_genai.Type.OBJECT,
-    properties,
-    required: required.length > 0 ? required : [],
-    ...schema._def.description ? { description: schema._def.description } : {}
-  };
+  throw new Error("Unsupported Zod schema version.");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/utils/variant_utils.js

@@ -46,7 +46,7 @@ function getBooleanEnvVar(envVar) {
     return false;
   }
   const envVarValue = (process.env[envVar] || "").toLowerCase();
-  return ["true", "1"].includes(envVar.toLowerCase());
+  return ["true", "1"].includes(envVarValue);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/version.js

@@ -32,7 +32,7 @@ module.exports = __toCommonJS(version_exports);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "0.2.4";
+const version = "0.3.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version