@google/adk 2.2.0 → 2.3.0

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

@@ -0,0 +1,393 @@
+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 * as fs from "node:fs";
+import { experimental } from "../../utils/experimental.js";
+import { logger } from "../../utils/logger.js";
+const GOOGLE_DISCOVERY_BASE_URL = "https://www.googleapis.com/discovery/v1/apis";
+const GOOGLE_OAUTH2_AUTH_URL = "https://accounts.google.com/o/oauth2/auth";
+const GOOGLE_OAUTH2_TOKEN_URL = "https://oauth2.googleapis.com/token";
+function normalizeGoogleSchemaRef(ref) {
+  if (ref.startsWith("#")) {
+    return `#/components/schemas/${ref.slice(1)}`;
+  }
+  return `#/components/schemas/${ref}`;
+}
+__name(normalizeGoogleSchemaRef, "normalizeGoogleSchemaRef");
+function convertInfo(googleApiSpec, openapiSpec, apiName, apiVersion) {
+  var _a, _b, _c, _d;
+  openapiSpec.info = {
+    title: (_a = googleApiSpec.title) != null ? _a : `${apiName} API`,
+    description: (_b = googleApiSpec.description) != null ? _b : "",
+    version: (_c = googleApiSpec.version) != null ? _c : apiVersion,
+    contact: {},
+    termsOfService: (_d = googleApiSpec.documentationLink) != null ? _d : ""
+  };
+  const docsLink = googleApiSpec.documentationLink;
+  if (docsLink) {
+    openapiSpec.externalDocs = {
+      description: "API Documentation",
+      url: docsLink
+    };
+  }
+}
+__name(convertInfo, "convertInfo");
+function convertServers(googleApiSpec, openapiSpec, apiName, apiVersion) {
+  var _a, _b;
+  let baseUrl = `${(_a = googleApiSpec.rootUrl) != null ? _a : ""}${(_b = googleApiSpec.servicePath) != null ? _b : ""}`;
+  if (baseUrl.endsWith("/")) {
+    baseUrl = baseUrl.slice(0, -1);
+  }
+  openapiSpec.servers = [
+    {
+      url: baseUrl,
+      description: `${apiName} ${apiVersion} API`
+    }
+  ];
+}
+__name(convertServers, "convertServers");
+function convertSecuritySchemes(googleApiSpec, openapiSpec) {
+  var _a, _b, _c, _d, _e;
+  openapiSpec.components = (_a = openapiSpec.components) != null ? _a : {};
+  openapiSpec.components.securitySchemes = (_b = openapiSpec.components.securitySchemes) != null ? _b : {};
+  const oauth2 = (_c = googleApiSpec.auth) == null ? void 0 : _c.oauth2;
+  const hasOauth2 = oauth2 !== void 0 && Object.keys(oauth2).length > 0;
+  const formattedScopes = {};
+  if (hasOauth2) {
+    const scopes = (_d = oauth2.scopes) != null ? _d : {};
+    for (const [scope, scopeInfo] of Object.entries(scopes)) {
+      formattedScopes[scope] = (_e = scopeInfo.description) != null ? _e : "";
+    }
+    openapiSpec.components.securitySchemes["oauth2"] = {
+      type: "oauth2",
+      description: "OAuth 2.0 authentication",
+      flows: {
+        authorizationCode: {
+          authorizationUrl: GOOGLE_OAUTH2_AUTH_URL,
+          tokenUrl: GOOGLE_OAUTH2_TOKEN_URL,
+          scopes: formattedScopes
+        }
+      }
+    };
+  }
+  openapiSpec.components.securitySchemes["apiKey"] = {
+    type: "apiKey",
+    in: "query",
+    name: "key",
+    description: "API key for accessing this API"
+  };
+  openapiSpec.security = [
+    hasOauth2 ? { oauth2: Object.keys(formattedScopes) } : {},
+    { apiKey: [] }
+  ];
+}
+__name(convertSecuritySchemes, "convertSecuritySchemes");
+function convertSchemaObject(schemaDef) {
+  var _a;
+  const result = {};
+  if (schemaDef.type !== void 0) {
+    const gtype = schemaDef.type;
+    if (gtype === "object") {
+      result["type"] = "object";
+      if (schemaDef.properties !== void 0) {
+        const properties = {};
+        for (const [propName, propDef] of Object.entries(
+          schemaDef.properties
+        )) {
+          properties[propName] = convertSchemaObject(propDef);
+        }
+        result["properties"] = properties;
+      }
+      const requiredFields = [];
+      for (const [propName, propDef] of Object.entries(
+        (_a = schemaDef.properties) != null ? _a : {}
+      )) {
+        if (propDef.required) {
+          requiredFields.push(propName);
+        }
+      }
+      if (requiredFields.length > 0) {
+        result["required"] = requiredFields;
+      }
+    } else if (gtype === "array") {
+      result["type"] = "array";
+      if (schemaDef.items !== void 0) {
+        result["items"] = convertSchemaObject(schemaDef.items);
+      }
+    } else if (gtype === "any") {
+      result["oneOf"] = [
+        { type: "object" },
+        { type: "array" },
+        { type: "string" },
+        { type: "number" },
+        { type: "boolean" },
+        { type: "null" }
+      ];
+    } else {
+      result["type"] = gtype;
+    }
+  }
+  if (schemaDef.$ref !== void 0) {
+    result["$ref"] = normalizeGoogleSchemaRef(schemaDef.$ref);
+  }
+  if (schemaDef.format !== void 0) {
+    result["format"] = schemaDef.format;
+  }
+  if (schemaDef.enum !== void 0) {
+    result["enum"] = schemaDef.enum;
+  }
+  if (schemaDef.description !== void 0) {
+    result["description"] = schemaDef.description;
+  }
+  if (schemaDef.pattern !== void 0) {
+    result["pattern"] = schemaDef.pattern;
+  }
+  if (schemaDef.default !== void 0) {
+    result["default"] = schemaDef.default;
+  }
+  return result;
+}
+__name(convertSchemaObject, "convertSchemaObject");
+function convertSchemas(googleApiSpec, openapiSpec) {
+  var _a, _b, _c;
+  openapiSpec.components = (_a = openapiSpec.components) != null ? _a : {};
+  openapiSpec.components.schemas = (_b = openapiSpec.components.schemas) != null ? _b : {};
+  const schemas = (_c = googleApiSpec.schemas) != null ? _c : {};
+  for (const [schemaName, schemaDef] of Object.entries(schemas)) {
+    openapiSpec.components.schemas[schemaName] = convertSchemaObject(schemaDef);
+  }
+}
+__name(convertSchemas, "convertSchemas");
+function extractPathParameters(path) {
+  const params = [];
+  for (const match of path.matchAll(/\{\+?([^{}]+)\}/g)) {
+    params.push(match[1]);
+  }
+  return params;
+}
+__name(extractPathParameters, "extractPathParameters");
+function convertParameterSchema(paramData) {
+  var _a;
+  const schema = {
+    type: (_a = paramData.type) != null ? _a : "string"
+  };
+  if (paramData.enum !== void 0) {
+    schema["enum"] = paramData.enum;
+  }
+  if (paramData.format !== void 0) {
+    schema["format"] = paramData.format;
+  }
+  if (paramData.default !== void 0) {
+    schema["default"] = paramData.default;
+  }
+  if (paramData.pattern !== void 0) {
+    schema["pattern"] = paramData.pattern;
+  }
+  return schema;
+}
+__name(convertParameterSchema, "convertParameterSchema");
+function convertOperation(methodData, pathParams) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const parameters = [];
+  for (const paramName of pathParams) {
+    parameters.push({
+      name: paramName,
+      in: "path",
+      required: true,
+      schema: { type: "string" }
+    });
+  }
+  const pathParamSet = new Set(pathParams);
+  for (const [paramName, paramData] of Object.entries(
+    (_a = methodData.parameters) != null ? _a : {}
+  )) {
+    if (pathParamSet.has(paramName)) {
+      continue;
+    }
+    const location = (_b = paramData.location) != null ? _b : "query";
+    parameters.push({
+      name: paramName,
+      in: location,
+      description: (_c = paramData.description) != null ? _c : "",
+      required: location === "path" ? true : (_d = paramData.required) != null ? _d : false,
+      schema: convertParameterSchema(paramData)
+    });
+  }
+  const response200 = {
+    description: "Successful operation"
+  };
+  const responseRef = (_e = methodData.response) == null ? void 0 : _e.$ref;
+  if (responseRef) {
+    response200.content = {
+      "application/json": {
+        schema: { $ref: normalizeGoogleSchemaRef(responseRef) }
+      }
+    };
+  }
+  const operation = {
+    operationId: (_f = methodData.id) != null ? _f : "",
+    summary: (_g = methodData.description) != null ? _g : "",
+    description: (_h = methodData.description) != null ? _h : "",
+    parameters,
+    responses: {
+      "200": response200,
+      "400": { description: "Bad request" },
+      "401": { description: "Unauthorized" },
+      "403": { description: "Forbidden" },
+      "404": { description: "Not found" },
+      "500": { description: "Server error" }
+    }
+  };
+  const requestRef = (_i = methodData.request) == null ? void 0 : _i.$ref;
+  if (requestRef) {
+    operation.requestBody = {
+      description: "Request body",
+      content: {
+        "application/json": {
+          schema: { $ref: normalizeGoogleSchemaRef(requestRef) }
+        }
+      },
+      required: true
+    };
+  }
+  const scopes = (_j = methodData.scopes) != null ? _j : [];
+  if (scopes.length > 0) {
+    operation.security = [{ oauth2: scopes }];
+  }
+  return operation;
+}
+__name(convertOperation, "convertOperation");
+function convertMethods(methods, _resourcePath, openapiSpec) {
+  var _a, _b;
+  for (const methodData of Object.values(methods)) {
+    const httpMethod = ((_a = methodData.httpMethod) != null ? _a : "GET").toLowerCase();
+    let restPath = ((_b = methodData.path) != null ? _b : "/").replace(
+      /\{\+([^{}]+)\}/g,
+      (_match, paramName) => `{${paramName}}`
+    );
+    if (!restPath.startsWith("/")) {
+      restPath = `/${restPath}`;
+    }
+    const pathParams = extractPathParameters(restPath);
+    if (!openapiSpec.paths[restPath]) {
+      openapiSpec.paths[restPath] = {};
+    }
+    const pathItem = openapiSpec.paths[restPath];
+    pathItem[httpMethod] = convertOperation(methodData, pathParams);
+  }
+}
+__name(convertMethods, "convertMethods");
+function convertResources(resources, openapiSpec, parentPath = "") {
+  var _a;
+  for (const [resourceName, resourceData] of Object.entries(resources)) {
+    const resourcePath = `${parentPath}/${resourceName}`;
+    convertMethods((_a = resourceData.methods) != null ? _a : {}, resourcePath, openapiSpec);
+    if (resourceData.resources && Object.keys(resourceData.resources).length > 0) {
+      convertResources(resourceData.resources, openapiSpec, resourcePath);
+    }
+  }
+}
+__name(convertResources, "convertResources");
+let GoogleApiToOpenApiConverter = class {
+  constructor(apiName, apiVersion) {
+    this.googleApiSpec = null;
+    this.apiName = apiName;
+    this.apiVersion = apiVersion;
+    this.openapiSpec = {
+      openapi: "3.0.0",
+      info: {},
+      servers: [],
+      paths: {},
+      components: { schemas: {}, securitySchemes: {} }
+    };
+  }
+  async fetchGoogleApiSpec() {
+    try {
+      logger.debug(
+        `Fetching Google API spec for ${this.apiName} ${this.apiVersion}`
+      );
+      const url = `${GOOGLE_DISCOVERY_BASE_URL}/${encodeURIComponent(this.apiName)}/${encodeURIComponent(this.apiVersion)}/rest`;
+      const response = await globalThis.fetch(url);
+      if (response.status >= 400) {
+        throw new Error(
+          `HTTP Error ${response.status}: Failed to fetch Google API spec for ${this.apiName} ${this.apiVersion}`
+        );
+      }
+      const spec = await response.json();
+      if (!spec || typeof spec !== "object" || Object.keys(spec).length === 0) {
+        throw new Error("Failed to retrieve API specification");
+      }
+      this.googleApiSpec = spec;
+      logger.debug(`Successfully fetched ${this.apiName} API specification`);
+    } catch (error) {
+      logger.error(
+        `Error fetching API spec: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  async convert() {
+    var _a, _b, _c;
+    if (!this.googleApiSpec) {
+      await this.fetchGoogleApiSpec();
+    }
+    const spec = (_a = this.googleApiSpec) != null ? _a : {};
+    convertInfo(spec, this.openapiSpec, this.apiName, this.apiVersion);
+    convertServers(spec, this.openapiSpec, this.apiName, this.apiVersion);
+    convertSecuritySchemes(spec, this.openapiSpec);
+    convertSchemas(spec, this.openapiSpec);
+    convertResources((_b = spec.resources) != null ? _b : {}, this.openapiSpec);
+    convertMethods((_c = spec.methods) != null ? _c : {}, "/", this.openapiSpec);
+    return this.openapiSpec;
+  }
+  saveOpenapiSpec(outputPath) {
+    fs.writeFileSync(
+      outputPath,
+      JSON.stringify(this.openapiSpec, null, 2),
+      "utf-8"
+    );
+    logger.info(`OpenAPI specification saved to ${outputPath}`);
+  }
+};
+__name(GoogleApiToOpenApiConverter, "GoogleApiToOpenApiConverter");
+__decorateClass([
+  experimental
+], GoogleApiToOpenApiConverter.prototype, "fetchGoogleApiSpec", 1);
+__decorateClass([
+  experimental
+], GoogleApiToOpenApiConverter.prototype, "convert", 1);
+__decorateClass([
+  experimental
+], GoogleApiToOpenApiConverter.prototype, "saveOpenapiSpec", 1);
+GoogleApiToOpenApiConverter = __decorateClass([
+  experimental
+], GoogleApiToOpenApiConverter);
+export {
+  GoogleApiToOpenApiConverter,
+  convertInfo,
+  convertMethods,
+  convertOperation,
+  convertParameterSchema,
+  convertResources,
+  convertSchemaObject,
+  convertSchemas,
+  convertSecuritySchemes,
+  convertServers,
+  extractPathParameters,
+  normalizeGoogleSchemaRef
+};

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

@@ -0,0 +1,33 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GoogleApiTool, isGoogleApiTool } from "./google_api_tool.js";
+import { GoogleApiToolSet, isGoogleApiToolSet } from "./google_api_tool_set.js";
+import {
+  bigqueryToolSet,
+  calendarToolSet,
+  docsToolSet,
+  gmailToolSet,
+  sheetsToolSet,
+  slidesToolSet,
+  youtubeToolSet
+} from "./google_api_tool_sets.js";
+import { GoogleApiToOpenApiConverter } from "./googleapi_to_openapi_converter.js";
+export {
+  GoogleApiToOpenApiConverter,
+  GoogleApiTool,
+  GoogleApiToolSet,
+  bigqueryToolSet,
+  calendarToolSet,
+  docsToolSet,
+  gmailToolSet,
+  isGoogleApiTool,
+  isGoogleApiToolSet,
+  sheetsToolSet,
+  slidesToolSet,
+  youtubeToolSet
+};

package/dist/esm/tools/langchain_tool.js

@@ -0,0 +1,148 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import { toJsonSchema } from "../utils/schema.js";
+import { isZodObject, isZodSchema } from "../utils/simple_zod_to_json.js";
+import { GoogleLLMVariant } from "../utils/variant_utils.js";
+import {
+  buildFunctionDeclarationForLangchain,
+  buildFunctionDeclarationUtil,
+  FunctionTool
+} from "./function_tool.js";
+const LANGCHAIN_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.langchainTool");
+function isLangchainTool(obj) {
+  return typeof obj === "object" && obj !== null && LANGCHAIN_TOOL_SIGNATURE_SYMBOL in obj && obj[LANGCHAIN_TOOL_SIGNATURE_SYMBOL] === true;
+}
+__name(isLangchainTool, "isLangchainTool");
+function isLangchainToolConfig(value) {
+  return typeof value === "object" && value !== null && "tool" in value && typeof value.tool === "object" && value.tool !== null;
+}
+__name(isLangchainToolConfig, "isLangchainToolConfig");
+function resolveRunnerFunction(tool) {
+  if (typeof tool._run === "function") {
+    return tool._run.bind(tool);
+  }
+  if (typeof tool._call === "function") {
+    return tool._call.bind(tool);
+  }
+  if (typeof tool.invoke === "function") {
+    return tool.invoke.bind(tool);
+  }
+  if (typeof tool.run === "function") {
+    return tool.run.bind(tool);
+  }
+  throw new TypeError(
+    "LangchainTool requires a tool object with a _run, _call, invoke, or run method."
+  );
+}
+__name(resolveRunnerFunction, "resolveRunnerFunction");
+function isStructuredLangchainTool(tool) {
+  return typeof tool._run === "function" || typeof tool._call === "function" || typeof tool.invoke === "function" || tool.argsSchema !== void 0 || tool.schema !== void 0 || tool.args !== void 0;
+}
+__name(isStructuredLangchainTool, "isStructuredLangchainTool");
+function extractLangchainPropertiesMap(tool) {
+  var _a2;
+  if (tool.args && typeof tool.args === "object") {
+    return structuredClone(tool.args);
+  }
+  const schemaSource = (_a2 = tool.argsSchema) != null ? _a2 : tool.schema;
+  if (!schemaSource) {
+    return {};
+  }
+  let rawSchema;
+  if (typeof schemaSource.modelJsonSchema === "function") {
+    rawSchema = schemaSource.modelJsonSchema();
+  } else if (typeof schemaSource.jsonSchema === "function") {
+    rawSchema = schemaSource.jsonSchema();
+  } else if (isZodSchema(schemaSource)) {
+    rawSchema = structuredClone(toJsonSchema(schemaSource));
+  } else {
+    rawSchema = structuredClone(schemaSource);
+  }
+  const properties = rawSchema["properties"] && typeof rawSchema["properties"] === "object" ? structuredClone(
+    rawSchema["properties"]
+  ) : structuredClone(rawSchema);
+  const requiredSet = Array.isArray(rawSchema["required"]) ? new Set(rawSchema["required"]) : void 0;
+  for (const [key, prop] of Object.entries(properties)) {
+    if (!prop || typeof prop !== "object") {
+      continue;
+    }
+    if (Array.isArray(prop["type"])) {
+      const types = prop["type"];
+      delete prop["type"];
+      prop["anyOf"] = types.map((t) => ({ type: t }));
+    } else if (requiredSet !== void 0 && !requiredSet.has(key) && !("default" in prop) && !("anyOf" in prop) && typeof prop["type"] === "string") {
+      const propType = prop["type"];
+      delete prop["type"];
+      prop["anyOf"] = [{ type: propType }, { type: "null" }];
+    }
+  }
+  return properties;
+}
+__name(extractLangchainPropertiesMap, "extractLangchainPropertiesMap");
+const _LangchainTool = class _LangchainTool extends (_b = FunctionTool, _a = LANGCHAIN_TOOL_SIGNATURE_SYMBOL, _b) {
+  constructor(toolOrConfig, options) {
+    var _a2, _b2, _c, _d;
+    const config = isLangchainToolConfig(toolOrConfig) ? toolOrConfig : {
+      tool: toolOrConfig,
+      name: options == null ? void 0 : options.name,
+      description: options == null ? void 0 : options.description
+    };
+    const runnerFn = resolveRunnerFunction(config.tool);
+    const rawFn = (_c = (_b2 = (_a2 = config.tool._run) != null ? _a2 : config.tool._call) != null ? _b2 : config.tool.invoke) != null ? _c : config.tool.run;
+    const resolvedName = config.name || config.tool.name || (rawFn == null ? void 0 : rawFn.name) || "langchain_tool";
+    const resolvedDescription = config.description || config.tool.description || "";
+    const schemaCandidate = (_d = config.tool.argsSchema) != null ? _d : config.tool.schema;
+    super({
+      name: resolvedName,
+      description: resolvedDescription,
+      parameters: isZodObject(schemaCandidate) ? schemaCandidate : void 0,
+      execute: /* @__PURE__ */ __name(async (args, toolContext) => {
+        return await runnerFn(
+          args != null ? args : {},
+          toolContext
+        );
+      }, "execute")
+    });
+    /** A unique symbol to identify ADK LangchainTool class. */
+    this[_a] = true;
+    this.tool = config.tool;
+  }
+  /**
+   * Builds the `FunctionDeclaration` for the wrapped LangChain tool.
+   */
+  _getDeclaration() {
+    var _a2, _b2, _c;
+    if (isStructuredLangchainTool(this.tool)) {
+      const propertiesMap = extractLangchainPropertiesMap(this.tool);
+      const rawFn = (_c = (_b2 = (_a2 = this.tool._run) != null ? _a2 : this.tool._call) != null ? _b2 : this.tool.invoke) != null ? _c : this.tool.run;
+      return buildFunctionDeclarationForLangchain(
+        this.apiVariant === GoogleLLMVariant.VERTEX_AI,
+        this.name,
+        this.description,
+        rawFn,
+        propertiesMap
+      );
+    }
+    return buildFunctionDeclarationUtil(
+      this.apiVariant === GoogleLLMVariant.VERTEX_AI,
+      this.name,
+      this.description,
+      this.tool.run,
+      { properties: extractLangchainPropertiesMap(this.tool) }
+    );
+  }
+};
+__name(_LangchainTool, "LangchainTool");
+let LangchainTool = _LangchainTool;
+export {
+  LangchainTool,
+  isLangchainTool
+};

package/dist/esm/tools/mcp/index.js

@@ -5,7 +5,13 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { toGeminiSchema } from "../../utils/gemini_schema_util.js";
+import { genaiSchemaToJsonSchema } from "../../utils/genai_schema_to_json.js";
 export * from "./load_mcp_resource_tool.js";
 export * from "./mcp_session_manager.js";
 export * from "./mcp_tool.js";
 export * from "./mcp_toolset.js";
+export {
+  genaiSchemaToJsonSchema,
+  toGeminiSchema
+};

package/dist/esm/tools/mcp/mcp_session_manager.js

@@ -52,6 +52,18 @@ function buildTransportOptions(params) {
   };
 }
 __name(buildTransportOptions, "buildTransportOptions");
+function buildSseTransportOptions(params) {
+  const { transportOptions, header, headers } = params;
+  const callerHeaders = (transportOptions == null ? void 0 : transportOptions.requestInit) === void 0 ? header != null ? header : headers : transportOptions.requestInit.headers;
+  return {
+    ...transportOptions,
+    requestInit: {
+      ...transportOptions == null ? void 0 : transportOptions.requestInit,
+      headers: mergeTrackingHeaders(callerHeaders)
+    }
+  };
+}
+__name(buildSseTransportOptions, "buildSseTransportOptions");
 const _MCPSessionManager = class _MCPSessionManager {
   constructor(connectionParams) {
     this.activeSessions = /* @__PURE__ */ new Set();
@@ -90,6 +102,19 @@ const _MCPSessionManager = class _MCPSessionManager {
           await client.connect(transport);
           break;
         }
+        case "SseConnectionParams": {
+          const { SSEClientTransport } = await loadOptionalPeer(
+            MCP_SDK,
+            () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/sse.js"), 1))
+          );
+          const transport = new SSEClientTransport(
+            new URL(this.connectionParams.url),
+            buildSseTransportOptions(this.connectionParams)
+          );
+          transport.onerror = logTransportError;
+          await client.connect(transport);
+          break;
+        }
         default: {
           const _exhaustiveCheck = this.connectionParams;
           break;

package/dist/esm/tools/openapi_tool/auth/auth_helpers.js

@@ -131,12 +131,11 @@ function bearerJwtScheme() {
 }
 __name(bearerJwtScheme, "bearerJwtScheme");
 function bearerTokenParam(authScheme, token) {
-  var _a;
   const param = {
     originalName: "Authorization",
     paramLocation: "header",
     paramSchema: { type: "string" },
-    description: (_a = authScheme.description) != null ? _a : "Bearer token",
+    description: authScheme.description || "Bearer token",
     name: `${INTERNAL_AUTH_PREFIX}Authorization`,
     required: true
   };