@google/adk 0.1.0

package/dist/web/tools/tool_context.js

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CallbackContext } from "../agents/callback_context.js";
+import { AuthHandler } from "../auth/auth_handler.js";
+import { ToolConfirmation } from "../tools/tool_confirmation.js";
+class ToolContext extends CallbackContext {
+  /**
+   * @param params.invocationContext The invocation context of the tool.
+   * @param params.eventActions The event actions of the current tool call.
+   * @param params.functionCallId The function call id of the current tool call.
+   *     This id was returned in the function call event from LLM to identify a
+   *     function call. If LLM didn't return this id, ADK will assign one to it.
+   *     This id is used to map function call response to the original function
+   *     call.
+   * @param params.toolConfirmation The tool confirmation of the current tool
+   *     call.
+   */
+  constructor({
+    invocationContext,
+    eventActions,
+    functionCallId,
+    toolConfirmation
+  }) {
+    super({ invocationContext, eventActions });
+    this.functionCallId = functionCallId;
+    this.toolConfirmation = toolConfirmation;
+  }
+  get actions() {
+    return this.eventActions;
+  }
+  requestCredential(authConfig) {
+    if (!this.functionCallId) {
+      throw new Error("functionCallId is not set.");
+    }
+    const authHandler = new AuthHandler(authConfig);
+    this.eventActions.requestedAuthConfigs[this.functionCallId] = authHandler.generateAuthRequest();
+  }
+  /**
+   * Gets the auth credential for the given auth config.
+   *
+   * @param authConfig The auth config to get the auth credential for.
+   * @return The auth credential for the given auth config.
+   */
+  getAuthResponse(authConfig) {
+    const authHandler = new AuthHandler(authConfig);
+    return authHandler.getAuthResponse(this.state);
+  }
+  /**
+   * Lists the filenames of the artifacts attached to the current session.
+   *
+   * @return A promise that resolves to a list of artifact filenames.
+   */
+  listArtifacts() {
+    if (!this.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.invocationContext.artifactService.listArtifactKeys({
+      appName: this.invocationContext.session.appName,
+      userId: this.invocationContext.session.userId,
+      sessionId: this.invocationContext.session.id
+    });
+  }
+  /**
+   * Searches the memory of the current user.
+   *
+   * @param query The query to search memory for.
+   * @return A promise that resolves to SearchMemoryResponse containing the
+   *     matching memories.
+   */
+  searchMemory(query) {
+    if (!this.invocationContext.memoryService) {
+      throw new Error("Memory service is not initialized.");
+    }
+    return this.invocationContext.memoryService.searchMemory({
+      appName: this.invocationContext.session.appName,
+      userId: this.invocationContext.session.userId,
+      query
+    });
+  }
+  /**
+   * Requests confirmation for the current tool call.
+   */
+  requestConfirmation({ hint, payload }) {
+    if (!this.functionCallId) {
+      throw new Error("functionCallId is not set.");
+    }
+    this.eventActions.requestedToolConfirmations[this.functionCallId] = new ToolConfirmation({
+      hint,
+      confirmed: false,
+      payload
+    });
+  }
+}
+export {
+  ToolContext
+};

package/dist/web/utils/deep_clone.js

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function deepClone(obj) {
+  if (obj === void 0) {
+    return void 0;
+  }
+  return JSON.parse(JSON.stringify(obj));
+}
+export {
+  deepClone
+};

package/dist/web/utils/env_aware_utils.js

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+const UUID_MASK = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+function randomUUID() {
+  let uuid = "";
+  for (let i = 0; i < UUID_MASK.length; i++) {
+    const randomValue = Math.random() * 16 | 0;
+    if (UUID_MASK[i] === "x") {
+      uuid += randomValue.toString(16);
+    } else if (UUID_MASK[i] === "y") {
+      uuid += (randomValue & 3 | 8).toString(16);
+    } else {
+      uuid += UUID_MASK[i];
+    }
+  }
+  return uuid;
+}
+function base64Encode(data) {
+  if (isBrowser()) {
+    return window.btoa(data);
+  }
+  return Buffer.from(data).toString("base64");
+}
+function base64Decode(data) {
+  if (isBrowser()) {
+    return window.atob(data);
+  }
+  return Buffer.from(data, "base64").toString();
+}
+function isBase64Encoded(data) {
+  try {
+    return base64Encode(base64Decode(data)) === data;
+  } catch (e) {
+    return false;
+  }
+}
+export {
+  base64Decode,
+  base64Encode,
+  isBase64Encoded,
+  isBrowser,
+  randomUUID
+};

package/dist/web/utils/gemini_schema_util.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { z } from "zod";
+const MCPToolSchema = z.object({
+  type: z.literal("object"),
+  properties: z.record(z.unknown()).optional(),
+  required: z.string().array().optional()
+});
+function toGeminiType(mcpType) {
+  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;
+    default:
+      return Type.TYPE_UNSPECIFIED;
+  }
+}
+function toGeminiSchema(mcpSchema) {
+  if (!mcpSchema) {
+    return void 0;
+  }
+  function recursiveConvert(mcp) {
+    const geminiType = toGeminiType(mcp.type);
+    const geminiSchema = { type: geminiType, description: mcp.description };
+    if (geminiType === Type.OBJECT) {
+      geminiSchema.properties = {};
+      if (mcp.properties) {
+        for (const name in mcp.properties) {
+          geminiSchema.properties[name] = recursiveConvert(mcp.properties[name]);
+        }
+      }
+      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,89 @@
+/**
+ * @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 || {});
+let logLevel = 1 /* INFO */;
+function setLogLevel(level) {
+  logLevel = level;
+}
+class SimpleLogger {
+  log(level, ...args) {
+    if (level < logLevel) {
+      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: ".concat(level));
+    }
+  }
+  debug(...args) {
+    if (logLevel > 0 /* DEBUG */) {
+      return;
+    }
+    console.debug(getColoredPrefix(0 /* DEBUG */), ...args);
+  }
+  info(...args) {
+    if (logLevel > 1 /* INFO */) {
+      return;
+    }
+    console.info(getColoredPrefix(1 /* INFO */), ...args);
+  }
+  warn(...args) {
+    if (logLevel > 2 /* WARN */) {
+      return;
+    }
+    console.warn(getColoredPrefix(2 /* WARN */), ...args);
+  }
+  error(...args) {
+    if (logLevel > 3 /* ERROR */) {
+      return;
+    }
+    console.error(getColoredPrefix(3 /* 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 "".concat(CONSOLE_COLOR_MAP[level], "[ADK ").concat(LOG_LEVEL_STR[level], "]:").concat(RESET_COLOR);
+}
+const logger = new SimpleLogger();
+export {
+  LogLevel,
+  logger,
+  setLogLevel
+};

package/dist/web/utils/model_name.js

@@ -0,0 +1,31 @@
+/**
+ * @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 isGemini1Model(modelString) {
+  const modelName = extractModelName(modelString);
+  return modelName.startsWith("gemini-1");
+}
+function isGemini2Model(modelString) {
+  const modelName = extractModelName(modelString);
+  return modelName.startsWith("gemini-2");
+}
+export {
+  extractModelName,
+  isGemini1Model,
+  isGemini2Model,
+  isGeminiModel
+};

package/dist/web/utils/simple_zod_to_json.js

@@ -0,0 +1,174 @@
+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";
+}
+function parseZodType(zodType) {
+  const def = zodType._def;
+  if (!def) {
+    return {};
+  }
+  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));
+  }
+}
+function zodObjectToSchema(schema) {
+  if (schema._def.typeName !== z.ZodFirstPartyTypeKind.ZodObject) {
+    throw new Error("Expected a ZodObject");
+  }
+  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);
+    }
+  }
+  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";
+  }
+  return __spreadValues({
+    type: Type.OBJECT,
+    properties,
+    required: required.length > 0 ? required : []
+  }, schema._def.description ? { description: schema._def.description } : {});
+}
+export {
+  isZodObject,
+  zodObjectToSchema
+};

package/dist/web/utils/variant_utils.js

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var GoogleLLMVariant = /* @__PURE__ */ ((GoogleLLMVariant2) => {
+  GoogleLLMVariant2["VERTEX_AI"] = "VERTEX_AI";
+  GoogleLLMVariant2["GEMINI_API"] = "GEMINI_API";
+  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(envVar.toLowerCase());
+}
+export {
+  GoogleLLMVariant,
+  getGoogleLlmVariant
+};

package/dist/web/version.js

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const version = "0.1.0";
+export {
+  version
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@google/adk",
+  "version": "0.1.0",
+  "description": "Google ADK JS",
+  "author": "Google",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/google/adk-js"
+  },
+  "files": [
+    "package.json",
+    "README.md",
+    "LICENSE",
+    "dist"
+  ],
+  "type": "module",
+  "typings": "./dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "browser": "./dist/web/index_web.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "clean:all": "npm run clean && rm -rf node_modules",
+    "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"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.7",
+    "@typescript-eslint/eslint-plugin": "^7.7.1",
+    "@typescript-eslint/parser": "^7.7.1",
+    "concurrently": "^9.2.1",
+    "esbuild": "^0.25.9",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint": "^8.57.0",
+    "openapi-types": "^12.1.3",
+    "prettier": "^3.2.5",
+    "tslib": "^2.6.2",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "@google/genai": "1.14.0",
+    "@modelcontextprotocol/sdk": "1.17.5",
+    "@opentelemetry/api": "1.9.0",
+    "zod": "3.25.76"
+  }
+}