@softactivate/adk 1.1.0

package/dist/esm/utils/failover_utils.js

@@ -0,0 +1,65 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "./logger.js";
+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;
+  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
+        });
+        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";
+}
+export {
+  runWithRouting
+};

package/dist/esm/utils/file_extension_utils.js

@@ -0,0 +1,51 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  CodeExecutionLanguage,
+  FileContentEncoding
+} from "../code_executors/code_execution_utils.js";
+const MIME_TYPE_MAP = {
+  ".js": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".py": { mimeType: "text/x-python", encoding: FileContentEncoding.UTF8 },
+  ".md": { mimeType: "text/markdown", encoding: FileContentEncoding.UTF8 },
+  ".txt": { mimeType: "text/plain", encoding: FileContentEncoding.UTF8 },
+  ".html": { mimeType: "text/html", encoding: FileContentEncoding.UTF8 },
+  ".css": { mimeType: "text/css", encoding: FileContentEncoding.UTF8 },
+  ".json": { mimeType: "application/json", encoding: FileContentEncoding.UTF8 },
+  ".csv": { mimeType: "text/csv", encoding: FileContentEncoding.UTF8 },
+  ".svg": { mimeType: "image/svg+xml", encoding: FileContentEncoding.UTF8 },
+  ".xml": { mimeType: "application/xml", encoding: FileContentEncoding.UTF8 },
+  ".yaml": { mimeType: "text/yaml", encoding: FileContentEncoding.UTF8 },
+  ".yml": { mimeType: "text/yaml", encoding: FileContentEncoding.UTF8 },
+  ".png": { mimeType: "image/png", encoding: FileContentEncoding.BASE64 },
+  ".jpg": { mimeType: "image/jpeg", encoding: FileContentEncoding.BASE64 },
+  ".jpeg": { mimeType: "image/jpeg", encoding: FileContentEncoding.BASE64 },
+  ".pdf": { mimeType: "application/pdf", encoding: FileContentEncoding.BASE64 }
+};
+const EXTENSION_TO_LANGUAGE = {
+  ".js": CodeExecutionLanguage.JAVASCRIPT,
+  ".ts": CodeExecutionLanguage.TYPESCRIPT,
+  ".py": CodeExecutionLanguage.PYTHON,
+  ".bat": CodeExecutionLanguage.WINDOWS_CMD,
+  ".cmd": CodeExecutionLanguage.WINDOWS_CMD,
+  ".ps1": CodeExecutionLanguage.POWERSHELL,
+  ".sh": CodeExecutionLanguage.SHELL
+};
+function getMimeTypeAndEncoding(ext) {
+  return MIME_TYPE_MAP[ext.toLowerCase()] || {
+    mimeType: "application/octet-stream",
+    encoding: FileContentEncoding.BASE64
+  };
+}
+function getScriptLanguageByExtension(ext) {
+  return EXTENSION_TO_LANGUAGE[ext.toLowerCase()] || CodeExecutionLanguage.UNSPECIFIED;
+}
+export {
+  getMimeTypeAndEncoding,
+  getScriptLanguageByExtension
+};

package/dist/esm/utils/file_utils.js

@@ -0,0 +1,56 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+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;
+}
+export {
+  materializeFiles
+};

package/dist/esm/utils/gemini_schema_util.js

@@ -0,0 +1,124 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { z } from "zod";
+const MCPToolSchemaObject = z.object({
+  type: z.literal("object"),
+  properties: z.record(z.string(), z.unknown()).optional(),
+  required: z.string().array().optional()
+});
+function toGeminiType(mcpType) {
+  if (!mcpType) return Type.TYPE_UNSPECIFIED;
+  switch (mcpType.toLowerCase()) {
+    case "text":
+    case "string":
+      return Type.STRING;
+    case "number":
+      return Type.NUMBER;
+    case "boolean":
+      return Type.BOOLEAN;
+    case "integer":
+      return Type.INTEGER;
+    case "array":
+      return Type.ARRAY;
+    case "object":
+      return Type.OBJECT;
+    case "null":
+      return Type.NULL;
+    default:
+      return 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 === 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 === Type.ARRAY) {
+      if (mcp.items) {
+        geminiSchema.items = recursiveConvert(mcp.items);
+      }
+    }
+    return geminiSchema;
+  }
+  return recursiveConvert(mcpSchema);
+}
+export {
+  toGeminiSchema
+};

package/dist/esm/utils/logger.js

@@ -0,0 +1,130 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as winston from "winston";
+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);
+  }
+};
+export {
+  LogLevel,
+  getLogger,
+  logger,
+  resetLogger,
+  setLogLevel,
+  setLogger
+};

package/dist/esm/utils/model_name.js

@@ -0,0 +1,58 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getBooleanEnvVar } from "./env_aware_utils.js";
+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 getBooleanEnvVar("ADK_DISABLE_GEMINI_MODEL_ID_CHECK");
+}
+export {
+  extractModelName,
+  isGemini1Model,
+  isGemini2OrAbove,
+  isGeminiModel,
+  isGeminiModelIdCheckDisabled
+};

package/dist/esm/utils/object_notation_utils.js

@@ -0,0 +1,49 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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/esm/utils/simple_zod_to_json.js

@@ -0,0 +1,123 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+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 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 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();
+        }
+      }
+    });
+  }
+  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;
+      }
+    });
+  }
+  throw new Error("Unsupported Zod schema version.");
+}
+export {
+  isZodObject,
+  zodObjectToSchema
+};