@google/adk 1.1.0 → 1.3.0

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

@@ -0,0 +1,232 @@
+/**
+  * @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 __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 openapi_spec_parser_exports = {};
+__export(openapi_spec_parser_exports, {
+  OpenApiSpecParser: () => OpenApiSpecParser
+});
+module.exports = __toCommonJS(openapi_spec_parser_exports);
+var import_experimental = require("../../../utils/experimental.js");
+var import_operation_parser = require("./operation_parser.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const VALID_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  "array",
+  "boolean",
+  "integer",
+  "null",
+  "number",
+  "object",
+  "string"
+]);
+let OpenApiSpecParser = class {
+  constructor(options = {}) {
+    var _a;
+    this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+  }
+  parse(openapiSpec) {
+    const resolvedSpec = resolveReferences(openapiSpec);
+    const sanitizedSpec = sanitizeSchemaTypes(resolvedSpec);
+    return collectOperations(sanitizedSpec, {
+      preservePropertyNames: this.preservePropertyNames
+    });
+  }
+};
+__decorateClass([
+  import_experimental.experimental
+], OpenApiSpecParser.prototype, "parse", 1);
+OpenApiSpecParser = __decorateClass([
+  import_experimental.experimental
+], OpenApiSpecParser);
+function resolveReferences(spec) {
+  const resolvedCache = /* @__PURE__ */ new Map();
+  const specCopy = JSON.parse(JSON.stringify(spec));
+  const recursiveResolve = (obj, currentDoc, seenRefs = /* @__PURE__ */ new Set()) => {
+    if (typeof obj !== "object" || obj === null) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => recursiveResolve(item, currentDoc, seenRefs));
+    }
+    const objRecord = obj;
+    if ("$ref" in objRecord && typeof objRecord["$ref"] === "string") {
+      const refString = objRecord["$ref"];
+      if (seenRefs.has(refString) && !resolvedCache.has(refString)) {
+        const copy = { ...objRecord };
+        delete copy["$ref"];
+        return copy;
+      }
+      seenRefs.add(refString);
+      if (resolvedCache.has(refString)) {
+        return resolvedCache.get(refString);
+      }
+      let resolvedValue = resolveRef(refString, currentDoc);
+      if (resolvedValue !== void 0) {
+        resolvedValue = recursiveResolve(resolvedValue, currentDoc, seenRefs);
+        resolvedCache.set(refString, resolvedValue);
+        return resolvedValue;
+      } else {
+        return obj;
+      }
+    }
+    const newDict = {};
+    for (const [key, value] of Object.entries(objRecord)) {
+      newDict[key] = recursiveResolve(value, currentDoc, seenRefs);
+    }
+    return newDict;
+  };
+  return recursiveResolve(specCopy, specCopy);
+}
+function resolveRef(refString, currentDoc) {
+  const parts = refString.split("/");
+  if (parts[0] !== "#") {
+    throw new Error(`External references not supported: ${refString}`);
+  }
+  let current = currentDoc;
+  for (const part of parts.slice(1)) {
+    if (typeof current === "object" && current !== null && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function sanitizeSchemaTypes(openapiSpec) {
+  const specCopy = JSON.parse(JSON.stringify(openapiSpec));
+  const sanitizeTypeField = (schemaDict) => {
+    if (!("type" in schemaDict)) return;
+    const typeValue = schemaDict["type"];
+    if (typeof typeValue === "string") {
+      const normalizedType = typeValue.toLowerCase();
+      if (VALID_SCHEMA_TYPES.has(normalizedType)) {
+        schemaDict["type"] = normalizedType;
+      } else {
+        delete schemaDict["type"];
+      }
+      return;
+    }
+    if (Array.isArray(typeValue)) {
+      const validTypes = [];
+      for (const entry of typeValue) {
+        if (typeof entry !== "string") continue;
+        const normalizedEntry = entry.toLowerCase();
+        if (VALID_SCHEMA_TYPES.has(normalizedEntry) && !validTypes.includes(normalizedEntry)) {
+          validTypes.push(normalizedEntry);
+        }
+      }
+      if (validTypes.length > 0) {
+        schemaDict["type"] = validTypes;
+      } else {
+        delete schemaDict["type"];
+      }
+    }
+  };
+  const sanitizeRecursive = (obj, inSchema) => {
+    if (typeof obj !== "object" || obj === null) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => sanitizeRecursive(item, inSchema));
+    }
+    const objRecord = obj;
+    if (inSchema) {
+      sanitizeTypeField(objRecord);
+    }
+    for (const [key, value] of Object.entries(objRecord)) {
+      const isSchemaContainer = key === "schema" || key === "schemas";
+      objRecord[key] = sanitizeRecursive(value, inSchema || isSchemaContainer);
+    }
+    return objRecord;
+  };
+  return sanitizeRecursive(specCopy, false);
+}
+function collectOperations(spec, options = {}) {
+  var _a, _b, _c, _d;
+  const preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+  const operations = [];
+  const baseUrl = ((_c = (_b = spec.servers) == null ? void 0 : _b[0]) == null ? void 0 : _c.url) || "";
+  const globalSecurity = spec.security || [];
+  let globalSchemeName;
+  if (globalSecurity.length > 0) {
+    globalSchemeName = Object.keys(globalSecurity[0])[0];
+  }
+  const authSchemes = ((_d = spec.components) == null ? void 0 : _d.securitySchemes) || {};
+  for (const [path, pathItem] of Object.entries(spec.paths || {})) {
+    if (!pathItem) continue;
+    const methods = [
+      "get",
+      "post",
+      "put",
+      "delete",
+      "patch",
+      "head",
+      "options",
+      "trace"
+    ];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const pathParams = pathItem.parameters || [];
+      const opParams = operation.parameters || [];
+      operation.parameters = [...opParams, ...pathParams];
+      if (!operation.operationId) {
+        operation.operationId = `${method}_${path.replace(/[^a-zA-Z0-9]/g, "_")}`;
+      }
+      const parser = new import_operation_parser.OperationParser(operation, {
+        preservePropertyNames
+      });
+      let authSchemeName;
+      if (operation.security && operation.security.length > 0) {
+        authSchemeName = Object.keys(operation.security[0])[0];
+      }
+      authSchemeName = authSchemeName || globalSchemeName;
+      const authScheme = authSchemeName ? authSchemes[authSchemeName] : void 0;
+      operations.push({
+        name: parser.getFunctionName(),
+        description: parser.getDescription(),
+        endpoint: { baseUrl, path, method },
+        operation,
+        parameters: parser.getParameters(),
+        authScheme
+      });
+    }
+  }
+  return operations;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenApiSpecParser
+});

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

@@ -0,0 +1,224 @@
+/**
+  * @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 __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 operation_parser_exports = {};
+__export(operation_parser_exports, {
+  OperationParser: () => OperationParser
+});
+module.exports = __toCommonJS(operation_parser_exports);
+var import_experimental = require("../../../utils/experimental.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let OperationParser = class {
+  constructor(operation, options = {}) {
+    this.operation = operation;
+    this.params = [];
+    var _a;
+    this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+    this.processOperationParameters();
+    this.processRequestBody();
+    this.processReturnValue();
+    this.dedupeParamNames();
+  }
+  getParamName(originalName) {
+    if (this.preservePropertyNames) {
+      return originalName;
+    }
+    return originalName.replace(/[A-Z]/g, (g) => "_" + g.toLowerCase()).replace(/^_/, "");
+  }
+  processOperationParameters() {
+    const parameters = this.operation.parameters || [];
+    for (const param of parameters) {
+      if ("name" in param) {
+        const originalName = param.name;
+        const description = param.description || "";
+        const location = param.in || "";
+        const schema = param.schema || {};
+        this.params.push({
+          originalName,
+          paramLocation: location,
+          paramSchema: schema,
+          description,
+          required: param.required || false,
+          name: this.getParamName(originalName)
+        });
+      }
+    }
+  }
+  processRequestBody() {
+    const requestBody = this.operation.requestBody;
+    if (!requestBody || "$ref" in requestBody) {
+      return;
+    }
+    const content = requestBody.content || {};
+    const firstMimeType = Object.keys(content)[0];
+    if (!firstMimeType) {
+      return;
+    }
+    const mediaTypeObject = content[firstMimeType];
+    const schema = mediaTypeObject.schema;
+    const description = requestBody.description || "";
+    if (schema && !("$ref" in schema)) {
+      if (schema.type === "object") {
+        const properties = schema.properties || {};
+        if (Object.keys(properties).length > 0) {
+          for (const [propName, propDetails] of Object.entries(properties)) {
+            if (!("$ref" in propDetails)) {
+              this.params.push({
+                originalName: propName,
+                paramLocation: "body",
+                paramSchema: propDetails,
+                description: propDetails.description,
+                required: (schema.required || []).includes(propName),
+                name: this.getParamName(propName)
+              });
+            }
+          }
+        } else {
+          this.params.push({
+            originalName: "",
+            paramLocation: "body",
+            paramSchema: schema,
+            description,
+            required: true,
+            name: "body"
+          });
+        }
+      } else if (schema.type === "array") {
+        this.params.push({
+          originalName: "array",
+          paramLocation: "body",
+          paramSchema: schema,
+          description,
+          required: true,
+          name: "body"
+        });
+      } else {
+        this.params.push({
+          originalName: "body",
+          paramLocation: "body",
+          paramSchema: schema,
+          description,
+          required: true,
+          name: "body"
+        });
+      }
+    }
+  }
+  processReturnValue() {
+    const responses = this.operation.responses || {};
+    const validCodes = Object.keys(responses).filter((k) => k.startsWith("2"));
+    const min20x = validCodes.sort()[0];
+    let returnSchema = {};
+    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;
+          if (schema && !("$ref" in schema)) {
+            returnSchema = schema;
+          }
+        }
+      }
+    }
+    this.returnValue = {
+      originalName: "",
+      paramLocation: "",
+      paramSchema: returnSchema,
+      required: true,
+      name: "return"
+    };
+  }
+  dedupeParamNames() {
+    const nameCounts = /* @__PURE__ */ new Map();
+    for (const param of this.params) {
+      const name = param.name;
+      const count = nameCounts.get(name) || 0;
+      if (count > 0) {
+        param.name = `${name}_${count}`;
+      }
+      nameCounts.set(name, count + 1);
+    }
+  }
+  getParameters() {
+    return this.params;
+  }
+  getJsonSchema() {
+    const properties = {};
+    const required = [];
+    for (const param of this.params) {
+      properties[param.name] = param.paramSchema;
+      if (param.required) {
+        required.push(param.name);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0,
+      title: `${this.operation.operationId || "unnamed"}_Arguments`
+    };
+  }
+  getFunctionName() {
+    const operationId = this.operation.operationId;
+    if (!operationId) {
+      throw new Error("Operation ID is missing");
+    }
+    return this.getParamName(operationId).substring(0, 60);
+  }
+  getDescription() {
+    return this.operation.description || this.operation.summary || "";
+  }
+};
+__decorateClass([
+  import_experimental.experimental
+], OperationParser.prototype, "getParameters", 1);
+__decorateClass([
+  import_experimental.experimental
+], OperationParser.prototype, "getJsonSchema", 1);
+__decorateClass([
+  import_experimental.experimental
+], OperationParser.prototype, "getFunctionName", 1);
+__decorateClass([
+  import_experimental.experimental
+], OperationParser.prototype, "getDescription", 1);
+OperationParser = __decorateClass([
+  import_experimental.experimental
+], OperationParser);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OperationParser
+});

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

@@ -0,0 +1,127 @@
+/**
+  * @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 __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 tool_auth_handler_exports = {};
+__export(tool_auth_handler_exports, {
+  ToolAuthHandler: () => ToolAuthHandler
+});
+module.exports = __toCommonJS(tool_auth_handler_exports);
+var import_experimental = require("../../../utils/experimental.js");
+var import_auto_auth_credential_exchanger = require("../auth/credential_exchangers/auto_auth_credential_exchanger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ToolContextCredentialStore {
+  constructor(context) {
+    this.context = context;
+  }
+  getCredentialKey(authScheme) {
+    const schemeName = (authScheme == null ? void 0 : authScheme.type) || "default";
+    return `${schemeName}_existing_exchanged_credential`;
+  }
+  getCredential(authScheme) {
+    const key = this.getCredentialKey(authScheme);
+    const state = this.context.state;
+    if (state) {
+      const serialized = state[key];
+      if (serialized) {
+        return serialized;
+      }
+    }
+    return void 0;
+  }
+  storeCredential(key, credential) {
+    const state = this.context.state;
+    if (state) {
+      state[key] = credential;
+    }
+  }
+}
+let ToolAuthHandler = class {
+  constructor(context, authScheme, authCredential, credentialKey) {
+    this.context = context;
+    this.authScheme = authScheme;
+    this.authCredential = authCredential;
+    this.credentialKey = credentialKey;
+  }
+  static fromToolContext(context, authScheme, authCredential, options = {}) {
+    return new ToolAuthHandler(
+      context,
+      authScheme,
+      authCredential,
+      options.credentialKey
+    );
+  }
+  async prepareAuthCredentials() {
+    if (!this.authScheme) {
+      return { state: "done" };
+    }
+    const store = new ToolContextCredentialStore(this.context);
+    const existingCredential = store.getCredential(this.authScheme);
+    if (existingCredential) {
+      return { state: "done", authCredential: existingCredential };
+    }
+    const authConfig = {
+      authScheme: this.authScheme,
+      rawAuthCredential: this.authCredential,
+      credentialKey: this.credentialKey || "default_openapi_key"
+    };
+    const credential = this.context.getAuthResponse(authConfig);
+    if (credential) {
+      const exchanger = new import_auto_auth_credential_exchanger.AutoAuthCredentialExchanger();
+      const result = await exchanger.exchange({
+        authScheme: this.authScheme,
+        authCredential: credential
+      });
+      const key = store.getCredentialKey(this.authScheme);
+      store.storeCredential(key, result.credential);
+      return { state: "done", authCredential: result.credential };
+    }
+    this.context.requestCredential(authConfig);
+    return { state: "pending" };
+  }
+};
+__decorateClass([
+  import_experimental.experimental
+], ToolAuthHandler.prototype, "prepareAuthCredentials", 1);
+__decorateClass([
+  import_experimental.experimental
+], ToolAuthHandler, "fromToolContext", 1);
+ToolAuthHandler = __decorateClass([
+  import_experimental.experimental
+], ToolAuthHandler);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolAuthHandler
+});