@google/adk 2.2.1 → 2.4.0

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

@@ -0,0 +1,124 @@
+/**
+  * @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_toolsets_exports = {};
+__export(google_api_toolsets_exports, {
+  BigQueryToolset: () => BigQueryToolset,
+  CalendarToolset: () => CalendarToolset,
+  DocsToolset: () => DocsToolset,
+  GmailToolset: () => GmailToolset,
+  SheetsToolset: () => SheetsToolset,
+  SlidesToolset: () => SlidesToolset,
+  YoutubeToolset: () => YoutubeToolset
+});
+module.exports = __toCommonJS(google_api_toolsets_exports);
+var import_experimental = require("../../utils/experimental.js");
+var import_google_api_toolset = require("./google_api_toolset.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let BigQueryToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "bigquery", apiVersion: "v2" });
+  }
+};
+__name(BigQueryToolset, "BigQueryToolset");
+BigQueryToolset = __decorateClass([
+  import_experimental.experimental
+], BigQueryToolset);
+let CalendarToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "calendar", apiVersion: "v3" });
+  }
+};
+__name(CalendarToolset, "CalendarToolset");
+CalendarToolset = __decorateClass([
+  import_experimental.experimental
+], CalendarToolset);
+let GmailToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "gmail", apiVersion: "v1" });
+  }
+};
+__name(GmailToolset, "GmailToolset");
+GmailToolset = __decorateClass([
+  import_experimental.experimental
+], GmailToolset);
+let YoutubeToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "youtube", apiVersion: "v3" });
+  }
+};
+__name(YoutubeToolset, "YoutubeToolset");
+YoutubeToolset = __decorateClass([
+  import_experimental.experimental
+], YoutubeToolset);
+let SlidesToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "slides", apiVersion: "v1" });
+  }
+};
+__name(SlidesToolset, "SlidesToolset");
+SlidesToolset = __decorateClass([
+  import_experimental.experimental
+], SlidesToolset);
+let SheetsToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "sheets", apiVersion: "v4" });
+  }
+};
+__name(SheetsToolset, "SheetsToolset");
+SheetsToolset = __decorateClass([
+  import_experimental.experimental
+], SheetsToolset);
+let DocsToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "docs", apiVersion: "v1" });
+  }
+};
+__name(DocsToolset, "DocsToolset");
+DocsToolset = __decorateClass([
+  import_experimental.experimental
+], DocsToolset);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset
+});

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

@@ -0,0 +1,440 @@
+/**
+  * @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 googleapi_to_openapi_converter_exports = {};
+__export(googleapi_to_openapi_converter_exports, {
+  GoogleApiToOpenApiConverter: () => GoogleApiToOpenApiConverter,
+  convertInfo: () => convertInfo,
+  convertMethods: () => convertMethods,
+  convertOperation: () => convertOperation,
+  convertParameterSchema: () => convertParameterSchema,
+  convertResources: () => convertResources,
+  convertSchemaObject: () => convertSchemaObject,
+  convertSchemas: () => convertSchemas,
+  convertSecuritySchemes: () => convertSecuritySchemes,
+  convertServers: () => convertServers,
+  extractPathParameters: () => extractPathParameters,
+  normalizeGoogleSchemaRef: () => normalizeGoogleSchemaRef
+});
+module.exports = __toCommonJS(googleapi_to_openapi_converter_exports);
+var fs = __toESM(require("node:fs"), 1);
+var import_experimental = require("../../utils/experimental.js");
+var import_logger = require("../../utils/logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const GOOGLE_DISCOVERY_BASE_URL = "https://www.googleapis.com/discovery/v1/apis";
+const GOOGLE_OAUTH2_AUTH_URL = "https://accounts.google.com/o/oauth2/auth";
+const GOOGLE_OAUTH2_TOKEN_URL = "https://oauth2.googleapis.com/token";
+function normalizeGoogleSchemaRef(ref) {
+  if (ref.startsWith("#")) {
+    return `#/components/schemas/${ref.slice(1)}`;
+  }
+  return `#/components/schemas/${ref}`;
+}
+__name(normalizeGoogleSchemaRef, "normalizeGoogleSchemaRef");
+function convertInfo(googleApiSpec, openapiSpec, apiName, apiVersion) {
+  var _a, _b, _c, _d;
+  openapiSpec.info = {
+    title: (_a = googleApiSpec.title) != null ? _a : `${apiName} API`,
+    description: (_b = googleApiSpec.description) != null ? _b : "",
+    version: (_c = googleApiSpec.version) != null ? _c : apiVersion,
+    contact: {},
+    termsOfService: (_d = googleApiSpec.documentationLink) != null ? _d : ""
+  };
+  const docsLink = googleApiSpec.documentationLink;
+  if (docsLink) {
+    openapiSpec.externalDocs = {
+      description: "API Documentation",
+      url: docsLink
+    };
+  }
+}
+__name(convertInfo, "convertInfo");
+function convertServers(googleApiSpec, openapiSpec, apiName, apiVersion) {
+  var _a, _b;
+  let baseUrl = `${(_a = googleApiSpec.rootUrl) != null ? _a : ""}${(_b = googleApiSpec.servicePath) != null ? _b : ""}`;
+  if (baseUrl.endsWith("/")) {
+    baseUrl = baseUrl.slice(0, -1);
+  }
+  openapiSpec.servers = [
+    {
+      url: baseUrl,
+      description: `${apiName} ${apiVersion} API`
+    }
+  ];
+}
+__name(convertServers, "convertServers");
+function convertSecuritySchemes(googleApiSpec, openapiSpec) {
+  var _a, _b, _c, _d, _e;
+  openapiSpec.components = (_a = openapiSpec.components) != null ? _a : {};
+  openapiSpec.components.securitySchemes = (_b = openapiSpec.components.securitySchemes) != null ? _b : {};
+  const oauth2 = (_c = googleApiSpec.auth) == null ? void 0 : _c.oauth2;
+  const hasOauth2 = oauth2 !== void 0 && Object.keys(oauth2).length > 0;
+  const formattedScopes = {};
+  if (hasOauth2) {
+    const scopes = (_d = oauth2.scopes) != null ? _d : {};
+    for (const [scope, scopeInfo] of Object.entries(scopes)) {
+      formattedScopes[scope] = (_e = scopeInfo.description) != null ? _e : "";
+    }
+    openapiSpec.components.securitySchemes["oauth2"] = {
+      type: "oauth2",
+      description: "OAuth 2.0 authentication",
+      flows: {
+        authorizationCode: {
+          authorizationUrl: GOOGLE_OAUTH2_AUTH_URL,
+          tokenUrl: GOOGLE_OAUTH2_TOKEN_URL,
+          scopes: formattedScopes
+        }
+      }
+    };
+  }
+  openapiSpec.components.securitySchemes["apiKey"] = {
+    type: "apiKey",
+    in: "query",
+    name: "key",
+    description: "API key for accessing this API"
+  };
+  openapiSpec.security = [
+    hasOauth2 ? { oauth2: Object.keys(formattedScopes) } : {},
+    { apiKey: [] }
+  ];
+}
+__name(convertSecuritySchemes, "convertSecuritySchemes");
+function convertSchemaObject(schemaDef) {
+  var _a;
+  const result = {};
+  if (schemaDef.type !== void 0) {
+    const gtype = schemaDef.type;
+    if (gtype === "object") {
+      result["type"] = "object";
+      if (schemaDef.properties !== void 0) {
+        const properties = {};
+        for (const [propName, propDef] of Object.entries(
+          schemaDef.properties
+        )) {
+          properties[propName] = convertSchemaObject(propDef);
+        }
+        result["properties"] = properties;
+      }
+      const requiredFields = [];
+      for (const [propName, propDef] of Object.entries(
+        (_a = schemaDef.properties) != null ? _a : {}
+      )) {
+        if (propDef.required) {
+          requiredFields.push(propName);
+        }
+      }
+      if (requiredFields.length > 0) {
+        result["required"] = requiredFields;
+      }
+    } else if (gtype === "array") {
+      result["type"] = "array";
+      if (schemaDef.items !== void 0) {
+        result["items"] = convertSchemaObject(schemaDef.items);
+      }
+    } else if (gtype === "any") {
+      result["oneOf"] = [
+        { type: "object" },
+        { type: "array" },
+        { type: "string" },
+        { type: "number" },
+        { type: "boolean" },
+        { type: "null" }
+      ];
+    } else {
+      result["type"] = gtype;
+    }
+  }
+  if (schemaDef.$ref !== void 0) {
+    result["$ref"] = normalizeGoogleSchemaRef(schemaDef.$ref);
+  }
+  if (schemaDef.format !== void 0) {
+    result["format"] = schemaDef.format;
+  }
+  if (schemaDef.enum !== void 0) {
+    result["enum"] = schemaDef.enum;
+  }
+  if (schemaDef.description !== void 0) {
+    result["description"] = schemaDef.description;
+  }
+  if (schemaDef.pattern !== void 0) {
+    result["pattern"] = schemaDef.pattern;
+  }
+  if (schemaDef.default !== void 0) {
+    result["default"] = schemaDef.default;
+  }
+  return result;
+}
+__name(convertSchemaObject, "convertSchemaObject");
+function convertSchemas(googleApiSpec, openapiSpec) {
+  var _a, _b, _c;
+  openapiSpec.components = (_a = openapiSpec.components) != null ? _a : {};
+  openapiSpec.components.schemas = (_b = openapiSpec.components.schemas) != null ? _b : {};
+  const schemas = (_c = googleApiSpec.schemas) != null ? _c : {};
+  for (const [schemaName, schemaDef] of Object.entries(schemas)) {
+    openapiSpec.components.schemas[schemaName] = convertSchemaObject(schemaDef);
+  }
+}
+__name(convertSchemas, "convertSchemas");
+function extractPathParameters(path) {
+  const params = [];
+  for (const match of path.matchAll(/\{\+?([^{}]+)\}/g)) {
+    params.push(match[1]);
+  }
+  return params;
+}
+__name(extractPathParameters, "extractPathParameters");
+function convertParameterSchema(paramData) {
+  var _a;
+  const schema = {
+    type: (_a = paramData.type) != null ? _a : "string"
+  };
+  if (paramData.enum !== void 0) {
+    schema["enum"] = paramData.enum;
+  }
+  if (paramData.format !== void 0) {
+    schema["format"] = paramData.format;
+  }
+  if (paramData.default !== void 0) {
+    schema["default"] = paramData.default;
+  }
+  if (paramData.pattern !== void 0) {
+    schema["pattern"] = paramData.pattern;
+  }
+  return schema;
+}
+__name(convertParameterSchema, "convertParameterSchema");
+function convertOperation(methodData, pathParams) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const parameters = [];
+  for (const paramName of pathParams) {
+    parameters.push({
+      name: paramName,
+      in: "path",
+      required: true,
+      schema: { type: "string" }
+    });
+  }
+  const pathParamSet = new Set(pathParams);
+  for (const [paramName, paramData] of Object.entries(
+    (_a = methodData.parameters) != null ? _a : {}
+  )) {
+    if (pathParamSet.has(paramName)) {
+      continue;
+    }
+    const location = (_b = paramData.location) != null ? _b : "query";
+    parameters.push({
+      name: paramName,
+      in: location,
+      description: (_c = paramData.description) != null ? _c : "",
+      required: location === "path" ? true : (_d = paramData.required) != null ? _d : false,
+      schema: convertParameterSchema(paramData)
+    });
+  }
+  const response200 = {
+    description: "Successful operation"
+  };
+  const responseRef = (_e = methodData.response) == null ? void 0 : _e.$ref;
+  if (responseRef) {
+    response200.content = {
+      "application/json": {
+        schema: { $ref: normalizeGoogleSchemaRef(responseRef) }
+      }
+    };
+  }
+  const operation = {
+    operationId: (_f = methodData.id) != null ? _f : "",
+    summary: (_g = methodData.description) != null ? _g : "",
+    description: (_h = methodData.description) != null ? _h : "",
+    parameters,
+    responses: {
+      "200": response200,
+      "400": { description: "Bad request" },
+      "401": { description: "Unauthorized" },
+      "403": { description: "Forbidden" },
+      "404": { description: "Not found" },
+      "500": { description: "Server error" }
+    }
+  };
+  const requestRef = (_i = methodData.request) == null ? void 0 : _i.$ref;
+  if (requestRef) {
+    operation.requestBody = {
+      description: "Request body",
+      content: {
+        "application/json": {
+          schema: { $ref: normalizeGoogleSchemaRef(requestRef) }
+        }
+      },
+      required: true
+    };
+  }
+  const scopes = (_j = methodData.scopes) != null ? _j : [];
+  if (scopes.length > 0) {
+    operation.security = [{ oauth2: scopes }];
+  }
+  return operation;
+}
+__name(convertOperation, "convertOperation");
+function convertMethods(methods, _resourcePath, openapiSpec) {
+  var _a, _b, _c;
+  for (const methodData of Object.values(methods)) {
+    const httpMethod = ((_a = methodData.httpMethod) != null ? _a : "GET").toLowerCase();
+    let restPath = ((_c = (_b = methodData.flatPath) != null ? _b : methodData.path) != null ? _c : "/").replace(
+      /\{\+([^{}]+)\}/g,
+      (_match, paramName) => `{${paramName}}`
+    );
+    if (!restPath.startsWith("/")) {
+      restPath = `/${restPath}`;
+    }
+    const pathParams = extractPathParameters(restPath);
+    if (!openapiSpec.paths[restPath]) {
+      openapiSpec.paths[restPath] = {};
+    }
+    const pathItem = openapiSpec.paths[restPath];
+    pathItem[httpMethod] = convertOperation(methodData, pathParams);
+  }
+}
+__name(convertMethods, "convertMethods");
+function convertResources(resources, openapiSpec, parentPath = "") {
+  var _a;
+  for (const [resourceName, resourceData] of Object.entries(resources)) {
+    const resourcePath = `${parentPath}/${resourceName}`;
+    convertMethods((_a = resourceData.methods) != null ? _a : {}, resourcePath, openapiSpec);
+    if (resourceData.resources && Object.keys(resourceData.resources).length > 0) {
+      convertResources(resourceData.resources, openapiSpec, resourcePath);
+    }
+  }
+}
+__name(convertResources, "convertResources");
+let GoogleApiToOpenApiConverter = class {
+  constructor(apiName, apiVersion) {
+    this.googleApiSpec = null;
+    this.apiName = apiName;
+    this.apiVersion = apiVersion;
+    this.openapiSpec = {
+      openapi: "3.0.0",
+      info: {},
+      servers: [],
+      paths: {},
+      components: { schemas: {}, securitySchemes: {} }
+    };
+  }
+  async fetchGoogleApiSpec() {
+    try {
+      import_logger.logger.debug(
+        `Fetching Google API spec for ${this.apiName} ${this.apiVersion}`
+      );
+      const url = `${GOOGLE_DISCOVERY_BASE_URL}/${encodeURIComponent(this.apiName)}/${encodeURIComponent(this.apiVersion)}/rest`;
+      const response = await globalThis.fetch(url);
+      if (response.status >= 400) {
+        throw new Error(
+          `HTTP Error ${response.status}: Failed to fetch Google API spec for ${this.apiName} ${this.apiVersion}`
+        );
+      }
+      const spec = await response.json();
+      if (!spec || typeof spec !== "object" || Object.keys(spec).length === 0) {
+        throw new Error("Failed to retrieve API specification");
+      }
+      this.googleApiSpec = spec;
+      import_logger.logger.debug(`Successfully fetched ${this.apiName} API specification`);
+    } catch (error) {
+      import_logger.logger.error(
+        `Error fetching API spec: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  async convert() {
+    var _a, _b, _c;
+    if (!this.googleApiSpec) {
+      await this.fetchGoogleApiSpec();
+    }
+    const spec = (_a = this.googleApiSpec) != null ? _a : {};
+    convertInfo(spec, this.openapiSpec, this.apiName, this.apiVersion);
+    convertServers(spec, this.openapiSpec, this.apiName, this.apiVersion);
+    convertSecuritySchemes(spec, this.openapiSpec);
+    convertSchemas(spec, this.openapiSpec);
+    convertResources((_b = spec.resources) != null ? _b : {}, this.openapiSpec);
+    convertMethods((_c = spec.methods) != null ? _c : {}, "/", this.openapiSpec);
+    return this.openapiSpec;
+  }
+  saveOpenapiSpec(outputPath) {
+    fs.writeFileSync(
+      outputPath,
+      JSON.stringify(this.openapiSpec, null, 2),
+      "utf-8"
+    );
+    import_logger.logger.info(`OpenAPI specification saved to ${outputPath}`);
+  }
+};
+__name(GoogleApiToOpenApiConverter, "GoogleApiToOpenApiConverter");
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToOpenApiConverter.prototype, "fetchGoogleApiSpec", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToOpenApiConverter.prototype, "convert", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToOpenApiConverter.prototype, "saveOpenapiSpec", 1);
+GoogleApiToOpenApiConverter = __decorateClass([
+  import_experimental.experimental
+], GoogleApiToOpenApiConverter);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleApiToOpenApiConverter,
+  convertInfo,
+  convertMethods,
+  convertOperation,
+  convertParameterSchema,
+  convertResources,
+  convertSchemaObject,
+  convertSchemas,
+  convertSecuritySchemes,
+  convertServers,
+  extractPathParameters,
+  normalizeGoogleSchemaRef
+});

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

@@ -0,0 +1,61 @@
+/**
+  * @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 google_api_tool_exports = {};
+__export(google_api_tool_exports, {
+  BigQueryToolset: () => import_google_api_toolsets.BigQueryToolset,
+  CalendarToolset: () => import_google_api_toolsets.CalendarToolset,
+  DocsToolset: () => import_google_api_toolsets.DocsToolset,
+  GmailToolset: () => import_google_api_toolsets.GmailToolset,
+  GoogleApiTool: () => import_google_api_tool.GoogleApiTool,
+  GoogleApiToolset: () => import_google_api_toolset.GoogleApiToolset,
+  SheetsToolset: () => import_google_api_toolsets.SheetsToolset,
+  SlidesToolset: () => import_google_api_toolsets.SlidesToolset,
+  YoutubeToolset: () => import_google_api_toolsets.YoutubeToolset,
+  isGoogleApiTool: () => import_google_api_tool.isGoogleApiTool,
+  isGoogleApiToolset: () => import_google_api_toolset.isGoogleApiToolset
+});
+module.exports = __toCommonJS(google_api_tool_exports);
+var import_google_api_tool = require("./google_api_tool.js");
+var import_google_api_toolset = require("./google_api_toolset.js");
+var import_google_api_toolsets = require("./google_api_toolsets.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
+  GoogleApiTool,
+  GoogleApiToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset,
+  isGoogleApiTool,
+  isGoogleApiToolset
+});

package/dist/cjs/tools/load_artifacts_tool.js

@@ -26,11 +26,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var load_artifacts_tool_exports = {};
 __export(load_artifacts_tool_exports, {
   LOAD_ARTIFACTS: () => LOAD_ARTIFACTS,
-  LoadArtifactsTool: () => LoadArtifactsTool
+  LoadArtifactsTool: () => LoadArtifactsTool,
+  asSafePartForLlm: () => asSafePartForLlm
 });
 module.exports = __toCommonJS(load_artifacts_tool_exports);
 var import_genai = require("@google/genai");
 var import_llm_request = require("../models/llm_request.js");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
 var import_logger = require("../utils/logger.js");
 var import_base_tool = require("./base_tool.js");
 /**
@@ -62,6 +64,11 @@ function isInlineMimeTypeSupported(mimeType) {
   ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
 }
 __name(isInlineMimeTypeSupported, "isInlineMimeTypeSupported");
+function base64ByteLength(data) {
+  const digits = data.replace(/[=\s]/g, "").length;
+  return Math.floor(digits * 3 / 4);
+}
+__name(base64ByteLength, "base64ByteLength");
 function asSafePartForLlm(artifact, artifactName) {
   const inlineData = artifact.inlineData;
   if (!inlineData) {
@@ -78,15 +85,13 @@ function asSafePartForLlm(artifact, artifactName) {
     };
   }
   const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
-  const decodedBuffer = Buffer.from(data, "base64");
   if (isTextLike) {
     try {
-      const decoded = decodedBuffer.toString("utf8");
-      return { text: decoded };
+      return { text: (0, import_env_aware_utils.base64Decode)(data.replace(/-/g, "+").replace(/_/g, "/")) };
     } catch {
     }
   }
-  const sizeKb = decodedBuffer.length / 1024;
+  const sizeKb = base64ByteLength(data) / 1024;
   return {
     text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${sizeKb.toFixed(1)} KB. Content cannot be displayed inline.]`
   };
@@ -214,5 +219,6 @@ const LOAD_ARTIFACTS = new LoadArtifactsTool();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LOAD_ARTIFACTS,
-  LoadArtifactsTool
+  LoadArtifactsTool,
+  asSafePartForLlm
 });