@rafads/plugin-openapi 1.5.38

package/dist/providers/google.js

@@ -0,0 +1,1446 @@
+import {
+  OpenApiParseError
+} from "../chunk-CXFO6TLJ.js";
+
+// src/providers/google/discovery.ts
+import { Effect, Option, Predicate, Schema, SchemaGetter } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+
+// src/providers/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/providers/google/discovery.ts
+import { AuthTemplateSlug } from "@rafads/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 GOOGLE_PHOTOS_PICKER_SERVICE = "photospicker";
+var GOOGLE_PHOTOS_PICKER_SCOPE = "https://www.googleapis.com/auth/photospicker.mediaitems.readonly";
+var GOOGLE_PHOTOS_PICKER_SCOPE_DESCRIPTION = "Read selected Google Photos media";
+var OPENAPI_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  "array",
+  "boolean",
+  "integer",
+  "null",
+  "number",
+  "object",
+  "string"
+]);
+var GOOGLE_DISCOVERY_SERVICE_OVERRIDES = {
+  forms: { preserveServiceHostedUrl: true },
+  keep: { preserveServiceHostedUrl: true },
+  [GOOGLE_PHOTOS_PICKER_SERVICE]: {
+    preserveServiceHostedUrl: true,
+    scopes: {
+      [GOOGLE_PHOTOS_PICKER_SCOPE]: GOOGLE_PHOTOS_PICKER_SCOPE_DESCRIPTION
+    },
+    fallbackMethodScopes: [GOOGLE_PHOTOS_PICKER_SCOPE]
+  }
+};
+var googleDiscoveryUrlForService = (service, version, host = `${service}.googleapis.com`) => {
+  const override = GOOGLE_DISCOVERY_SERVICE_OVERRIDES[service];
+  return override?.preserveServiceHostedUrl === true ? `https://${host}/$discovery/rest?version=${version}` : `${DISCOVERY_SERVICE_HOST}/${service}/${version}/rest`;
+};
+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 DiscoveryMediaUploadProtocol = Schema.Struct({
+  path: TextOption,
+  multipart: Schema.optional(Schema.Boolean)
+});
+var DiscoveryMediaUploadProtocols = Schema.Struct({
+  simple: Schema.optional(DiscoveryMediaUploadProtocol),
+  resumable: Schema.optional(DiscoveryMediaUploadProtocol)
+});
+var DiscoveryMediaUpload = Schema.Struct({
+  accept: Schema.optional(TextArray),
+  maxSize: Schema.optional(Schema.String),
+  protocols: Schema.optional(DiscoveryMediaUploadProtocols)
+});
+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,
+  supportsMediaUpload: Schema.optional(Schema.Boolean),
+  mediaUpload: Schema.optional(DiscoveryMediaUpload),
+  supportsMediaDownload: Schema.optional(Schema.Boolean),
+  useMediaDownloadService: Schema.optional(Schema.Boolean)
+});
+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 DISCOVERY_SERVICE_PATH_RE = /^\/discovery\/v1\/apis\/([A-Za-z0-9._-]+)\/([A-Za-z0-9._-]+)\/rest\/?$/;
+var DISCOVERY_VERSION_RE = /^[A-Za-z0-9._-]+$/;
+var serviceFromGoogleApisHost = (host) => {
+  if (!host.endsWith(".googleapis.com")) return null;
+  const rawService = host.slice(0, -".googleapis.com".length);
+  if (!rawService || rawService.includes(".")) return null;
+  const service = rawService === "calendar-json" ? "calendar" : rawService.endsWith("-json") ? rawService.slice(0, -5) : rawService;
+  return /^[a-z0-9][a-z0-9-]*$/.test(service) ? service : null;
+};
+var normalizeGoogleDiscoveryUrl = (discoveryUrl) => {
+  const trimmed = discoveryUrl.trim();
+  if (!URL.canParse(trimmed)) return null;
+  const parsed = new URL(trimmed);
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.hash) {
+    return null;
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (host === "www.googleapis.com") {
+    if (parsed.search) return null;
+    const match = parsed.pathname.match(DISCOVERY_SERVICE_PATH_RE);
+    const service2 = match?.[1];
+    const version2 = match?.[2];
+    return service2 && version2 ? googleDiscoveryUrlForService(service2, version2) : null;
+  }
+  const service = serviceFromGoogleApisHost(host);
+  if (!service || !["/$discovery/rest", "/$discovery/rest/"].includes(parsed.pathname)) {
+    return null;
+  }
+  const keys = [...parsed.searchParams.keys()];
+  const version = parsed.searchParams.get("version")?.trim();
+  if (keys.length !== 1 || keys[0] !== "version" || !version || !DISCOVERY_VERSION_RE.test(version)) {
+    return null;
+  }
+  return googleDiscoveryUrlForService(service, version, host);
+};
+var normalizeDiscoveryUrl = (discoveryUrl) => {
+  return normalizeGoogleDiscoveryUrl(discoveryUrl) ?? discoveryUrl.trim();
+};
+var isGoogleDiscoveryUrl = (url) => {
+  return normalizeGoogleDiscoveryUrl(url) !== null;
+};
+var fetchGoogleDiscoveryDocument = Effect.fn("OpenApi.fetchGoogleDiscoveryDocument")(
+  function* (discoveryUrl, credentials) {
+    const normalizedDiscoveryUrl = normalizeGoogleDiscoveryUrl(discoveryUrl);
+    if (!normalizedDiscoveryUrl) {
+      return yield* new OpenApiParseError({
+        message: "Google Discovery document URL must be a supported googleapis.com HTTPS Discovery endpoint"
+      });
+    }
+    const client = yield* HttpClient.HttpClient;
+    const requestUrl = new URL(normalizedDiscoveryUrl);
+    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 googleDiscoveryResponseContent = (method, schemaNameForRef) => {
+  if ((method.supportsMediaDownload === true || method.useMediaDownloadService === true) && method.response === void 0) {
+    return {
+      "application/octet-stream": {
+        schema: {
+          type: "string",
+          format: "binary"
+        }
+      }
+    };
+  }
+  return {
+    "application/json": {
+      schema: method.response?.$ref ? { $ref: schemaRef(schemaNameForRef(method.response.$ref)) } : {}
+    }
+  };
+};
+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.oauthScopes ?? 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: googleDiscoveryResponseContent(input.method, schemaNameForRef)
+      }
+    },
+    ...methodScopes.length > 0 ? { security: [{ googleOAuth2: methodScopes }] } : {},
+    "x-google-scopes": methodScopes
+  };
+};
+var buildDiscoveryMediaUploadOperation = (input) => {
+  if (input.method.supportsMediaUpload !== true) return void 0;
+  const mediaUpload = input.method.mediaUpload;
+  if (mediaUpload === void 0) return void 0;
+  const simpleProtocol = mediaUpload.protocols?.simple;
+  const uploadPath = simpleProtocol ? Option.getOrUndefined(simpleProtocol.path) : void 0;
+  if (!uploadPath) return void 0;
+  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);
+  }
+  mergedParameters.set("uploadType", {
+    type: "string",
+    location: "query",
+    required: true,
+    description: Option.some("The upload type for the media upload."),
+    properties: {},
+    items: void 0,
+    additionalProperties: void 0,
+    enum: ["media"],
+    format: void 0,
+    readOnly: void 0,
+    default: "media",
+    $ref: void 0,
+    repeated: void 0
+  });
+  const methodScopes = input.oauthScopes ?? input.method.scopes ?? [];
+  const schemaNameForRef = input.schemaNameForRef ?? identitySchemaName;
+  const methodDescription = Option.getOrUndefined(input.method.description);
+  return {
+    operationId: `${input.toolPath}Media`,
+    "x-executor-toolPath": `${input.toolPath}Media`,
+    "x-executor-pathTemplate": uploadPath,
+    ...input.tags && input.tags.length > 0 ? { tags: input.tags } : {},
+    ...methodDescription !== void 0 ? { description: `${methodDescription} (media upload)` } : {},
+    ...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(uploadPath, 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 } : {}
+        }
+      ];
+    }),
+    requestBody: {
+      required: true,
+      content: {
+        "application/octet-stream": {
+          schema: { type: "string", format: "binary" }
+        }
+      }
+    },
+    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 GOOGLE_PHOTOS_LIBRARY_SERVICE = "photoslibrary";
+var GOOGLE_PHOTOS_APPENDONLY_SCOPE = "https://www.googleapis.com/auth/photoslibrary.appendonly";
+var GOOGLE_PHOTOS_UPLOAD_TOOL_PATH = "photoslibrary.mediaItems.upload";
+var GOOGLE_PHOTOS_UPLOAD_PATH = "/uploads";
+var isGooglePhotosService = (service) => service === GOOGLE_PHOTOS_LIBRARY_SERVICE || service === GOOGLE_PHOTOS_PICKER_SERVICE;
+var discoveryScopesForService = (service, document) => {
+  const scopes = discoveryScopes(document);
+  const overrideScopes = GOOGLE_DISCOVERY_SERVICE_OVERRIDES[service]?.scopes;
+  if (!overrideScopes) {
+    return scopes;
+  }
+  const missingScopes = Object.fromEntries(
+    Object.entries(overrideScopes).filter(([scope]) => scopes[scope] === void 0)
+  );
+  return Object.keys(missingScopes).length === 0 ? scopes : { ...scopes, ...missingScopes };
+};
+var discoveryMethodScopesForService = (service, method) => {
+  const scopes = method.scopes ?? [];
+  return scopes.length === 0 ? GOOGLE_DISCOVERY_SERVICE_OVERRIDES[service]?.fallbackMethodScopes ?? scopes : scopes;
+};
+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 googlePhotosUploadOperation = (input) => ({
+  operationId: input.toolPath,
+  "x-executor-toolPath": input.toolPath,
+  "x-executor-pathTemplate": GOOGLE_PHOTOS_UPLOAD_PATH,
+  ...input.tags && input.tags.length > 0 ? { tags: input.tags } : {},
+  description: "Uploads raw photo or video bytes to Google Photos and returns a plain-text upload token. Call mediaItems.batchCreate with the returned token to create the media item.",
+  servers: [{ url: input.serverUrl }],
+  parameters: [
+    {
+      name: "X-Goog-Upload-File-Name",
+      in: "header",
+      required: true,
+      description: "File name Google Photos should associate with the uploaded bytes.",
+      schema: { type: "string" }
+    },
+    {
+      name: "X-Goog-Upload-Protocol",
+      in: "header",
+      required: true,
+      description: "Google Photos raw upload protocol. Set to raw.",
+      schema: { type: "string", enum: ["raw"], default: "raw" }
+    },
+    {
+      name: "X-Goog-Upload-Content-Type",
+      in: "header",
+      required: false,
+      description: "MIME type of the uploaded media, for example image/jpeg or video/mp4.",
+      schema: { type: "string" }
+    }
+  ],
+  requestBody: {
+    required: true,
+    content: {
+      "application/octet-stream": {
+        schema: { type: "string", format: "binary" }
+      }
+    }
+  },
+  responses: {
+    "200": {
+      description: "Successful response",
+      content: {
+        "text/plain": {
+          schema: { type: "string" }
+        }
+      }
+    }
+  },
+  ...input.oauthScopes.length > 0 ? { security: [{ googleOAuth2: input.oauthScopes }] } : {},
+  "x-google-scopes": input.oauthScopes
+});
+var hasOperation = (paths, operationId) => Object.values(paths).some(
+  (pathItem) => Object.values(pathItem).some((operation) => operation.operationId === operationId)
+);
+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, rootUrl, 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}`,
+        oauthScopes: discoveryMethodScopesForService(service, method)
+      });
+      const mediaUploadOperation = buildDiscoveryMediaUploadOperation({
+        document,
+        method,
+        toolPath,
+        oauthScopes: discoveryMethodScopesForService(service, method),
+        serverUrl: rootUrl
+      });
+      if (mediaUploadOperation) {
+        const mediaUploadPathTemplate = mediaUploadOperation["x-executor-pathTemplate"] ?? "";
+        const uploadPath = normalizeDiscoveryPathTemplate(
+          mediaUploadPathTemplate.startsWith("/") ? mediaUploadPathTemplate : `/${mediaUploadPathTemplate}`
+        );
+        const uploadMethodKey = method.httpMethod.toLowerCase();
+        const uploadPathKey = uniquePathKey(
+          paths,
+          uploadPath,
+          uploadMethodKey,
+          mediaUploadOperation.operationId
+        );
+        paths[uploadPathKey] ??= {};
+        paths[uploadPathKey][uploadMethodKey] = mediaUploadOperation;
+      }
+    }
+    if (service === GOOGLE_PHOTOS_LIBRARY_SERVICE && !hasOperation(paths, GOOGLE_PHOTOS_UPLOAD_TOOL_PATH)) {
+      paths[GOOGLE_PHOTOS_UPLOAD_PATH] ??= {};
+      paths[GOOGLE_PHOTOS_UPLOAD_PATH].post = googlePhotosUploadOperation({
+        toolPath: GOOGLE_PHOTOS_UPLOAD_TOOL_PATH,
+        oauthScopes: [GOOGLE_PHOTOS_APPENDONLY_SCOPE],
+        serverUrl: baseUrl
+      });
+    }
+    const scopes = compactDiscoveryScopeMap(discoveryScopesForService(service, 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 = {};
+  const consentScopeSet = input.consentScopes ? new Set(input.consentScopes) : null;
+  for (const info of infos) {
+    const schemaPrefix = schemaComponentPart(`${info.service}_${info.version}`);
+    const schemaNameForRef = (name) => `${schemaPrefix}_${schemaComponentPart(name)}`;
+    const scopeDescriptions = discoveryScopesForService(info.service, info.document);
+    const filterPhotosScopes = consentScopeSet !== null && isGooglePhotosService(info.service);
+    for (const [scope, description] of Object.entries(scopeDescriptions)) {
+      if (filterPhotosScopes && !consentScopeSet.has(scope)) continue;
+      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 methodScopes = discoveryMethodScopesForService(info.service, method);
+      const oauthScopes = filterPhotosScopes ? methodScopes.filter((scope) => consentScopeSet.has(scope)) : methodScopes;
+      if (filterPhotosScopes && methodScopes.length > 0 && oauthScopes.length === 0) 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,
+        oauthScopes,
+        schemaNameForRef,
+        serverUrl: info.baseUrl,
+        tags: [info.title]
+      });
+      const mediaUploadOperation = buildDiscoveryMediaUploadOperation({
+        document: info.document,
+        method,
+        toolPath,
+        oauthScopes,
+        schemaNameForRef,
+        serverUrl: info.rootUrl,
+        tags: [info.title]
+      });
+      if (mediaUploadOperation) {
+        const mediaUploadPathTemplate = mediaUploadOperation["x-executor-pathTemplate"] ?? "";
+        const uploadPath = normalizeDiscoveryPathTemplate(
+          mediaUploadPathTemplate.startsWith("/") ? mediaUploadPathTemplate : `/${mediaUploadPathTemplate}`
+        );
+        const uploadMethodKey = method.httpMethod.toLowerCase();
+        const uploadPathKey = uniquePathKey(
+          paths,
+          uploadPath,
+          uploadMethodKey,
+          mediaUploadOperation.operationId
+        );
+        paths[uploadPathKey] ??= {};
+        paths[uploadPathKey][uploadMethodKey] = mediaUploadOperation;
+      }
+    }
+    if (info.service === GOOGLE_PHOTOS_LIBRARY_SERVICE && (!consentScopeSet || consentScopeSet.has(GOOGLE_PHOTOS_APPENDONLY_SCOPE)) && !hasOperation(paths, GOOGLE_PHOTOS_UPLOAD_TOOL_PATH)) {
+      paths[GOOGLE_PHOTOS_UPLOAD_PATH] ??= {};
+      paths[GOOGLE_PHOTOS_UPLOAD_PATH].post = googlePhotosUploadOperation({
+        toolPath: GOOGLE_PHOTOS_UPLOAD_TOOL_PATH,
+        oauthScopes: [GOOGLE_PHOTOS_APPENDONLY_SCOPE],
+        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/providers/google/presets.ts
+var gd = (service, version) => `https://www.googleapis.com/discovery/v1/apis/${service}/${version}/rest`;
+var GOOGLE_G = "https://fonts.gstatic.com/s/i/productlogos/googleg/v6/192px.svg";
+var GOOGLE_BUNDLE_PRESET_ID = "google";
+var GOOGLE_PHOTOS_PRESET_ID = "google-photos";
+var GOOGLE_PHOTOS_ICON = "https://www.gstatic.com/images/branding/product/2x/photos_96dp.png";
+var googleOpenApiBundlePreset = {
+  id: GOOGLE_BUNDLE_PRESET_ID,
+  name: "Google",
+  summary: "Bundle Gmail, Calendar, Drive, Docs, and other Google APIs into one integration.",
+  icon: GOOGLE_G,
+  featured: true
+};
+var googlePhotosOpenApiBundlePreset = {
+  id: GOOGLE_PHOTOS_PRESET_ID,
+  name: "Google Photos",
+  summary: "Albums, uploads, app-created media, and user-selected picker media.",
+  icon: GOOGLE_PHOTOS_ICON,
+  featured: true
+};
+var googleOpenApiPresets = [
+  {
+    id: "google-calendar",
+    name: "Google Calendar",
+    summary: "Calendars, events, ACLs, and scheduling.",
+    url: gd("calendar", "v3"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/calendar_2020q4/v8/192px.svg",
+    featured: true,
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-gmail",
+    name: "Gmail",
+    summary: "Messages, threads, labels, and drafts.",
+    url: gd("gmail", "v1"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/gmail_2020q4/v8/web-96dp/logo_gmail_2020q4_color_2x_web_96dp.png",
+    featured: true,
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-sheets",
+    name: "Google Sheets",
+    summary: "Spreadsheets, values, ranges, and formatting.",
+    url: gd("sheets", "v4"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/sheets_2020q4/v8/192px.svg",
+    featured: true,
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-drive",
+    name: "Google Drive",
+    summary: "Files, folders, permissions, and shared drives.",
+    url: gd("drive", "v3"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/drive_2020q4/v8/192px.svg",
+    featured: true,
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-docs",
+    name: "Google Docs",
+    summary: "Documents, structural edits, and formatting.",
+    url: gd("docs", "v1"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/docs_2020q4/v12/192px.svg",
+    featured: true,
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-slides",
+    name: "Google Slides",
+    summary: "Presentations, slides, page elements, and deck updates.",
+    url: gd("slides", "v1"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/slides_2020q4/v12/192px.svg",
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-forms",
+    name: "Google Forms",
+    summary: "Forms, questions, responses, and quizzes.",
+    url: "https://forms.googleapis.com/$discovery/rest?version=v1",
+    icon: "https://fonts.gstatic.com/s/i/productlogos/forms_2020q4/v6/192px.svg",
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-tasks",
+    name: "Google Tasks",
+    summary: "Task lists, task items, notes, and due dates.",
+    url: gd("tasks", "v1"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/tasks/v5/192px.svg",
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-people",
+    name: "Google People",
+    summary: "Contacts, profiles, directory people, and contact groups.",
+    url: gd("people", "v1"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/contacts_2022/v2/192px.svg",
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-photos-library",
+    name: "Google Photos Library",
+    summary: "Albums, uploads, and app-created media through Google Photos.",
+    url: gd("photoslibrary", "v1"),
+    icon: GOOGLE_PHOTOS_ICON,
+    oauthAudience: "advanced-user"
+  },
+  {
+    id: "google-photos-picker",
+    name: "Google Photos Picker",
+    summary: "Picker sessions and user-selected Google Photos media items.",
+    url: "https://photospicker.googleapis.com/$discovery/rest?version=v1",
+    icon: GOOGLE_PHOTOS_ICON,
+    oauthAudience: "advanced-user"
+  },
+  {
+    id: "google-chat",
+    name: "Google Chat",
+    summary: "Spaces, messages, members, reactions, and chat workflows.",
+    url: gd("chat", "v1"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/chat_2020q4/v8/192px.svg",
+    oauthAudience: "workspace-admin"
+  },
+  {
+    id: "google-keep",
+    name: "Google Keep",
+    summary: "Notes, lists, attachments, and annotations.",
+    url: "https://keep.googleapis.com/$discovery/rest?version=v1",
+    icon: "https://fonts.gstatic.com/s/i/productlogos/keep_2020q4/v8/192px.svg",
+    oauthAudience: "unsupported-user"
+  },
+  {
+    id: "google-youtube-data",
+    name: "YouTube Data",
+    summary: "Channels, playlists, videos, comments, and uploads.",
+    url: gd("youtube", "v3"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/youtube/v9/192px.svg",
+    oauthAudience: "advanced-user"
+  },
+  {
+    id: "google-search-console",
+    name: "Google Search Console",
+    summary: "Sites, sitemaps, URL inspection, and search performance.",
+    url: gd("searchconsole", "v1"),
+    icon: GOOGLE_G,
+    oauthAudience: "standard-user"
+  },
+  {
+    id: "google-classroom",
+    name: "Google Classroom",
+    summary: "Courses, rosters, coursework, and grading.",
+    url: gd("classroom", "v1"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/classroom/v7/192px.svg",
+    oauthAudience: "advanced-user"
+  },
+  {
+    id: "google-admin-directory",
+    name: "Google Admin Directory",
+    summary: "Users, groups, org units, roles, and domain resources.",
+    url: "https://admin.googleapis.com/$discovery/rest?version=directory_v1",
+    icon: "https://fonts.gstatic.com/s/i/productlogos/admin_2020q4/v6/192px.svg",
+    oauthAudience: "workspace-admin"
+  },
+  {
+    id: "google-admin-reports",
+    name: "Google Admin Reports",
+    summary: "Audit events, usage reports, and admin activity logs.",
+    url: "https://admin.googleapis.com/$discovery/rest?version=reports_v1",
+    icon: "https://fonts.gstatic.com/s/i/productlogos/admin_2020q4/v6/192px.svg",
+    oauthAudience: "workspace-admin"
+  },
+  {
+    id: "google-apps-script",
+    name: "Google Apps Script",
+    summary: "Projects, deployments, and script execution.",
+    url: gd("script", "v1"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/apps_script/v10/192px.svg",
+    oauthAudience: "advanced-user"
+  },
+  {
+    id: "google-bigquery",
+    name: "Google BigQuery",
+    summary: "Datasets, tables, jobs, and analytical queries.",
+    url: gd("bigquery", "v2"),
+    icon: "https://fonts.gstatic.com/s/i/productlogos/google_cloud/v6/192px.svg",
+    oauthAudience: "advanced-user"
+  },
+  {
+    id: "google-cloud-resource-manager",
+    name: "Google Cloud Resource Manager",
+    summary: "Projects, folders, organizations, and IAM hierarchy.",
+    url: "https://cloudresourcemanager.googleapis.com/$discovery/rest?version=v3",
+    icon: "https://fonts.gstatic.com/s/i/productlogos/google_cloud/v6/192px.svg",
+    oauthAudience: "advanced-user"
+  }
+];
+var googleStandardUserOAuthPresets = googleOpenApiPresets.filter(
+  (preset) => preset.oauthAudience === "standard-user"
+);
+var googlePhotosPresetIds = [
+  "google-photos-library",
+  "google-photos-picker"
+];
+var googlePhotosOpenApiPresets = googleOpenApiPresets.filter((preset) => googlePhotosPresetIds.includes(preset.id));
+var googleOAuthConsentScopes = {
+  "google-calendar": ["https://www.googleapis.com/auth/calendar"],
+  "google-gmail": ["https://mail.google.com/"],
+  "google-sheets": ["https://www.googleapis.com/auth/spreadsheets"],
+  "google-drive": ["https://www.googleapis.com/auth/drive"],
+  "google-docs": ["https://www.googleapis.com/auth/documents"],
+  "google-slides": ["https://www.googleapis.com/auth/presentations"],
+  "google-forms": ["https://www.googleapis.com/auth/forms.body"],
+  "google-tasks": ["https://www.googleapis.com/auth/tasks"],
+  "google-people": ["https://www.googleapis.com/auth/contacts"],
+  "google-photos-library": [
+    "https://www.googleapis.com/auth/photoslibrary.appendonly",
+    "https://www.googleapis.com/auth/photoslibrary.readonly.appcreateddata"
+  ],
+  "google-photos-picker": ["https://www.googleapis.com/auth/photospicker.mediaitems.readonly"],
+  "google-chat": ["https://www.googleapis.com/auth/chat.spaces"],
+  "google-keep": ["https://www.googleapis.com/auth/keep"],
+  "google-youtube-data": ["https://www.googleapis.com/auth/youtube"],
+  "google-search-console": ["https://www.googleapis.com/auth/webmasters"],
+  "google-classroom": ["https://www.googleapis.com/auth/classroom.courses"],
+  "google-admin-directory": ["https://www.googleapis.com/auth/admin.directory.user"],
+  "google-admin-reports": ["https://www.googleapis.com/auth/admin.reports.audit.readonly"],
+  "google-apps-script": ["https://www.googleapis.com/auth/script.projects"],
+  "google-bigquery": ["https://www.googleapis.com/auth/bigquery"],
+  "google-cloud-resource-manager": ["https://www.googleapis.com/auth/cloud-platform"]
+};
+var googleOAuthConsentScopesForPreset = (presetId) => googleOAuthConsentScopes[presetId] ?? [];
+var googleServiceSlug = (presetId) => presetId.replaceAll("-", "_");
+var GOOGLE_OAUTH_AUTHORIZATION_URL2 = "https://accounts.google.com/o/oauth2/v2/auth";
+var GOOGLE_OAUTH_TOKEN_URL2 = "https://oauth2.googleapis.com/token";
+var GOOGLE_OAUTH_SECURITY_SCHEME2 = "googleOAuth2";
+var GOOGLE_IDENTITY_SCOPES = ["openid", "email", "profile"];
+var GOOGLE_HEALTH_CHECKS = {
+  "google-calendar": { operation: "calendar.calendarList.list" },
+  "google-gmail": {
+    operation: "gmail.users.labels.list",
+    args: { userId: "me" }
+  },
+  "google-drive": {
+    operation: "drive.about.get",
+    args: { fields: "user" }
+  },
+  "google-tasks": { operation: "tasks.tasklists.list" },
+  "google-people": {
+    operation: "people.people.get",
+    args: { resourceName: "people/me", personFields: "emailAddresses" }
+  },
+  "google-photos-library": { operation: "photoslibrary.albums.list" },
+  "google-chat": { operation: "chat.spaces.list" },
+  "google-keep": { operation: "keep.notes.list" },
+  "google-youtube-data": {
+    operation: "youtube.channels.list",
+    args: { part: "id", mine: true }
+  },
+  "google-search-console": { operation: "webmasters.sites.list" },
+  "google-classroom": { operation: "classroom.courses.list" },
+  "google-admin-directory": {
+    operation: "directory.users.list",
+    args: { customer: "my_customer", maxResults: 1 }
+  },
+  "google-apps-script": { operation: "script.processes.list" },
+  "google-bigquery": { operation: "bigquery.projects.list" },
+  "google-cloud-resource-manager": { operation: "cloudresourcemanager.projects.list" }
+};
+var googleCatalogAuthTemplate = (presetId) => [
+  {
+    slug: GOOGLE_OAUTH_SECURITY_SCHEME2,
+    kind: "oauth2",
+    authorizationUrl: GOOGLE_OAUTH_AUTHORIZATION_URL2,
+    tokenUrl: GOOGLE_OAUTH_TOKEN_URL2,
+    scopes: compactGoogleOAuthScopes([
+      ...GOOGLE_IDENTITY_SCOPES,
+      ...googleOAuthConsentScopesForPreset(presetId)
+    ])
+  }
+];
+var googleCatalog = googleOpenApiPresets.map((preset) => ({
+  id: preset.id,
+  name: preset.name,
+  summary: preset.summary,
+  ...preset.url ? { url: preset.url } : {},
+  ...preset.icon ? { icon: preset.icon } : {},
+  ...preset.featured ? { featured: preset.featured } : {},
+  family: "google",
+  specFormat: "google-discovery",
+  defaultSlug: googleServiceSlug(preset.id),
+  authTemplate: googleCatalogAuthTemplate(preset.id),
+  ...GOOGLE_HEALTH_CHECKS[preset.id] ? { healthCheck: GOOGLE_HEALTH_CHECKS[preset.id] } : {}
+}));
+var normalizeGooglePresetUrl = (url) => {
+  const discoveryUrl = normalizeGoogleDiscoveryUrl(url);
+  if (discoveryUrl) return discoveryUrl;
+  const trimmed = url.trim();
+  if (!URL.canParse(trimmed)) return trimmed.replace(/\/$/, "");
+  const parsed = new URL(trimmed);
+  parsed.hash = "";
+  parsed.searchParams.sort();
+  return parsed.toString().replace(/\/$/, "");
+};
+var googlePresetsByNormalizedUrl = new Map(
+  googleOpenApiPresets.flatMap(
+    (preset) => preset.url ? [[normalizeGooglePresetUrl(preset.url), preset]] : []
+  )
+);
+var googlePresetForDiscoveryUrl = (url) => googlePresetsByNormalizedUrl.get(normalizeGooglePresetUrl(url));
+var googleAudienceWarningsForUrls = (urls) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const url of urls) {
+    const audience = googlePresetForDiscoveryUrl(url)?.oauthAudience;
+    if (audience === "workspace-admin" || audience === "unsupported-user") seen.add(audience);
+  }
+  return [...seen];
+};
+
+// src/providers/google/spec-format-adapter.ts
+import { Effect as Effect2, Schema as Schema2 } from "effect";
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseJson2 = (text) => Schema2.decodeUnknownEffect(Schema2.fromJsonString(Schema2.Unknown))(text).pipe(
+  Effect2.mapError(
+    () => new OpenApiParseError({
+      message: "Failed to parse Google Discovery document"
+    })
+  )
+);
+var googleDiscoverySlug = (service) => `google_${service.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
+var deriveGoogleDiscoveryIdentity = (doc) => {
+  if (!isRecord2(doc)) return null;
+  const rawName = typeof doc.name === "string" ? doc.name.trim() : "";
+  if (!rawName) return null;
+  const title = typeof doc.title === "string" && doc.title.trim() ? doc.title.trim() : rawName;
+  const description = typeof doc.description === "string" && doc.description.trim() ? doc.description.trim() : void 0;
+  return {
+    slug: googleDiscoverySlug(rawName),
+    name: title,
+    ...description ? { description } : {}
+  };
+};
+var googleDiscoveryAdapter = {
+  id: "google-discovery",
+  fetch: (input) => Effect2.gen(function* () {
+    const documents = yield* Effect2.forEach(
+      input.urls,
+      (url) => fetchGoogleDiscoveryDocument(url, input.credentials).pipe(
+        Effect2.provide(input.httpClientLayer),
+        Effect2.map((documentText) => ({
+          discoveryUrl: normalizeGoogleDiscoveryUrl(url) ?? url,
+          documentText
+        }))
+      ),
+      { concurrency: 4 }
+    );
+    const conversion = yield* convertGoogleDiscoveryBundleToOpenApi({ documents });
+    const document = documents.length === 1 ? yield* parseJson2(documents[0].documentText) : yield* Effect2.forEach(
+      documents,
+      (item) => parseJson2(item.documentText).pipe(
+        Effect2.map((parsed) => ({
+          discoveryUrl: item.discoveryUrl,
+          document: parsed
+        }))
+      )
+    );
+    return {
+      specText: conversion.specText,
+      specUrl: documents[0]?.discoveryUrl,
+      baseUrl: conversion.baseUrl,
+      authenticationTemplate: conversion.authenticationTemplate,
+      document
+    };
+  }),
+  deriveIdentity: deriveGoogleDiscoveryIdentity
+};
+
+// src/providers/google/openapi-ownership-migration.ts
+import { Effect as Effect3 } from "effect";
+import { DataMigrationError } from "@rafads/sdk/core";
+var MIGRATION_NAME = "2026-06-20-google-openapi-ownership";
+var googleOpenApiCandidate = (alias) => {
+  const column = (name) => alias ? `${alias}.${name}` : name;
+  return `${column("plugin_id")} = 'openapi' AND ${column("config")} IS NOT NULL AND json_valid(${column("config")}) AND json_type(${column("config")}, '$.googleDiscoveryUrls') = 'array'`;
+};
+var execute = (client, stmt) => Effect3.tryPromise({
+  try: () => client.execute(stmt),
+  catch: (cause) => new DataMigrationError({ migration: MIGRATION_NAME, cause })
+});
+var runSqliteGoogleOpenApiOwnershipMigration = (client) => Effect3.gen(function* () {
+  const exists = yield* execute(
+    client,
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'integration'"
+  );
+  if (exists.rows.length === 0) return 0;
+  const count = yield* execute(
+    client,
+    `SELECT COUNT(*) AS count FROM integration WHERE ${googleOpenApiCandidate()}`
+  );
+  const moved = Number(count.rows[0]?.count ?? 0);
+  if (moved === 0) return 0;
+  const applyAll = Effect3.gen(function* () {
+    yield* execute(
+      client,
+      `INSERT OR IGNORE INTO blob (namespace, key, value, row_id, id)
+         SELECT
+           'o:' || g.tenant || '/google',
+           b.key,
+           b.value,
+           lower(hex(randomblob(16))),
+           json_array('o:' || g.tenant || '/google', b.key)
+         FROM integration g
+         JOIN blob b
+           ON b.namespace = 'o:' || g.tenant || '/openapi'
+          AND b.key = 'spec/' || json_extract(g.config, '$.specHash')
+         WHERE ${googleOpenApiCandidate("g")}
+           AND json_extract(g.config, '$.specHash') IS NOT NULL
+           AND json_extract(g.config, '$.specHash') <> ''`
+    );
+    yield* execute(
+      client,
+      `INSERT OR IGNORE INTO plugin_storage
+           (tenant, owner, subject, plugin_id, collection, key, data, created_at, updated_at, row_id)
+         SELECT
+           ps.tenant,
+           ps.owner,
+           ps.subject,
+           'google',
+           ps.collection,
+           ps.key,
+           ps.data,
+           ps.created_at,
+           ps.updated_at,
+           lower(hex(randomblob(16)))
+         FROM plugin_storage ps
+         JOIN integration g
+           ON g.tenant = ps.tenant
+         WHERE ps.plugin_id = 'openapi'
+           AND ${googleOpenApiCandidate("g")}
+           AND ps.collection = 'operation'
+           AND (
+             json_extract(ps.data, '$.integration') = g.slug
+             OR ps.key LIKE g.slug || '.%'
+           )`
+    );
+    yield* execute(
+      client,
+      `DELETE FROM plugin_storage
+         WHERE plugin_id = 'openapi'
+           AND collection = 'operation'
+           AND EXISTS (
+             SELECT 1
+             FROM integration g
+             WHERE g.tenant = plugin_storage.tenant
+               AND ${googleOpenApiCandidate("g")}
+               AND (
+                 json_extract(plugin_storage.data, '$.integration') = g.slug
+                 OR plugin_storage.key LIKE g.slug || '.%'
+               )
+           )`
+    );
+    yield* execute(
+      client,
+      `UPDATE tool
+         SET plugin_id = 'google'
+         WHERE plugin_id = 'openapi'
+           AND EXISTS (
+             SELECT 1
+             FROM integration g
+             WHERE g.tenant = tool.tenant
+               AND ${googleOpenApiCandidate("g")}
+               AND g.slug = tool.integration
+           )`
+    );
+    yield* execute(
+      client,
+      `UPDATE definition
+         SET plugin_id = 'google'
+         WHERE plugin_id = 'openapi'
+           AND EXISTS (
+             SELECT 1
+             FROM integration g
+             WHERE g.tenant = definition.tenant
+               AND ${googleOpenApiCandidate("g")}
+               AND g.slug = definition.integration
+           )`
+    );
+    yield* execute(
+      client,
+      `UPDATE integration
+         SET plugin_id = 'google'
+         WHERE ${googleOpenApiCandidate()}`
+    );
+    yield* execute(client, "COMMIT");
+    return moved;
+  });
+  yield* execute(client, "BEGIN");
+  return yield* applyAll.pipe(
+    Effect3.tapError(() => execute(client, "ROLLBACK").pipe(Effect3.ignore))
+  );
+});
+var googleOpenApiOwnershipDataMigration = {
+  name: MIGRATION_NAME,
+  run: (client) => runSqliteGoogleOpenApiOwnershipMigration(client).pipe(Effect3.asVoid)
+};
+export {
+  GOOGLE_PHOTOS_ICON,
+  GOOGLE_PHOTOS_PRESET_ID,
+  compactGoogleOAuthScopes,
+  convertGoogleDiscoveryBundleToOpenApi,
+  convertGoogleDiscoveryToOpenApi,
+  deriveGoogleDiscoveryIdentity,
+  fetchGoogleDiscoveryDocument,
+  filterGoogleUserConsentOAuthScopes,
+  googleAudienceWarningsForUrls,
+  googleCatalog,
+  googleDiscoveryAdapter,
+  googleOAuthConsentScopes,
+  googleOAuthConsentScopesForPreset,
+  googleOpenApiBundlePreset,
+  googleOpenApiOwnershipDataMigration,
+  googleOpenApiPresets,
+  googlePhotosOpenApiBundlePreset,
+  googlePhotosOpenApiPresets,
+  googlePhotosPresetIds,
+  googlePresetForDiscoveryUrl,
+  googleServiceSlug,
+  googleStandardUserOAuthPresets,
+  isGoogleDiscoveryUrl,
+  isGoogleUserConsentOAuthScope,
+  runSqliteGoogleOpenApiOwnershipMigration
+};
+//# sourceMappingURL=google.js.map