@google/adk 2.3.0 → 2.4.0

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

@@ -0,0 +1,173 @@
+/**
+  * @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_toolset_exports = {};
+__export(google_api_toolset_exports, {
+  GoogleApiToolset: () => GoogleApiToolset,
+  isGoogleApiToolset: () => isGoogleApiToolset
+});
+module.exports = __toCommonJS(google_api_toolset_exports);
+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_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 = import_base_toolset.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;
+  }
+  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 import_googleapi_to_openapi_converter.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 = 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 import_openapi_toolset.OpenAPIToolset({
+      specDict,
+      specType: "yaml",
+      authScheme
+    });
+  }
+  async ensureToolsLoaded() {
+    var _a2;
+    if (this.openapiToolset || !this.apiName || !this.apiVersion) {
+      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 import_google_api_tool.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([
+  import_experimental.experimental
+], GoogleApiToolset.prototype, "getTools", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolset.prototype, "setToolFilter", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolset.prototype, "configureAuth", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolset.prototype, "close", 1);
+GoogleApiToolset = __decorateClass([
+  import_experimental.experimental
+], GoogleApiToolset);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleApiToolset,
+  isGoogleApiToolset
+});

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

@@ -319,10 +319,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}}`
     );

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

@@ -24,24 +24,22 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var google_api_tool_exports = {};
 __export(google_api_tool_exports, {
-  GoogleApiToOpenApiConverter: () => import_googleapi_to_openapi_converter.GoogleApiToOpenApiConverter,
+  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_tool_set.GoogleApiToolSet,
-  bigqueryToolSet: () => import_google_api_tool_sets.bigqueryToolSet,
-  calendarToolSet: () => import_google_api_tool_sets.calendarToolSet,
-  docsToolSet: () => import_google_api_tool_sets.docsToolSet,
-  gmailToolSet: () => import_google_api_tool_sets.gmailToolSet,
+  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_tool_set.isGoogleApiToolSet,
-  sheetsToolSet: () => import_google_api_tool_sets.sheetsToolSet,
-  slidesToolSet: () => import_google_api_tool_sets.slidesToolSet,
-  youtubeToolSet: () => import_google_api_tool_sets.youtubeToolSet
+  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_tool_set = require("./google_api_tool_set.js");
-var import_google_api_tool_sets = require("./google_api_tool_sets.js");
-var import_googleapi_to_openapi_converter = require("./googleapi_to_openapi_converter.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
@@ -49,16 +47,15 @@ var import_googleapi_to_openapi_converter = require("./googleapi_to_openapi_conv
  */
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  GoogleApiToOpenApiConverter,
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
   GoogleApiTool,
-  GoogleApiToolSet,
-  bigqueryToolSet,
-  calendarToolSet,
-  docsToolSet,
-  gmailToolSet,
+  GoogleApiToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset,
   isGoogleApiTool,
-  isGoogleApiToolSet,
-  sheetsToolSet,
-  slidesToolSet,
-  youtubeToolSet
+  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
 });

package/dist/cjs/tools/load_memory_tool.js

@@ -38,11 +38,13 @@ var import_base_tool = require("./base_tool.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 const _LoadMemoryTool = class _LoadMemoryTool extends import_base_tool.BaseTool {
-  constructor() {
+  constructor(options = {}) {
+    var _a;
     super({
       name: "load_memory",
       description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
     });
+    this.textOnlyContent = (_a = options.textOnlyContent) != null ? _a : false;
   }
   _getDeclaration() {
     return {
@@ -64,12 +66,12 @@ const _LoadMemoryTool = class _LoadMemoryTool extends import_base_tool.BaseTool
     args,
     toolContext
   }) {
-    try {
-      const query = args["query"];
-      if (!toolContext.invocationContext.memoryService) {
-        throw new Error("Memory service is not initialized.");
-      }
-      const searchMemoryResponse = await toolContext.searchMemory(query);
+    const query = args["query"];
+    if (!toolContext.invocationContext.memoryService) {
+      throw new Error("Memory service is not initialized.");
+    }
+    const searchMemoryResponse = await toolContext.searchMemory(query);
+    if (this.textOnlyContent) {
       return {
         memories: searchMemoryResponse.memories.map((m) => {
           var _a, _b;
@@ -84,10 +86,10 @@ const _LoadMemoryTool = class _LoadMemoryTool extends import_base_tool.BaseTool
           };
         })
       };
-    } catch (e) {
-      console.error("ERROR in LoadMemoryTool runAsync:", e);
-      throw e;
     }
+    return {
+      memories: searchMemoryResponse.memories
+    };
   }
   async processLlmRequest(request) {
     await super.processLlmRequest(request);

package/dist/cjs/tools/mcp/mcp_toolset.js

@@ -61,20 +61,7 @@ const _MCPToolset = class _MCPToolset extends import_base_toolset.BaseToolset {
       };
       return new import_mcp_tool.MCPTool(toolWithPrefix, this.mcpSessionManager, tool.name);
     });
-    const filter = this.toolFilter;
-    if (!filter || Array.isArray(filter) && filter.length === 0) {
-      return tools;
-    }
-    if (Array.isArray(filter)) {
-      return tools.filter((tool) => filter.includes(tool.name));
-    }
-    if (context) {
-      return tools.filter((tool) => filter(tool, context));
-    }
-    import_logger.logger.warn(
-      "MCPToolset: a ToolPredicate toolFilter was provided but getTools() was called without a ReadonlyContext. The filter will not be applied."
-    );
-    return tools;
+    return tools.filter((tool) => this.isToolSelected(tool, context));
   }
   /**
    * Lists the names of the resources advertised by the MCP server.

package/dist/cjs/tools/openapi_tool/auth/credential_exchangers/oauth2_exchanger.js

@@ -81,12 +81,12 @@ function generateAuthToken(authCredential) {
 }
 __name(generateAuthToken, "generateAuthToken");
 function exchangeCredential(authScheme, authCredential) {
-  var _a, _b;
+  var _a;
   checkSchemeCredentialType(authScheme, authCredential);
   if (authCredential.http) {
     return authCredential;
   }
-  if (((_a = authCredential.oauth2) == null ? void 0 : _a.accessToken) || ((_b = authCredential.oauth2) == null ? void 0 : _b.refreshToken)) {
+  if ((_a = authCredential.oauth2) == null ? void 0 : _a.accessToken) {
     return generateAuthToken(authCredential);
   }
   return null;

package/dist/cjs/tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js

@@ -54,15 +54,27 @@ const VALID_SCHEMA_TYPES = /* @__PURE__ */ new Set([
   "string"
 ]);
 let OpenApiSpecParser = class {
+  /**
+   * @param options.preservePropertyNames Keeps the original parameter and
+   *     function names instead of converting them to snake_case.
+   * @param options.unconstrainedObjectBodyAsParameter Emits a whole-body
+   *     parameter named `body` when an object request body schema has no
+   *     properties. Defaults to `false`.
+   *     @deprecated Retained for backwards compatibility; empty object schemas
+   *     produce no parameters by default. This option will be removed in a
+   *     future release.
+   */
   constructor(options = {}) {
-    var _a;
+    var _a, _b;
     this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+    this.unconstrainedObjectBodyAsParameter = (_b = options.unconstrainedObjectBodyAsParameter) != null ? _b : false;
   }
   parse(openapiSpec) {
     const resolvedSpec = resolveReferences(openapiSpec);
     const sanitizedSpec = sanitizeSchemaTypes(resolvedSpec);
     return collectOperations(sanitizedSpec, {
-      preservePropertyNames: this.preservePropertyNames
+      preservePropertyNames: this.preservePropertyNames,
+      unconstrainedObjectBodyAsParameter: this.unconstrainedObjectBodyAsParameter
     });
   }
 };
@@ -197,17 +209,18 @@ function resolveServerUrl(server) {
 }
 __name(resolveServerUrl, "resolveServerUrl");
 function collectOperations(spec, options = {}) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+  const unconstrainedObjectBodyAsParameter = (_b = options.unconstrainedObjectBodyAsParameter) != null ? _b : false;
   const operations = [];
-  const server = (_b = spec.servers) == null ? void 0 : _b[0];
+  const server = (_c = spec.servers) == null ? void 0 : _c[0];
   const baseUrl = server ? resolveServerUrl(server) : "";
   const globalSecurity = spec.security || [];
   let globalSchemeName;
   if (globalSecurity.length > 0) {
     globalSchemeName = Object.keys(globalSecurity[0])[0];
   }
-  const authSchemes = ((_c = spec.components) == null ? void 0 : _c.securitySchemes) || {};
+  const authSchemes = ((_d = spec.components) == null ? void 0 : _d.securitySchemes) || {};
   for (const [path, pathItem] of Object.entries(spec.paths || {})) {
     if (!pathItem) continue;
     const methods = [
@@ -230,7 +243,8 @@ function collectOperations(spec, options = {}) {
         operation.operationId = (0, import_case_utils.toSnakeCaseName)(`${path}_${method}`);
       }
       const parser = new import_operation_parser.OperationParser(operation, {
-        preservePropertyNames
+        preservePropertyNames,
+        unconstrainedObjectBodyAsParameter
       });
       let authSchemeName;
       if (operation.security && operation.security.length > 0) {

package/dist/cjs/tools/openapi_tool/openapi_spec_parser/operation_parser.js

@@ -52,13 +52,20 @@ let OperationParser = class {
    *     function names instead of converting them to snake_case.
    * @param options.shouldParse Whether to parse the operation during
    *     construction. Defaults to `true`.
+   * @param options.unconstrainedObjectBodyAsParameter Emits a whole-body
+   *     parameter named `body` when an object request body schema has no
+   *     properties. Defaults to `false`.
+   *     @deprecated Retained for backwards compatibility; empty object schemas
+   *     produce no parameters by default. This option will be removed in a
+   *     future release.
    */
   constructor(operation, options = {}) {
     this.params = [];
-    var _a, _b;
+    var _a, _b, _c;
     this.operation = typeof operation === "string" ? JSON.parse(operation) : operation;
     this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
-    if ((_b = options.shouldParse) != null ? _b : true) {
+    this.unconstrainedObjectBodyAsParameter = (_b = options.unconstrainedObjectBodyAsParameter) != null ? _b : false;
+    if ((_c = options.shouldParse) != null ? _c : true) {
       this.processOperationParameters();
       this.processRequestBody();
       this.returnValue = this.processReturnValue();
@@ -78,6 +85,7 @@ let OperationParser = class {
     return (0, import_case_utils.renameReservedKeywords)((0, import_case_utils.toSnakeCaseName)(originalName));
   }
   processOperationParameters() {
+    var _a;
     const parameters = this.operation.parameters || [];
     for (const param of parameters) {
       if ("name" in param) {
@@ -88,9 +96,12 @@ let OperationParser = class {
         this.params.push({
           originalName,
           paramLocation: location,
-          paramSchema: schema,
+          paramSchema: {
+            ...schema,
+            description: schema.description || description || void 0
+          },
           description,
-          required: param.required || false,
+          required: (_a = param.required) != null ? _a : false,
           name: this.getParamName(originalName)
         });
       }
@@ -126,7 +137,7 @@ let OperationParser = class {
               });
             }
           }
-        } else {
+        } else if (this.unconstrainedObjectBodyAsParameter) {
           this.params.push({
             originalName: "",
             paramLocation: "body",
@@ -147,7 +158,7 @@ let OperationParser = class {
         });
       } else {
         this.params.push({
-          originalName: "body",
+          originalName: "",
           paramLocation: "body",
           paramSchema: schema,
           description,