@google/adk 2.0.0 → 2.2.0

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

@@ -1,200 +0,0 @@
-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";
-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 = "".concat(name, "_").concat(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: "".concat(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 || "";
-  }
-};
-__name(OperationParser, "OperationParser");
-__decorateClass([
-  experimental
-], OperationParser.prototype, "getParameters", 1);
-__decorateClass([
-  experimental
-], OperationParser.prototype, "getJsonSchema", 1);
-__decorateClass([
-  experimental
-], OperationParser.prototype, "getFunctionName", 1);
-__decorateClass([
-  experimental
-], OperationParser.prototype, "getDescription", 1);
-OperationParser = __decorateClass([
-  experimental
-], OperationParser);
-export {
-  OperationParser
-};

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

@@ -1,98 +0,0 @@
-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 { AutoAuthCredentialExchanger } from "../auth/credential_exchangers/auto_auth_credential_exchanger.js";
-const _ToolContextCredentialStore = class _ToolContextCredentialStore {
-  constructor(context) {
-    this.context = context;
-  }
-  getCredentialKey(authScheme) {
-    const schemeName = (authScheme == null ? void 0 : authScheme.type) || "default";
-    return "".concat(schemeName, "_existing_exchanged_credential");
-  }
-  getCredential(authScheme) {
-    const key = this.getCredentialKey(authScheme);
-    return this.context.state.get(key);
-  }
-  storeCredential(key, credential) {
-    this.context.state.set(key, credential);
-  }
-};
-__name(_ToolContextCredentialStore, "ToolContextCredentialStore");
-let ToolContextCredentialStore = _ToolContextCredentialStore;
-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 authResponseCredential = this.context.getAuthResponse(authConfig);
-    const credential = authResponseCredential != null ? authResponseCredential : this.authCredential;
-    if (!credential) {
-      this.context.requestCredential(authConfig);
-      return { state: "pending" };
-    }
-    const exchanger = new AutoAuthCredentialExchanger();
-    const result = await exchanger.exchange({
-      authScheme: this.authScheme,
-      authCredential: credential
-    });
-    if (authResponseCredential || result.wasExchanged) {
-      const key = store.getCredentialKey(this.authScheme);
-      store.storeCredential(key, result.credential);
-    }
-    return { state: "done", authCredential: result.credential };
-  }
-};
-__name(ToolAuthHandler, "ToolAuthHandler");
-__decorateClass([
-  experimental
-], ToolAuthHandler.prototype, "prepareAuthCredentials", 1);
-__decorateClass([
-  experimental
-], ToolAuthHandler, "fromToolContext", 1);
-ToolAuthHandler = __decorateClass([
-  experimental
-], ToolAuthHandler);
-export {
-  ToolAuthHandler
-};

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

@@ -1,99 +0,0 @@
-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 yaml from "js-yaml";
-import { experimental } from "../../utils/experimental.js";
-import { BaseToolset } from "../base_toolset.js";
-import { OpenApiSpecParser } from "./openapi_spec_parser/openapi_spec_parser.js";
-import { createRestApiTool } from "./rest_api_tool.js";
-let OpenAPIToolset = class extends BaseToolset {
-  constructor(options = {}) {
-    super(options.toolFilter || [], options.prefix);
-    this.tools = [];
-    let spec = options.specDict;
-    if (!spec && options.specStr) {
-      if (options.specType === "yaml" || !options.specType && options.specStr.trim().startsWith("---")) {
-        spec = yaml.load(options.specStr);
-      } else {
-        spec = JSON.parse(options.specStr);
-      }
-    }
-    if (!spec) {
-      throw new Error("Either specDict or specStr must be provided.");
-    }
-    const parser = new OpenApiSpecParser({
-      preservePropertyNames: options.preservePropertyNames
-    });
-    const parsedOperations = parser.parse(spec);
-    for (const op of parsedOperations) {
-      let toolName = op.name;
-      if (this.prefix) {
-        toolName = "".concat(this.prefix, "_").concat(toolName);
-      }
-      const tool = createRestApiTool(
-        {
-          name: toolName,
-          description: op.description,
-          endpoint: op.endpoint,
-          operation: op.operation,
-          authScheme: op.authScheme
-        },
-        {
-          preservePropertyNames: options.preservePropertyNames,
-          headerProvider: options.headerProvider,
-          credentialKey: options.credentialKey
-        }
-      );
-      this.tools.push(tool);
-    }
-    if (options.authScheme || options.authCredential) {
-      for (const tool of this.tools) {
-        if (options.authScheme) tool.configureAuthScheme(options.authScheme);
-        if (options.authCredential)
-          tool.configureAuthCredential(options.authCredential);
-      }
-    }
-  }
-  async getTools(context) {
-    return this.tools.filter((tool) => {
-      if (Array.isArray(this.toolFilter) && this.toolFilter.length > 0) {
-        return this.toolFilter.includes(tool.name);
-      }
-      if (context) {
-        return this.isToolSelected(tool, context);
-      }
-      return true;
-    });
-  }
-  async close() {
-    return Promise.resolve();
-  }
-};
-__name(OpenAPIToolset, "OpenAPIToolset");
-__decorateClass([
-  experimental
-], OpenAPIToolset.prototype, "getTools", 1);
-__decorateClass([
-  experimental
-], OpenAPIToolset.prototype, "close", 1);
-OpenAPIToolset = __decorateClass([
-  experimental
-], OpenAPIToolset);
-export {
-  OpenAPIToolset
-};

package/dist/web/tools/openapi_tool/rest_api_tool.js

@@ -1,247 +0,0 @@
-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 { BaseTool } from "../base_tool.js";
-import { applyCredential } from "./auth/auth_helpers.js";
-import {
-  OperationParser
-} from "./openapi_spec_parser/operation_parser.js";
-import { ToolAuthHandler } from "./openapi_spec_parser/tool_auth_handler.js";
-let RestApiTool = class extends BaseTool {
-  constructor(name, description, endpoint, operation, authScheme, authCredential, options = {}) {
-    super({ name, description });
-    this.endpoint = endpoint;
-    this.operation = operation;
-    this.authScheme = authScheme;
-    this.authCredential = authCredential;
-    this.authScheme = authScheme;
-    this.authCredential = authCredential;
-    this.headerProvider = options.headerProvider;
-    this.credentialKey = options.credentialKey;
-    this.operationParser = new OperationParser(operation, options);
-  }
-  configureAuthScheme(authScheme) {
-    this.authScheme = authScheme;
-  }
-  configureAuthCredential(authCredential) {
-    this.authCredential = authCredential;
-  }
-  configureCredentialKey(credentialKey) {
-    this.credentialKey = credentialKey;
-  }
-  _getDeclaration() {
-    const schema = this.operationParser.getJsonSchema();
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: schema
-    };
-  }
-  async runAsync(request) {
-    const context = request.toolContext;
-    const args = request.args;
-    const authHandler = ToolAuthHandler.fromToolContext(
-      context,
-      this.authScheme,
-      this.authCredential,
-      { credentialKey: this.credentialKey }
-    );
-    const authResult = await authHandler.prepareAuthCredentials();
-    if (authResult.state === "pending") {
-      return {
-        pending: true,
-        message: "Needs your authorization to access your data."
-      };
-    }
-    const credential = authResult.authCredential;
-    const method = this.endpoint.method.toUpperCase();
-    const {
-      url: initialUrl,
-      headers,
-      body: parsedBody,
-      bodyData
-    } = prepareRequestParams(
-      this.endpoint,
-      this.operationParser.getParameters(),
-      args
-    );
-    const body = prepareRequestBody(
-      this.operation.requestBody,
-      parsedBody,
-      bodyData,
-      headers
-    );
-    const url = applyCredential(
-      initialUrl,
-      headers,
-      credential,
-      this.authScheme
-    );
-    if (this.headerProvider) {
-      const providerHeaders = this.headerProvider(context);
-      Object.assign(headers, providerHeaders);
-    }
-    try {
-      const response = await globalThis.fetch(url, {
-        method,
-        headers,
-        // eslint-disable-next-line no-undef
-        body
-      });
-      const contentType = response.headers.get("content-type");
-      if (contentType && contentType.includes("application/json")) {
-        return await response.json();
-      } else {
-        return await response.text();
-      }
-    } catch (error) {
-      return {
-        error: "Failed to execute API call: ".concat(error.message)
-      };
-    }
-  }
-};
-__name(RestApiTool, "RestApiTool");
-__decorateClass([
-  experimental
-], RestApiTool.prototype, "configureAuthScheme", 1);
-__decorateClass([
-  experimental
-], RestApiTool.prototype, "configureAuthCredential", 1);
-__decorateClass([
-  experimental
-], RestApiTool.prototype, "configureCredentialKey", 1);
-__decorateClass([
-  experimental
-], RestApiTool.prototype, "_getDeclaration", 1);
-__decorateClass([
-  experimental
-], RestApiTool.prototype, "runAsync", 1);
-RestApiTool = __decorateClass([
-  experimental
-], RestApiTool);
-function encodePathParamValue(name, value) {
-  if (value === "." || value === "..") {
-    throw new Error(
-      "Invalid value for path parameter '".concat(name, "': relative path segments ") + "('.' and '..') are not allowed."
-    );
-  }
-  return encodeURIComponent(value);
-}
-__name(encodePathParamValue, "encodePathParamValue");
-function prepareRequestParams(endpoint, parameters, args) {
-  const headers = {};
-  const queryParams = new URLSearchParams();
-  let body = void 0;
-  const paramsMap = new Map(parameters.map((p) => [p.name, p]));
-  const pathParams = {};
-  const bodyData = {};
-  for (const [argName, argValue] of Object.entries(args)) {
-    const param = paramsMap.get(argName);
-    if (!param) continue;
-    const originalName = param.originalName;
-    const location = param.paramLocation;
-    if (location === "path") {
-      pathParams[originalName] = encodePathParamValue(
-        originalName,
-        String(argValue)
-      );
-    } else if (location === "query") {
-      queryParams.append(originalName, String(argValue));
-    } else if (location === "header") {
-      headers[originalName] = String(argValue);
-    } else if (location === "body") {
-      if (originalName === "body" || originalName === "array" || originalName === "") {
-        body = argValue;
-      } else {
-        bodyData[originalName] = argValue;
-      }
-    }
-  }
-  const resolvedPath = endpoint.path.replace(
-    /\{([^{}]+)\}/g,
-    (placeholder, name) => Object.hasOwn(pathParams, name) ? pathParams[name] : placeholder
-  );
-  let url = "".concat(endpoint.baseUrl).concat(resolvedPath);
-  const urlParts = url.split("?");
-  if (urlParts.length > 1) {
-    const pathQueryParams = new URLSearchParams(urlParts[1]);
-    for (const [key, value] of pathQueryParams.entries()) {
-      queryParams.append(key, value);
-    }
-    url = urlParts[0];
-  }
-  const queryString = queryParams.toString();
-  if (queryString) {
-    url += "?".concat(queryString);
-  }
-  return { url, headers, body, bodyData };
-}
-__name(prepareRequestParams, "prepareRequestParams");
-function prepareRequestBody(requestBody, body, bodyData, headers) {
-  const finalData = body !== void 0 ? body : Object.keys(bodyData).length > 0 ? bodyData : void 0;
-  if (requestBody && "content" in requestBody) {
-    const content = requestBody.content;
-    for (const [mimeType, _mediaTypeObject] of Object.entries(content)) {
-      if (finalData !== void 0) {
-        if (mimeType === "application/json" || mimeType.endsWith("+json")) {
-          headers["Content-Type"] = mimeType;
-          return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
-        } else if (mimeType === "application/x-www-form-urlencoded") {
-          return new URLSearchParams(finalData);
-        } else if (mimeType === "multipart/form-data") {
-          const formData = new FormData();
-          if (typeof finalData === "object" && finalData !== null) {
-            for (const [key, value] of Object.entries(finalData)) {
-              formData.append(key, String(value));
-            }
-          }
-          return formData;
-        } else if (mimeType === "text/plain") {
-          headers["Content-Type"] = mimeType;
-          return String(finalData);
-        }
-      }
-      break;
-    }
-  } else if (finalData !== void 0) {
-    headers["Content-Type"] = "application/json";
-    return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
-  }
-  return void 0;
-}
-__name(prepareRequestBody, "prepareRequestBody");
-function createRestApiTool(parsed, options = {}) {
-  return new RestApiTool(
-    parsed.name,
-    parsed.description,
-    parsed.endpoint,
-    parsed.operation,
-    parsed.authScheme,
-    void 0,
-    options
-  );
-}
-__name(createRestApiTool, "createRestApiTool");
-export {
-  RestApiTool,
-  createRestApiTool,
-  prepareRequestBody,
-  prepareRequestParams
-};