@softactivate/adk 1.1.0

package/dist/cjs/utils/gemini_schema_util.js

@@ -0,0 +1,152 @@
+/**
+  * @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 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 MCPToolSchemaObject = import_zod.z.object({
+  type: import_zod.z.literal("object"),
+  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":
+      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;
+    case "null":
+      return import_genai.Type.NULL;
+    default:
+      return import_genai.Type.TYPE_UNSPECIFIED;
+  }
+}
+const getTypeFromArrayItem = (mcpType) => {
+  var _a, _b;
+  if (typeof mcpType === "string") {
+    return mcpType.toLowerCase();
+  }
+  return (_b = (_a = mcpType == null ? void 0 : mcpType.type) == null ? void 0 : _a.toLowerCase) == null ? void 0 : _b.call(_a);
+};
+function toGeminiSchema(mcpSchema) {
+  if (!mcpSchema) {
+    return void 0;
+  }
+  function recursiveConvert(mcp) {
+    var _a;
+    const sourceType = (_a = mcp.anyOf) != null ? _a : mcp.type;
+    let isNullable = false;
+    let nonNullTypes;
+    if (Array.isArray(sourceType)) {
+      nonNullTypes = sourceType.filter(
+        (t) => getTypeFromArrayItem(t) !== "null"
+      );
+      isNullable = sourceType.some(
+        (t) => getTypeFromArrayItem(t) === "null"
+      );
+      if (nonNullTypes.length === 1) {
+        const nonNullType = nonNullTypes[0];
+        if (typeof nonNullType === "object") {
+          mcp = nonNullType;
+        } else {
+          const { type: _removed, anyOf: _removedAnyOf, ...rest } = mcp;
+          mcp = { ...rest, type: nonNullType };
+        }
+      } else if (nonNullTypes.length === 0 && isNullable) {
+        const { type: _removed, anyOf: _removedAnyOf, ...rest } = mcp;
+        mcp = { ...rest, type: "null" };
+      } else if (typeof mcp.anyOf === "undefined") {
+        const anyOfItems = mcp.type.map((t) => ({ type: t }));
+        const { type: _removed, ...rest } = mcp;
+        mcp = { ...rest, anyOf: anyOfItems };
+      }
+    }
+    if (!mcp.type) {
+      if (mcp.properties || mcp.$ref) {
+        mcp.type = "object";
+      } else if (mcp.items) {
+        mcp.type = "array";
+      } else if (isNullable) {
+        mcp.type = "null";
+      }
+    }
+    const geminiType = toGeminiType(mcp.type);
+    const geminiSchema = {};
+    if (mcp.anyOf) {
+      geminiSchema.anyOf = mcp.anyOf.map(
+        (item) => recursiveConvert(item)
+      );
+    } else {
+      geminiSchema.type = geminiType;
+    }
+    if (mcp.description) {
+      geminiSchema.description = mcp.description;
+    }
+    if (isNullable && mcp.type !== "null") {
+      geminiSchema.nullable = true;
+    }
+    if (geminiType === import_genai.Type.OBJECT) {
+      geminiSchema.properties = {};
+      if (mcp.properties) {
+        for (const name in mcp.properties) {
+          geminiSchema.properties[name] = recursiveConvert(
+            mcp.properties[name]
+          );
+        }
+      }
+      if (mcp.required) {
+        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,173 @@
+/**
+  * @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 logger_exports = {};
+__export(logger_exports, {
+  LogLevel: () => LogLevel,
+  getLogger: () => getLogger,
+  logger: () => logger,
+  resetLogger: () => resetLogger,
+  setLogLevel: () => setLogLevel,
+  setLogger: () => setLogger
+});
+module.exports = __toCommonJS(logger_exports);
+var winston = __toESM(require("winston"), 1);
+/**
+ * @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 || {});
+class SimpleLogger {
+  constructor() {
+    this.logLevel = 1 /* INFO */;
+    this.logger = winston.createLogger({
+      levels: {
+        "debug": 0 /* DEBUG */,
+        "info": 1 /* INFO */,
+        "warn": 2 /* WARN */,
+        "error": 3 /* ERROR */
+      },
+      level: "error",
+      format: winston.format.combine(
+        winston.format.label({ label: "ADK" }),
+        winston.format((info) => {
+          info.level = info.level.toUpperCase();
+          return info;
+        })(),
+        winston.format.colorize(),
+        winston.format.timestamp(),
+        winston.format.printf((info) => {
+          return `${info.level}: [${info.label}] ${info.timestamp} ${info.message}`;
+        })
+      ),
+      transports: [new winston.transports.Console()]
+    });
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  log(level, ...messages) {
+    if (this.logLevel > level) {
+      return;
+    }
+    this.logger.log(level.toString(), messages.join(" "));
+  }
+  debug(...messages) {
+    if (this.logLevel > 0 /* DEBUG */) {
+      return;
+    }
+    this.logger.debug(messages.join(" "));
+  }
+  info(...messages) {
+    if (this.logLevel > 1 /* INFO */) {
+      return;
+    }
+    this.logger.info(messages.join(" "));
+  }
+  warn(...messages) {
+    if (this.logLevel > 2 /* WARN */) {
+      return;
+    }
+    this.logger.warn(messages.join(" "));
+  }
+  error(...messages) {
+    if (this.logLevel > 3 /* ERROR */) {
+      return;
+    }
+    this.logger.error(messages.join(" "));
+  }
+}
+class NoOpLogger {
+  setLogLevel(_level) {
+  }
+  log(_level, ..._args) {
+  }
+  debug(..._args) {
+  }
+  info(..._args) {
+  }
+  warn(..._args) {
+  }
+  error(..._args) {
+  }
+}
+let currentLogger = new SimpleLogger();
+function setLogger(customLogger) {
+  currentLogger = customLogger != null ? customLogger : new NoOpLogger();
+}
+function getLogger() {
+  return currentLogger;
+}
+function resetLogger() {
+  currentLogger = new SimpleLogger();
+}
+function setLogLevel(level) {
+  logger.setLogLevel(level);
+}
+const logger = {
+  setLogLevel(level) {
+    currentLogger.setLogLevel(level);
+  },
+  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,
+  resetLogger,
+  setLogLevel,
+  setLogger
+});

package/dist/cjs/utils/model_name.js

@@ -0,0 +1,90 @@
+/**
+  * @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 model_name_exports = {};
+__export(model_name_exports, {
+  extractModelName: () => extractModelName,
+  isGemini1Model: () => isGemini1Model,
+  isGemini2OrAbove: () => isGemini2OrAbove,
+  isGeminiModel: () => isGeminiModel,
+  isGeminiModelIdCheckDisabled: () => isGeminiModelIdCheckDisabled
+});
+module.exports = __toCommonJS(model_name_exports);
+var import_env_aware_utils = require("./env_aware_utils.js");
+/**
+ * @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 parseVersion(versionString) {
+  if (!/^\d+(\.\d+)*$/.test(versionString)) {
+    return { valid: false, major: 0, minor: 0, patch: 0 };
+  }
+  const parts = versionString.split(".").map((part) => parseInt(part, 10));
+  return {
+    valid: true,
+    major: parts[0],
+    minor: parts.length > 1 ? parts[1] : 0,
+    patch: parts.length > 2 ? parts[2] : 0
+  };
+}
+function isGemini1Model(modelString) {
+  const modelName = extractModelName(modelString);
+  return modelName.startsWith("gemini-1");
+}
+function isGemini2OrAbove(modelString) {
+  if (!modelString) {
+    return false;
+  }
+  const modelName = extractModelName(modelString);
+  if (!modelName.startsWith("gemini-")) {
+    return false;
+  }
+  const versionString = modelName.slice("gemini-".length).split("-", 1)[0];
+  const parsedVersion = parseVersion(versionString);
+  return parsedVersion.valid && parsedVersion.major >= 2;
+}
+function isGeminiModelIdCheckDisabled() {
+  return (0, import_env_aware_utils.getBooleanEnvVar)("ADK_DISABLE_GEMINI_MODEL_ID_CHECK");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractModelName,
+  isGemini1Model,
+  isGemini2OrAbove,
+  isGeminiModel,
+  isGeminiModelIdCheckDisabled
+});

package/dist/cjs/utils/object_notation_utils.js

@@ -0,0 +1,78 @@
+/**
+  * @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 object_notation_utils_exports = {};
+__export(object_notation_utils_exports, {
+  toCamelCase: () => toCamelCase,
+  toSnakeCase: () => toSnakeCase
+});
+module.exports = __toCommonJS(object_notation_utils_exports);
+/**
+ * @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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toCamelCase,
+  toSnakeCase
+});

package/dist/cjs/utils/simple_zod_to_json.js

@@ -0,0 +1,150 @@
+/**
+  * @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 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_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 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 getZodTypeName(schema) {
+  var _a, _b;
+  const schemaAny = schema;
+  if ((_a = schemaAny._def) == null ? void 0 : _a.typeName) {
+    return schemaAny._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 (!isZodObject(schema)) {
+    throw new Error("Expected a Zod Object");
+  }
+  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();
+        }
+      }
+    });
+  }
+  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;
+      }
+    });
+  }
+  throw new Error("Unsupported Zod schema version.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isZodObject,
+  zodObjectToSchema
+});