@softactivate/adk 1.1.0

package/dist/web/utils/failover_utils.js

@@ -0,0 +1,96 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "./logger.js";
+function runWithRouting(items, context, router, runFn) {
+  return __asyncGenerator(this, null, function* () {
+    const initialKey = yield new __await(router(items, context));
+    if (!initialKey) {
+      throw new Error("Initial routing failed, no item selected.");
+    }
+    let selectedKey = initialKey;
+    logger.debug("Router selected initial key: ".concat(selectedKey));
+    let selectedItem = items[selectedKey];
+    if (!selectedItem) {
+      throw new Error("Item not found for key: ".concat(selectedKey));
+    }
+    const triedKeys = /* @__PURE__ */ new Set([selectedKey]);
+    while (true) {
+      const generatorOrPromise = runFn(selectedItem);
+      let firstYielded = false;
+      try {
+        if (isAsyncGenerator(generatorOrPromise)) {
+          try {
+            for (var iter = __forAwait(generatorOrPromise), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+              const result2 = temp.value;
+              yield result2;
+              firstYielded = true;
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+          return;
+        }
+        const result = yield new __await(generatorOrPromise);
+        yield result;
+        return;
+      } catch (error2) {
+        if (!firstYielded) {
+          const nextKey = yield new __await(router(items, context, {
+            failedKeys: triedKeys,
+            lastError: error2
+          }));
+          logger.debug("Router selected next key: ".concat(nextKey));
+          if (nextKey === void 0) {
+            throw error2;
+          }
+          if (triedKeys.has(nextKey)) {
+            throw error2;
+          }
+          selectedKey = nextKey;
+          selectedItem = items[selectedKey];
+          if (!selectedItem) {
+            throw new Error("Item not found for key: ".concat(selectedKey));
+          }
+          triedKeys.add(selectedKey);
+        } else {
+          throw error2;
+        }
+      }
+    }
+  });
+}
+function isAsyncGenerator(obj) {
+  return typeof obj === "object" && typeof obj[Symbol.asyncIterator] === "function";
+}
+export {
+  runWithRouting
+};

package/dist/web/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/web/utils/file_utils.js

@@ -0,0 +1,74 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+/**
+ * @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: ".concat(file.name, " resolves outside of ").concat(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 = "".concat(base, "_").concat(counter).concat(ext);
+        finalPath = path.join(dirName, newName);
+        const originalDir = path.dirname(file.name);
+        file.name = originalDir === "." ? newName : path.join(originalDir, newName);
+        counter++;
+      } catch (e) {
+        break;
+      }
+    }
+    if (!finalPath.startsWith(resolvedBaseDir)) {
+      throw new Error(
+        "Path traversal detected: ".concat(file.name, " resolves outside of ").concat(dir)
+      );
+    }
+    await fs.mkdir(path.dirname(finalPath), { recursive: true });
+    await fs.writeFile(
+      finalPath,
+      Buffer.from(file.content, file.contentEncoding)
+    );
+    createdFiles.push(__spreadProps(__spreadValues({}, file), {
+      name: path.relative(dir, finalPath)
+    }));
+  }
+  return createdFiles;
+}
+export {
+  materializeFiles
+};

package/dist/web/utils/gemini_schema_util.js

@@ -0,0 +1,155 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+/**
+ * @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 _b = mcp, { type: _removed, anyOf: _removedAnyOf } = _b, rest = __objRest(_b, ["type", "anyOf"]);
+          mcp = __spreadProps(__spreadValues({}, rest), { type: nonNullType });
+        }
+      } else if (nonNullTypes.length === 0 && isNullable) {
+        const _c = mcp, { type: _removed, anyOf: _removedAnyOf } = _c, rest = __objRest(_c, ["type", "anyOf"]);
+        mcp = __spreadProps(__spreadValues({}, rest), { type: "null" });
+      } else if (typeof mcp.anyOf === "undefined") {
+        const anyOfItems = mcp.type.map((t) => ({ type: t }));
+        const _d = mcp, { type: _removed } = _d, rest = __objRest(_d, ["type"]);
+        mcp = __spreadProps(__spreadValues({}, 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/web/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 "".concat(info.level, ": [").concat(info.label, "] ").concat(info.timestamp, " ").concat(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/web/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/web/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
+};