@google/adk 0.2.5 → 0.4.0

package/dist/web/utils/logger.js

@@ -61,6 +61,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",
@@ -81,9 +93,38 @@ const RESET_COLOR = "\x1B[0m";
 function getColoredPrefix(level) {
   return "".concat(CONSOLE_COLOR_MAP[level], "[ADK ").concat(LOG_LEVEL_STR[level], "]:").concat(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);
+  }
+};
 export {
   LogLevel,
+  getLogger,
   logger,
-  setLogLevel
+  resetLogger,
+  setLogLevel,
+  setLogger
 };

package/dist/web/utils/object_notation_utils.js

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function toCamelCase(obj, preserveKeys = []) {
+  return toNotation(obj, toCamelCaseKey, "", preserveKeys);
+}
+function toSnakeCase(obj, preserveKeys = []) {
+  return toNotation(obj, toSnakeCaseKey, "", preserveKeys);
+}
+const toCamelCaseKey = (key) => key.replace(
+  /_([a-z])/g,
+  (_match, letter) => letter.toUpperCase()
+);
+const toSnakeCaseKey = (key) => key.replace(/[A-Z]/g, (g) => "_" + g.toLowerCase());
+function toNotation(obj, converter, parentKey = "", preserveKeys = []) {
+  if (Array.isArray(obj)) {
+    return obj.map(
+      (item) => toNotation(item, converter, parentKey, preserveKeys)
+    );
+  }
+  if (typeof obj === "object" && obj !== null) {
+    const source = obj;
+    const result = {};
+    for (const key of Object.keys(source)) {
+      const convertedKey = converter(key);
+      const fullPath = parentKey !== "" ? parentKey + "." + key : key;
+      if (preserveKeys.includes(fullPath)) {
+        result[convertedKey] = source[key];
+      } else {
+        result[convertedKey] = toNotation(
+          source[key],
+          converter,
+          fullPath,
+          preserveKeys
+        );
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+export {
+  toCamelCase,
+  toSnakeCase
+};

package/dist/web/utils/simple_zod_to_json.js

@@ -1,172 +1,119 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Type } from "@google/genai";
-import { z } from "zod";
-function isZodObject(obj) {
-  var _a;
-  return obj !== null && typeof obj === "object" && ((_a = obj._def) == null ? void 0 : _a.typeName) === "ZodObject";
+import {
+  zodToJsonSchema as toJSONSchemaV3
+} from "zod-to-json-schema";
+import { toJSONSchema as toJSONSchemaV4 } from "zod/v4";
+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 parseZodType(zodType) {
-  const def = zodType._def;
-  if (!def) {
-    return {};
+function isZodV4Schema(obj) {
+  return isZodSchema(obj) && "_zod" in obj;
+}
+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 z.ZodFirstPartyTypeKind.ZodString:
-      result.type = 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 z.ZodFirstPartyTypeKind.ZodNumber:
-      result.type = 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 = Type.INTEGER;
-      }
-      return returnResult(result);
-    case z.ZodFirstPartyTypeKind.ZodBoolean:
-      result.type = Type.BOOLEAN;
-      return returnResult(result);
-    case z.ZodFirstPartyTypeKind.ZodArray:
-      result.type = 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 z.ZodFirstPartyTypeKind.ZodObject: {
-      const nestedSchema = zodObjectToSchema(zodType);
-      return nestedSchema;
-    }
-    case z.ZodFirstPartyTypeKind.ZodLiteral:
-      const literalType = typeof def.value;
-      result.enum = [def.value.toString()];
-      if (literalType === "string") {
-        result.type = Type.STRING;
-      } else if (literalType === "number") {
-        result.type = Type.NUMBER;
-      } else if (literalType === "boolean") {
-        result.type = Type.BOOLEAN;
-      } else if (def.value === null) {
-        result.type = Type.NULL;
-      } else {
-        throw new Error("Unsupported ZodLiteral value type: ".concat(literalType));
-      }
-      return returnResult(result);
-    case z.ZodFirstPartyTypeKind.ZodEnum:
-      result.type = Type.STRING;
-      result.enum = def.values;
-      return returnResult(result);
-    case z.ZodFirstPartyTypeKind.ZodNativeEnum:
-      result.type = Type.STRING;
-      result.enum = Object.values(def.values);
-      return returnResult(result);
-    case z.ZodFirstPartyTypeKind.ZodUnion:
-      result.anyOf = def.options.map(parseZodType);
-      return returnResult(result);
-    case z.ZodFirstPartyTypeKind.ZodOptional:
-      return parseZodType(def.innerType);
-    case z.ZodFirstPartyTypeKind.ZodNullable:
-      const nullableInner = parseZodType(def.innerType);
-      return nullableInner ? returnResult(__spreadValues({
-        anyOf: [nullableInner, { type: Type.NULL }]
-      }, description && { description })) : returnResult(__spreadValues({ type: Type.NULL }, description && { description }));
-    case z.ZodFirstPartyTypeKind.ZodDefault:
-      const defaultInner = parseZodType(def.innerType);
-      if (defaultInner) defaultInner.default = def.defaultValue();
-      return defaultInner;
-    case z.ZodFirstPartyTypeKind.ZodBranded:
-      return parseZodType(def.type);
-    case z.ZodFirstPartyTypeKind.ZodReadonly:
-      return parseZodType(def.innerType);
-    case z.ZodFirstPartyTypeKind.ZodNull:
-      result.type = Type.NULL;
-      return returnResult(result);
-    case z.ZodFirstPartyTypeKind.ZodAny:
-    case z.ZodFirstPartyTypeKind.ZodUnknown:
-      return returnResult(__spreadValues({}, description && { description }));
-    default:
-      throw new Error("Unsupported Zod type: ".concat(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 !== 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 === z.ZodFirstPartyTypeKind.ZodOptional || currentSchema._def.typeName === z.ZodFirstPartyTypeKind.ZodDefault) {
-      isOptional = true;
-      currentSchema = currentSchema._def.innerType;
-    }
-    if (!isOptional) {
-      required.push(key);
-    }
+  if (isZodV4Schema(schema)) {
+    return toJSONSchemaV4(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 = 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 !== z.ZodFirstPartyTypeKind.ZodNever) {
-    additionalProperties = parseZodType(catchall) || true;
-  } else {
-    additionalProperties = schema._def.unknownKeys === "passthrough";
+  if (isZodV3Schema(schema)) {
+    return toJSONSchemaV3(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 = 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 __spreadValues({
-    type: Type.OBJECT,
-    properties,
-    required: required.length > 0 ? required : []
-  }, schema._def.description ? { description: schema._def.description } : {});
+  throw new Error("Unsupported Zod schema version.");
 }
 export {
   isZodObject,

package/dist/web/utils/variant_utils.js

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { getBooleanEnvVar } from "./env_aware_utils.js";
 var GoogleLLMVariant = /* @__PURE__ */ ((GoogleLLMVariant2) => {
   GoogleLLMVariant2["VERTEX_AI"] = "VERTEX_AI";
   GoogleLLMVariant2["GEMINI_API"] = "GEMINI_API";
@@ -11,13 +12,6 @@ var GoogleLLMVariant = /* @__PURE__ */ ((GoogleLLMVariant2) => {
 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());
-}
 export {
   GoogleLLMVariant,
   getGoogleLlmVariant

package/dist/web/version.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "0.2.5";
+const version = "0.4.0";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/adk",
-  "version": "0.2.5",
+  "version": "0.4.0",
   "description": "Google ADK JS",
   "author": "Google",
   "license": "Apache-2.0",
@@ -30,29 +30,40 @@
   "scripts": {
     "clean": "rm -rf dist",
     "clean:all": "npm run clean && rm -rf node_modules",
+    "rebuild": "npm run clean:all && npm install && npm run build",
     "build": "tsc --emitDeclarationOnly && node ./build.js",
     "build:bundle": "tsc --emitDeclarationOnly && node ./build.js --bundle",
     "build:watch": "concurrently \"tsc --noEmit --watch --preserveWatchOutput\" \"node ./build.js --watch\"",
     "test": "vitest",
     "lint": "eslint 'src/**/*.ts'",
     "format": "prettier --write 'src/**/*.ts'",
-    "prepublishOnly": "npm run build:bundle"
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@a2a-js/sdk": "^0.3.10",
     "@google/genai": "^1.37.0",
-    "@modelcontextprotocol/sdk": "^1.24.0",
+    "@mikro-orm/core": "^6.6.6",
+    "@mikro-orm/reflection": "^6.6.6",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "google-auth-library": "^10.3.0",
     "lodash-es": "^4.17.23",
-    "zod": "3.25.76"
+    "zod": "^4.2.1",
+    "zod-to-json-schema": "^3.25.1"
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.12",
-    "openapi-types": "^12.1.3"
+    "openapi-types": "^12.1.3",
+    "@mikro-orm/sqlite": "^6.6.6"
   },
   "peerDependencies": {
     "@google-cloud/opentelemetry-cloud-monitoring-exporter": "^0.21.0",
     "@google-cloud/opentelemetry-cloud-trace-exporter": "^3.0.0",
     "@google-cloud/storage": "^7.17.1",
+    "@mikro-orm/mariadb": "^6.6.6",
+    "@mikro-orm/mssql": "^6.6.6",
+    "@mikro-orm/mysql": "^6.6.6",
+    "@mikro-orm/postgresql": "^6.6.6",
+    "@mikro-orm/sqlite": "^6.6.6",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/api-logs": "^0.205.0",
     "@opentelemetry/exporter-logs-otlp-http": "^0.205.0",