@google/adk 2.3.0 → 2.5.0

package/dist/esm/tools/computer_use/computer_use_toolset.js

@@ -0,0 +1,344 @@
+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 { Environment } from "@google/genai";
+import { experimental } from "../../utils/experimental.js";
+import { logger } from "../../utils/logger.js";
+import { getGeminiMajorVersion } from "../../utils/model_name.js";
+import { BaseToolset } from "../base_toolset.js";
+import {
+  checkComputerUseEnabled,
+  ComputerEnvironment
+} from "./base_computer.js";
+import {
+  createComputerActions,
+  LEGACY_ACTION_NAMES,
+  OPTIONAL_KEY_ACTIONS,
+  OPTIONAL_MOUSE_ACTIONS,
+  unimplementedOptionalActions
+} from "./computer_use_actions.js";
+import {
+  ComputerUseTool,
+  isComputerUseTool
+} from "./computer_use_tool.js";
+const DIRECT_EXCLUSION_MAP = Object.freeze({
+  // Legacy -> modern.
+  click_at: ["click"],
+  hover_at: ["move"],
+  type_text_at: ["type"],
+  type_text: ["type"],
+  scroll_at: ["scroll"],
+  // Whole-page scroll has no modern counterpart.
+  scroll_document: [],
+  current_state: ["take_screenshot"],
+  key_combination: ["press_key", "hotkey"],
+  wait_5_seconds: ["wait"],
+  // Modern -> legacy.
+  click: ["click_at"],
+  move: ["hover_at"],
+  type: ["type_text_at"],
+  // Does not drop scroll_document.
+  scroll: ["scroll_at"],
+  take_screenshot: ["current_state"],
+  // key_combination is dropped only when both of these are excluded.
+  press_key: [],
+  hotkey: [],
+  wait: ["wait_5_seconds"]
+});
+const LEGACY_EXCLUSION_NAMES = /* @__PURE__ */ new Set([
+  "click_at",
+  "hover_at",
+  "type_text_at",
+  "type_text",
+  "scroll_at",
+  "scroll_document",
+  "current_state",
+  "key_combination",
+  "wait_5_seconds"
+]);
+const MODERN_EXCLUSION_NAMES = /* @__PURE__ */ new Set([
+  "click",
+  "move",
+  "type",
+  "scroll",
+  "take_screenshot",
+  "press_key",
+  "hotkey",
+  "wait",
+  ...OPTIONAL_MOUSE_ACTIONS,
+  ...OPTIONAL_KEY_ACTIONS
+]);
+const TYPING_ACTIONS = ["type", "type_text_at", "type_text"];
+const computerQueues = /* @__PURE__ */ new WeakMap();
+function expandLocalExclusions(excludedNames) {
+  var _a2;
+  const expanded = new Set(excludedNames);
+  for (const name of excludedNames) {
+    for (const counterpart of (_a2 = DIRECT_EXCLUSION_MAP[name]) != null ? _a2 : []) {
+      expanded.add(counterpart);
+    }
+  }
+  if (TYPING_ACTIONS.some((name) => expanded.has(name))) {
+    TYPING_ACTIONS.forEach((name) => expanded.add(name));
+  }
+  if (expanded.has("press_key") && expanded.has("hotkey")) {
+    expanded.add("key_combination");
+  }
+  return expanded;
+}
+__name(expandLocalExclusions, "expandLocalExclusions");
+function resolveExcludedPredefinedFunctions({
+  excludedNames,
+  model,
+  unimplementedActions
+}) {
+  var _a2;
+  const major = getGeminiMajorVersion(model);
+  if (major !== void 0 && major < 3) {
+    if (excludedNames === void 0) {
+      return void 0;
+    }
+    const bothModernKeys = excludedNames.includes("press_key") && excludedNames.includes("hotkey");
+    const resolved2 = [];
+    for (const name of excludedNames) {
+      if (name === "press_key" || name === "hotkey") {
+        if (bothModernKeys) {
+          resolved2.push("key_combination");
+        }
+      } else if (name === "type_text") {
+        resolved2.push("type_text_at");
+      } else if (MODERN_EXCLUSION_NAMES.has(name)) {
+        resolved2.push(...(_a2 = DIRECT_EXCLUSION_MAP[name]) != null ? _a2 : []);
+      } else {
+        resolved2.push(name);
+      }
+    }
+    return [...new Set(resolved2)];
+  }
+  const resolved = [];
+  for (const name of excludedNames != null ? excludedNames : []) {
+    if (LEGACY_EXCLUSION_NAMES.has(name)) {
+      resolved.push(...DIRECT_EXCLUSION_MAP[name]);
+    } else {
+      resolved.push(name);
+    }
+  }
+  if (major !== void 0 && major >= 3) {
+    resolved.push(...unimplementedActions);
+  }
+  const deduped = [...new Set(resolved)];
+  if (deduped.length === 0 && excludedNames === void 0) {
+    return void 0;
+  }
+  return deduped;
+}
+__name(resolveExcludedPredefinedFunctions, "resolveExcludedPredefinedFunctions");
+async function runExclusive(computer, action) {
+  var _a2;
+  const previous = (_a2 = computerQueues.get(computer)) != null ? _a2 : Promise.resolve();
+  const result = previous.then(action);
+  computerQueues.set(
+    computer,
+    result.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return result;
+}
+__name(runExclusive, "runExclusive");
+function toGenaiEnvironment(environment) {
+  switch (environment) {
+    case ComputerEnvironment.ENVIRONMENT_UNSPECIFIED:
+      return Environment.ENVIRONMENT_UNSPECIFIED;
+    case ComputerEnvironment.ENVIRONMENT_BROWSER:
+      return Environment.ENVIRONMENT_BROWSER;
+    default: {
+      const exhaustive = environment;
+      throw new Error(`Unknown computer environment: ${exhaustive}`);
+    }
+  }
+}
+__name(toGenaiEnvironment, "toGenaiEnvironment");
+function isComputerUseConfig(tool) {
+  return "computerUse" in tool && tool.computerUse !== void 0;
+}
+__name(isComputerUseConfig, "isComputerUseConfig");
+async function adaptComputerUseTool({
+  methodName,
+  adapter,
+  llmRequest
+}) {
+  if (!LEGACY_ACTION_NAMES.includes(methodName)) {
+    logger.warn(`Method ${methodName} is not a valid BaseComputer method`);
+    return;
+  }
+  const original = Object.hasOwn(llmRequest.toolsDict, methodName) ? llmRequest.toolsDict[methodName] : void 0;
+  if (!isComputerUseTool(original)) {
+    logger.warn(`Method ${methodName} not found in toolsDict`);
+    return;
+  }
+  const adapted = await adapter(original.func);
+  llmRequest.toolsDict[adapted.name] = new ComputerUseTool({
+    ...adapted,
+    screenSize: original.screenSize,
+    virtualScreenSize: original.virtualScreenSize
+  });
+  if (adapted.name !== methodName) {
+    delete llmRequest.toolsDict[methodName];
+  }
+  logger.debug(`Adapted tool ${methodName} to ${adapted.name}`);
+}
+__name(adaptComputerUseTool, "adaptComputerUseTool");
+const COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.computerUseToolset"
+);
+function isComputerUseToolset(obj) {
+  return typeof obj === "object" && obj !== null && COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+__name(isComputerUseToolset, "isComputerUseToolset");
+let ComputerUseToolset = class extends (_b = BaseToolset, _a = COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL, _b) {
+  /**
+   * @param options The computer and its configuration.
+   */
+  constructor(options) {
+    var _a2;
+    checkComputerUseEnabled();
+    super([]);
+    /** A unique symbol to identify ADK computer use toolset class. */
+    this[_a] = true;
+    this.closed = false;
+    this.computer = options.computer;
+    this.excludedPredefinedFunctions = options.excludedPredefinedFunctions;
+    this.allowPrivateNetworkAccess = (_a2 = options.allowPrivateNetworkAccess) != null ? _a2 : false;
+  }
+  /**
+   * Returns a tool for every action the computer supports, except the
+   * excluded ones. The computer is initialized on the first call, and the
+   * tools are cached until {@link close}.
+   */
+  async getTools() {
+    var _a2;
+    (_a2 = this.loadingTools) != null ? _a2 : this.loadingTools = this.loadTools();
+    try {
+      return await this.loadingTools;
+    } catch (error) {
+      this.loadingTools = void 0;
+      throw error;
+    }
+  }
+  /**
+   * Closes the computer and drops the cached tools. The next call to
+   * {@link getTools} initializes the computer again.
+   */
+  async close() {
+    if (!this.closed) {
+      await this.computer.close();
+      this.closed = true;
+    }
+    this.initializing = void 0;
+    this.loadingTools = void 0;
+  }
+  /**
+   * Registers the computer use tools in the request and adds the computer use
+   * configuration, unless the request already has one.
+   *
+   * @param _toolContext The context of the tool.
+   * @param llmRequest The outgoing request.
+   */
+  async processLlmRequest(_toolContext, llmRequest) {
+    var _a2, _b2, _c;
+    for (const tool of await this.getTools()) {
+      llmRequest.toolsDict[tool.name] = tool;
+    }
+    (_a2 = llmRequest.config) != null ? _a2 : llmRequest.config = {};
+    (_c = (_b2 = llmRequest.config).tools) != null ? _c : _b2.tools = [];
+    if (llmRequest.config.tools.some(isComputerUseConfig)) {
+      logger.debug("Computer use already configured in LLM request");
+      return;
+    }
+    const environment = toGenaiEnvironment(await this.computer.environment());
+    const excludedPredefinedFunctions = resolveExcludedPredefinedFunctions({
+      excludedNames: this.excludedPredefinedFunctions,
+      model: llmRequest.model,
+      unimplementedActions: unimplementedOptionalActions(this.computer)
+    });
+    llmRequest.config.tools.push({
+      computerUse: excludedPredefinedFunctions === void 0 ? { environment } : { environment, excludedPredefinedFunctions }
+    });
+    logger.debug(
+      `Added computer use tool with environment: ${environment}, excluded functions: ${excludedPredefinedFunctions}`
+    );
+  }
+  ensureInitialized() {
+    var _a2;
+    (_a2 = this.initializing) != null ? _a2 : this.initializing = this.computer.initialize().then(
+      () => {
+        this.closed = false;
+      },
+      (error) => {
+        this.initializing = void 0;
+        throw error;
+      }
+    );
+    return this.initializing;
+  }
+  async loadTools() {
+    var _a2;
+    await this.ensureInitialized();
+    const screenSize = await this.computer.screenSize();
+    const excluded = expandLocalExclusions(
+      (_a2 = this.excludedPredefinedFunctions) != null ? _a2 : []
+    );
+    return createComputerActions({
+      computer: this.computer,
+      allowPrivateNetworkAccess: this.allowPrivateNetworkAccess
+    }).filter((action) => !excluded.has(action.name)).map(
+      (action) => new ComputerUseTool({
+        name: action.name,
+        description: action.description,
+        parameters: action.parameters,
+        execute: this.bindToComputer(action),
+        screenSize
+      })
+    );
+  }
+  /**
+   * Wraps an action so it runs exclusively on the computer, after the
+   * computer has prepared for the calling session.
+   */
+  bindToComputer(action) {
+    const computer = this.computer;
+    return (args, toolContext) => runExclusive(computer, async () => {
+      if (toolContext) {
+        await computer.prepare(toolContext);
+      }
+      return action.execute(args);
+    });
+  }
+};
+__name(ComputerUseToolset, "ComputerUseToolset");
+ComputerUseToolset = __decorateClass([
+  experimental
+], ComputerUseToolset);
+export {
+  ComputerUseToolset,
+  adaptComputerUseTool,
+  isComputerUseToolset
+};

package/dist/esm/tools/function_tool.js

@@ -29,9 +29,10 @@ function toResponseSchema(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 };
+    const jsonSchema = toJsonSchema(response);
+    return (_a2 = toGeminiSchema(jsonSchema)) != null ? _a2 : {
+      type: Type.TYPE_UNSPECIFIED
+    };
   }
   return response;
 }
@@ -251,6 +252,11 @@ function annotateNullableFields(schema) {
     if (!isPlainRecord(propertySchema)) {
       continue;
     }
+    const propType = propertySchema["type"];
+    if (propType === null || propType === "null" || propType === Type.NULL) {
+      propertySchema["type"] = Type.OBJECT;
+      propertySchema["nullable"] = true;
+    }
     const anyOf = propertySchema["anyOf"];
     if (!Array.isArray(anyOf)) {
       continue;
@@ -353,8 +359,12 @@ function processParameterSchema(vertexai, 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;
+  const rawType = propertySchema["type"];
+  if (rawType === null || rawType === "null" || rawType === Type.NULL) {
+    propertySchema["type"] = Type.OBJECT;
+    propertySchema["nullable"] = true;
+  } else if (typeof rawType === "string") {
+    propertySchema["type"] = (_a2 = SCHEMA_TYPE_MAP[rawType]) != null ? _a2 : Type.TYPE_UNSPECIFIED;
     if (propertySchema["type"] === Type.ARRAY && isPlainRecord(propertySchema["items"])) {
       mapPropertySchemaType(propertySchema["items"]);
     }

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

@@ -26,7 +26,7 @@ function isGoogleApiTool(obj) {
 }
 __name(isGoogleApiTool, "isGoogleApiTool");
 let GoogleApiTool = class extends (_b = BaseTool, _a = GOOGLE_API_TOOL_SIGNATURE_SYMBOL, _b) {
-  constructor(restApiTool) {
+  constructor(restApiTool, options = {}) {
     super({
       name: restApiTool.name,
       description: restApiTool.description,
@@ -34,6 +34,9 @@ let GoogleApiTool = class extends (_b = BaseTool, _a = GOOGLE_API_TOOL_SIGNATURE
     });
     this[_a] = true;
     this.restApiTool = restApiTool;
+    if (options.clientId !== void 0 || options.clientSecret !== void 0) {
+      this.configureAuth(options.clientId, options.clientSecret);
+    }
   }
   _getDeclaration() {
     return this.restApiTool._getDeclaration();

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

@@ -0,0 +1,147 @@
+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 { experimental } from "../../utils/experimental.js";
+import { BaseToolset } from "../base_toolset.js";
+import { OpenAPIToolset } from "../openapi_tool/openapi_toolset.js";
+import { GoogleApiTool } from "./google_api_tool.js";
+import { GoogleApiToOpenApiConverter } from "./googleapi_to_openapi_converter.js";
+const GOOGLE_API_TOOLSET_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_TOOLSET_SIGNATURE_SYMBOL in obj && obj[GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+__name(isGoogleApiToolset, "isGoogleApiToolset");
+let GoogleApiToolset = class extends (_b = BaseToolset, _a = GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL, _b) {
+  constructor(options = {}) {
+    var _a2;
+    const toolFilter = (_a2 = options.toolFilter) != null ? _a2 : [];
+    super(toolFilter);
+    this[_a] = true;
+    this.tools = [];
+    this.toolFilter = toolFilter;
+    this.apiName = options.apiName;
+    this.apiVersion = options.apiVersion;
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+    this.scopes = options.scopes ? [...options.scopes] : void 0;
+  }
+  async loadToolsetWithOidcAuth() {
+    var _a2, _b2, _c, _d, _e;
+    if (!this.apiName || !this.apiVersion) {
+      throw new Error(
+        "Both apiName and apiVersion are required to load a GoogleApiToolset."
+      );
+    }
+    const specDict = await new GoogleApiToOpenApiConverter(
+      this.apiName,
+      this.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 = this.scopes !== void 0 ? [...this.scopes] : firstScope ? [firstScope] : void 0;
+    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
+    };
+    return new OpenAPIToolset({
+      specDict,
+      specType: "yaml",
+      authScheme
+    });
+  }
+  async ensureToolsLoaded() {
+    var _a2;
+    if (this.openapiToolset) {
+      return;
+    }
+    (_a2 = this.loadingPromise) != null ? _a2 : this.loadingPromise = (async () => {
+      try {
+        const openapiToolset = await this.loadToolsetWithOidcAuth();
+        const restTools = await openapiToolset.getTools();
+        this.tools = restTools.map(
+          (tool) => new GoogleApiTool(tool, {
+            clientId: this.clientId,
+            clientSecret: this.clientSecret
+          })
+        );
+        this.openapiToolset = openapiToolset;
+      } catch (error) {
+        this.loadingPromise = void 0;
+        throw error;
+      }
+    })();
+    await this.loadingPromise;
+  }
+  async getTools(context) {
+    await this.ensureToolsLoaded();
+    return this.tools.filter((tool) => this.isToolSelected(tool, context));
+  }
+  setToolFilter(toolFilter) {
+    this.toolFilter = toolFilter;
+  }
+  configureAuth(clientId, clientSecret) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    for (const tool of this.tools) {
+      tool.configureAuth(clientId, clientSecret);
+    }
+  }
+  async close() {
+    if (this.openapiToolset) {
+      await this.openapiToolset.close();
+    }
+  }
+};
+__name(GoogleApiToolset, "GoogleApiToolset");
+__decorateClass([
+  experimental
+], GoogleApiToolset.prototype, "getTools", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolset.prototype, "setToolFilter", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolset.prototype, "configureAuth", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolset.prototype, "close", 1);
+GoogleApiToolset = __decorateClass([
+  experimental
+], GoogleApiToolset);
+export {
+  GoogleApiToolset,
+  isGoogleApiToolset
+};

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

@@ -0,0 +1,94 @@
+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
+ */
+import { experimental } from "../../utils/experimental.js";
+import {
+  GoogleApiToolset
+} from "./google_api_toolset.js";
+let BigQueryToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "bigquery", apiVersion: "v2" });
+  }
+};
+__name(BigQueryToolset, "BigQueryToolset");
+BigQueryToolset = __decorateClass([
+  experimental
+], BigQueryToolset);
+let CalendarToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "calendar", apiVersion: "v3" });
+  }
+};
+__name(CalendarToolset, "CalendarToolset");
+CalendarToolset = __decorateClass([
+  experimental
+], CalendarToolset);
+let GmailToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "gmail", apiVersion: "v1" });
+  }
+};
+__name(GmailToolset, "GmailToolset");
+GmailToolset = __decorateClass([
+  experimental
+], GmailToolset);
+let YoutubeToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "youtube", apiVersion: "v3" });
+  }
+};
+__name(YoutubeToolset, "YoutubeToolset");
+YoutubeToolset = __decorateClass([
+  experimental
+], YoutubeToolset);
+let SlidesToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "slides", apiVersion: "v1" });
+  }
+};
+__name(SlidesToolset, "SlidesToolset");
+SlidesToolset = __decorateClass([
+  experimental
+], SlidesToolset);
+let SheetsToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "sheets", apiVersion: "v4" });
+  }
+};
+__name(SheetsToolset, "SheetsToolset");
+SheetsToolset = __decorateClass([
+  experimental
+], SheetsToolset);
+let DocsToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "docs", apiVersion: "v1" });
+  }
+};
+__name(DocsToolset, "DocsToolset");
+DocsToolset = __decorateClass([
+  experimental
+], DocsToolset);
+export {
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset
+};

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

@@ -205,11 +205,13 @@ function convertOperation(methodData, pathParams) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   const parameters = [];
   for (const paramName of pathParams) {
+    const paramData = methodData.parameters && Object.hasOwn(methodData.parameters, paramName) ? methodData.parameters[paramName] : void 0;
     parameters.push({
       name: paramName,
       in: "path",
+      ...(paramData == null ? void 0 : paramData.description) !== void 0 ? { description: paramData.description } : {},
       required: true,
-      schema: { type: "string" }
+      schema: paramData ? convertParameterSchema(paramData) : { type: "string" }
     });
   }
   const pathParamSet = new Set(pathParams);
@@ -273,10 +275,10 @@ function convertOperation(methodData, pathParams) {
 }
 __name(convertOperation, "convertOperation");
 function convertMethods(methods, _resourcePath, openapiSpec) {
-  var _a, _b;
+  var _a, _b, _c;
   for (const methodData of Object.values(methods)) {
     const httpMethod = ((_a = methodData.httpMethod) != null ? _a : "GET").toLowerCase();
-    let restPath = ((_b = methodData.path) != null ? _b : "/").replace(
+    let restPath = ((_c = (_b = methodData.flatPath) != null ? _b : methodData.path) != null ? _c : "/").replace(
       /\{\+([^{}]+)\}/g,
       (_match, paramName) => `{${paramName}}`
     );