@google/adk 0.3.0 → 0.5.0

package/dist/cjs/utils/logger.js

@@ -1,13 +1,15 @@
 /**
   * @license
-  * Copyright 2025 Google LLC
+  * 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)
@@ -21,6 +23,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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, {
@@ -32,6 +42,7 @@ __export(logger_exports, {
   setLogger: () => setLogger
 });
 module.exports = __toCommonJS(logger_exports);
+var winston = __toESM(require("winston"), 1);
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -44,58 +55,68 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
   return LogLevel2;
 })(LogLevel || {});
-let logLevel = 1 /* INFO */;
-function setLogLevel(level) {
-  logLevel = level;
-}
 class SimpleLogger {
-  log(level, ...args) {
-    if (level < logLevel) {
+  constructor() {
+    this.logLevel = 1 /* INFO */;
+    this.logger = winston.createLogger({
+      levels: {
+        "debug": 0 /* DEBUG */,
+        "info": 1 /* INFO */,
+        "warn": 2 /* WARN */,
+        "error": 3 /* 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;
     }
-    switch (level) {
-      case 0 /* DEBUG */:
-        this.debug(...args);
-        break;
-      case 1 /* INFO */:
-        this.info(...args);
-        break;
-      case 2 /* WARN */:
-        this.warn(...args);
-        break;
-      case 3 /* ERROR */:
-        this.error(...args);
-        break;
-      default:
-        throw new Error(`Unsupported log level: ${level}`);
-    }
+    this.logger.log(level.toString(), messages.join(" "));
   }
-  debug(...args) {
-    if (logLevel > 0 /* DEBUG */) {
+  debug(...messages) {
+    if (this.logLevel > 0 /* DEBUG */) {
       return;
     }
-    console.debug(getColoredPrefix(0 /* DEBUG */), ...args);
+    this.logger.debug(messages.join(" "));
   }
-  info(...args) {
-    if (logLevel > 1 /* INFO */) {
+  info(...messages) {
+    if (this.logLevel > 1 /* INFO */) {
       return;
     }
-    console.info(getColoredPrefix(1 /* INFO */), ...args);
+    this.logger.info(messages.join(" "));
   }
-  warn(...args) {
-    if (logLevel > 2 /* WARN */) {
+  warn(...messages) {
+    if (this.logLevel > 2 /* WARN */) {
       return;
     }
-    console.warn(getColoredPrefix(2 /* WARN */), ...args);
+    this.logger.warn(messages.join(" "));
   }
-  error(...args) {
-    if (logLevel > 3 /* ERROR */) {
+  error(...messages) {
+    if (this.logLevel > 3 /* ERROR */) {
       return;
     }
-    console.error(getColoredPrefix(3 /* ERROR */), ...args);
+    this.logger.error(messages.join(" "));
   }
 }
 class NoOpLogger {
+  setLogLevel(_level) {
+  }
   log(_level, ..._args) {
   }
   debug(..._args) {
@@ -107,26 +128,6 @@ class NoOpLogger {
   error(..._args) {
   }
 }
-const LOG_LEVEL_STR = {
-  [0 /* DEBUG */]: "DEBUG",
-  [1 /* INFO */]: "INFO",
-  [2 /* WARN */]: "WARN",
-  [3 /* ERROR */]: "ERROR"
-};
-const CONSOLE_COLOR_MAP = {
-  [0 /* DEBUG */]: "\x1B[34m",
-  // Blue
-  [1 /* INFO */]: "\x1B[32m",
-  // Green
-  [2 /* WARN */]: "\x1B[33m",
-  // Yellow
-  [3 /* ERROR */]: "\x1B[31m"
-  // Red
-};
-const RESET_COLOR = "\x1B[0m";
-function getColoredPrefix(level) {
-  return `${CONSOLE_COLOR_MAP[level]}[ADK ${LOG_LEVEL_STR[level]}]:${RESET_COLOR}`;
-}
 let currentLogger = new SimpleLogger();
 function setLogger(customLogger) {
   currentLogger = customLogger != null ? customLogger : new NoOpLogger();
@@ -137,7 +138,13 @@ function getLogger() {
 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);
   },

package/dist/cjs/utils/model_name.js

@@ -1,6 +1,6 @@
 /**
   * @license
-  * Copyright 2025 Google LLC
+  * Copyright 2026 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   */
 

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

@@ -1,6 +1,6 @@
 /**
   * @license
-  * Copyright 2025 Google LLC
+  * Copyright 2026 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   */
 

package/dist/cjs/utils/variant_utils.js

@@ -1,6 +1,6 @@
 /**
   * @license
-  * Copyright 2025 Google LLC
+  * Copyright 2026 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   */
 
@@ -28,6 +28,7 @@ __export(variant_utils_exports, {
   getGoogleLlmVariant: () => getGoogleLlmVariant
 });
 module.exports = __toCommonJS(variant_utils_exports);
+var import_env_aware_utils = require("./env_aware_utils.js");
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -39,14 +40,7 @@ var GoogleLLMVariant = /* @__PURE__ */ ((GoogleLLMVariant2) => {
   return GoogleLLMVariant2;
 })(GoogleLLMVariant || {});
 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(envVarValue);
+  return (0, import_env_aware_utils.getBooleanEnvVar)("GOOGLE_GENAI_USE_VERTEXAI") ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/version.js

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

package/dist/esm/a2a/a2a_event.js

@@ -0,0 +1,243 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { randomUUID } from "../utils/env_aware_utils.js";
+var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
+  MessageRole2["USER"] = "user";
+  MessageRole2["AGENT"] = "agent";
+  return MessageRole2;
+})(MessageRole || {});
+function isTaskStatusUpdateEvent(event) {
+  return (event == null ? void 0 : event.kind) === "status-update";
+}
+function isTaskArtifactUpdateEvent(event) {
+  return (event == null ? void 0 : event.kind) === "artifact-update";
+}
+function isMessage(event) {
+  return (event == null ? void 0 : event.kind) === "message";
+}
+function isTask(event) {
+  return (event == null ? void 0 : event.kind) === "task";
+}
+function getEventMetadata(event) {
+  if (isTaskArtifactUpdateEvent(event)) {
+    return event.artifact.metadata || {};
+  }
+  if (isTaskStatusUpdateEvent(event) || isTask(event) || isMessage(event)) {
+    return event.metadata || {};
+  }
+  return {};
+}
+function isFailedTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "failed";
+}
+function isTerminalTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && ["completed", "failed", "canceled", "rejected"].includes(event.status.state);
+}
+function isInputRequiredTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "input-required";
+}
+function getFailedTaskStatusUpdateEventError(event) {
+  var _a;
+  if (!isFailedTaskStatusUpdateEvent(event)) {
+    return void 0;
+  }
+  const parts = ((_a = event.status.message) == null ? void 0 : _a.parts) || [];
+  if (parts.length === 0) {
+    return void 0;
+  }
+  if (parts[0].kind !== "text") {
+    return void 0;
+  }
+  return parts[0].text;
+}
+function createTaskSubmittedEvent({
+  taskId,
+  contextId,
+  message
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: false,
+    status: {
+      state: "submitted",
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createTask({
+  contextId,
+  message,
+  taskId
+}) {
+  return {
+    kind: "task",
+    id: taskId || randomUUID(),
+    contextId,
+    history: [message],
+    status: {
+      state: "submitted",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createTaskWorkingEvent({
+  taskId,
+  contextId,
+  message
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: false,
+    status: {
+      state: "working",
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createTaskCompletedEvent({
+  taskId,
+  contextId,
+  metadata = {}
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "completed",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTaskArtifactUpdateEvent({
+  taskId,
+  contextId,
+  artifactId,
+  parts = [],
+  metadata,
+  append,
+  lastChunk
+}) {
+  return {
+    kind: "artifact-update",
+    taskId,
+    contextId,
+    append,
+    lastChunk,
+    artifact: {
+      artifactId: artifactId || randomUUID(),
+      parts,
+      metadata
+    }
+  };
+}
+function createTaskFailedEvent({
+  taskId,
+  contextId,
+  error,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    status: {
+      state: "failed",
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts: [
+          {
+            kind: "text",
+            text: error.message
+          }
+        ]
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata,
+    final: true
+  };
+}
+function createTaskInputRequiredEvent({
+  taskId,
+  contextId,
+  parts
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "input-required",
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createInputMissingErrorEvent({
+  taskId,
+  contextId,
+  parts
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "input-required",
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+export {
+  MessageRole,
+  createInputMissingErrorEvent,
+  createTask,
+  createTaskArtifactUpdateEvent,
+  createTaskCompletedEvent,
+  createTaskFailedEvent,
+  createTaskInputRequiredEvent,
+  createTaskSubmittedEvent,
+  createTaskWorkingEvent,
+  getEventMetadata,
+  getFailedTaskStatusUpdateEventError,
+  isFailedTaskStatusUpdateEvent,
+  isInputRequiredTaskStatusUpdateEvent,
+  isMessage,
+  isTask,
+  isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent,
+  isTerminalTaskStatusUpdateEvent
+};