@executor-js/plugin-openapi 1.4.33 → 1.5.1

package/dist/chunk-OSIFYIQP.js

@@ -0,0 +1,623 @@
+import {
+  OpenApiParseError
+} from "./chunk-YVRI7KRC.js";
+
+// src/sdk/google-discovery.ts
+import { Effect, Option, Predicate, Schema, SchemaGetter } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+
+// src/sdk/google-oauth-scopes.ts
+var googleUserConsentBlockedScopes = /* @__PURE__ */ new Set([
+  "https://www.googleapis.com/auth/chat.bot",
+  "https://www.googleapis.com/auth/chat.import",
+  "https://www.googleapis.com/auth/keep",
+  "https://www.googleapis.com/auth/keep.readonly"
+]);
+var googleUserConsentBlockedScopePrefixes = ["https://www.googleapis.com/auth/chat.app."];
+var googleBroadScopeGroups = [
+  {
+    broad: "https://mail.google.com/",
+    prefixes: ["https://www.googleapis.com/auth/gmail."]
+  },
+  {
+    broad: "https://www.googleapis.com/auth/calendar",
+    prefixes: ["https://www.googleapis.com/auth/calendar."]
+  },
+  {
+    broad: "https://www.googleapis.com/auth/drive",
+    prefixes: ["https://www.googleapis.com/auth/drive."]
+  }
+];
+var normalizeGoogleIdentityScope = (scope) => scope === "https://www.googleapis.com/auth/userinfo.email" ? "email" : scope === "https://www.googleapis.com/auth/userinfo.profile" ? "profile" : scope;
+var orderedUniqueScopes = (scopes) => {
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const scope of scopes) {
+    const trimmed = scope.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    ordered.push(trimmed);
+  }
+  return ordered;
+};
+var isGoogleUserConsentOAuthScope = (scope) => !googleUserConsentBlockedScopes.has(scope) && !googleUserConsentBlockedScopePrefixes.some((prefix) => scope.startsWith(prefix));
+var filterGoogleUserConsentOAuthScopes = (scopes) => orderedUniqueScopes(scopes).filter(isGoogleUserConsentOAuthScope);
+var compactGoogleOAuthScopes = (scopes) => {
+  const ordered = filterGoogleUserConsentOAuthScopes([...scopes].map(normalizeGoogleIdentityScope));
+  const present = new Set(ordered);
+  return ordered.filter(
+    (scope) => !googleBroadScopeGroups.some(
+      (group) => scope !== group.broad && present.has(group.broad) && group.prefixes.some((prefix) => scope.startsWith(prefix))
+    )
+  );
+};
+
+// src/sdk/google-discovery.ts
+import { AuthTemplateSlug } from "@executor-js/sdk/shared";
+var DISCOVERY_SERVICE_HOST = "https://www.googleapis.com/discovery/v1/apis";
+var GOOGLE_BUNDLE_BASE_URL = "https://www.googleapis.com/";
+var GOOGLE_OAUTH_AUTHORIZATION_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var GOOGLE_OAUTH_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var OPENAPI_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  "array",
+  "boolean",
+  "integer",
+  "null",
+  "number",
+  "object",
+  "string"
+]);
+var TextOption = Schema.OptionFromOptional(Schema.Trim).pipe(
+  Schema.decode({
+    decode: SchemaGetter.transform((value) => Option.filter(value, (text) => text.length > 0)),
+    encode: SchemaGetter.transform((value) => value)
+  }),
+  Schema.withDecodingDefaultType(Effect.succeed(Option.none()))
+);
+var TextArray = Schema.optional(Schema.Array(Schema.String)).pipe(
+  Schema.withDecodingDefaultType(Effect.succeed([]))
+);
+var UnknownRecord = Schema.Record(Schema.String, Schema.Unknown);
+var UnknownRecordWithDefault = Schema.optional(UnknownRecord).pipe(
+  Schema.withDecodingDefaultType(Effect.succeed({}))
+);
+var DiscoveryParameter = Schema.Struct({
+  type: Schema.optional(Schema.String),
+  description: TextOption,
+  properties: UnknownRecordWithDefault,
+  items: Schema.optional(Schema.Unknown),
+  additionalProperties: Schema.optional(Schema.Union([Schema.Boolean, Schema.Unknown])),
+  enum: TextArray,
+  format: Schema.optional(Schema.String),
+  readOnly: Schema.optional(Schema.Boolean),
+  default: Schema.optional(Schema.Union([Schema.String, Schema.Number, Schema.Boolean])),
+  $ref: Schema.optional(Schema.String),
+  location: Schema.optional(Schema.Literals(["path", "query", "header"])),
+  required: Schema.optional(Schema.Boolean),
+  repeated: Schema.optional(Schema.Boolean)
+});
+var DiscoveryRef = Schema.Struct({
+  $ref: Schema.optional(Schema.String)
+});
+var DiscoveryMethod = Schema.Struct({
+  id: TextOption,
+  description: TextOption,
+  httpMethod: Schema.optional(Schema.String),
+  path: TextOption,
+  parameters: UnknownRecordWithDefault,
+  request: Schema.optional(DiscoveryRef),
+  response: Schema.optional(DiscoveryRef),
+  scopes: TextArray
+});
+var DiscoveryResource = Schema.Struct({
+  methods: UnknownRecordWithDefault,
+  resources: UnknownRecordWithDefault
+});
+var DiscoveryDocument = Schema.Struct({
+  name: TextOption,
+  version: TextOption,
+  title: TextOption,
+  rootUrl: TextOption,
+  servicePath: Schema.optional(Schema.Trim).pipe(
+    Schema.withDecodingDefaultType(Effect.succeed(""))
+  ),
+  parameters: UnknownRecordWithDefault,
+  methods: UnknownRecordWithDefault,
+  resources: UnknownRecordWithDefault,
+  schemas: UnknownRecordWithDefault,
+  auth: Schema.optional(
+    Schema.Struct({
+      oauth2: Schema.optional(
+        Schema.Struct({
+          scopes: Schema.optional(
+            Schema.Record(
+              Schema.String,
+              Schema.Struct({
+                description: TextOption
+              })
+            )
+          ).pipe(Schema.withDecodingDefaultType(Effect.succeed({})))
+        })
+      )
+    })
+  )
+});
+var decodeDiscoveryDocument = Schema.decodeUnknownSync(DiscoveryDocument);
+var decodeDiscoveryParameter = Schema.decodeUnknownSync(DiscoveryParameter);
+var decodeDiscoveryMethod = Schema.decodeUnknownSync(DiscoveryMethod);
+var decodeDiscoveryResource = Schema.decodeUnknownSync(DiscoveryResource);
+var parseJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+var normalizeDiscoveryUrl = (discoveryUrl) => {
+  const trimmed = discoveryUrl.trim();
+  if (!URL.canParse(trimmed)) return trimmed;
+  const parsed = new URL(trimmed);
+  if (parsed.pathname !== "/$discovery/rest") return trimmed;
+  const version = parsed.searchParams.get("version")?.trim();
+  if (!version) return trimmed;
+  const host = parsed.hostname.toLowerCase();
+  if (!host.endsWith(".googleapis.com")) return trimmed;
+  const rawService = host.slice(0, -".googleapis.com".length);
+  const service = rawService === "calendar-json" ? "calendar" : rawService.endsWith("-json") ? rawService.slice(0, -5) : rawService;
+  return service ? `${DISCOVERY_SERVICE_HOST}/${service}/${version}/rest` : trimmed;
+};
+var isGoogleDiscoveryUrl = (url) => {
+  const trimmed = url.trim();
+  if (!URL.canParse(trimmed)) return false;
+  const parsed = new URL(trimmed);
+  const host = parsed.hostname.toLowerCase();
+  if (!host.endsWith("googleapis.com")) return false;
+  return parsed.pathname.includes("/discovery/") || parsed.pathname.includes("$discovery");
+};
+var fetchGoogleDiscoveryDocument = Effect.fn("OpenApi.fetchGoogleDiscoveryDocument")(
+  function* (discoveryUrl, credentials) {
+    const client = yield* HttpClient.HttpClient;
+    const requestUrl = new URL(discoveryUrl);
+    for (const [name, value] of Object.entries(credentials?.queryParams ?? {})) {
+      requestUrl.searchParams.set(name, value);
+    }
+    let request = HttpClientRequest.get(requestUrl.toString()).pipe(
+      HttpClientRequest.setHeader("Accept", "application/json, */*")
+    );
+    for (const [name, value] of Object.entries(credentials?.headers ?? {})) {
+      request = HttpClientRequest.setHeader(request, name, value);
+    }
+    const response = yield* client.execute(request).pipe(
+      Effect.mapError(
+        () => new OpenApiParseError({
+          message: "Failed to fetch Google Discovery document"
+        })
+      )
+    );
+    if (response.status < 200 || response.status >= 300) {
+      return yield* new OpenApiParseError({
+        message: `Failed to fetch Google Discovery document: HTTP ${response.status}`
+      });
+    }
+    return yield* response.text.pipe(
+      Effect.mapError(
+        () => new OpenApiParseError({
+          message: "Failed to read Google Discovery document body"
+        })
+      )
+    );
+  }
+);
+var schemaRef = (name) => `#/components/schemas/${name}`;
+var identitySchemaName = (name) => name;
+var schemaComponentPart = (value) => value.trim().replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "schema";
+var normalizeDiscoveryPathTemplate = (pathTemplate) => pathTemplate.replaceAll(/\{\+([^{}]+)\}/g, "{$1}");
+var pathUsesReservedExpansion = (pathTemplate, parameterName) => pathTemplate.includes(`{+${parameterName}}`);
+var uniquePathKey = (paths, preferredPath, method, toolPath) => {
+  if (!paths[preferredPath]?.[method]) return preferredPath;
+  const disambiguated = `/${toolPath.replace(/[^A-Za-z0-9._~-]+/g, "/")}`;
+  if (!paths[disambiguated]?.[method]) return disambiguated;
+  let index = 2;
+  while (paths[`${disambiguated}/${index}`]?.[method]) index += 1;
+  return `${disambiguated}/${index}`;
+};
+var discoveryDescription = (value) => typeof value === "string" ? value : Option.isOption(value) && Option.isSome(value) ? typeof value.value === "string" ? value.value : void 0 : void 0;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var jsonValue = (value) => {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const values = value.map(jsonValue);
+    return values.every(Predicate.isNotUndefined) ? values : void 0;
+  }
+  if (!isRecord(value)) return void 0;
+  const entries = Object.entries(value).flatMap(([key, item]) => {
+    const converted = jsonValue(item);
+    return converted === void 0 ? [] : [[key, converted]];
+  });
+  return Object.fromEntries(entries);
+};
+var stringArray = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const strings = value.filter((item) => typeof item === "string");
+  return strings.length === value.length ? strings : void 0;
+};
+var schemaType = (value) => typeof value === "string" && OPENAPI_SCHEMA_TYPES.has(value) ? value : void 0;
+var discoverySchemaToOpenApiSchema = (raw, schemaNameForRef = identitySchemaName) => {
+  if (!isRecord(raw)) return {};
+  const schema = raw;
+  if (typeof schema.$ref === "string") return { $ref: schemaRef(schemaNameForRef(schema.$ref)) };
+  const description = discoveryDescription(schema.description);
+  const title = discoveryDescription(schema.title);
+  const defaultValue = jsonValue(schema.default);
+  const enumValues = Array.isArray(schema.enum) ? schema.enum.map(jsonValue).filter(Predicate.isNotUndefined) : [];
+  const format = typeof schema.format === "string" ? schema.format : void 0;
+  const readOnly = typeof schema.readOnly === "boolean" ? schema.readOnly : void 0;
+  const type = schemaType(schema.type);
+  const base = {
+    ...description !== void 0 ? { description } : {},
+    ...title !== void 0 ? { title } : {},
+    ...format !== void 0 ? { format } : {},
+    ...readOnly !== void 0 ? { readOnly } : {},
+    ...defaultValue !== void 0 ? { default: defaultValue } : {},
+    ...enumValues.length > 0 ? { enum: enumValues } : {}
+  };
+  if (type === "array") {
+    return {
+      ...base,
+      type: "array",
+      items: discoverySchemaToOpenApiSchema(schema.items, schemaNameForRef)
+    };
+  }
+  const properties = schema.properties;
+  if (type === "object" || isRecord(properties) && Object.keys(properties).length > 0 || schema.additionalProperties !== void 0) {
+    const convertedProperties = isRecord(properties) ? Object.fromEntries(
+      Object.entries(properties).map(([name, value]) => [
+        name,
+        discoverySchemaToOpenApiSchema(value, schemaNameForRef)
+      ])
+    ) : void 0;
+    const required = stringArray(schema.required);
+    const additionalProperties = schema.additionalProperties === void 0 ? void 0 : typeof schema.additionalProperties === "boolean" ? schema.additionalProperties : discoverySchemaToOpenApiSchema(schema.additionalProperties, schemaNameForRef);
+    return {
+      ...base,
+      type: "object",
+      ...convertedProperties && Object.keys(convertedProperties).length > 0 ? { properties: convertedProperties } : {},
+      ...required && required.length > 0 ? { required } : {},
+      ...additionalProperties !== void 0 ? { additionalProperties } : {}
+    };
+  }
+  return type !== void 0 ? { ...base, type } : base;
+};
+var parameterSchema = (parameter, schemaNameForRef = identitySchemaName) => {
+  const base = discoverySchemaToOpenApiSchema(parameter, schemaNameForRef);
+  return parameter.repeated ? {
+    type: "array",
+    items: base
+  } : base;
+};
+var methodToolPath = (service, methodId) => methodId.startsWith(`${service}.`) ? methodId.slice(service.length + 1) : methodId;
+var collectMethods = (resource) => {
+  const decoded = decodeDiscoveryResource(resource);
+  const direct = Object.values(decoded.methods ?? {}).map((raw) => decodeDiscoveryMethod(raw));
+  const nested = Object.values(decoded.resources ?? {}).flatMap(collectMethods);
+  return [...direct, ...nested];
+};
+var discoveryScopes = (document) => Object.fromEntries(
+  Object.entries(document.auth?.oauth2?.scopes ?? {}).map(([scope, value]) => [
+    scope,
+    Option.getOrElse(value.description, () => "")
+  ])
+);
+var compactDiscoveryScopeMap = (raw) => {
+  const descriptionFor = (scope) => {
+    if (raw[scope] !== void 0) return raw[scope];
+    if (scope === "email") return raw["https://www.googleapis.com/auth/userinfo.email"] ?? "";
+    if (scope === "profile") return raw["https://www.googleapis.com/auth/userinfo.profile"] ?? "";
+    return "";
+  };
+  return Object.fromEntries(
+    compactGoogleOAuthScopes(Object.keys(raw)).map((scope) => [scope, descriptionFor(scope)])
+  );
+};
+var allDiscoveryMethods = (document) => [
+  ...Object.values(document.methods ?? {}).map((raw) => decodeDiscoveryMethod(raw)),
+  ...Object.values(document.resources ?? {}).flatMap(collectMethods)
+];
+var discoveryDocumentInfo = (document, discoveryUrl) => Effect.gen(function* () {
+  const service = Option.getOrUndefined(document.name);
+  const version = Option.getOrUndefined(document.version);
+  const rootUrl = Option.getOrUndefined(document.rootUrl);
+  if (!service || !version || !rootUrl) {
+    return yield* new OpenApiParseError({
+      message: "Google Discovery document is missing one of: name, version, rootUrl"
+    });
+  }
+  return {
+    discoveryUrl,
+    document,
+    service,
+    version,
+    rootUrl,
+    baseUrl: new URL(document.servicePath || "", rootUrl).toString(),
+    title: Option.getOrElse(document.title, () => `${service} ${version}`)
+  };
+});
+var buildDiscoveryOperation = (input) => {
+  const mergedParameters = /* @__PURE__ */ new Map();
+  for (const [name, raw] of Object.entries(input.document.parameters ?? {})) {
+    const parameter = decodeDiscoveryParameter(raw);
+    if (parameter.location) mergedParameters.set(name, parameter);
+  }
+  for (const [name, raw] of Object.entries(input.method.parameters ?? {})) {
+    const parameter = decodeDiscoveryParameter(raw);
+    if (parameter.location) mergedParameters.set(name, parameter);
+  }
+  const methodScopes = input.method.scopes ?? [];
+  const methodDescription = Option.getOrUndefined(input.method.description);
+  const schemaNameForRef = input.schemaNameForRef ?? identitySchemaName;
+  return {
+    operationId: input.toolPath,
+    "x-executor-toolPath": input.toolPath,
+    "x-executor-pathTemplate": input.pathTemplate,
+    ...input.tags && input.tags.length > 0 ? { tags: input.tags } : {},
+    ...methodDescription !== void 0 ? { description: methodDescription } : {},
+    ...input.serverUrl ? { servers: [{ url: input.serverUrl }] } : {},
+    parameters: [...mergedParameters.entries()].flatMap(([name, parameter]) => {
+      const location = parameter.location;
+      if (!location) return [];
+      const description = Option.getOrUndefined(parameter.description);
+      const allowReserved = location === "path" && pathUsesReservedExpansion(input.pathTemplate, name);
+      return [
+        {
+          name,
+          in: location,
+          required: location === "path" ? true : parameter.required === true,
+          ...description !== void 0 ? { description } : {},
+          schema: parameterSchema(parameter, schemaNameForRef),
+          ...location === "query" ? { style: "form", explode: parameter.repeated === true } : {},
+          ...allowReserved ? { allowReserved: true } : {}
+        }
+      ];
+    }),
+    ...input.method.request?.$ref ? {
+      requestBody: {
+        required: false,
+        content: {
+          "application/json": {
+            schema: { $ref: schemaRef(schemaNameForRef(input.method.request.$ref)) }
+          }
+        }
+      }
+    } : {},
+    responses: {
+      "200": {
+        description: "Successful response",
+        content: {
+          "application/json": {
+            schema: input.method.response?.$ref ? { $ref: schemaRef(schemaNameForRef(input.method.response.$ref)) } : {}
+          }
+        }
+      }
+    },
+    ...methodScopes.length > 0 ? { security: [{ googleOAuth2: methodScopes }] } : {},
+    "x-google-scopes": methodScopes
+  };
+};
+var GOOGLE_OAUTH_SECURITY_SCHEME = "googleOAuth2";
+var googleOauthTemplate = (scopes) => (
+  // A Google-discovery integration is ALWAYS OAuth, so it ALWAYS declares its
+  // oauth method — even when the compacted scope set is empty (e.g. a bundle of
+  // only limited-consent APIs like Google Keep, whose scopes Google won't grant
+  // through standard consent). Without this the integration declares no auth
+  // method and the "Add account" / "Add a connection" actions are disabled, so
+  // you can't even start the flow. Empty `scopes` just requests no scope.
+  [
+    {
+      slug: AuthTemplateSlug.make(GOOGLE_OAUTH_SECURITY_SCHEME),
+      type: "oauth",
+      authorizationUrl: GOOGLE_OAUTH_AUTHORIZATION_URL,
+      tokenUrl: GOOGLE_OAUTH_TOKEN_URL,
+      scopes: Object.keys(scopes)
+    }
+  ]
+);
+var convertGoogleDiscoveryToOpenApi = Effect.fn("OpenApi.convertGoogleDiscovery")(
+  function* (input) {
+    const parsed = yield* parseJson(input.documentText).pipe(
+      Effect.mapError(
+        () => new OpenApiParseError({
+          message: "Failed to parse Google Discovery document"
+        })
+      )
+    );
+    const document = yield* Effect.try({
+      try: () => decodeDiscoveryDocument(parsed),
+      catch: () => new OpenApiParseError({
+        message: "Failed to decode Google Discovery document"
+      })
+    });
+    const info = yield* discoveryDocumentInfo(document, input.discoveryUrl);
+    const { service, version, baseUrl, title } = info;
+    const paths = {};
+    for (const method of allDiscoveryMethods(document)) {
+      const methodId = Option.getOrUndefined(method.id);
+      const pathTemplate = Option.getOrUndefined(method.path);
+      if (!methodId || !pathTemplate || !method.httpMethod) continue;
+      const toolPath = methodToolPath(service, methodId);
+      const path = normalizeDiscoveryPathTemplate(
+        pathTemplate.startsWith("/") ? pathTemplate : `/${pathTemplate}`
+      );
+      const methodKey = method.httpMethod.toLowerCase();
+      const pathKey = uniquePathKey(paths, path, methodKey, toolPath);
+      paths[pathKey] ??= {};
+      paths[pathKey][methodKey] = buildDiscoveryOperation({
+        document,
+        method,
+        toolPath,
+        pathTemplate: pathTemplate.startsWith("/") ? pathTemplate : `/${pathTemplate}`
+      });
+    }
+    const scopes = compactDiscoveryScopeMap(discoveryScopes(document));
+    const authenticationTemplate = googleOauthTemplate(scopes);
+    const spec = {
+      openapi: "3.1.0",
+      info: {
+        title,
+        version
+      },
+      servers: [{ url: baseUrl }],
+      paths,
+      components: {
+        schemas: Object.fromEntries(
+          Object.entries(document.schemas ?? {}).map(([name, schema]) => [
+            name,
+            discoverySchemaToOpenApiSchema(schema)
+          ])
+        ),
+        ...authenticationTemplate ? {
+          securitySchemes: {
+            googleOAuth2: {
+              type: "oauth2",
+              flows: {
+                authorizationCode: {
+                  authorizationUrl: GOOGLE_OAUTH_AUTHORIZATION_URL,
+                  tokenUrl: GOOGLE_OAUTH_TOKEN_URL,
+                  scopes
+                }
+              }
+            }
+          }
+        } : {}
+      },
+      ...authenticationTemplate ? { security: [{ googleOAuth2: Object.keys(scopes) }] } : {},
+      "x-executor-origin": {
+        kind: "googleDiscovery",
+        discoveryUrl: normalizeDiscoveryUrl(input.discoveryUrl),
+        service,
+        version
+      }
+    };
+    return {
+      // @effect-diagnostics-next-line preferSchemaOverJson:off
+      specText: JSON.stringify(spec),
+      baseUrl,
+      title,
+      service,
+      version,
+      ...authenticationTemplate ? { authenticationTemplate } : {}
+    };
+  }
+);
+var convertGoogleDiscoveryBundleToOpenApi = Effect.fn(
+  "OpenApi.convertGoogleDiscoveryBundle"
+)(function* (input) {
+  if (input.documents.length === 0) {
+    return yield* new OpenApiParseError({
+      message: "Google Discovery bundle requires at least one document"
+    });
+  }
+  const infos = yield* Effect.forEach(
+    input.documents,
+    ({ discoveryUrl, documentText }) => Effect.gen(function* () {
+      const parsed = yield* parseJson(documentText).pipe(
+        Effect.mapError(
+          () => new OpenApiParseError({
+            message: "Failed to parse Google Discovery document"
+          })
+        )
+      );
+      const document = yield* Effect.try({
+        try: () => decodeDiscoveryDocument(parsed),
+        catch: () => new OpenApiParseError({
+          message: "Failed to decode Google Discovery document"
+        })
+      });
+      return yield* discoveryDocumentInfo(document, discoveryUrl);
+    })
+  );
+  const paths = {};
+  const schemas = {};
+  const rawScopes = {};
+  for (const info of infos) {
+    const schemaPrefix = schemaComponentPart(`${info.service}_${info.version}`);
+    const schemaNameForRef = (name) => `${schemaPrefix}_${schemaComponentPart(name)}`;
+    for (const [scope, description] of Object.entries(discoveryScopes(info.document))) {
+      rawScopes[scope] ??= description;
+    }
+    for (const [name, schema] of Object.entries(info.document.schemas ?? {})) {
+      schemas[schemaNameForRef(name)] = discoverySchemaToOpenApiSchema(schema, schemaNameForRef);
+    }
+    for (const method of allDiscoveryMethods(info.document)) {
+      const methodId = Option.getOrUndefined(method.id);
+      const rawPathTemplate = Option.getOrUndefined(method.path);
+      if (!methodId || !rawPathTemplate || !method.httpMethod) continue;
+      const toolPath = methodId;
+      const wirePath = rawPathTemplate.startsWith("/") ? rawPathTemplate : `/${rawPathTemplate}`;
+      const openApiPath = normalizeDiscoveryPathTemplate(wirePath);
+      const methodKey = method.httpMethod.toLowerCase();
+      const pathKey = uniquePathKey(paths, openApiPath, methodKey, toolPath);
+      paths[pathKey] ??= {};
+      paths[pathKey][methodKey] = buildDiscoveryOperation({
+        document: info.document,
+        method,
+        toolPath,
+        pathTemplate: wirePath,
+        schemaNameForRef,
+        serverUrl: info.baseUrl,
+        tags: [info.title]
+      });
+    }
+  }
+  const scopes = compactDiscoveryScopeMap(rawScopes);
+  const authenticationTemplate = googleOauthTemplate(scopes);
+  const spec = {
+    openapi: "3.1.0",
+    info: {
+      title: "Google",
+      version: "google-discovery-bundle"
+    },
+    servers: [{ url: GOOGLE_BUNDLE_BASE_URL }],
+    paths,
+    components: {
+      schemas,
+      ...authenticationTemplate ? {
+        securitySchemes: {
+          googleOAuth2: {
+            type: "oauth2",
+            flows: {
+              authorizationCode: {
+                authorizationUrl: GOOGLE_OAUTH_AUTHORIZATION_URL,
+                tokenUrl: GOOGLE_OAUTH_TOKEN_URL,
+                scopes
+              }
+            }
+          }
+        }
+      } : {}
+    },
+    ...authenticationTemplate ? { security: [{ googleOAuth2: Object.keys(scopes) }] } : {},
+    "x-executor-origin": {
+      kind: "googleDiscoveryBundle",
+      services: infos.map((info) => ({
+        discoveryUrl: normalizeDiscoveryUrl(info.discoveryUrl),
+        service: info.service,
+        version: info.version
+      }))
+    }
+  };
+  return {
+    // @effect-diagnostics-next-line preferSchemaOverJson:off
+    specText: JSON.stringify(spec),
+    baseUrl: GOOGLE_BUNDLE_BASE_URL,
+    title: "Google",
+    service: "google",
+    version: "google-discovery-bundle",
+    discoveryUrls: infos.map((info) => normalizeDiscoveryUrl(info.discoveryUrl)),
+    ...authenticationTemplate ? { authenticationTemplate } : {}
+  };
+});
+
+export {
+  compactGoogleOAuthScopes,
+  isGoogleDiscoveryUrl,
+  fetchGoogleDiscoveryDocument,
+  convertGoogleDiscoveryToOpenApi,
+  convertGoogleDiscoveryBundleToOpenApi
+};
+//# sourceMappingURL=chunk-OSIFYIQP.js.map