@google/adk 2.2.0 → 2.3.0

package/dist/esm/tools/function_tool.js

@@ -11,6 +11,8 @@ var _a, _b;
 import { Type } from "@google/genai";
 import { isZodObject, zodObjectToSchema } from "../utils/simple_zod_to_json.js";
 import { BaseTool } from "./base_tool.js";
+import { toGeminiSchema } from "../utils/gemini_schema_util.js";
+import { toJsonSchema } from "../utils/schema.js";
 function toSchema(parameters) {
   if (parameters === void 0) {
     return { type: Type.OBJECT, properties: {} };
@@ -21,6 +23,27 @@ function toSchema(parameters) {
   return parameters;
 }
 __name(toSchema, "toSchema");
+function toResponseSchema(response) {
+  var _a2;
+  if (isZodObject(response)) {
+    return zodObjectToSchema(response);
+  }
+  if (typeof response === "object" && response !== null && "safeParse" in response && typeof response.safeParse === "function") {
+    return (_a2 = toGeminiSchema(
+      toJsonSchema(response)
+    )) != null ? _a2 : { type: 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;
@@ -48,6 +71,7 @@ const _FunctionTool = class _FunctionTool extends (_b = BaseTool, _a = FUNCTION_
     this[_a] = true;
     this.execute = options.execute;
     this.parameters = options.parameters;
+    this.response = options.response;
     this.requireConfirmation = (_b2 = options.requireConfirmation) != null ? _b2 : false;
   }
   /**
@@ -55,6 +79,14 @@ const _FunctionTool = class _FunctionTool extends (_b = BaseTool, _a = FUNCTION_
    * 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,
@@ -87,6 +119,41 @@ const _FunctionTool = class _FunctionTool extends (_b = BaseTool, _a = FUNCTION_
       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.
@@ -148,7 +215,256 @@ const _FunctionTool = class _FunctionTool extends (_b = BaseTool, _a = FUNCTION_
 };
 __name(_FunctionTool, "FunctionTool");
 let FunctionTool = _FunctionTool;
+const SCHEMA_TYPE_MAP = {
+  str: Type.STRING,
+  int: Type.INTEGER,
+  float: Type.NUMBER,
+  bool: Type.BOOLEAN,
+  string: Type.STRING,
+  integer: Type.INTEGER,
+  number: Type.NUMBER,
+  boolean: Type.BOOLEAN,
+  list: Type.ARRAY,
+  array: Type.ARRAY,
+  tuple: Type.ARRAY,
+  object: Type.OBJECT,
+  Dict: Type.OBJECT,
+  List: Type.ARRAY,
+  Tuple: Type.ARRAY,
+  Any: Type.TYPE_UNSPECIFIED,
+  STRING: Type.STRING,
+  INTEGER: Type.INTEGER,
+  NUMBER: Type.NUMBER,
+  BOOLEAN: Type.BOOLEAN,
+  ARRAY: Type.ARRAY,
+  OBJECT: Type.OBJECT,
+  NULL: Type.NULL,
+  null: Type.NULL,
+  TYPE_UNSPECIFIED: 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"] === 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"] !== 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 : Type.TYPE_UNSPECIFIED;
+    if (propertySchema["type"] === 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 : 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 : Type.TYPE_UNSPECIFIED
+    };
+  }
+  if (typeof func === "function") {
+    return { type: 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: 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");
 export {
   FunctionTool,
+  buildFunctionDeclarationForLangchain,
+  buildFunctionDeclarationForParamsForCrewai,
+  buildFunctionDeclarationUtil,
   isFunctionTool
 };

package/dist/esm/tools/google_api_tool/google_api_tool.js

@@ -0,0 +1,70 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import { AuthCredentialTypes } from "../../auth/auth_credential.js";
+import { experimental } from "../../utils/experimental.js";
+import { BaseTool } from "../base_tool.js";
+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 = 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: AuthCredentialTypes.OPEN_ID_CONNECT,
+      oauth2: {
+        clientId,
+        clientSecret
+      }
+    });
+  }
+};
+__name(GoogleApiTool, "GoogleApiTool");
+__decorateClass([
+  experimental
+], GoogleApiTool.prototype, "_getDeclaration", 1);
+__decorateClass([
+  experimental
+], GoogleApiTool.prototype, "runAsync", 1);
+__decorateClass([
+  experimental
+], GoogleApiTool.prototype, "configureAuth", 1);
+GoogleApiTool = __decorateClass([
+  experimental
+], GoogleApiTool);
+export {
+  GoogleApiTool,
+  isGoogleApiTool
+};

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

@@ -0,0 +1,188 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { experimental } from "../../utils/experimental.js";
+import { BaseToolset } from "../base_toolset.js";
+import { OpenAPIToolset } from "../openapi_tool/openapi_toolset.js";
+import { GoogleApiTool, isGoogleApiTool } from "./google_api_tool.js";
+import { GoogleApiToOpenApiConverter } from "./googleapi_to_openapi_converter.js";
+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 = 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) => isGoogleApiTool(tool) ? tool : new 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 OpenAPIToolset({
+      specDict: options.specDict,
+      specStr,
+      specType: "yaml",
+      authScheme
+    });
+  }
+  static async loadToolSet(apiName, apiVersion) {
+    var _a2, _b2, _c, _d, _e;
+    const specDict = await new 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([
+  experimental
+], GoogleApiToolSet.prototype, "getTools", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolSet.prototype, "getTool", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolSet.prototype, "configureAuth", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolSet.prototype, "close", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolSet, "loadToolSetWithOidcAuth", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolSet, "loadToolSet", 1);
+GoogleApiToolSet = __decorateClass([
+  experimental
+], GoogleApiToolSet);
+function createLazyGoogleApiToolSet(apiName, apiVersion) {
+  const BaseConstructor = Object.getPrototypeOf(
+    GoogleApiToolSet
+  );
+  return Reflect.construct(
+    BaseConstructor,
+    [void 0, { apiName, apiVersion }],
+    GoogleApiToolSet
+  );
+}
+__name(createLazyGoogleApiToolSet, "createLazyGoogleApiToolSet");
+export {
+  GoogleApiToolSet,
+  createLazyGoogleApiToolSet,
+  isGoogleApiToolSet
+};

package/dist/esm/tools/google_api_tool/google_api_tool_sets.js

@@ -0,0 +1,24 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createLazyGoogleApiToolSet } from "./google_api_tool_set.js";
+const calendarToolSet = createLazyGoogleApiToolSet("calendar", "v3");
+const bigqueryToolSet = createLazyGoogleApiToolSet("bigquery", "v2");
+const gmailToolSet = createLazyGoogleApiToolSet("gmail", "v1");
+const youtubeToolSet = createLazyGoogleApiToolSet("youtube", "v3");
+const slidesToolSet = createLazyGoogleApiToolSet("slides", "v1");
+const sheetsToolSet = createLazyGoogleApiToolSet("sheets", "v4");
+const docsToolSet = createLazyGoogleApiToolSet("docs", "v1");
+export {
+  bigqueryToolSet,
+  calendarToolSet,
+  docsToolSet,
+  gmailToolSet,
+  sheetsToolSet,
+  slidesToolSet,
+  youtubeToolSet
+};