@executor-js/plugin-openapi 1.5.15 → 1.5.17

package/dist/chunk-UOLBAX5D.js

@@ -1,712 +0,0 @@
-import {
-  OpenApiParseError,
-  resolveServerUrl
-} from "./chunk-O54VFSWE.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),
-      kind: "oauth2",
-      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 } : {}
-  };
-});
-
-// src/sdk/derive-auth.ts
-import * as Option2 from "effect/Option";
-import { AuthTemplateSlug as AuthTemplateSlug2 } from "@executor-js/sdk/shared";
-function resolveOAuthUrl(url, baseUrl) {
-  if (!url) return url;
-  try {
-    new URL(url);
-    return url;
-  } catch {
-    if (!baseUrl) return url;
-    try {
-      return new URL(url, baseUrl).toString();
-    } catch {
-      return url;
-    }
-  }
-}
-var standardOidcIdentityScopes = ["openid", "email", "profile"];
-var identityScopesForPreset = (identityScopes) => {
-  if (identityScopes === false) return [];
-  return identityScopes === "auto" ? standardOidcIdentityScopes : identityScopes;
-};
-var resolvedOAuthScopes = (apiScopes, identityScopes) => {
-  const merged = new Set(apiScopes);
-  for (const scope of identityScopesForPreset(identityScopes)) merged.add(scope);
-  return [...merged];
-};
-var headerPrefix = (preset, headerName) => {
-  const label = preset.label.toLowerCase();
-  if (headerName.toLowerCase() === "authorization") {
-    if (label.includes("bearer")) return "Bearer ";
-    if (label.includes("basic")) return "Basic ";
-  }
-  return void 0;
-};
-var apiKeyTemplateFromHeaderPreset = (preset, slug) => ({
-  slug,
-  kind: "apikey",
-  // Every secret header shares the one credential input (the canonical
-  // `token`, stored as an absent placement variable).
-  placements: preset.secretHeaders.map((headerName) => {
-    const prefix = headerPrefix(preset, headerName);
-    return { carrier: "header", name: headerName, ...prefix ? { prefix } : {} };
-  })
-});
-var oauthTemplateFromPreset = (preset, baseUrl, slug, scopes) => ({
-  slug,
-  kind: "oauth2",
-  authorizationUrl: resolveOAuthUrl(
-    Option2.getOrElse(preset.authorizationUrl, () => ""),
-    baseUrl
-  ),
-  tokenUrl: resolveOAuthUrl(preset.tokenUrl, baseUrl),
-  scopes: [...scopes]
-});
-var detectedAuthenticationTemplates = (headerPresets, oauth2Presets, baseUrl) => {
-  const templates = [];
-  headerPresets.forEach((preset, index) => {
-    templates.push(
-      apiKeyTemplateFromHeaderPreset(preset, AuthTemplateSlug2.make(`apikey-${index}`))
-    );
-  });
-  for (const preset of oauth2Presets) {
-    const scopes = resolvedOAuthScopes(Object.keys(preset.scopes), preset.identityScopes);
-    templates.push(
-      oauthTemplateFromPreset(
-        preset,
-        baseUrl,
-        AuthTemplateSlug2.make(`oauth-${preset.securitySchemeName}`),
-        scopes
-      )
-    );
-  }
-  return templates;
-};
-var firstBaseUrlForPreview = (preview) => {
-  const firstServer = preview.servers[0];
-  return firstServer ? resolveServerUrl(firstServer.url, Option2.getOrUndefined(firstServer.variables), {}) : "";
-};
-var deriveAuthenticationTemplateFromPreview = (preview, baseUrl) => detectedAuthenticationTemplates(
-  preview.headerPresets,
-  preview.oauth2Presets,
-  baseUrl ?? firstBaseUrlForPreview(preview)
-);
-
-export {
-  compactGoogleOAuthScopes,
-  isGoogleDiscoveryUrl,
-  fetchGoogleDiscoveryDocument,
-  convertGoogleDiscoveryToOpenApi,
-  convertGoogleDiscoveryBundleToOpenApi,
-  detectedAuthenticationTemplates,
-  firstBaseUrlForPreview,
-  deriveAuthenticationTemplateFromPreview
-};
-//# sourceMappingURL=chunk-UOLBAX5D.js.map