@google/adk 2.1.0 → 2.2.0

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

@@ -0,0 +1,139 @@
+/**
+  * @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 common_exports = {};
+__export(common_exports, {
+  createApiParameter: () => createApiParameter,
+  generateParamDoc: () => generateParamDoc,
+  generateReturnDoc: () => generateReturnDoc,
+  getTypeHint: () => getTypeHint
+});
+module.exports = __toCommonJS(common_exports);
+var import_case_utils = require("../../../utils/case_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const ANY_TYPE_HINT = "Any";
+const PARAM_PROPERTY_INDENT = "       ";
+const RETURN_PROPERTY_INDENT = "        ";
+const TYPE_HINTS = {
+  integer: "int",
+  number: "float",
+  boolean: "bool",
+  string: "str",
+  object: "Dict[str, Any]"
+};
+function getTypeHint(schema) {
+  var _a;
+  if (!(schema == null ? void 0 : schema.type)) {
+    return ANY_TYPE_HINT;
+  }
+  if (schema.type === "array") {
+    return `List[${getArrayItemTypeHint(schema.items)}]`;
+  }
+  return (_a = TYPE_HINTS[schema.type]) != null ? _a : ANY_TYPE_HINT;
+}
+__name(getTypeHint, "getTypeHint");
+function getArrayItemTypeHint(items) {
+  var _a, _b;
+  const itemType = (_a = resolveSchema(items)) == null ? void 0 : _a.type;
+  if (!itemType || itemType === "array") {
+    return ANY_TYPE_HINT;
+  }
+  return (_b = TYPE_HINTS[itemType]) != null ? _b : ANY_TYPE_HINT;
+}
+__name(getArrayItemTypeHint, "getArrayItemTypeHint");
+function generateParamDoc(param) {
+  var _a, _b;
+  const description = (_b = (_a = param.description) == null ? void 0 : _a.trim()) != null ? _b : "";
+  const typeHint = getTypeHint(param.paramSchema);
+  return `${param.name} (${typeHint}): ${description}` + describeProperties(param.paramSchema, PARAM_PROPERTY_INDENT);
+}
+__name(generateParamDoc, "generateParamDoc");
+function generateReturnDoc(responses) {
+  var _a;
+  const response = Object.entries(responses).filter(([code]) => /^2(\d\d|XX)$/i.test(code)).sort(([a], [b]) => {
+    const numeric = /* @__PURE__ */ __name((c) => /^\d+$/.test(c) ? Number(c) : Infinity, "numeric");
+    return numeric(a) - numeric(b);
+  }).map(([, value]) => value).find(hasContent);
+  if (!response) {
+    return "";
+  }
+  const description = (response.description || "").trim();
+  const firstMimeType = Object.keys(response.content)[0];
+  const schema = resolveSchema((_a = response.content[firstMimeType]) == null ? void 0 : _a.schema);
+  return `Returns (${getTypeHint(schema)}): ${description}` + describeProperties(schema, RETURN_PROPERTY_INDENT);
+}
+__name(generateReturnDoc, "generateReturnDoc");
+function hasContent(response) {
+  return !("$ref" in response) && response.content !== void 0 && Object.keys(response.content).length > 0;
+}
+__name(hasContent, "hasContent");
+function resolveSchema(schema) {
+  return schema && !("$ref" in schema) ? schema : void 0;
+}
+__name(resolveSchema, "resolveSchema");
+function describeProperties(schema, indent) {
+  var _a;
+  if ((schema == null ? void 0 : schema.type) !== "object") {
+    return "";
+  }
+  const properties = Object.entries((_a = schema.properties) != null ? _a : {});
+  if (properties.length === 0) {
+    return "";
+  }
+  return properties.reduce((doc, [propName, propDetails]) => {
+    var _a2;
+    const propSchema = resolveSchema(propDetails);
+    if (!propSchema) {
+      return doc;
+    }
+    const propDesc = (_a2 = propSchema.description) != null ? _a2 : "";
+    return `${doc}${indent}${propName} (${getTypeHint(propSchema)}): ${propDesc}
+`;
+  }, " Object properties:\n");
+}
+__name(describeProperties, "describeProperties");
+function createApiParameter(init) {
+  var _a;
+  return {
+    originalName: init.originalName,
+    paramLocation: init.paramLocation,
+    paramSchema: init.paramSchema,
+    description: init.description || init.paramSchema.description || "",
+    name: init.name || (0, import_case_utils.renameReservedKeywords)((0, import_case_utils.toSnakeCaseName)(init.originalName)),
+    required: (_a = init.required) != null ? _a : false
+  };
+}
+__name(createApiParameter, "createApiParameter");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createApiParameter,
+  generateParamDoc,
+  generateReturnDoc,
+  getTypeHint
+});

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

@@ -36,6 +36,7 @@ __export(openapi_spec_parser_exports, {
   OpenApiSpecParser: () => OpenApiSpecParser
 });
 module.exports = __toCommonJS(openapi_spec_parser_exports);
+var import_case_utils = require("../../../utils/case_utils.js");
 var import_experimental = require("../../../utils/experimental.js");
 var import_operation_parser = require("./operation_parser.js");
 /**
@@ -72,9 +73,13 @@ __decorateClass([
 OpenApiSpecParser = __decorateClass([
   import_experimental.experimental
 ], OpenApiSpecParser);
+function deepCopy(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+__name(deepCopy, "deepCopy");
 function resolveReferences(spec) {
   const resolvedCache = /* @__PURE__ */ new Map();
-  const specCopy = JSON.parse(JSON.stringify(spec));
+  const specCopy = deepCopy(spec);
   const recursiveResolve = /* @__PURE__ */ __name((obj, currentDoc, seenRefs = /* @__PURE__ */ new Set()) => {
     if (typeof obj !== "object" || obj === null) {
       return obj;
@@ -92,13 +97,13 @@ function resolveReferences(spec) {
       }
       seenRefs.add(refString);
       if (resolvedCache.has(refString)) {
-        return resolvedCache.get(refString);
+        return deepCopy(resolvedCache.get(refString));
       }
       let resolvedValue = resolveRef(refString, currentDoc);
       if (resolvedValue !== void 0) {
         resolvedValue = recursiveResolve(resolvedValue, currentDoc, seenRefs);
         resolvedCache.set(refString, resolvedValue);
-        return resolvedValue;
+        return deepCopy(resolvedValue);
       } else {
         return obj;
       }
@@ -129,7 +134,6 @@ function resolveRef(refString, currentDoc) {
 }
 __name(resolveRef, "resolveRef");
 function sanitizeSchemaTypes(openapiSpec) {
-  const specCopy = JSON.parse(JSON.stringify(openapiSpec));
   const sanitizeTypeField = /* @__PURE__ */ __name((schemaDict) => {
     if (!("type" in schemaDict)) return;
     const typeValue = schemaDict["type"];
@@ -175,7 +179,7 @@ function sanitizeSchemaTypes(openapiSpec) {
     }
     return objRecord;
   }, "sanitizeRecursive");
-  return sanitizeRecursive(specCopy, false);
+  return sanitizeRecursive(openapiSpec, false);
 }
 __name(sanitizeSchemaTypes, "sanitizeSchemaTypes");
 function resolveServerUrl(server) {
@@ -223,7 +227,7 @@ function collectOperations(spec, options = {}) {
       const opParams = operation.parameters || [];
       operation.parameters = [...opParams, ...pathParams];
       if (!operation.operationId) {
-        operation.operationId = `${method}_${path.replace(/[^a-zA-Z0-9]/g, "_")}`;
+        operation.operationId = (0, import_case_utils.toSnakeCaseName)(`${path}_${method}`);
       }
       const parser = new import_operation_parser.OperationParser(operation, {
         preservePropertyNames
@@ -240,6 +244,7 @@ function collectOperations(spec, options = {}) {
         endpoint: { baseUrl, path, method },
         operation,
         parameters: parser.getParameters(),
+        returnValue: parser.getReturnValue(),
         authScheme
       });
     }

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

@@ -36,28 +36,46 @@ __export(operation_parser_exports, {
   OperationParser: () => OperationParser
 });
 module.exports = __toCommonJS(operation_parser_exports);
+var import_case_utils = require("../../../utils/case_utils.js");
 var import_experimental = require("../../../utils/experimental.js");
+var import_common = require("../common/common.js");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 let OperationParser = class {
+  /**
+   * @param operation The operation to parse. A string is parsed as JSON, and a
+   *     plain object is used as given.
+   * @param options.preservePropertyNames Keeps the original parameter and
+   *     function names instead of converting them to snake_case.
+   * @param options.shouldParse Whether to parse the operation during
+   *     construction. Defaults to `true`.
+   */
   constructor(operation, options = {}) {
-    this.operation = operation;
     this.params = [];
-    var _a;
+    var _a, _b;
+    this.operation = typeof operation === "string" ? JSON.parse(operation) : operation;
     this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
-    this.processOperationParameters();
-    this.processRequestBody();
-    this.processReturnValue();
-    this.dedupeParamNames();
+    if ((_b = options.shouldParse) != null ? _b : true) {
+      this.processOperationParameters();
+      this.processRequestBody();
+      this.returnValue = this.processReturnValue();
+      this.dedupeParamNames();
+    }
+  }
+  static load(operation, params, returnValue) {
+    const parser = new this(operation, { shouldParse: false });
+    parser.params = params;
+    parser.returnValue = returnValue;
+    return parser;
   }
   getParamName(originalName) {
     if (this.preservePropertyNames) {
       return originalName;
     }
-    return originalName.replace(/[A-Z]/g, (g) => "_" + g.toLowerCase()).replace(/^_/, "");
+    return (0, import_case_utils.renameReservedKeywords)((0, import_case_utils.toSnakeCaseName)(originalName));
   }
   processOperationParameters() {
     const parameters = this.operation.parameters || [];
@@ -79,6 +97,7 @@ let OperationParser = class {
     }
   }
   processRequestBody() {
+    var _a;
     const requestBody = this.operation.requestBody;
     if (!requestBody || "$ref" in requestBody) {
       return;
@@ -89,9 +108,9 @@ let OperationParser = class {
       return;
     }
     const mediaTypeObject = content[firstMimeType];
-    const schema = mediaTypeObject.schema;
+    const schema = (_a = mediaTypeObject.schema) != null ? _a : {};
     const description = requestBody.description || "";
-    if (schema && !("$ref" in schema)) {
+    if (!("$ref" in schema)) {
       if (schema.type === "object") {
         const properties = schema.properties || {};
         if (Object.keys(properties).length > 0) {
@@ -146,16 +165,16 @@ let OperationParser = class {
     if (min20x) {
       const response = responses[min20x];
       if (!("$ref" in response) && response.content) {
-        const firstMimeType = Object.keys(response.content)[0];
-        if (firstMimeType) {
-          const schema = response.content[firstMimeType].schema;
+        for (const mediaType of Object.values(response.content)) {
+          const schema = mediaType.schema;
           if (schema && !("$ref" in schema)) {
             returnSchema = schema;
+            break;
           }
         }
       }
     }
-    this.returnValue = {
+    return {
       originalName: "",
       paramLocation: "",
       paramSchema: returnSchema,
@@ -203,6 +222,32 @@ let OperationParser = class {
   getDescription() {
     return this.operation.description || this.operation.summary || "";
   }
+  getAuthSchemeName() {
+    var _a, _b;
+    const security = (_a = this.operation.security) != null ? _a : [];
+    return security.length > 0 ? (_b = Object.keys(security[0])[0]) != null ? _b : "" : "";
+  }
+  getReturnValue() {
+    return this.returnValue;
+  }
+  getReturnTypeHint() {
+    var _a;
+    return (0, import_common.getTypeHint)((_a = this.returnValue) == null ? void 0 : _a.paramSchema);
+  }
+  getPydocString() {
+    var _a;
+    const description = this.operation.summary || this.operation.description || "";
+    const argLines = this.params.map((param) => `    ${(0, import_common.generateParamDoc)(param)}`).join("\n");
+    const returnDoc = (0, import_common.generateReturnDoc)((_a = this.operation.responses) != null ? _a : {});
+    const returnBlock = returnDoc ? `
+
+${returnDoc}` : "";
+    return `"""${description}
+
+Args:
+${argLines}${returnBlock}
+"""`;
+  }
 };
 __name(OperationParser, "OperationParser");
 __decorateClass([
@@ -217,6 +262,21 @@ __decorateClass([
 __decorateClass([
   import_experimental.experimental
 ], OperationParser.prototype, "getDescription", 1);
+__decorateClass([
+  import_experimental.experimental
+], OperationParser.prototype, "getAuthSchemeName", 1);
+__decorateClass([
+  import_experimental.experimental
+], OperationParser.prototype, "getReturnValue", 1);
+__decorateClass([
+  import_experimental.experimental
+], OperationParser.prototype, "getReturnTypeHint", 1);
+__decorateClass([
+  import_experimental.experimental
+], OperationParser.prototype, "getPydocString", 1);
+__decorateClass([
+  import_experimental.experimental
+], OperationParser, "load", 1);
 OperationParser = __decorateClass([
   import_experimental.experimental
 ], OperationParser);

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

@@ -33,79 +33,190 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var tool_auth_handler_exports = {};
 __export(tool_auth_handler_exports, {
-  ToolAuthHandler: () => ToolAuthHandler
+  ToolAuthHandler: () => ToolAuthHandler,
+  ToolContextCredentialStore: () => ToolContextCredentialStore
 });
 module.exports = __toCommonJS(tool_auth_handler_exports);
+var import_lodash_es = require("lodash-es");
+var import_auth_credential = require("../../../auth/auth_credential.js");
 var import_experimental = require("../../../utils/experimental.js");
+var import_hash_utils = require("../../../utils/hash_utils.js");
+var import_logger = require("../../../utils/logger.js");
 var import_auto_auth_credential_exchanger = require("../auth/credential_exchangers/auto_auth_credential_exchanger.js");
+var import_base_auth_credential_exchanger = require("../auth/credential_exchangers/base_auth_credential_exchanger.js");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const DEFAULT_CREDENTIAL_KEY = "default_openapi_key";
 const _ToolContextCredentialStore = class _ToolContextCredentialStore {
   constructor(context) {
     this.context = context;
   }
-  getCredentialKey(authScheme) {
-    const schemeName = (authScheme == null ? void 0 : authScheme.type) || "default";
-    return `${schemeName}_existing_exchanged_credential`;
+  /**
+   * Returns the state key that holds the credential exchanged for this scheme
+   * and credential pair.
+   *
+   * Both operands are hashed into the key, so two tools configured with
+   * different schemes, or with different credentials under one scheme, never
+   * share a slot.
+   *
+   * The key deliberately carries no `temp:` prefix. Session state is a copy and
+   * only the delta is persisted, and `temp:` is cleared at the end of a run,
+   * while an exchanged token has to stay readable across runs.
+   */
+  getCredentialKey(authScheme, authCredential) {
+    const schemeName = authScheme ? `${authScheme.type}_${(0, import_hash_utils.stableHash)(authScheme)}` : "";
+    const credentialName = authCredential ? `${authCredential.authType}_${(0, import_hash_utils.stableHash)(authCredential)}` : "";
+    return `${schemeName}_${credentialName}_existing_exchanged_credential`;
   }
-  getCredential(authScheme) {
-    const key = this.getCredentialKey(authScheme);
-    return this.context.state.get(key);
+  /**
+   * Returns the credential stored for this scheme and credential pair, or
+   * `undefined` when there is none.
+   *
+   * @throws Error if the state entry under the key is not an
+   *     {@link AuthCredential}, which means something else wrote to the key.
+   */
+  getCredential(authScheme, authCredential) {
+    const key = this.getCredentialKey(authScheme, authCredential);
+    const stored = this.context.state.get(key);
+    if (stored === void 0 || stored === null) {
+      return void 0;
+    }
+    if (!(0, import_auth_credential.isAuthCredential)(stored)) {
+      throw new Error(
+        `State entry '${key}' is not an AuthCredential. Another writer has taken this key.`
+      );
+    }
+    return stored;
   }
   storeCredential(key, credential) {
-    this.context.state.set(key, credential);
+    this.context.state.set(key, JSON.parse(JSON.stringify(credential)));
+  }
+  /**
+   * Makes the credential under `key` unreadable again.
+   *
+   * adk-python deletes the state entry. `State` has no delete, so this writes
+   * `undefined`, which `State.get` returns for a missing key as well, and
+   * {@link getCredential} therefore misses exactly as a delete would make it.
+   */
+  removeCredential(key) {
+    this.context.state.set(key, void 0);
   }
 };
 __name(_ToolContextCredentialStore, "ToolContextCredentialStore");
 let ToolContextCredentialStore = _ToolContextCredentialStore;
 let ToolAuthHandler = class {
-  constructor(context, authScheme, authCredential, credentialKey) {
+  constructor(context, authScheme, authCredential, options = {}) {
     this.context = context;
-    this.authScheme = authScheme;
-    this.authCredential = authCredential;
-    this.credentialKey = credentialKey;
+    var _a;
+    this.authScheme = authScheme ? (0, import_lodash_es.cloneDeep)(authScheme) : void 0;
+    this.authCredential = authCredential ? (0, import_lodash_es.cloneDeep)(authCredential) : void 0;
+    this.credentialKey = options.credentialKey;
+    this.credentialExchanger = options.credentialExchanger;
+    this.credentialStore = (_a = options.credentialStore) != null ? _a : new ToolContextCredentialStore(context);
   }
   static fromToolContext(context, authScheme, authCredential, options = {}) {
-    return new ToolAuthHandler(
-      context,
-      authScheme,
-      authCredential,
-      options.credentialKey
-    );
+    return new ToolAuthHandler(context, authScheme, authCredential, options);
   }
   async prepareAuthCredentials() {
     if (!this.authScheme) {
       return { state: "done" };
     }
-    const store = new ToolContextCredentialStore(this.context);
-    const existingCredential = store.getCredential(this.authScheme);
+    const existingCredential = this.credentialStore.getCredential(
+      this.authScheme,
+      this.authCredential
+    );
     if (existingCredential) {
-      return { state: "done", authCredential: existingCredential };
+      return {
+        state: "done",
+        authScheme: this.authScheme,
+        authCredential: existingCredential
+      };
     }
     const authConfig = {
       authScheme: this.authScheme,
       rawAuthCredential: this.authCredential,
-      credentialKey: this.credentialKey || "default_openapi_key"
+      credentialKey: this.credentialKey || DEFAULT_CREDENTIAL_KEY
     };
     const authResponseCredential = this.context.getAuthResponse(authConfig);
     const credential = authResponseCredential != null ? authResponseCredential : this.authCredential;
-    if (!credential) {
-      this.context.requestCredential(authConfig);
-      return { state: "pending" };
+    const exchanged = credential ? await this.tryExchange(credential) : void 0;
+    if (!exchanged) {
+      this.requestCredential(authConfig);
+      return {
+        state: "pending",
+        authScheme: this.authScheme,
+        authCredential: this.authCredential
+      };
     }
-    const exchanger = new import_auto_auth_credential_exchanger.AutoAuthCredentialExchanger();
-    const result = await exchanger.exchange({
+    if (authResponseCredential || exchanged.wasExchanged) {
+      const key = this.credentialStore.getCredentialKey(
+        this.authScheme,
+        this.authCredential
+      );
+      this.credentialStore.storeCredential(key, exchanged.credential);
+    }
+    return {
+      state: "done",
       authScheme: this.authScheme,
-      authCredential: credential
-    });
-    if (authResponseCredential || result.wasExchanged) {
-      const key = store.getCredentialKey(this.authScheme);
-      store.storeCredential(key, result.credential);
+      authCredential: exchanged.credential
+    };
+  }
+  /**
+   * Exchanges `credential`, or returns `undefined` when the exchange failed.
+   *
+   * An exchange failure is transient far more often than it is fatal, so it
+   * becomes a `pending` result the client can resume from rather than an
+   * exception that fails the whole tool call.
+   */
+  async tryExchange(credential) {
+    var _a;
+    const exchanger = (_a = this.credentialExchanger) != null ? _a : new import_auto_auth_credential_exchanger.AutoAuthCredentialExchanger();
+    try {
+      return await exchanger.exchange({
+        authScheme: this.authScheme,
+        authCredential: credential
+      });
+    } catch (e) {
+      import_logger.logger.error(
+        `Failed to exchange credential: ${e instanceof Error ? e.message : e}`
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Asks the client for a credential, after checking that an interactive
+   * scheme has the OAuth2 client configuration it cannot proceed without.
+   *
+   * @throws Error if an `oauth2` or `openIdConnect` scheme has no OAuth2
+   *     credential.
+   * @throws AuthCredentialMissingError if that credential omits `clientId` or
+   *     `clientSecret`.
+   */
+  requestCredential(authConfig) {
+    var _a, _b;
+    const schemeType = (_a = this.authScheme) == null ? void 0 : _a.type;
+    if (schemeType === "oauth2" || schemeType === "openIdConnect") {
+      const oauth2 = (_b = this.authCredential) == null ? void 0 : _b.oauth2;
+      if (!oauth2) {
+        throw new Error(
+          `authCredential is empty for scheme ${schemeType}. Please create AuthCredential using OAuth2Auth.`
+        );
+      }
+      if (!oauth2.clientId) {
+        throw new import_base_auth_credential_exchanger.AuthCredentialMissingError(
+          "OAuth2 credentials clientId is missing."
+        );
+      }
+      if (!oauth2.clientSecret) {
+        throw new import_base_auth_credential_exchanger.AuthCredentialMissingError(
+          "OAuth2 credentials clientSecret is missing."
+        );
+      }
     }
-    return { state: "done", authCredential: result.credential };
+    this.context.requestCredential(authConfig);
   }
 };
 __name(ToolAuthHandler, "ToolAuthHandler");
@@ -120,5 +231,6 @@ ToolAuthHandler = __decorateClass([
 ], ToolAuthHandler);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ToolAuthHandler
+  ToolAuthHandler,
+  ToolContextCredentialStore
 });

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

@@ -48,6 +48,7 @@ __export(openapi_toolset_exports, {
 module.exports = __toCommonJS(openapi_toolset_exports);
 var import_js_yaml = __toESM(require("js-yaml"), 1);
 var import_experimental = require("../../utils/experimental.js");
+var import_logger = require("../../utils/logger.js");
 var import_base_toolset = require("../base_toolset.js");
 var import_openapi_spec_parser = require("./openapi_spec_parser/openapi_spec_parser.js");
 var import_rest_api_tool = require("./rest_api_tool.js");
@@ -64,8 +65,10 @@ let OpenAPIToolset = class extends import_base_toolset.BaseToolset {
     if (!spec && options.specStr) {
       if (options.specType === "yaml" || !options.specType && options.specStr.trim().startsWith("---")) {
         spec = import_js_yaml.default.load(options.specStr);
-      } else {
+      } else if (options.specType === "json" || !options.specType) {
         spec = JSON.parse(options.specStr);
+      } else {
+        throw new Error(`Unsupported spec type: ${options.specType}`);
       }
     }
     if (!spec) {
@@ -86,7 +89,9 @@ let OpenAPIToolset = class extends import_base_toolset.BaseToolset {
           description: op.description,
           endpoint: op.endpoint,
           operation: op.operation,
-          authScheme: op.authScheme
+          authScheme: op.authScheme,
+          parameters: op.parameters,
+          authCredential: op.authCredential
         },
         {
           preservePropertyNames: options.preservePropertyNames,
@@ -95,6 +100,7 @@ let OpenAPIToolset = class extends import_base_toolset.BaseToolset {
         }
       );
       this.tools.push(tool);
+      import_logger.logger.info(`Parsed tool: ${tool.name}`);
     }
     if (options.authScheme || options.authCredential) {
       for (const tool of this.tools) {
@@ -115,6 +121,9 @@ let OpenAPIToolset = class extends import_base_toolset.BaseToolset {
       return true;
     });
   }
+  getTool(toolName) {
+    return this.tools.find((tool) => tool.name === toolName);
+  }
   async close() {
     return Promise.resolve();
   }
@@ -123,6 +132,9 @@ __name(OpenAPIToolset, "OpenAPIToolset");
 __decorateClass([
   import_experimental.experimental
 ], OpenAPIToolset.prototype, "getTools", 1);
+__decorateClass([
+  import_experimental.experimental
+], OpenAPIToolset.prototype, "getTool", 1);
 __decorateClass([
   import_experimental.experimental
 ], OpenAPIToolset.prototype, "close", 1);