@google/adk 2.2.1 → 2.3.0

package/dist/cjs/tools/function_tool.js

@@ -26,12 +26,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var function_tool_exports = {};
 __export(function_tool_exports, {
   FunctionTool: () => FunctionTool,
+  buildFunctionDeclarationForLangchain: () => buildFunctionDeclarationForLangchain,
+  buildFunctionDeclarationForParamsForCrewai: () => buildFunctionDeclarationForParamsForCrewai,
+  buildFunctionDeclarationUtil: () => buildFunctionDeclarationUtil,
   isFunctionTool: () => isFunctionTool
 });
 module.exports = __toCommonJS(function_tool_exports);
 var import_genai = require("@google/genai");
 var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
 var import_base_tool = require("./base_tool.js");
+var import_gemini_schema_util = require("../utils/gemini_schema_util.js");
+var import_schema = require("../utils/schema.js");
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -48,6 +53,27 @@ function toSchema(parameters) {
   return parameters;
 }
 __name(toSchema, "toSchema");
+function toResponseSchema(response) {
+  var _a2;
+  if ((0, import_simple_zod_to_json.isZodObject)(response)) {
+    return (0, import_simple_zod_to_json.zodObjectToSchema)(response);
+  }
+  if (typeof response === "object" && response !== null && "safeParse" in response && typeof response.safeParse === "function") {
+    return (_a2 = (0, import_gemini_schema_util.toGeminiSchema)(
+      (0, import_schema.toJsonSchema)(response)
+    )) != null ? _a2 : { type: import_genai.Type.TYPE_UNSPECIFIED };
+  }
+  return response;
+}
+__name(toResponseSchema, "toResponseSchema");
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isPlainRecord, "isPlainRecord");
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+__name(isAsyncIterable, "isAsyncIterable");
 const FUNCTION_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.functionTool");
 function isFunctionTool(obj) {
   return typeof obj === "object" && obj !== null && FUNCTION_TOOL_SIGNATURE_SYMBOL in obj && obj[FUNCTION_TOOL_SIGNATURE_SYMBOL] === true;
@@ -75,6 +101,7 @@ const _FunctionTool = class _FunctionTool extends (_b = import_base_tool.BaseToo
     this[_a] = true;
     this.execute = options.execute;
     this.parameters = options.parameters;
+    this.response = options.response;
     this.requireConfirmation = (_b2 = options.requireConfirmation) != null ? _b2 : false;
   }
   /**
@@ -82,6 +109,14 @@ const _FunctionTool = class _FunctionTool extends (_b = import_base_tool.BaseToo
    * and parameter schema.
    */
   _getDeclaration() {
+    if (this.response !== void 0) {
+      return {
+        name: this.name,
+        description: this.description,
+        parameters: toSchema(this.parameters),
+        response: toResponseSchema(this.response)
+      };
+    }
     return {
       name: this.name,
       description: this.description,
@@ -114,6 +149,41 @@ const _FunctionTool = class _FunctionTool extends (_b = import_base_tool.BaseToo
       throw new Error(`Error in tool '${this.name}': ${errorMessage}`);
     }
   }
+  /**
+   * Invokes the tool in live streaming mode, injecting any active input stream
+   * from the invocation context and yielding items from the returned stream.
+   *
+   * @param req The live tool invocation request.
+   */
+  async *_callLive(req) {
+    var _a2;
+    const validatedArgs = this.validateArgs(req.args);
+    const argsToCall = isPlainRecord(validatedArgs) ? { ...validatedArgs } : { ...req.args };
+    const activeTool = (_a2 = req.invocationContext.activeStreamingTools) == null ? void 0 : _a2[this.name];
+    if (activeTool == null ? void 0 : activeTool.stream) {
+      argsToCall["inputStream"] = activeTool.stream;
+    }
+    const rawResult = this.execute(
+      argsToCall,
+      req.toolContext
+    );
+    if (isAsyncIterable(rawResult)) {
+      for await (const item of rawResult) {
+        yield item;
+      }
+      return;
+    }
+    const awaited = await rawResult;
+    if (isAsyncIterable(awaited)) {
+      for await (const item of awaited) {
+        yield item;
+      }
+      return;
+    }
+    if (awaited !== void 0) {
+      yield awaited;
+    }
+  }
   /**
    * Whether this call is gated on human approval — the static flag, or the
    * predicate evaluated against the validated arguments.
@@ -175,8 +245,257 @@ const _FunctionTool = class _FunctionTool extends (_b = import_base_tool.BaseToo
 };
 __name(_FunctionTool, "FunctionTool");
 let FunctionTool = _FunctionTool;
+const SCHEMA_TYPE_MAP = {
+  str: import_genai.Type.STRING,
+  int: import_genai.Type.INTEGER,
+  float: import_genai.Type.NUMBER,
+  bool: import_genai.Type.BOOLEAN,
+  string: import_genai.Type.STRING,
+  integer: import_genai.Type.INTEGER,
+  number: import_genai.Type.NUMBER,
+  boolean: import_genai.Type.BOOLEAN,
+  list: import_genai.Type.ARRAY,
+  array: import_genai.Type.ARRAY,
+  tuple: import_genai.Type.ARRAY,
+  object: import_genai.Type.OBJECT,
+  Dict: import_genai.Type.OBJECT,
+  List: import_genai.Type.ARRAY,
+  Tuple: import_genai.Type.ARRAY,
+  Any: import_genai.Type.TYPE_UNSPECIFIED,
+  STRING: import_genai.Type.STRING,
+  INTEGER: import_genai.Type.INTEGER,
+  NUMBER: import_genai.Type.NUMBER,
+  BOOLEAN: import_genai.Type.BOOLEAN,
+  ARRAY: import_genai.Type.ARRAY,
+  OBJECT: import_genai.Type.OBJECT,
+  NULL: import_genai.Type.NULL,
+  null: import_genai.Type.NULL,
+  TYPE_UNSPECIFIED: import_genai.Type.TYPE_UNSPECIFIED
+};
+function annotateNullableFields(schema) {
+  const properties = schema["properties"];
+  if (!isPlainRecord(properties)) {
+    return;
+  }
+  for (const propertySchema of Object.values(properties)) {
+    if (!isPlainRecord(propertySchema)) {
+      continue;
+    }
+    const anyOf = propertySchema["anyOf"];
+    if (!Array.isArray(anyOf)) {
+      continue;
+    }
+    for (let i = 0; i < anyOf.length; i++) {
+      const branch = anyOf[i];
+      if (isPlainRecord(branch) && (branch["type"] === "null" || branch["type"] === import_genai.Type.NULL)) {
+        propertySchema["nullable"] = true;
+        anyOf.splice(i, 1);
+        break;
+      }
+    }
+  }
+}
+__name(annotateNullableFields, "annotateNullableFields");
+function annotateRequiredFields(schema) {
+  const properties = schema["properties"];
+  if (!isPlainRecord(properties)) {
+    schema["required"] = [];
+    return;
+  }
+  const required = [];
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    if (isPlainRecord(fieldSchema) && !fieldSchema["nullable"] && !("default" in fieldSchema)) {
+      required.push(fieldName);
+    }
+  }
+  schema["required"] = required;
+}
+__name(annotateRequiredFields, "annotateRequiredFields");
+function removeAnyOf(schema) {
+  const properties = schema["properties"];
+  if (!isPlainRecord(properties)) {
+    return;
+  }
+  for (const propertySchema of Object.values(properties)) {
+    if (!isPlainRecord(propertySchema)) {
+      continue;
+    }
+    const unionTypes = propertySchema["anyOf"];
+    delete propertySchema["anyOf"];
+    if (Array.isArray(unionTypes)) {
+      for (const branch of unionTypes) {
+        if (isPlainRecord(branch) && branch["type"] !== "null" && branch["type"] !== import_genai.Type.NULL) {
+          Object.assign(propertySchema, branch);
+          break;
+        }
+      }
+    }
+  }
+}
+__name(removeAnyOf, "removeAnyOf");
+function removeDefault(schema) {
+  const properties = schema["properties"];
+  if (!isPlainRecord(properties)) {
+    return;
+  }
+  for (const propertySchema of Object.values(properties)) {
+    if (isPlainRecord(propertySchema)) {
+      delete propertySchema["default"];
+    }
+  }
+}
+__name(removeDefault, "removeDefault");
+function removeNullable(schema) {
+  const properties = schema["properties"];
+  if (!isPlainRecord(properties)) {
+    return;
+  }
+  for (const propertySchema of Object.values(properties)) {
+    if (isPlainRecord(propertySchema)) {
+      delete propertySchema["nullable"];
+    }
+  }
+}
+__name(removeNullable, "removeNullable");
+function removeTitle(schema) {
+  const properties = schema["properties"];
+  if (!isPlainRecord(properties)) {
+    return;
+  }
+  for (const propertySchema of Object.values(properties)) {
+    if (isPlainRecord(propertySchema)) {
+      delete propertySchema["title"];
+    }
+  }
+}
+__name(removeTitle, "removeTitle");
+function processParameterSchema(vertexai, schema) {
+  annotateNullableFields(schema);
+  annotateRequiredFields(schema);
+  if (!vertexai) {
+    removeAnyOf(schema);
+    removeDefault(schema);
+    removeNullable(schema);
+    removeTitle(schema);
+  }
+  return schema;
+}
+__name(processParameterSchema, "processParameterSchema");
+function mapPropertySchemaType(propertySchema) {
+  var _a2, _b2;
+  if (typeof propertySchema["type"] === "string") {
+    propertySchema["type"] = (_a2 = SCHEMA_TYPE_MAP[propertySchema["type"]]) != null ? _a2 : import_genai.Type.TYPE_UNSPECIFIED;
+    if (propertySchema["type"] === import_genai.Type.ARRAY && isPlainRecord(propertySchema["items"])) {
+      mapPropertySchemaType(propertySchema["items"]);
+    }
+  }
+  if (isPlainRecord(propertySchema["properties"])) {
+    for (const nestedProp of Object.values(propertySchema["properties"])) {
+      if (isPlainRecord(nestedProp)) {
+        mapPropertySchemaType(nestedProp);
+      }
+    }
+  }
+  if (Array.isArray(propertySchema["anyOf"])) {
+    for (const branch of propertySchema["anyOf"]) {
+      if (isPlainRecord(branch) && typeof branch["type"] === "string") {
+        branch["type"] = (_b2 = SCHEMA_TYPE_MAP[branch["type"]]) != null ? _b2 : import_genai.Type.TYPE_UNSPECIFIED;
+        propertySchema["type"] = branch["type"];
+      }
+    }
+  }
+}
+__name(mapPropertySchemaType, "mapPropertySchemaType");
+function mapSchemaTypes(schema) {
+  const properties = schema["properties"];
+  if (!isPlainRecord(properties)) {
+    return;
+  }
+  for (const propertySchema of Object.values(properties)) {
+    if (isPlainRecord(propertySchema)) {
+      mapPropertySchemaType(propertySchema);
+    }
+  }
+}
+__name(mapSchemaTypes, "mapSchemaTypes");
+function resolveReturnSchema(func, beforeParamSchema) {
+  var _a2, _b2, _c;
+  const funcObj = typeof func === "function" || isPlainRecord(func) ? func : void 0;
+  const responseCandidate = (_a2 = funcObj == null ? void 0 : funcObj.response) != null ? _a2 : beforeParamSchema["response"];
+  if (responseCandidate !== void 0) {
+    return toResponseSchema(responseCandidate);
+  }
+  const returnTypeCandidate = (_b2 = funcObj == null ? void 0 : funcObj.returnType) != null ? _b2 : typeof beforeParamSchema["returnType"] === "string" ? beforeParamSchema["returnType"] : void 0;
+  if (typeof returnTypeCandidate === "string") {
+    return {
+      type: (_c = SCHEMA_TYPE_MAP[returnTypeCandidate]) != null ? _c : import_genai.Type.TYPE_UNSPECIFIED
+    };
+  }
+  if (typeof func === "function") {
+    return { type: import_genai.Type.TYPE_UNSPECIFIED };
+  }
+  return void 0;
+}
+__name(resolveReturnSchema, "resolveReturnSchema");
+function buildFunctionDeclarationUtil(vertexai, name, description, func, beforeParamSchema) {
+  const schemaCopy = structuredClone(beforeParamSchema);
+  mapSchemaTypes(schemaCopy);
+  const properties = isPlainRecord(schemaCopy["properties"]) ? schemaCopy["properties"] : {};
+  const hasProperties = Object.keys(properties).length > 0;
+  const declaration = {
+    name,
+    description
+  };
+  if (hasProperties) {
+    const parameters = {
+      type: import_genai.Type.OBJECT,
+      properties
+    };
+    if (Array.isArray(schemaCopy["required"]) && schemaCopy["required"].length > 0) {
+      parameters.required = schemaCopy["required"];
+    }
+    declaration.parameters = parameters;
+  }
+  if (vertexai) {
+    const responseSchema = resolveReturnSchema(func, schemaCopy);
+    if (responseSchema !== void 0) {
+      declaration.response = responseSchema;
+    }
+  }
+  return declaration;
+}
+__name(buildFunctionDeclarationUtil, "buildFunctionDeclarationUtil");
+function buildFunctionDeclarationForLangchain(vertexai, name, description, func, paramSchema) {
+  const rawCopy = structuredClone(paramSchema);
+  const explicitRequired = Array.isArray(rawCopy["required"]) ? rawCopy["required"] : void 0;
+  delete rawCopy["required"];
+  const wrapped = processParameterSchema(vertexai, {
+    properties: rawCopy
+  });
+  const properties = isPlainRecord(wrapped["properties"]) ? { ...wrapped["properties"] } : {};
+  const computedRequired = Array.isArray(wrapped["required"]) ? wrapped["required"] : [];
+  const requiredFields = explicitRequired !== void 0 ? explicitRequired : computedRequired;
+  return buildFunctionDeclarationUtil(vertexai, name, description, func, {
+    properties,
+    required: requiredFields
+  });
+}
+__name(buildFunctionDeclarationForLangchain, "buildFunctionDeclarationForLangchain");
+function buildFunctionDeclarationForParamsForCrewai(vertexai, name, description, func, paramSchema) {
+  const processed = processParameterSchema(
+    vertexai,
+    structuredClone(paramSchema)
+  );
+  return buildFunctionDeclarationUtil(vertexai, name, description, func, {
+    ...processed
+  });
+}
+__name(buildFunctionDeclarationForParamsForCrewai, "buildFunctionDeclarationForParamsForCrewai");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FunctionTool,
+  buildFunctionDeclarationForLangchain,
+  buildFunctionDeclarationForParamsForCrewai,
+  buildFunctionDeclarationUtil,
   isFunctionTool
 });

package/dist/cjs/tools/google_api_tool/google_api_tool.js

@@ -0,0 +1,97 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var google_api_tool_exports = {};
+__export(google_api_tool_exports, {
+  GoogleApiTool: () => GoogleApiTool,
+  isGoogleApiTool: () => isGoogleApiTool
+});
+module.exports = __toCommonJS(google_api_tool_exports);
+var import_auth_credential = require("../../auth/auth_credential.js");
+var import_experimental = require("../../utils/experimental.js");
+var import_base_tool = require("../base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const GOOGLE_API_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.googleApiTool");
+function isGoogleApiTool(obj) {
+  return typeof obj === "object" && obj !== null && GOOGLE_API_TOOL_SIGNATURE_SYMBOL in obj && obj[GOOGLE_API_TOOL_SIGNATURE_SYMBOL] === true;
+}
+__name(isGoogleApiTool, "isGoogleApiTool");
+let GoogleApiTool = class extends (_b = import_base_tool.BaseTool, _a = GOOGLE_API_TOOL_SIGNATURE_SYMBOL, _b) {
+  constructor(restApiTool) {
+    super({
+      name: restApiTool.name,
+      description: restApiTool.description,
+      isLongRunning: restApiTool.isLongRunning
+    });
+    this[_a] = true;
+    this.restApiTool = restApiTool;
+  }
+  _getDeclaration() {
+    return this.restApiTool._getDeclaration();
+  }
+  runAsync(request) {
+    return this.restApiTool.runAsync(request);
+  }
+  configureAuth(clientId, clientSecret) {
+    this.restApiTool.configureAuthCredential({
+      authType: import_auth_credential.AuthCredentialTypes.OPEN_ID_CONNECT,
+      oauth2: {
+        clientId,
+        clientSecret
+      }
+    });
+  }
+};
+__name(GoogleApiTool, "GoogleApiTool");
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiTool.prototype, "_getDeclaration", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiTool.prototype, "runAsync", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiTool.prototype, "configureAuth", 1);
+GoogleApiTool = __decorateClass([
+  import_experimental.experimental
+], GoogleApiTool);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleApiTool,
+  isGoogleApiTool
+});

package/dist/cjs/tools/google_api_tool/google_api_tool_set.js

@@ -0,0 +1,226 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var google_api_tool_set_exports = {};
+__export(google_api_tool_set_exports, {
+  GoogleApiToolSet: () => GoogleApiToolSet,
+  createLazyGoogleApiToolSet: () => createLazyGoogleApiToolSet,
+  isGoogleApiToolSet: () => isGoogleApiToolSet
+});
+module.exports = __toCommonJS(google_api_tool_set_exports);
+var fs = __toESM(require("node:fs"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_experimental = require("../../utils/experimental.js");
+var import_base_toolset = require("../base_toolset.js");
+var import_openapi_toolset = require("../openapi_tool/openapi_toolset.js");
+var import_google_api_tool = require("./google_api_tool.js");
+var import_googleapi_to_openapi_converter = require("./googleapi_to_openapi_converter.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const GOOGLE_API_TOOL_SET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.googleApiToolSet"
+);
+const GOOGLE_OIDC_AUTH_ENDPOINT = "https://accounts.google.com/o/oauth2/v2/auth";
+const GOOGLE_OIDC_TOKEN_ENDPOINT = "https://oauth2.googleapis.com/token";
+const GOOGLE_OIDC_USERINFO_ENDPOINT = "https://openidconnect.googleapis.com/v1/userinfo";
+const GOOGLE_OIDC_REVOCATION_ENDPOINT = "https://oauth2.googleapis.com/revoke";
+function isGoogleApiToolSet(obj) {
+  return typeof obj === "object" && obj !== null && GOOGLE_API_TOOL_SET_SIGNATURE_SYMBOL in obj && obj[GOOGLE_API_TOOL_SET_SIGNATURE_SYMBOL] === true;
+}
+__name(isGoogleApiToolSet, "isGoogleApiToolSet");
+let GoogleApiToolSet = class extends (_b = import_base_toolset.BaseToolset, _a = GOOGLE_API_TOOL_SET_SIGNATURE_SYMBOL, _b) {
+  constructor(tools, options = {}) {
+    var _a2;
+    super((_a2 = options.toolFilter) != null ? _a2 : []);
+    this[_a] = true;
+    this.apiName = options.apiName;
+    this.apiVersion = options.apiVersion;
+    if (tools !== void 0) {
+      this.tools = tools.map(
+        (tool) => (0, import_google_api_tool.isGoogleApiTool)(tool) ? tool : new import_google_api_tool.GoogleApiTool(tool)
+      );
+      this.toolsLoaded = true;
+    } else {
+      this.tools = [];
+      this.toolsLoaded = false;
+    }
+  }
+  async ensureToolsLoaded() {
+    if (this.toolsLoaded || !this.apiName || !this.apiVersion) {
+      return;
+    }
+    if (!this.loadingPromise) {
+      const apiName = this.apiName;
+      const apiVersion = this.apiVersion;
+      this.loadingPromise = (async () => {
+        try {
+          const loaded = await GoogleApiToolSet.loadToolSet(
+            apiName,
+            apiVersion
+          );
+          this.tools = loaded.tools;
+          if (this.pendingAuth) {
+            for (const tool of this.tools) {
+              tool.configureAuth(
+                this.pendingAuth.clientId,
+                this.pendingAuth.clientSecret
+              );
+            }
+          }
+          this.toolsLoaded = true;
+        } finally {
+          this.loadingPromise = void 0;
+        }
+      })();
+    }
+    await this.loadingPromise;
+  }
+  async getTools(context) {
+    await this.ensureToolsLoaded();
+    return this.tools.filter(
+      (tool) => this.isToolSelected(tool, context)
+    );
+  }
+  async getTool(toolName) {
+    await this.ensureToolsLoaded();
+    return this.tools.find((tool) => tool.name === toolName);
+  }
+  configureAuth(clientId, clientSecret) {
+    this.pendingAuth = { clientId, clientSecret };
+    for (const tool of this.tools) {
+      tool.configureAuth(clientId, clientSecret);
+    }
+  }
+  async close() {
+    return Promise.resolve();
+  }
+  static loadToolSetWithOidcAuth(options = {}) {
+    var _a2;
+    let specStr;
+    if (options.specFile) {
+      const dir = (_a2 = options.callerDir) != null ? _a2 : process.cwd();
+      const yamlPath = path.isAbsolute(options.specFile) ? options.specFile : path.join(dir, options.specFile);
+      specStr = fs.readFileSync(yamlPath, "utf-8");
+    }
+    const authScheme = {
+      type: "openIdConnect",
+      openIdConnectUrl: "",
+      authorizationEndpoint: GOOGLE_OIDC_AUTH_ENDPOINT,
+      tokenEndpoint: GOOGLE_OIDC_TOKEN_ENDPOINT,
+      userinfoEndpoint: GOOGLE_OIDC_USERINFO_ENDPOINT,
+      revocationEndpoint: GOOGLE_OIDC_REVOCATION_ENDPOINT,
+      tokenEndpointAuthMethodsSupported: [
+        "client_secret_post",
+        "client_secret_basic"
+      ],
+      grantTypesSupported: ["authorization_code"],
+      scopes: options.scopes
+    };
+    return new import_openapi_toolset.OpenAPIToolset({
+      specDict: options.specDict,
+      specStr,
+      specType: "yaml",
+      authScheme
+    });
+  }
+  static async loadToolSet(apiName, apiVersion) {
+    var _a2, _b2, _c, _d, _e;
+    const specDict = await new import_googleapi_to_openapi_converter.GoogleApiToOpenApiConverter(
+      apiName,
+      apiVersion
+    ).convert();
+    const oauth2Scheme = (_b2 = (_a2 = specDict.components) == null ? void 0 : _a2.securitySchemes) == null ? void 0 : _b2["oauth2"];
+    const scopesMap = (_e = (_d = (_c = oauth2Scheme == null ? void 0 : oauth2Scheme.flows) == null ? void 0 : _c.authorizationCode) == null ? void 0 : _d.scopes) != null ? _e : {};
+    const firstScope = Object.keys(scopesMap)[0];
+    const scopes = firstScope ? [firstScope] : void 0;
+    const openapiToolset = this.loadToolSetWithOidcAuth({
+      specDict,
+      scopes
+    });
+    const tools = await openapiToolset.getTools();
+    return new this(tools, { apiName, apiVersion });
+  }
+};
+__name(GoogleApiToolSet, "GoogleApiToolSet");
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolSet.prototype, "getTools", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolSet.prototype, "getTool", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolSet.prototype, "configureAuth", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolSet.prototype, "close", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolSet, "loadToolSetWithOidcAuth", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolSet, "loadToolSet", 1);
+GoogleApiToolSet = __decorateClass([
+  import_experimental.experimental
+], GoogleApiToolSet);
+function createLazyGoogleApiToolSet(apiName, apiVersion) {
+  const BaseConstructor = Object.getPrototypeOf(
+    GoogleApiToolSet
+  );
+  return Reflect.construct(
+    BaseConstructor,
+    [void 0, { apiName, apiVersion }],
+    GoogleApiToolSet
+  );
+}
+__name(createLazyGoogleApiToolSet, "createLazyGoogleApiToolSet");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleApiToolSet,
+  createLazyGoogleApiToolSet,
+  isGoogleApiToolSet
+});