@google/adk 2.1.0 → 2.2.0

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

@@ -28,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { mergeTrackingHeaders } from "../../utils/client_labels.js";
 import { formatError } from "../../utils/error_utils.js";
 import { logger } from "../../utils/logger.js";
 import { loadOptionalPeer } from "../../utils/optional_peer.js";
@@ -39,13 +40,24 @@ function logTransportError(err) {
   logger.error("MCP transport error: " + formatError(err));
 }
 __name(logTransportError, "logTransportError");
+function buildTransportOptions(params) {
+  const { transportOptions, header } = params;
+  const callerHeaders = (transportOptions == null ? void 0 : transportOptions.requestInit) === void 0 ? header : transportOptions.requestInit.headers;
+  return {
+    ...transportOptions,
+    requestInit: {
+      ...transportOptions == null ? void 0 : transportOptions.requestInit,
+      headers: mergeTrackingHeaders(callerHeaders)
+    }
+  };
+}
+__name(buildTransportOptions, "buildTransportOptions");
 const _MCPSessionManager = class _MCPSessionManager {
   constructor(connectionParams) {
     this.activeSessions = /* @__PURE__ */ new Set();
     this.connectionParams = connectionParams;
   }
   async createSession() {
-    var _a;
     const { Client } = await loadOptionalPeer(
       MCP_SDK,
       () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/index.js"), 1))
@@ -66,19 +78,13 @@ const _MCPSessionManager = class _MCPSessionManager {
           break;
         }
         case "StreamableHTTPConnectionParams": {
-          const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
-          if (!options.requestInit && this.connectionParams.header !== void 0) {
-            options.requestInit = {
-              headers: this.connectionParams.header
-            };
-          }
           const { StreamableHTTPClientTransport } = await loadOptionalPeer(
             MCP_SDK,
             () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/streamableHttp.js"), 1))
           );
           const transport = new StreamableHTTPClientTransport(
             new URL(this.connectionParams.url),
-            options
+            buildTransportOptions(this.connectionParams)
           );
           transport.onerror = logTransportError;
           await client.connect(transport);

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

@@ -7,9 +7,74 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { z } from "zod";
 import {
   AuthCredentialTypes
 } from "../../../auth/auth_credential.js";
+import { camelCaseKeys } from "../../../utils/case_utils.js";
+const INTERNAL_AUTH_PREFIX = "_auth_prefix_vaf_";
+const API_KEY_LOCATIONS = ["header", "query", "cookie"];
+const OPENID_FETCH_TIMEOUT_MS = 1e4;
+const REQUIRED_CREDENTIAL_FIELDS = ["client_id", "client_secret"];
+const scopesSchema = z.record(z.string(), z.string()).default({});
+const OAuthFlowsSchema = z.looseObject({
+  implicit: z.looseObject({
+    authorizationUrl: z.string(),
+    refreshUrl: z.string().optional(),
+    scopes: scopesSchema
+  }).optional(),
+  password: z.looseObject({
+    tokenUrl: z.string(),
+    refreshUrl: z.string().optional(),
+    scopes: scopesSchema
+  }).optional(),
+  clientCredentials: z.looseObject({
+    tokenUrl: z.string(),
+    refreshUrl: z.string().optional(),
+    scopes: scopesSchema
+  }).optional(),
+  authorizationCode: z.looseObject({
+    authorizationUrl: z.string(),
+    tokenUrl: z.string(),
+    refreshUrl: z.string().optional(),
+    scopes: scopesSchema
+  }).optional()
+});
+const ApiKeySchemeSchema = z.looseObject({
+  type: z.literal("apiKey"),
+  description: z.string().optional(),
+  name: z.string(),
+  in: z.enum(API_KEY_LOCATIONS)
+});
+const HttpSchemeSchema = z.looseObject({
+  type: z.literal("http"),
+  description: z.string().optional(),
+  scheme: z.string(),
+  bearerFormat: z.string().optional()
+});
+const Oauth2SchemeSchema = z.looseObject({
+  type: z.literal("oauth2"),
+  description: z.string().optional(),
+  flows: OAuthFlowsSchema
+});
+const OpenIdConnectSchemeSchema = z.looseObject({
+  type: z.literal("openIdConnect"),
+  description: z.string().optional(),
+  openIdConnectUrl: z.string()
+});
+const OpenIdConnectConfigSchema = z.looseObject({
+  type: z.literal("openIdConnect").default("openIdConnect"),
+  description: z.string().optional(),
+  openIdConnectUrl: z.string().default(""),
+  authorizationEndpoint: z.string(),
+  tokenEndpoint: z.string(),
+  userinfoEndpoint: z.string().optional(),
+  revocationEndpoint: z.string().optional(),
+  tokenEndpointAuthMethodsSupported: z.array(z.string()).optional(),
+  grantTypesSupported: z.array(z.string()).optional(),
+  scopes: z.array(z.string()).optional()
+});
+const JsonObjectSchema = z.record(z.string(), z.unknown());
 function applyCredential(url, headers, credential, authScheme) {
   var _a;
   if (!credential) return url;
@@ -57,8 +122,214 @@ function createBearerScheme() {
   };
 }
 __name(createBearerScheme, "createBearerScheme");
+function isApiKeyLocation(value) {
+  return API_KEY_LOCATIONS.some((location) => location === value);
+}
+__name(isApiKeyLocation, "isApiKeyLocation");
+function bearerJwtScheme() {
+  return { type: "http", scheme: "bearer", bearerFormat: "JWT" };
+}
+__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",
+    name: `${INTERNAL_AUTH_PREFIX}Authorization`,
+    required: true
+  };
+  return [param, { [param.name]: `Bearer ${token}` }];
+}
+__name(bearerTokenParam, "bearerTokenParam");
+function tokenToSchemeCredential(tokenType, location, name, credentialValue) {
+  if (tokenType === "apikey") {
+    if (!isApiKeyLocation(location)) {
+      throw new Error(`Invalid location for apiKey: ${location}`);
+    }
+    const authScheme = {
+      type: "apiKey",
+      in: location,
+      name: name != null ? name : ""
+    };
+    const authCredential = credentialValue ? { authType: AuthCredentialTypes.API_KEY, apiKey: credentialValue } : void 0;
+    return [authScheme, authCredential];
+  }
+  if (tokenType === "oauth2Token") {
+    const authCredential = credentialValue ? {
+      authType: AuthCredentialTypes.HTTP,
+      http: { scheme: "bearer", credentials: { token: credentialValue } }
+    } : void 0;
+    return [bearerJwtScheme(), authCredential];
+  }
+  throw new Error(`Invalid security scheme type: ${tokenType}`);
+}
+__name(tokenToSchemeCredential, "tokenToSchemeCredential");
+function serviceAccountDictToSchemeCredential(config, scopes) {
+  const authCredential = {
+    authType: AuthCredentialTypes.SERVICE_ACCOUNT,
+    serviceAccount: {
+      // The reference calls `ServiceAccountCredential.model_construct`, which
+      // skips validation on purpose, so the port does not validate either.
+      serviceAccountCredential: camelCaseKeys(
+        config
+      ),
+      scopes
+    }
+  };
+  return [bearerJwtScheme(), authCredential];
+}
+__name(serviceAccountDictToSchemeCredential, "serviceAccountDictToSchemeCredential");
+function serviceAccountSchemeCredential(config) {
+  const authCredential = {
+    authType: AuthCredentialTypes.SERVICE_ACCOUNT,
+    serviceAccount: config
+  };
+  return [bearerJwtScheme(), authCredential];
+}
+__name(serviceAccountSchemeCredential, "serviceAccountSchemeCredential");
+function openidDictToSchemeCredential(configDict, scopes, credentialDict) {
+  const parsedConfig = OpenIdConnectConfigSchema.safeParse(
+    camelCaseKeys(configDict)
+  );
+  if (!parsedConfig.success) {
+    throw new Error(
+      `Invalid OpenID Connect configuration: ${z.prettifyError(parsedConfig.error)}`
+    );
+  }
+  const openidScheme = { ...parsedConfig.data, scopes };
+  const values = Object.values(credentialDict);
+  if (values.length === 1) {
+    const wrapped = JsonObjectSchema.safeParse(values[0]);
+    if (wrapped.success && "client_id" in wrapped.data && "client_secret" in wrapped.data) {
+      credentialDict = wrapped.data;
+    }
+  }
+  const missingFields = REQUIRED_CREDENTIAL_FIELDS.filter(
+    (field) => !(field in credentialDict)
+  );
+  if (missingFields.length > 0) {
+    throw new Error(
+      `Missing required fields in credential_dict: ${missingFields.join(", ")}`
+    );
+  }
+  const authCredential = {
+    authType: AuthCredentialTypes.OPEN_ID_CONNECT,
+    oauth2: {
+      clientId: String(credentialDict["client_id"]),
+      clientSecret: String(credentialDict["client_secret"]),
+      redirectUri: "redirect_uri" in credentialDict ? String(credentialDict["redirect_uri"]) : void 0
+    }
+  };
+  return [openidScheme, authCredential];
+}
+__name(openidDictToSchemeCredential, "openidDictToSchemeCredential");
+async function openidUrlToSchemeCredential(openidUrl, scopes, credentialDict) {
+  let response;
+  try {
+    response = await fetch(openidUrl, {
+      signal: AbortSignal.timeout(OPENID_FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      throw new Error(`responded with status ${response.status}`);
+    }
+  } catch (e) {
+    throw new Error(
+      `Failed to fetch OpenID configuration from ${openidUrl}: ${String(e)}`
+    );
+  }
+  let configDict;
+  try {
+    configDict = JsonObjectSchema.parse(await response.json());
+  } catch (e) {
+    throw new Error(
+      `Invalid JSON response from OpenID configuration endpoint ${openidUrl}: ${String(e)}`
+    );
+  }
+  return openidDictToSchemeCredential(
+    { ...configDict, openIdConnectUrl: openidUrl },
+    scopes,
+    credentialDict
+  );
+}
+__name(openidUrlToSchemeCredential, "openidUrlToSchemeCredential");
+function credentialToParam(authScheme, authCredential) {
+  var _a, _b, _c, _d;
+  if (!authCredential) {
+    return [void 0, void 0];
+  }
+  if (authScheme.type === "apiKey" && authCredential.apiKey) {
+    if (!isApiKeyLocation(authScheme.in)) {
+      throw new Error(`Invalid API Key location: ${authScheme.in}`);
+    }
+    const paramName = authScheme.name || "";
+    const param = {
+      originalName: paramName,
+      paramLocation: authScheme.in,
+      paramSchema: { type: "string" },
+      description: (_a = authScheme.description) != null ? _a : "",
+      name: INTERNAL_AUTH_PREFIX + paramName,
+      required: true
+    };
+    return [param, { [param.name]: authCredential.apiKey }];
+  }
+  if (authCredential.authType === AuthCredentialTypes.HTTP) {
+    const credentials = (_b = authCredential.http) == null ? void 0 : _b.credentials;
+    if (credentials == null ? void 0 : credentials.token) {
+      return bearerTokenParam(authScheme, credentials.token);
+    }
+    if ((credentials == null ? void 0 : credentials.username) || (credentials == null ? void 0 : credentials.password)) {
+      throw new Error("Basic Authentication is not supported.");
+    }
+    throw new Error("Invalid HTTP auth credentials");
+  }
+  if (authScheme.type === "oauth2" || authScheme.type === "openIdConnect") {
+    const token = (_d = (_c = authCredential.http) == null ? void 0 : _c.credentials) == null ? void 0 : _d.token;
+    return token ? bearerTokenParam(authScheme, token) : [void 0, void 0];
+  }
+  throw new Error("Invalid security scheme and credential combination");
+}
+__name(credentialToParam, "credentialToParam");
+function parseSecurityScheme(schema, data) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      `Invalid security scheme data: ${z.prettifyError(result.error)}`
+    );
+  }
+  return result.data;
+}
+__name(parseSecurityScheme, "parseSecurityScheme");
+function dictToAuthScheme(data) {
+  if (!("type" in data)) {
+    throw new Error("Missing 'type' field in security scheme dictionary.");
+  }
+  const securityType = data["type"];
+  switch (securityType) {
+    case "apiKey":
+      return parseSecurityScheme(ApiKeySchemeSchema, data);
+    case "http":
+      return parseSecurityScheme(HttpSchemeSchema, data);
+    case "oauth2":
+      return parseSecurityScheme(Oauth2SchemeSchema, data);
+    case "openIdConnect":
+      return parseSecurityScheme(OpenIdConnectSchemeSchema, data);
+    default:
+      throw new Error(`Invalid security scheme type: ${securityType}`);
+  }
+}
+__name(dictToAuthScheme, "dictToAuthScheme");
 export {
+  INTERNAL_AUTH_PREFIX,
   applyCredential,
   createApiKeyScheme,
-  createBearerScheme
+  createBearerScheme,
+  credentialToParam,
+  dictToAuthScheme,
+  openidDictToSchemeCredential,
+  openidUrlToSchemeCredential,
+  serviceAccountDictToSchemeCredential,
+  serviceAccountSchemeCredential,
+  tokenToSchemeCredential
 };

package/dist/esm/tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.js

@@ -23,7 +23,12 @@ import { OAuth2CredentialExchanger } from "../../../../auth/oauth2/oauth2_creden
 import { experimental } from "../../../../utils/experimental.js";
 import { ServiceAccountCredentialExchanger } from "./service_account_exchanger.js";
 let AutoAuthCredentialExchanger = class {
-  constructor() {
+  /**
+   * @param customExchangers - Optional exchangers that add to or override the
+   *   built-in ones. The key is the auth credential type; the value is the
+   *   exchanger instance to use for that type.
+   */
+  constructor(customExchangers) {
     this.exchangers = /* @__PURE__ */ new Map();
     this.exchangers.set(
       AuthCredentialTypes.OAUTH2,
@@ -37,9 +42,18 @@ let AutoAuthCredentialExchanger = class {
       AuthCredentialTypes.SERVICE_ACCOUNT,
       new ServiceAccountCredentialExchanger()
     );
+    for (const authType of Object.values(AuthCredentialTypes)) {
+      const customExchanger = customExchangers == null ? void 0 : customExchangers[authType];
+      if (customExchanger) {
+        this.exchangers.set(authType, customExchanger);
+      }
+    }
   }
   async exchange(params) {
     const { authCredential, authScheme } = params;
+    if (!authCredential) {
+      return null;
+    }
     const exchanger = this.exchangers.get(authCredential.authType);
     if (!exchanger) {
       return {

package/dist/esm/tools/openapi_tool/auth/credential_exchangers/base_auth_credential_exchanger.js

@@ -0,0 +1,43 @@
+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";
+const _AuthCredentialMissingError = class _AuthCredentialMissingError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthCredentialMissingError";
+  }
+};
+__name(_AuthCredentialMissingError, "AuthCredentialMissingError");
+let AuthCredentialMissingError = _AuthCredentialMissingError;
+let BaseAuthCredentialExchanger = class {
+  exchangeCredential(_authScheme, _authCredential) {
+    throw new Error("Subclasses must implement exchangeCredential.");
+  }
+};
+__name(BaseAuthCredentialExchanger, "BaseAuthCredentialExchanger");
+__decorateClass([
+  experimental
+], BaseAuthCredentialExchanger.prototype, "exchangeCredential", 1);
+BaseAuthCredentialExchanger = __decorateClass([
+  experimental
+], BaseAuthCredentialExchanger);
+export {
+  AuthCredentialMissingError,
+  BaseAuthCredentialExchanger
+};

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

@@ -0,0 +1,93 @@
+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 {
+  AuthCredentialTypes
+} from "../../../../auth/auth_credential.js";
+import { experimental } from "../../../../utils/experimental.js";
+function checkSchemeCredentialType(authScheme, authCredential) {
+  if (!authCredential) {
+    throw new Error(
+      "auth_credential is empty. Please create AuthCredential using OAuth2Auth."
+    );
+  }
+  if (authScheme.type !== "openIdConnect" && authScheme.type !== "oauth2") {
+    throw new Error(
+      `Invalid security scheme, expect AuthSchemeType.openIdConnect or AuthSchemeType.oauth2 auth scheme, but got ${authScheme.type}`
+    );
+  }
+  if (!authCredential.oauth2 && !authCredential.http) {
+    throw new Error(
+      "auth_credential is not configured with oauth2. Please create AuthCredential and set OAuth2Auth."
+    );
+  }
+}
+__name(checkSchemeCredentialType, "checkSchemeCredentialType");
+function generateAuthToken(authCredential) {
+  var _a;
+  const accessToken = (_a = authCredential.oauth2) == null ? void 0 : _a.accessToken;
+  if (!accessToken) {
+    return authCredential;
+  }
+  return {
+    authType: AuthCredentialTypes.HTTP,
+    http: {
+      scheme: "bearer",
+      credentials: { token: accessToken }
+    }
+  };
+}
+__name(generateAuthToken, "generateAuthToken");
+function exchangeCredential(authScheme, authCredential) {
+  var _a, _b;
+  checkSchemeCredentialType(authScheme, authCredential);
+  if (authCredential.http) {
+    return authCredential;
+  }
+  if (((_a = authCredential.oauth2) == null ? void 0 : _a.accessToken) || ((_b = authCredential.oauth2) == null ? void 0 : _b.refreshToken)) {
+    return generateAuthToken(authCredential);
+  }
+  return null;
+}
+__name(exchangeCredential, "exchangeCredential");
+let OAuth2BearerExchanger = class {
+  async exchange(params) {
+    const { authScheme, authCredential } = params;
+    if (!authScheme) {
+      throw new Error("authScheme is required for OAuth2 credential exchange");
+    }
+    const credential = exchangeCredential(authScheme, authCredential);
+    return {
+      credential: credential != null ? credential : authCredential,
+      wasExchanged: credential !== null && credential !== authCredential
+    };
+  }
+};
+__name(OAuth2BearerExchanger, "OAuth2BearerExchanger");
+__decorateClass([
+  experimental
+], OAuth2BearerExchanger.prototype, "exchange", 1);
+OAuth2BearerExchanger = __decorateClass([
+  experimental
+], OAuth2BearerExchanger);
+export {
+  OAuth2BearerExchanger,
+  checkSchemeCredentialType,
+  exchangeCredential,
+  generateAuthToken
+};

package/dist/esm/tools/openapi_tool/auth/credential_exchangers/service_account_exchanger.js

@@ -20,18 +20,15 @@ import { GoogleAuth, JWT } from "google-auth-library";
 import {
   AuthCredentialTypes
 } from "../../../../auth/auth_credential.js";
-import {
-  CredentialExchangeError
-} from "../../../../auth/exchanger/base_credential_exchanger.js";
 import { experimental } from "../../../../utils/experimental.js";
+import { AuthCredentialMissingError } from "./base_auth_credential_exchanger.js";
 const DEFAULT_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"];
+const MISSING_SERVICE_ACCOUNT_CREDENTIALS = "Service account credentials are missing. Please provide them, or set `useDefaultCredential: true` to use application default credentials in a hosted service like Cloud Run.";
 let ServiceAccountCredentialExchanger = class {
   async exchange(params) {
     const { authCredential } = params;
-    if (authCredential.authType !== AuthCredentialTypes.SERVICE_ACCOUNT || !authCredential.serviceAccount) {
-      throw new CredentialExchangeError(
-        "Invalid credential type for ServiceAccountCredentialExchanger"
-      );
+    if (!authCredential.serviceAccount) {
+      throw new AuthCredentialMissingError(MISSING_SERVICE_ACCOUNT_CREDENTIALS);
     }
     const saConfig = authCredential.serviceAccount;
     if (saConfig.useDefaultCredential) {
@@ -61,7 +58,7 @@ let ServiceAccountCredentialExchanger = class {
         wasExchanged: true
       };
     } catch (error) {
-      throw new CredentialExchangeError(
+      throw new AuthCredentialMissingError(
         `Failed to exchange default service account token: ${error.message}`
       );
     }
@@ -69,14 +66,15 @@ let ServiceAccountCredentialExchanger = class {
   async exchangeForExplicitCredential(saConfig) {
     const creds = saConfig.serviceAccountCredential;
     if (!creds) {
-      throw new CredentialExchangeError(
-        "Service account credentials are missing."
-      );
+      throw new AuthCredentialMissingError(MISSING_SERVICE_ACCOUNT_CREDENTIALS);
     }
     try {
       const client = new JWT({
         email: creds.clientEmail,
         key: creds.privateKey,
+        keyId: creds.privateKeyId,
+        projectId: creds.projectId,
+        universeDomain: creds.universeDomain,
         scopes: saConfig.scopes
       });
       const tokens = await client.authorize();
@@ -95,7 +93,7 @@ let ServiceAccountCredentialExchanger = class {
         wasExchanged: true
       };
     } catch (error) {
-      throw new CredentialExchangeError(
+      throw new AuthCredentialMissingError(
         `Failed to exchange explicit service account token: ${error.message}`
       );
     }

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

@@ -0,0 +1,112 @@
+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
+ */
+import {
+  renameReservedKeywords,
+  toSnakeCaseName
+} from "../../../utils/case_utils.js";
+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 || renameReservedKeywords(toSnakeCaseName(init.originalName)),
+    required: (_a = init.required) != null ? _a : false
+  };
+}
+__name(createApiParameter, "createApiParameter");
+export {
+  createApiParameter,
+  generateParamDoc,
+  generateReturnDoc,
+  getTypeHint
+};