@opengeni/capabilities 0.1.1

package/dist/index.js

@@ -0,0 +1,1944 @@
+// src/types.ts
+var IntegrationProtocolError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "IntegrationProtocolError";
+  }
+};
+var IntegrationInvocationError = class extends Error {
+  constructor(code, message, outcome, retryable, status) {
+    super(message);
+    this.code = code;
+    this.outcome = outcome;
+    this.retryable = retryable;
+    this.status = status;
+    this.name = "IntegrationInvocationError";
+  }
+};
+
+// src/auth.ts
+var forbiddenCredentialHeaders = /* @__PURE__ */ new Set([
+  "connection",
+  "content-length",
+  "host",
+  "proxy-authorization",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var MAX_CREDENTIAL_PLACEMENTS = 32;
+var MAX_CREDENTIAL_NAME_LENGTH = 256;
+var MAX_CREDENTIAL_VALUE_LENGTH = 16384;
+var headerNamePattern = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
+var queryNamePattern = /^[A-Za-z0-9._~-]+$/;
+var cookieNamePattern = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+function normalizeAudiencePath(path) {
+  if (!path?.trim()) return "/";
+  const normalized = path.startsWith("/") ? path : `/${path}`;
+  return normalized.endsWith("/") ? normalized : `${normalized}/`;
+}
+function assertCredentialAudience(credential, destination) {
+  let audience;
+  try {
+    audience = new URL(credential.audience.origin);
+  } catch {
+    throw new IntegrationInvocationError(
+      "credential_audience_invalid",
+      "Connection credential audience is invalid",
+      "not_started",
+      false
+    );
+  }
+  if (audience.origin !== destination.origin || audience.username || audience.password || audience.pathname !== "/" || audience.search || audience.hash) {
+    throw new IntegrationInvocationError(
+      "credential_audience_mismatch",
+      "Connection credential is not authorized for this integration destination",
+      "not_started",
+      false
+    );
+  }
+  const prefix = normalizeAudiencePath(credential.audience.pathPrefix);
+  const path = destination.pathname.endsWith("/") ? destination.pathname : `${destination.pathname}/`;
+  if (!path.startsWith(prefix)) {
+    throw new IntegrationInvocationError(
+      "credential_path_mismatch",
+      "Connection credential is not authorized for this integration path",
+      "not_started",
+      false
+    );
+  }
+}
+function placementValue(placement) {
+  return `${placement.prefix ?? ""}${placement.value}`;
+}
+function validateCredentialPlacements(placements) {
+  if (placements.length === 0 || placements.length > MAX_CREDENTIAL_PLACEMENTS) {
+    throw new IntegrationInvocationError(
+      "credential_placement_invalid",
+      "Connection credential placement count is invalid",
+      "not_started",
+      false
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const placement of placements) {
+    const name = placement.name;
+    const value = placementValue(placement);
+    const normalizedName = placement.carrier === "header" ? name.toLowerCase() : name;
+    if (name.length === 0 || name.length > MAX_CREDENTIAL_NAME_LENGTH || placement.value.length === 0 || value.length > MAX_CREDENTIAL_VALUE_LENGTH || /[\r\n\0]/.test(name) || /[\r\n\0]/.test(value)) {
+      throw new IntegrationInvocationError(
+        "credential_placement_invalid",
+        "Connection credential placement is invalid",
+        "not_started",
+        false
+      );
+    }
+    if (placement.carrier === "header") {
+      if (!headerNamePattern.test(name) || forbiddenCredentialHeaders.has(normalizedName) || normalizedName.startsWith("sec-")) {
+        throw new IntegrationInvocationError(
+          "credential_header_forbidden",
+          "Connection credential targets a forbidden request header",
+          "not_started",
+          false
+        );
+      }
+    } else if (placement.carrier === "query") {
+      if (!queryNamePattern.test(name)) {
+        throw new IntegrationInvocationError(
+          "credential_placement_invalid",
+          "Connection credential query placement is invalid",
+          "not_started",
+          false
+        );
+      }
+    } else if (!cookieNamePattern.test(name) || /;/.test(value)) {
+      throw new IntegrationInvocationError(
+        "credential_cookie_invalid",
+        "Connection credential cookie placement is invalid",
+        "not_started",
+        false
+      );
+    }
+    const key = `${placement.carrier}\0${normalizedName}`;
+    if (seen.has(key)) {
+      throw new IntegrationInvocationError(
+        "credential_placement_invalid",
+        "Connection credential placements contain a duplicate destination",
+        "not_started",
+        false
+      );
+    }
+    seen.add(key);
+  }
+}
+function applyCredentialPlacements(destination, headers, credential) {
+  assertCredentialAudience(credential, destination);
+  validateCredentialPlacements(credential.placements);
+  const cookies = [];
+  for (const placement of credential.placements) {
+    const name = placement.name;
+    const value = placementValue(placement);
+    if (placement.carrier === "header") {
+      headers.set(name, value);
+    } else if (placement.carrier === "query") {
+      destination.searchParams.set(name, value);
+    } else {
+      cookies.push(`${name}=${value}`);
+    }
+  }
+  if (cookies.length > 0) {
+    const current = headers.get("cookie");
+    headers.set("cookie", [...current ? [current] : [], ...cookies].join("; "));
+  }
+}
+
+// src/graphql.ts
+import {
+  buildClientSchema,
+  getIntrospectionQuery,
+  getNamedType,
+  isEnumType,
+  isInputObjectType,
+  isInterfaceType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isScalarType,
+  isUnionType,
+  parse
+} from "graphql";
+
+// src/http.ts
+import { pinnedFetch, readResponseBodyBounded } from "@opengeni/network";
+var DEFAULT_INTEGRATION_TIMEOUT_MS = 3e4;
+var DEFAULT_INTEGRATION_RESPONSE_BYTES = 4 * 1024 * 1024;
+var MAX_INTEGRATION_SPEC_BYTES = 8 * 1024 * 1024;
+var MAX_INTEGRATION_TOOLS = 2e3;
+async function fetchIntegrationSourceDocument(transport, sourceUrl, maxBytes = MAX_INTEGRATION_SPEC_BYTES) {
+  const url = new URL(sourceUrl);
+  const response = await fetchWithDeadline(
+    transport,
+    url,
+    {
+      method: "GET",
+      headers: { accept: "application/json, application/yaml, text/yaml, */*;q=0.5" }
+    },
+    DEFAULT_INTEGRATION_TIMEOUT_MS
+  );
+  if (response.status >= 300 && response.status < 400) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new IntegrationInvocationError(
+      "source_redirect_rejected",
+      "Integration source attempted to redirect",
+      "failed",
+      false,
+      response.status
+    );
+  }
+  if (!response.ok) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new IntegrationInvocationError(
+      "source_fetch_rejected",
+      "Integration source could not be read",
+      "failed",
+      response.status >= 500,
+      response.status
+    );
+  }
+  return await readResponseBodyBounded(response, maxBytes, "Integration source");
+}
+function createPinnedIntegrationTransport(options) {
+  return {
+    fetch: (input, init) => pinnedFetch(input, init, options.network, {
+      ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {},
+      label: "Integration request",
+      requireHttpsOutsideLocalTest: true
+    })
+  };
+}
+function directIntegrationTransport(fetchImpl) {
+  return { fetch: fetchImpl };
+}
+async function fetchWithDeadline(transport, url, init, timeoutMs = DEFAULT_INTEGRATION_TIMEOUT_MS) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 12e4) {
+    throw new RangeError("integration timeout must be between 1 and 120000 milliseconds");
+  }
+  const controller = new AbortController();
+  const onAbort = () => controller.abort(init.signal?.reason);
+  if (init.signal?.aborted) onAbort();
+  else init.signal?.addEventListener("abort", onAbort, { once: true });
+  const timer = setTimeout(
+    () => controller.abort(new Error("integration request timed out")),
+    timeoutMs
+  );
+  try {
+    return await transport.fetch(url, {
+      ...init,
+      signal: controller.signal,
+      redirect: "manual"
+    });
+  } catch {
+    const timedOut = controller.signal.aborted && !init.signal?.aborted;
+    throw new IntegrationInvocationError(
+      timedOut ? "request_timeout" : "request_failed",
+      timedOut ? "Integration request timed out" : "Integration request failed",
+      requestCouldHaveStarted(init.method) ? "unknown" : "not_started",
+      !requestCouldHaveStarted(init.method)
+    );
+  } finally {
+    clearTimeout(timer);
+    init.signal?.removeEventListener("abort", onAbort);
+  }
+}
+function requestCouldHaveStarted(method) {
+  const normalized = (method ?? "GET").toUpperCase();
+  return normalized !== "GET" && normalized !== "HEAD" && normalized !== "OPTIONS";
+}
+async function readIntegrationResponse(response, maxBytes = DEFAULT_INTEGRATION_RESPONSE_BYTES) {
+  const body = await readResponseBodyBounded(response, maxBytes, "Integration response");
+  const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+  if (body.byteLength === 0) return { data: null, contentType, bytes: 0 };
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(body);
+  if (contentType === "application/json" || contentType.endsWith("+json")) {
+    try {
+      return { data: JSON.parse(text), contentType, bytes: body.byteLength };
+    } catch {
+      throw new IntegrationInvocationError(
+        "response_json_invalid",
+        "Integration returned invalid JSON",
+        "failed",
+        false,
+        response.status
+      );
+    }
+  }
+  return { data: text, contentType, bytes: body.byteLength };
+}
+
+// src/revision.ts
+import { createHash } from "crypto";
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonicalize(entry)])
+  );
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function immutableRevisionId(protocol, contentSha256) {
+  if (!/^[a-f0-9]{64}$/.test(contentSha256)) {
+    throw new Error("contentSha256 must be a lowercase SHA-256 digest");
+  }
+  return `${protocol}:${contentSha256.slice(0, 24)}`;
+}
+function stableToolId(value, seen) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 54);
+  const base = normalized || "tool";
+  if (!seen) return base;
+  const count = (seen.get(base) ?? 0) + 1;
+  seen.set(base, count);
+  return count === 1 ? base : `${base}_${count}`;
+}
+
+// src/graphql.ts
+function compileGraphqlRevision(introspection, options) {
+  const document = parseIntrospection(introspection);
+  let schema;
+  try {
+    schema = buildClientSchema(document);
+  } catch {
+    throw new IntegrationProtocolError(
+      "graphql_introspection_invalid",
+      "GraphQL introspection result cannot build a client schema"
+    );
+  }
+  const endpoint = validateGraphqlEndpoint(options.endpoint);
+  const contentSha256 = sha256Hex(canonicalJson(document));
+  const id = immutableRevisionId("graphql", contentSha256);
+  const tools = [];
+  const bindings = {};
+  const seen = /* @__PURE__ */ new Map();
+  for (const [kind, root] of [
+    ["query", schema.getQueryType()],
+    ["mutation", schema.getMutationType()]
+  ]) {
+    if (!root) continue;
+    for (const field of Object.values(root.getFields()).sort(
+      (left, right) => left.name.localeCompare(right.name)
+    )) {
+      const toolId = stableToolId(`${kind}_${field.name}`, seen);
+      const namedOutput = getNamedType(field.type);
+      const selectionAllowed = !isLeafType(namedOutput);
+      const defaultSelection = selectionAllowed ? buildDefaultSelection(field.type, /* @__PURE__ */ new Set(), 0) : void 0;
+      const properties = Object.fromEntries(
+        field.args.map((arg) => [
+          arg.name,
+          {
+            ...inputTypeSchema(arg.type, /* @__PURE__ */ new Set(), 0),
+            ...arg.description ? { description: arg.description } : {}
+          }
+        ])
+      );
+      if (selectionAllowed) {
+        properties.select = {
+          type: "string",
+          description: "Optional GraphQL field selection without outer braces. The default selects safe scalar fields.",
+          maxLength: 4e3
+        };
+      }
+      const required = field.args.filter((arg) => isNonNullType(arg.type)).map((arg) => arg.name);
+      const description = [
+        field.description?.trim(),
+        kind === "mutation" ? "Changes external state and requires approval." : "Read-only GraphQL query."
+      ].filter(Boolean).join(" ");
+      tools.push({
+        id: toolId,
+        operationKey: `${kind}:${field.name}`,
+        name: field.name,
+        description,
+        inputSchema: {
+          type: "object",
+          properties,
+          required,
+          additionalProperties: false
+        },
+        safety: kind === "query" ? "read" : "write",
+        approvalMode: kind === "query" ? "never" : "ask",
+        deprecated: field.deprecationReason != null
+      });
+      bindings[toolId] = {
+        kind,
+        fieldName: field.name,
+        operationName: stableGraphqlName(`${kind}_${field.name}`),
+        variableDefinitions: field.args.map((arg) => `$${arg.name}: ${String(arg.type)}`),
+        variableNames: field.args.map((arg) => arg.name),
+        ...defaultSelection ? { defaultSelection } : {},
+        selectionAllowed
+      };
+      if (tools.length > MAX_INTEGRATION_TOOLS) {
+        throw new IntegrationProtocolError(
+          "graphql_tool_limit",
+          `GraphQL schema exceeds the ${MAX_INTEGRATION_TOOLS}-tool limit`
+        );
+      }
+    }
+  }
+  if (tools.length === 0) {
+    throw new IntegrationProtocolError("graphql_empty", "GraphQL schema exposes no root fields");
+  }
+  return {
+    id,
+    protocol: "graphql",
+    integrationId: options.integrationId,
+    contentSha256,
+    source: {
+      url: options.sourceUrl ?? endpoint,
+      ...options.provider ? { provider: options.provider } : {}
+    },
+    title: options.name?.trim() || options.integrationId,
+    tools,
+    bindings
+  };
+}
+async function fetchGraphqlIntrospection(options) {
+  const request = { query: getIntrospectionQuery({ descriptions: true }) };
+  const firstCredential = await resolveGraphqlCredential(
+    options,
+    "graphql-introspection",
+    "pending",
+    "__introspection",
+    false
+  );
+  let response = await sendGraphqlRequest(options, request, firstCredential);
+  if (response.status === 401 && options.credentialResolver && options.authority.connectionRef) {
+    const refreshed = await resolveGraphqlCredential(
+      options,
+      "graphql-introspection",
+      "pending",
+      "__introspection",
+      true
+    );
+    await response.body?.cancel().catch(() => void 0);
+    if (!refreshed) {
+      throw new IntegrationInvocationError(
+        "graphql_introspection_rejected",
+        "GraphQL endpoint did not return an introspection schema",
+        "failed",
+        false,
+        401
+      );
+    }
+    response = await sendGraphqlRequest(options, request, refreshed);
+  }
+  if (response.status >= 300 && response.status < 400) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new IntegrationInvocationError(
+      "redirect_rejected",
+      "GraphQL endpoint attempted to redirect the introspection request",
+      "unknown",
+      false,
+      response.status
+    );
+  }
+  const body = await readIntegrationResponse(response, MAX_INTEGRATION_SPEC_BYTES);
+  if (!response.ok || !isRecord(body.data) || !isRecord(body.data.data)) {
+    throw new IntegrationInvocationError(
+      "graphql_introspection_rejected",
+      "GraphQL endpoint did not return an introspection schema",
+      "failed",
+      false,
+      response.status
+    );
+  }
+  return body.data.data;
+}
+var GraphqlMcpServer = class {
+  constructor(options) {
+    this.options = options;
+    this.name = `graphql:${stableToolId(options.revision.integrationId)}`;
+  }
+  cacheToolsList = true;
+  useStructuredContent = true;
+  name;
+  async connect() {
+  }
+  async close() {
+  }
+  async invalidateToolsCache() {
+  }
+  async listTools() {
+    return this.options.revision.tools.map(
+      (tool) => ({
+        name: tool.id,
+        description: tool.description,
+        inputSchema: normalizeMcpSchema(tool.inputSchema),
+        annotations: {
+          readOnlyHint: tool.safety === "read",
+          destructiveHint: false,
+          idempotentHint: tool.safety === "read",
+          openWorldHint: true
+        },
+        _meta: {
+          "opengeni/approvalMode": tool.approvalMode,
+          "opengeni/operationKey": tool.operationKey,
+          "opengeni/revisionId": this.options.revision.id
+        }
+      })
+    );
+  }
+  async callTool(toolName, args, _meta, callOptions) {
+    const result = await invokeGraphqlOperation(
+      this.options,
+      toolName,
+      args ?? {},
+      callOptions?.signal
+    );
+    const content = [
+      { type: "text", text: JSON.stringify(result) }
+    ];
+    content.structuredContent = result;
+    content.isError = result.ok === false;
+    return content;
+  }
+};
+function createGraphqlMcpServer(options) {
+  return new GraphqlMcpServer(options);
+}
+async function invokeGraphqlOperation(options, toolId, args, signal) {
+  const binding = options.revision.bindings[toolId];
+  if (!binding) {
+    throw new IntegrationInvocationError(
+      "operation_not_found",
+      "GraphQL operation is not present in the frozen revision",
+      "not_started",
+      false
+    );
+  }
+  const select = binding.selectionAllowed ? validateGraphqlSelection(
+    typeof args.select === "string" ? args.select : binding.defaultSelection ?? "__typename"
+  ) : void 0;
+  const variables = Object.fromEntries(
+    binding.variableNames.flatMap((name) => args[name] === void 0 ? [] : [[name, args[name]]])
+  );
+  const definitions = binding.variableDefinitions.length ? `(${binding.variableDefinitions.join(", ")})` : "";
+  const argumentsText = binding.variableNames.length ? `(${binding.variableNames.map((name) => `${name}: $${name}`).join(", ")})` : "";
+  const query = `${binding.kind} ${binding.operationName}${definitions} { ${binding.fieldName}${argumentsText}${select ? ` { ${select} }` : ""} }`;
+  const request = { query, variables, operationName: binding.operationName };
+  const firstCredential = await resolveGraphqlCredential(
+    options,
+    options.revision.integrationId,
+    options.revision.id,
+    toolId,
+    false
+  );
+  let response = await sendGraphqlRequest(options, request, firstCredential, signal);
+  if (response.status === 401 && options.credentialResolver && options.authority.connectionRef) {
+    const refreshed = await resolveGraphqlCredential(
+      options,
+      options.revision.integrationId,
+      options.revision.id,
+      toolId,
+      true
+    );
+    await response.body?.cancel().catch(() => void 0);
+    if (binding.kind === "query" && refreshed) {
+      response = await sendGraphqlRequest(options, request, refreshed, signal);
+    } else {
+      throw new IntegrationInvocationError(
+        "authorization_rejected",
+        "The connected account is no longer authorized for this GraphQL operation",
+        binding.kind === "mutation" ? "unknown" : "failed",
+        false,
+        401
+      );
+    }
+  }
+  if (response.status >= 300 && response.status < 400) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new IntegrationInvocationError(
+      "redirect_rejected",
+      "GraphQL endpoint attempted to redirect a credential-bearing request",
+      binding.kind === "mutation" ? "unknown" : "failed",
+      false,
+      response.status
+    );
+  }
+  const payload = await readIntegrationResponse(
+    response,
+    options.maxResponseBytes ?? DEFAULT_INTEGRATION_RESPONSE_BYTES
+  );
+  if (response.status === 401 || response.status === 403) {
+    throw new IntegrationInvocationError(
+      "authorization_rejected",
+      "The connected account is no longer authorized for this GraphQL operation",
+      binding.kind === "mutation" ? "unknown" : "failed",
+      false,
+      response.status
+    );
+  }
+  const graph = isRecord(payload.data) ? payload.data : {};
+  return {
+    ok: response.ok && !Array.isArray(graph.errors),
+    status: response.status,
+    data: graph.data ?? null,
+    errors: graph.errors ?? null
+  };
+}
+async function resolveGraphqlCredential(options, integrationId, revisionId, operationKey, forceRefresh) {
+  if (!options.credentialResolver || !options.authority.connectionRef) return null;
+  const credential = await options.credentialResolver.resolve({
+    ...options.authority,
+    protocol: "graphql",
+    integrationId,
+    revisionId,
+    operationKey,
+    destinationUrl: graphqlEndpoint(options).toString(),
+    ...forceRefresh ? { forceRefresh: true } : {}
+  });
+  if (!credential && !forceRefresh) {
+    throw new IntegrationInvocationError(
+      "connection_required",
+      "This GraphQL integration needs a connected account",
+      "not_started",
+      false
+    );
+  }
+  return credential;
+}
+async function sendGraphqlRequest(options, request, credential, signal) {
+  const endpoint = graphqlEndpoint(options);
+  const headers = new Headers(options.staticHeaders);
+  headers.set("accept", "application/json");
+  headers.set("content-type", "application/json");
+  if (credential) applyCredentialPlacements(endpoint, headers, credential);
+  return await fetchWithDeadline(
+    options.transport,
+    endpoint,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      ...signal ? { signal } : {}
+    },
+    options.timeoutMs ?? DEFAULT_INTEGRATION_TIMEOUT_MS
+  );
+}
+function graphqlEndpoint(options) {
+  const endpoint = new URL(validateGraphqlEndpoint(options.endpoint));
+  for (const [name, value] of Object.entries(options.staticQuery ?? {})) {
+    endpoint.searchParams.set(name, value);
+  }
+  return endpoint;
+}
+function validateGraphqlSelection(value) {
+  const normalized = value.trim();
+  if (!normalized || normalized.length > 4e3) {
+    throw new IntegrationInvocationError(
+      "graphql_selection_invalid",
+      "GraphQL selection must contain between 1 and 4000 characters",
+      "not_started",
+      false
+    );
+  }
+  try {
+    const document = parse(`fragment OpenGeniSelection on Placeholder { ${normalized} }`);
+    if (document.definitions.length !== 1 || document.definitions[0]?.kind !== "FragmentDefinition") {
+      throw new Error("invalid selection document");
+    }
+    return normalized;
+  } catch {
+    throw new IntegrationInvocationError(
+      "graphql_selection_invalid",
+      "GraphQL selection is invalid",
+      "not_started",
+      false
+    );
+  }
+}
+function parseIntrospection(value) {
+  let parsed = value;
+  if (typeof value === "string") {
+    if (Buffer.byteLength(value) > MAX_INTEGRATION_SPEC_BYTES) {
+      throw new IntegrationProtocolError(
+        "graphql_introspection_size",
+        `GraphQL introspection exceeds ${MAX_INTEGRATION_SPEC_BYTES} bytes`
+      );
+    }
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      throw new IntegrationProtocolError(
+        "graphql_introspection_parse",
+        "GraphQL introspection is not valid JSON"
+      );
+    }
+  }
+  if (isRecord(parsed) && isRecord(parsed.data) && isRecord(parsed.data.__schema)) {
+    return parsed.data;
+  }
+  if (isRecord(parsed) && isRecord(parsed.__schema)) {
+    return parsed;
+  }
+  throw new IntegrationProtocolError(
+    "graphql_introspection_shape",
+    "GraphQL introspection result has no __schema object"
+  );
+}
+function validateGraphqlEndpoint(value) {
+  let endpoint;
+  try {
+    endpoint = new URL(value);
+  } catch {
+    throw new IntegrationProtocolError(
+      "graphql_endpoint_invalid",
+      "GraphQL endpoint URL is invalid"
+    );
+  }
+  if (!/^https?:$/.test(endpoint.protocol) || endpoint.username || endpoint.password || endpoint.hash) {
+    throw new IntegrationProtocolError(
+      "graphql_endpoint_invalid",
+      "GraphQL endpoint URL is invalid"
+    );
+  }
+  return endpoint.toString();
+}
+function inputTypeSchema(input, seen, depth) {
+  if (depth > 12) return {};
+  if (isNonNullType(input)) return inputTypeSchema(input.ofType, seen, depth + 1);
+  if (isListType(input)) {
+    return { type: "array", items: inputTypeSchema(input.ofType, seen, depth + 1) };
+  }
+  const type = getNamedType(input);
+  if (isScalarType(type)) return scalarSchema(type.name);
+  if (isEnumType(type))
+    return { type: "string", enum: type.getValues().map((entry) => entry.name) };
+  if (isInputObjectType(type)) {
+    if (seen.has(type.name)) return { type: "object", additionalProperties: true };
+    const nextSeen = new Set(seen).add(type.name);
+    const fields = Object.values(type.getFields());
+    return {
+      type: "object",
+      properties: Object.fromEntries(
+        fields.map((field) => [
+          field.name,
+          {
+            ...inputTypeSchema(field.type, nextSeen, depth + 1),
+            ...field.description ? { description: field.description } : {}
+          }
+        ])
+      ),
+      required: fields.filter((field) => isNonNullType(field.type)).map((field) => field.name),
+      additionalProperties: false
+    };
+  }
+  return {};
+}
+function scalarSchema(name) {
+  if (name === "Boolean") return { type: "boolean" };
+  if (name === "Int") return { type: "integer" };
+  if (name === "Float") return { type: "number" };
+  if (name === "ID" || name === "String") return { type: "string" };
+  return { description: `GraphQL scalar ${name}` };
+}
+function buildDefaultSelection(output, seen, depth) {
+  const type = getNamedType(output);
+  if (isLeafType(type)) return void 0;
+  if (depth > 2 || seen.has(type.name)) return "__typename";
+  if (isUnionType(type) || isInterfaceType(type)) return "__typename";
+  if (!isObjectType(type)) return "__typename";
+  const nextSeen = new Set(seen).add(type.name);
+  const fields = Object.values(type.getFields());
+  const scalarFields = fields.filter((field) => isLeafType(getNamedType(field.type))).slice(0, 20);
+  const selections = scalarFields.map((field) => field.name);
+  if (selections.length < 3 && depth < 2) {
+    const nested = fields.find(
+      (field) => field.args.length === 0 && !isLeafType(getNamedType(field.type))
+    );
+    if (nested) {
+      const child = buildDefaultSelection(nested.type, nextSeen, depth + 1);
+      if (child) selections.push(`${nested.name} { ${child} }`);
+    }
+  }
+  return selections.length ? selections.join(" ") : "__typename";
+}
+function isLeafType(type) {
+  return isScalarType(type) || isEnumType(type);
+}
+function stableGraphqlName(value) {
+  const normalized = value.replace(/[^_0-9A-Za-z]/g, "_").replace(/^([^_A-Za-z])/, "_$1");
+  return normalized || "OpenGeniOperation";
+}
+function normalizeMcpSchema(schema) {
+  return {
+    type: "object",
+    properties: isRecord(schema.properties) ? schema.properties : {},
+    required: Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : [],
+    additionalProperties: schema.additionalProperties === true
+  };
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/mcp-manifest.ts
+function extractMcpToolManifest(listToolsResult, metadata = {}) {
+  const listed = listToolsResult && typeof listToolsResult === "object" && Array.isArray(listToolsResult.tools) ? listToolsResult.tools : [];
+  const seen = /* @__PURE__ */ new Map();
+  const tools = listed.flatMap((value) => {
+    if (!value || typeof value !== "object") return [];
+    const tool = value;
+    if (typeof tool.name !== "string" || !tool.name.trim()) return [];
+    const toolName = tool.name.trim();
+    return [
+      {
+        toolId: stableToolId(toolName, seen),
+        toolName,
+        description: typeof tool.description === "string" ? tool.description : null,
+        ...tool.inputSchema !== void 0 ? { inputSchema: tool.inputSchema } : tool.parameters !== void 0 ? { inputSchema: tool.parameters } : {},
+        ...tool.outputSchema !== void 0 ? { outputSchema: tool.outputSchema } : {},
+        ...tool.annotations && typeof tool.annotations === "object" ? { annotations: tool.annotations } : {}
+      }
+    ];
+  });
+  const info = metadata.serverInfo && typeof metadata.serverInfo === "object" ? metadata.serverInfo : null;
+  return {
+    server: info ? {
+      name: typeof info.name === "string" ? info.name : null,
+      version: typeof info.version === "string" ? info.version : null,
+      instructions: metadata.instructions ?? null
+    } : null,
+    tools
+  };
+}
+function deriveMcpNamespace(input) {
+  const candidate = input.name?.trim() || hostname(input.endpoint) || basename(input.command) || "mcp";
+  return stableToolId(candidate);
+}
+function hostname(value) {
+  if (!value || !URL.canParse(value)) return "";
+  return new URL(value).hostname;
+}
+function basename(value) {
+  return value?.trim().split(/[\\/]/).pop() ?? "";
+}
+
+// src/openapi.ts
+import { load as parseYaml } from "js-yaml";
+var methods = /* @__PURE__ */ new Set([
+  "get",
+  "put",
+  "post",
+  "delete",
+  "patch",
+  "head",
+  "options",
+  "trace"
+]);
+var forbiddenParameterHeaders = /* @__PURE__ */ new Set([
+  "host",
+  "content-length",
+  "connection",
+  "transfer-encoding"
+]);
+function parseOpenApiDocument(source) {
+  const bytes = typeof source === "string" ? Buffer.byteLength(source) : source.byteLength;
+  if (bytes === 0 || bytes > MAX_INTEGRATION_SPEC_BYTES) {
+    throw new IntegrationProtocolError(
+      "openapi_spec_size",
+      `OpenAPI document must be between 1 and ${MAX_INTEGRATION_SPEC_BYTES} bytes`
+    );
+  }
+  const text = typeof source === "string" ? source : new TextDecoder("utf-8", { fatal: true }).decode(source);
+  let parsed;
+  try {
+    parsed = parseYaml(text, { json: true });
+  } catch {
+    throw new IntegrationProtocolError(
+      "openapi_parse",
+      "OpenAPI document is not valid JSON or YAML"
+    );
+  }
+  if (!isRecord2(parsed) || typeof parsed.openapi !== "string" || !/^3\.(?:0|1)(?:\.|$)/.test(parsed.openapi)) {
+    throw new IntegrationProtocolError(
+      "openapi_version",
+      "Only OpenAPI 3.0 and 3.1 documents are supported"
+    );
+  }
+  if (!isRecord2(parsed.paths)) {
+    throw new IntegrationProtocolError("openapi_paths", "OpenAPI document has no paths object");
+  }
+  return parsed;
+}
+function compileOpenApiRevision(source, options) {
+  const document = isRecord2(source) ? source : parseOpenApiDocument(source);
+  const contentSha256 = sha256Hex(canonicalJson(document));
+  const revisionId = immutableRevisionId("openapi", contentSha256);
+  const info = isRecord2(document.info) ? document.info : {};
+  const documentServers = readServers(document.servers, options.baseUrl, options.sourceUrl);
+  const documentSecurity = readSecurity(document.security);
+  const tools = [];
+  const bindings = {};
+  const seen = /* @__PURE__ */ new Map();
+  for (const [pathTemplate, rawPathItem] of Object.entries(
+    document.paths
+  )) {
+    const pathItem = resolveObject(document, rawPathItem, "path item");
+    const sharedParameters = readParameters(document, pathItem.parameters);
+    const pathServers = readServers(pathItem.servers, void 0, void 0);
+    for (const [rawMethod, rawOperation] of Object.entries(pathItem)) {
+      const method = rawMethod.toLowerCase();
+      if (!methods.has(method) || !isRecord2(rawOperation)) continue;
+      const operation = resolveObject(document, rawOperation, "operation");
+      const operationKey = operationIdentity(method, pathTemplate, operation.operationId);
+      const id = stableToolId(operationKey, seen);
+      const parameters = mergeParameters(
+        sharedParameters,
+        readParameters(document, operation.parameters)
+      );
+      const requestBody = readRequestBody(document, operation.requestBody);
+      const serverUrl = firstServerUrl(
+        readServers(operation.servers, void 0, void 0),
+        pathServers,
+        documentServers
+      );
+      const requiredScopeAlternatives = operation.security === void 0 ? documentSecurity : readSecurity(operation.security);
+      const safety = classifyHttpSafety(method, operation);
+      const inputSchema = operationInputSchema(parameters, requestBody);
+      const outputSchema = operationOutputSchema(document, operation.responses);
+      const summary = stringValue(operation.summary) ?? stringValue(operation.description);
+      tools.push({
+        id,
+        operationKey,
+        name: summary ?? `${method.toUpperCase()} ${pathTemplate}`,
+        description: toolDescription(method, pathTemplate, operation, safety),
+        inputSchema,
+        ...outputSchema ? { outputSchema } : {},
+        safety,
+        approvalMode: safety === "read" ? "never" : "ask",
+        deprecated: operation.deprecated === true
+      });
+      bindings[id] = {
+        method,
+        pathTemplate,
+        serverUrl,
+        parameters,
+        ...requestBody ? { requestBody } : {},
+        ...requiredScopeAlternatives.length > 0 ? { requiredScopeAlternatives } : {}
+      };
+      if (tools.length > MAX_INTEGRATION_TOOLS) {
+        throw new IntegrationProtocolError(
+          "openapi_tool_limit",
+          `OpenAPI document exceeds the ${MAX_INTEGRATION_TOOLS}-tool limit`
+        );
+      }
+    }
+  }
+  if (tools.length === 0) {
+    throw new IntegrationProtocolError("openapi_empty", "OpenAPI document exposes no operations");
+  }
+  return {
+    id: revisionId,
+    protocol: "openapi",
+    integrationId: options.integrationId,
+    contentSha256,
+    source: {
+      ...options.sourceUrl ? { url: options.sourceUrl } : {},
+      ...options.provider ? { provider: options.provider } : {}
+    },
+    title: stringValue(info.title) ?? options.integrationId,
+    ...stringValue(info.description) ? { description: stringValue(info.description) } : {},
+    ...stringValue(info.version) ? { version: stringValue(info.version) } : {},
+    tools,
+    bindings
+  };
+}
+function discoverOpenApiAuth(document) {
+  const components = isRecord2(document.components) ? document.components : {};
+  const schemes = isRecord2(components.securitySchemes) ? components.securitySchemes : {};
+  for (const raw of Object.values(schemes)) {
+    const scheme = resolveObject(document, raw, "security scheme");
+    if (scheme.type === "oauth2") {
+      const flows = isRecord2(scheme.flows) ? scheme.flows : {};
+      const scopes = /* @__PURE__ */ new Set();
+      for (const flow of Object.values(flows)) {
+        if (!isRecord2(flow) || !isRecord2(flow.scopes)) continue;
+        for (const scope of Object.keys(flow.scopes)) scopes.add(scope);
+      }
+      return { kind: "oauth2", scopes: [...scopes].sort() };
+    }
+    if (scheme.type === "apiKey" && (scheme.in === "header" || scheme.in === "query" || scheme.in === "cookie") && typeof scheme.name === "string" && scheme.name.length > 0) {
+      return { kind: "api_key", carrier: scheme.in, name: scheme.name };
+    }
+    if (scheme.type === "http" && typeof scheme.scheme === "string") {
+      return { kind: "http", scheme: scheme.scheme.toLowerCase() };
+    }
+  }
+  return { kind: "none" };
+}
+var OpenApiMcpServer = class {
+  constructor(options) {
+    this.options = options;
+    this.name = `openapi:${stableToolId(options.revision.integrationId)}`;
+  }
+  cacheToolsList = true;
+  useStructuredContent = true;
+  name;
+  async connect() {
+  }
+  async close() {
+  }
+  async invalidateToolsCache() {
+  }
+  async listTools() {
+    return this.options.revision.tools.map(
+      (tool) => ({
+        name: tool.id,
+        description: tool.description,
+        inputSchema: normalizeMcpSchema2(tool.inputSchema),
+        annotations: {
+          readOnlyHint: tool.safety === "read",
+          destructiveHint: tool.safety === "destructive",
+          idempotentHint: isIdempotentMethod(this.options.revision.bindings[tool.id]?.method),
+          openWorldHint: true
+        },
+        _meta: {
+          "opengeni/approvalMode": tool.approvalMode,
+          "opengeni/operationKey": tool.operationKey,
+          "opengeni/revisionId": this.options.revision.id
+        }
+      })
+    );
+  }
+  async callTool(toolName, args, _meta, callOptions) {
+    const result = await invokeOpenApiOperation(
+      this.options,
+      toolName,
+      args ?? {},
+      callOptions?.signal
+    );
+    const content = [
+      {
+        type: "text",
+        text: JSON.stringify(result)
+      }
+    ];
+    content.structuredContent = result;
+    content.isError = result.ok === false;
+    return content;
+  }
+};
+function createOpenApiMcpServer(options) {
+  return new OpenApiMcpServer(options);
+}
+async function invokeOpenApiOperation(options, toolId, args, signal) {
+  const binding = options.revision.bindings[toolId];
+  if (!binding) {
+    throw new IntegrationInvocationError(
+      "operation_not_found",
+      "Integration operation is not present in the frozen revision",
+      "not_started",
+      false
+    );
+  }
+  const firstCredential = await resolveOpenApiCredential(options, binding, toolId, args, false);
+  let response = await sendOpenApiRequest(options, binding, args, firstCredential, signal);
+  if (response.status === 401 && options.credentialResolver && options.authority.connectionRef) {
+    const refreshed = await resolveOpenApiCredential(options, binding, toolId, args, true);
+    if (isReplaySafeMethod(binding.method) && refreshed) {
+      await response.body?.cancel().catch(() => void 0);
+      response = await sendOpenApiRequest(options, binding, args, refreshed, signal);
+    } else {
+      await response.body?.cancel().catch(() => void 0);
+      throw new IntegrationInvocationError(
+        "authorization_rejected",
+        "The connected account is no longer authorized for this operation",
+        isReplaySafeMethod(binding.method) ? "failed" : "unknown",
+        false,
+        response.status
+      );
+    }
+  }
+  if (response.status >= 300 && response.status < 400) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new IntegrationInvocationError(
+      "redirect_rejected",
+      "Integration attempted to redirect a credential-bearing request",
+      binding.method === "get" || binding.method === "head" ? "failed" : "unknown",
+      false,
+      response.status
+    );
+  }
+  const payload = await readIntegrationResponse(
+    response,
+    options.maxResponseBytes ?? DEFAULT_INTEGRATION_RESPONSE_BYTES
+  );
+  const result = {
+    ok: response.ok,
+    status: response.status,
+    contentType: payload.contentType,
+    data: payload.data
+  };
+  if (!response.ok && (response.status === 401 || response.status === 403)) {
+    throw new IntegrationInvocationError(
+      "authorization_rejected",
+      "The connected account is no longer authorized for this operation",
+      binding.method === "get" || binding.method === "head" ? "failed" : "unknown",
+      false,
+      response.status
+    );
+  }
+  return result;
+}
+async function resolveOpenApiCredential(options, binding, toolId, args, forceRefresh) {
+  if (!options.credentialResolver || !options.authority.connectionRef) return null;
+  const destinationUrl = buildOperationUrl(binding, args).toString();
+  const credential = await options.credentialResolver.resolve({
+    ...options.authority,
+    protocol: "openapi",
+    integrationId: options.revision.integrationId,
+    revisionId: options.revision.id,
+    operationKey: toolId,
+    destinationUrl,
+    ...binding.requiredScopeAlternatives ? { requiredScopeAlternatives: binding.requiredScopeAlternatives } : {},
+    ...forceRefresh ? { forceRefresh: true } : {}
+  });
+  if (!credential && !forceRefresh) {
+    throw new IntegrationInvocationError(
+      "connection_required",
+      "This integration needs a connected account",
+      "not_started",
+      false
+    );
+  }
+  return credential;
+}
+async function sendOpenApiRequest(options, binding, args, credential, signal) {
+  const url = buildOperationUrl(binding, args);
+  const headers = buildOperationHeaders(binding, args);
+  const body = buildOperationBody(binding, args, headers);
+  if (credential) applyCredentialPlacements(url, headers, credential);
+  return await fetchWithDeadline(
+    options.transport,
+    url,
+    {
+      method: binding.method.toUpperCase(),
+      headers,
+      ...body !== void 0 ? { body } : {},
+      ...signal ? { signal } : {}
+    },
+    options.timeoutMs ?? DEFAULT_INTEGRATION_TIMEOUT_MS
+  );
+}
+function readServers(value, explicitBaseUrl, sourceUrl) {
+  if (explicitBaseUrl) return [normalizeServerUrl(explicitBaseUrl)];
+  const servers = Array.isArray(value) ? value.flatMap(
+    (entry) => isRecord2(entry) && typeof entry.url === "string" ? [resolveServerUrl(entry.url, sourceUrl)] : []
+  ) : [];
+  if (servers.length > 0) return servers;
+  if (sourceUrl && URL.canParse(sourceUrl)) {
+    const source = new URL(sourceUrl);
+    return [`${source.origin}/`];
+  }
+  return [];
+}
+function firstServerUrl(...groups) {
+  const server = groups.flat().find(Boolean);
+  if (!server) {
+    throw new IntegrationProtocolError(
+      "openapi_server_missing",
+      "OpenAPI operation has no resolvable server URL"
+    );
+  }
+  return server;
+}
+function resolveServerUrl(value, sourceUrl) {
+  if (/[{}]/.test(value)) {
+    throw new IntegrationProtocolError(
+      "openapi_server_variable",
+      "OpenAPI server variables require an explicit resolved base URL"
+    );
+  }
+  try {
+    return normalizeServerUrl(sourceUrl ? new URL(value, sourceUrl).toString() : value);
+  } catch {
+    throw new IntegrationProtocolError("openapi_server_invalid", "OpenAPI server URL is invalid");
+  }
+}
+function normalizeServerUrl(value) {
+  const url = new URL(value);
+  if (!/^https?:$/.test(url.protocol) || url.username || url.password || url.hash) {
+    throw new IntegrationProtocolError("openapi_server_invalid", "OpenAPI server URL is invalid");
+  }
+  return url.toString();
+}
+function readParameters(document, value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((raw) => {
+    const parameter = resolveObject(document, raw, "parameter");
+    const location = parameter.in;
+    if (typeof parameter.name !== "string" || location !== "path" && location !== "query" && location !== "header" && location !== "cookie") {
+      return [];
+    }
+    if (location === "header" && forbiddenParameterHeaders.has(parameter.name.toLowerCase()))
+      return [];
+    return [
+      {
+        name: parameter.name,
+        location,
+        required: location === "path" || parameter.required === true,
+        schema: dereferenceSchema(document, parameter.schema),
+        ...stringValue(parameter.description) ? { description: stringValue(parameter.description) } : {}
+      }
+    ];
+  });
+}
+function mergeParameters(base, override) {
+  const merged = new Map(base.map((entry) => [`${entry.location}:${entry.name}`, entry]));
+  for (const entry of override) merged.set(`${entry.location}:${entry.name}`, entry);
+  return [...merged.values()];
+}
+function readRequestBody(document, value) {
+  if (value === void 0) return void 0;
+  const body = resolveObject(document, value, "request body");
+  if (!isRecord2(body.content)) return void 0;
+  const schemas = {};
+  for (const [contentType, rawMedia] of Object.entries(body.content)) {
+    if (!isRecord2(rawMedia)) continue;
+    schemas[contentType.toLowerCase()] = dereferenceSchema(document, rawMedia.schema);
+  }
+  const contentTypes = Object.keys(schemas);
+  return contentTypes.length === 0 ? void 0 : { required: body.required === true, contentTypes, schemas };
+}
+function operationInputSchema(parameters, body) {
+  const properties = {};
+  const required = [];
+  for (const location of ["path", "query", "header", "cookie"]) {
+    const group = parameters.filter((entry) => entry.location === location);
+    if (group.length === 0) continue;
+    properties[location] = {
+      type: "object",
+      properties: Object.fromEntries(
+        group.map((entry) => [
+          entry.name,
+          { ...entry.schema, ...entry.description ? { description: entry.description } : {} }
+        ])
+      ),
+      required: group.filter((entry) => entry.required).map((entry) => entry.name),
+      additionalProperties: false
+    };
+    if (group.some((entry) => entry.required)) required.push(location);
+  }
+  if (body) {
+    properties.body = body.schemas[body.contentTypes[0]] ?? {};
+    if (body.contentTypes.length > 1) {
+      properties.contentType = { type: "string", enum: body.contentTypes };
+    }
+    if (body.required) required.push("body");
+  }
+  return { type: "object", properties, required, additionalProperties: false };
+}
+function operationOutputSchema(document, value) {
+  if (!isRecord2(value)) return void 0;
+  for (const status of ["200", "201", "202", "203", "204", "default"]) {
+    if (!(status in value)) continue;
+    const response = resolveObject(document, value[status], "response");
+    if (!isRecord2(response.content)) return void 0;
+    for (const media of Object.values(response.content)) {
+      if (isRecord2(media) && media.schema !== void 0) {
+        return dereferenceSchema(document, media.schema);
+      }
+    }
+  }
+  return void 0;
+}
+function readSecurity(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    if (!isRecord2(entry)) return [];
+    const scopes = Object.values(entry).flatMap(
+      (raw) => Array.isArray(raw) ? raw.filter((scope) => typeof scope === "string") : []
+    );
+    return scopes.length > 0 ? [[...new Set(scopes)].sort()] : [];
+  });
+}
+function classifyHttpSafety(method, operation) {
+  if (method === "get" || method === "head" || method === "options") return "read";
+  const text = `${stringValue(operation.operationId) ?? ""} ${stringValue(operation.summary) ?? ""}`.toLowerCase();
+  return method === "delete" || /\b(delete|destroy|remove|revoke|cancel|purge)\b/.test(text) ? "destructive" : "write";
+}
+function operationIdentity(method, path, operationId) {
+  return typeof operationId === "string" && operationId.trim() ? operationId.trim() : `${method}_${path}`;
+}
+function toolDescription(method, path, operation, safety) {
+  const description = stringValue(operation.description) ?? stringValue(operation.summary);
+  const approval = safety === "read" ? "Read-only." : "Changes external state and requires approval.";
+  return `${description ? `${description.trim()} ` : ""}${method.toUpperCase()} ${path}. ${approval}`.trim();
+}
+function isIdempotentMethod(method) {
+  return method === "get" || method === "head" || method === "options" || method === "put" || method === "delete";
+}
+function isReplaySafeMethod(method) {
+  return method === "get" || method === "head" || method === "options";
+}
+function buildOperationUrl(binding, args) {
+  const pathArgs = objectValue(args.path);
+  const path = binding.pathTemplate.replace(/\{([^}]+)\}/g, (_match, name) => {
+    const value = pathArgs[name];
+    if (value === void 0 || value === null) {
+      throw new IntegrationInvocationError(
+        "path_parameter_missing",
+        "A required integration path parameter is missing",
+        "not_started",
+        false
+      );
+    }
+    return encodeURIComponent(scalarString(value));
+  });
+  const base = new URL(binding.serverUrl);
+  const url = new URL(
+    path.replace(/^\//, ""),
+    base.toString().endsWith("/") ? base : new URL(`${base}/`)
+  );
+  const query = objectValue(args.query);
+  for (const [name, value] of Object.entries(query)) appendQueryValue(url, name, value);
+  return url;
+}
+function buildOperationHeaders(binding, args) {
+  const headers = new Headers({ accept: "application/json, text/plain;q=0.9, */*;q=0.5" });
+  for (const [name, value] of Object.entries(objectValue(args.header))) {
+    if (forbiddenParameterHeaders.has(name.toLowerCase())) continue;
+    headers.set(name, scalarString(value));
+  }
+  const cookies = Object.entries(objectValue(args.cookie)).map(
+    ([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(scalarString(value))}`
+  );
+  if (cookies.length > 0) headers.set("cookie", cookies.join("; "));
+  if (binding.requestBody && args.body !== void 0) {
+    const requested = typeof args.contentType === "string" ? args.contentType.toLowerCase() : void 0;
+    const contentType = requested && binding.requestBody.contentTypes.includes(requested) ? requested : binding.requestBody.contentTypes[0];
+    headers.set("content-type", contentType);
+  }
+  return headers;
+}
+function buildOperationBody(binding, args, headers) {
+  if (!binding.requestBody || args.body === void 0) return void 0;
+  const contentType = headers.get("content-type") ?? "application/json";
+  if (contentType === "application/x-www-form-urlencoded") {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(objectValue(args.body)))
+      appendSearchParam(params, key, value);
+    return params;
+  }
+  if (contentType === "application/json" || contentType.endsWith("+json")) {
+    return JSON.stringify(args.body);
+  }
+  if (typeof args.body === "string") return args.body;
+  throw new IntegrationInvocationError(
+    "request_body_unsupported",
+    "This operation requires a text body for the selected content type",
+    "not_started",
+    false
+  );
+}
+function appendQueryValue(url, name, value) {
+  if (Array.isArray(value)) {
+    for (const entry of value) url.searchParams.append(name, scalarString(entry));
+  } else if (value !== void 0 && value !== null) {
+    url.searchParams.append(name, scalarString(value));
+  }
+}
+function appendSearchParam(params, name, value) {
+  if (Array.isArray(value)) {
+    for (const entry of value) params.append(name, scalarString(entry));
+  } else if (value !== void 0 && value !== null) {
+    params.append(name, scalarString(value));
+  }
+}
+function scalarString(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  throw new IntegrationInvocationError(
+    "parameter_invalid",
+    "Integration parameters must be strings, numbers, booleans, or arrays of them",
+    "not_started",
+    false
+  );
+}
+function objectValue(value) {
+  return isRecord2(value) ? value : {};
+}
+function resolveObject(document, value, label) {
+  const resolved = resolveLocalRef(document, value);
+  if (!isRecord2(resolved)) {
+    throw new IntegrationProtocolError("openapi_shape", `OpenAPI ${label} is invalid`);
+  }
+  return resolved;
+}
+function resolveLocalRef(document, value) {
+  if (!isRecord2(value) || typeof value.$ref !== "string") return value;
+  if (!value.$ref.startsWith("#/")) {
+    throw new IntegrationProtocolError(
+      "openapi_external_ref",
+      "External OpenAPI references are not supported; bundle the document first"
+    );
+  }
+  return value.$ref.slice(2).split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~")).reduce((current, part) => isRecord2(current) ? current[part] : void 0, document);
+}
+function dereferenceSchema(document, value, seen = /* @__PURE__ */ new Set(), depth = 0) {
+  if (depth > 20) return {};
+  if (isRecord2(value) && typeof value.$ref === "string") {
+    if (seen.has(value.$ref)) return {};
+    const nextSeen = new Set(seen).add(value.$ref);
+    return dereferenceSchema(document, resolveLocalRef(document, value), nextSeen, depth + 1);
+  }
+  if (!isRecord2(value)) return {};
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "properties" && isRecord2(entry)) {
+      result.properties = Object.fromEntries(
+        Object.entries(entry).map(([name, schema]) => [
+          name,
+          dereferenceSchema(document, schema, seen, depth + 1)
+        ])
+      );
+    } else if (key === "items") {
+      result.items = dereferenceSchema(document, entry, seen, depth + 1);
+    } else if (key === "allOf" || key === "anyOf" || key === "oneOf") {
+      result[key] = Array.isArray(entry) ? entry.map((schema) => dereferenceSchema(document, schema, seen, depth + 1)) : [];
+    } else if (key !== "$ref") {
+      result[key] = entry;
+    }
+  }
+  return result;
+}
+function normalizeMcpSchema2(schema) {
+  return {
+    type: "object",
+    properties: isRecord2(schema.properties) ? schema.properties : {},
+    required: Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : [],
+    additionalProperties: schema.additionalProperties === true
+  };
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/providers.ts
+var accountIdentityFeature = (provider) => ({
+  featureKey: "account-identity",
+  kind: "identity_link",
+  configSchema: { type: "object", properties: {}, additionalProperties: false },
+  capabilities: {
+    provider,
+    connectionRequired: true,
+    identity: "connected_account"
+  }
+});
+var driveKnowledgeFeature = (provider) => ({
+  featureKey: "drive-content",
+  kind: "knowledge_source",
+  configSchema: {
+    type: "object",
+    required: ["sources", "destination", "syncCadence", "readPolicy"],
+    properties: {
+      sources: {
+        type: "array",
+        minItems: 1,
+        maxItems: 100,
+        items: {
+          type: "object",
+          required: ["id", "name", "mimeType", "sourceKind", "includeDescendants"],
+          properties: {
+            id: { type: "string", minLength: 1, maxLength: 512 },
+            name: { type: "string", minLength: 1, maxLength: 1024 },
+            mimeType: { type: "string", minLength: 1, maxLength: 256 },
+            driveId: { type: "string", minLength: 1, maxLength: 512 },
+            sourceKind: {
+              type: "string",
+              enum: provider === "google-drive" ? ["my_drive", "shared_drive", "folder"] : ["my_drive", "shared_library", "folder"]
+            },
+            includeDescendants: { type: "boolean" }
+          },
+          additionalProperties: false
+        }
+      },
+      destination: {
+        type: "object",
+        required: ["authorityKind", "authorityAccountId"],
+        properties: {
+          authorityKind: {
+            type: "string",
+            enum: ["organization", "workspace", "personal"]
+          },
+          authorityAccountId: { type: "string", minLength: 1, maxLength: 128 },
+          authorityWorkspaceId: { type: "string", minLength: 1, maxLength: 128 },
+          authoritySubjectId: { type: "string", minLength: 1, maxLength: 512 },
+          collectionId: { type: "string", minLength: 1, maxLength: 512 }
+        },
+        additionalProperties: false
+      },
+      syncCadence: { type: "string", enum: ["manual", "hourly", "daily"] },
+      readPolicy: { type: "string", enum: ["allow", "ask", "block"] }
+    },
+    additionalProperties: false
+  },
+  capabilities: {
+    provider,
+    connectionRequired: true,
+    sync: "incremental",
+    cursor: provider === "google-drive" ? "page_token" : "delta_link"
+  }
+});
+var mailboxFeatures = (provider) => [
+  {
+    featureKey: "mail-inbox",
+    kind: "inbound_trigger",
+    configSchema: {
+      type: "object",
+      properties: {
+        folder: { type: "string", minLength: 1, maxLength: 256 },
+        unreadOnly: { type: "boolean" }
+      },
+      additionalProperties: false
+    },
+    capabilities: {
+      provider,
+      connectionRequired: true,
+      delivery: "poll",
+      cursor: provider === "google-gmail" ? "history_id" : "delta_link"
+    }
+  },
+  {
+    featureKey: "mail-delivery",
+    kind: "delivery_destination",
+    configSchema: {
+      type: "object",
+      properties: {
+        fromAlias: { type: "string", minLength: 1, maxLength: 512 },
+        saveToSent: { type: "boolean" }
+      },
+      additionalProperties: false
+    },
+    capabilities: {
+      provider,
+      connectionRequired: true,
+      delivery: "email"
+    }
+  },
+  accountIdentityFeature(provider === "google-gmail" ? "google" : "microsoft")
+];
+var googleDiscoveryUrl = (service, version) => `https://www.googleapis.com/discovery/v1/apis/${service}/${version}/rest`;
+var googleOAuth = (scopes) => ({
+  authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenUrl: "https://oauth2.googleapis.com/token",
+  scopes: ["openid", "email", "profile", ...scopes],
+  tokenPlacement: { carrier: "header", name: "Authorization", prefix: "Bearer " }
+});
+var GOOGLE_DRIVE_PRESET = {
+  id: "google-drive",
+  name: "Google Drive",
+  summary: "Files, folders, permissions, and shared drives.",
+  family: "google",
+  sourceFormat: "google-discovery",
+  sourceUrl: googleDiscoveryUrl("drive", "v3"),
+  baseUrl: "https://www.googleapis.com/drive/v3/",
+  oauth: googleOAuth(["https://www.googleapis.com/auth/drive"]),
+  healthOperation: "drive.about.get",
+  healthArgs: { query: { fields: "user" } },
+  features: [driveKnowledgeFeature("google-drive"), accountIdentityFeature("google")]
+};
+var GOOGLE_GMAIL_PRESET = {
+  id: "google-gmail",
+  name: "Gmail",
+  summary: "Messages, threads, labels, drafts, and sending mail.",
+  family: "google",
+  sourceFormat: "google-discovery",
+  sourceUrl: googleDiscoveryUrl("gmail", "v1"),
+  baseUrl: "https://gmail.googleapis.com/",
+  oauth: googleOAuth(["https://mail.google.com/"]),
+  healthOperation: "gmail.users.labels.list",
+  healthArgs: { path: { userId: "me" } },
+  features: mailboxFeatures("google-gmail")
+};
+var MICROSOFT_GRAPH_OPENAPI_URL = "https://raw.githubusercontent.com/microsoftgraph/msgraph-metadata/master/openapi/v1.0/openapi.yaml";
+var MICROSOFT_GRAPH_BASE_URL = "https://graph.microsoft.com/v1.0";
+var microsoftOAuth = (scopes) => ({
+  authorizationUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+  tokenUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+  scopes: ["offline_access", "User.Read", ...scopes],
+  tokenPlacement: { carrier: "header", name: "Authorization", prefix: "Bearer " }
+});
+var MICROSOFT_OUTLOOK_MAIL_PRESET = {
+  id: "microsoft-outlook-mail",
+  name: "Outlook Mail",
+  summary: "Messages, folders, attachments, settings, and sending mail.",
+  family: "microsoft",
+  sourceFormat: "openapi",
+  sourceUrl: MICROSOFT_GRAPH_OPENAPI_URL,
+  baseUrl: MICROSOFT_GRAPH_BASE_URL,
+  oauth: microsoftOAuth(["Mail.ReadWrite", "Mail.Send", "MailboxSettings.ReadWrite"]),
+  pathPrefixes: [
+    "/me/messages",
+    "/me/mailFolders",
+    "/me/sendMail",
+    "/me/getMailTips",
+    "/me/inferenceClassification",
+    "/me/mailboxSettings",
+    "/me/outlook"
+  ],
+  features: mailboxFeatures("microsoft-outlook-mail")
+};
+var MICROSOFT_OUTLOOK_CALENDAR_PRESET = {
+  id: "microsoft-outlook-calendar",
+  name: "Outlook Calendar",
+  summary: "Calendars, events, availability, and scheduling.",
+  family: "microsoft",
+  sourceFormat: "openapi",
+  sourceUrl: MICROSOFT_GRAPH_OPENAPI_URL,
+  baseUrl: MICROSOFT_GRAPH_BASE_URL,
+  oauth: microsoftOAuth(["Calendars.ReadWrite"]),
+  pathPrefixes: [
+    "/me/calendar",
+    "/me/calendars",
+    "/me/calendarGroups",
+    "/me/calendarView",
+    "/me/events",
+    "/me/findMeetingTimes",
+    "/me/reminderView"
+  ],
+  features: [
+    {
+      featureKey: "calendar-events",
+      kind: "inbound_trigger",
+      configSchema: {
+        type: "object",
+        properties: {
+          calendarId: { type: "string", minLength: 1, maxLength: 512 },
+          lookaheadDays: { type: "integer", minimum: 1, maximum: 365 }
+        },
+        additionalProperties: false
+      },
+      capabilities: {
+        provider: "microsoft-outlook-calendar",
+        connectionRequired: true,
+        delivery: "poll",
+        cursor: "delta_link"
+      }
+    },
+    {
+      featureKey: "calendar-delivery",
+      kind: "delivery_destination",
+      configSchema: {
+        type: "object",
+        properties: {
+          calendarId: { type: "string", minLength: 1, maxLength: 512 }
+        },
+        additionalProperties: false
+      },
+      capabilities: {
+        provider: "microsoft-outlook-calendar",
+        connectionRequired: true,
+        delivery: "calendar_event"
+      }
+    },
+    accountIdentityFeature("microsoft")
+  ]
+};
+var MICROSOFT_OUTLOOK_CONTACTS_PRESET = {
+  id: "microsoft-outlook-contacts",
+  name: "Outlook Contacts",
+  summary: "Contacts, contact folders, and people suggestions.",
+  family: "microsoft",
+  sourceFormat: "openapi",
+  sourceUrl: MICROSOFT_GRAPH_OPENAPI_URL,
+  baseUrl: MICROSOFT_GRAPH_BASE_URL,
+  oauth: microsoftOAuth(["Contacts.ReadWrite", "People.Read.All"]),
+  pathPrefixes: ["/me/contacts", "/me/contactFolders", "/me/people"],
+  features: [accountIdentityFeature("microsoft")]
+};
+var MICROSOFT_ONEDRIVE_PRESET = {
+  id: "microsoft-onedrive",
+  name: "OneDrive",
+  summary: "Drives, files, folders, sharing links, and permissions.",
+  family: "microsoft",
+  sourceFormat: "openapi",
+  sourceUrl: MICROSOFT_GRAPH_OPENAPI_URL,
+  baseUrl: MICROSOFT_GRAPH_BASE_URL,
+  oauth: microsoftOAuth(["Files.ReadWrite.All", "Sites.ReadWrite.All"]),
+  pathPrefixes: ["/me/drive", "/me/drives", "/me/followedSites", "/drives", "/shares"],
+  features: [driveKnowledgeFeature("microsoft-onedrive"), accountIdentityFeature("microsoft")]
+};
+var CORE_PROVIDER_PRESETS = [
+  GOOGLE_DRIVE_PRESET,
+  GOOGLE_GMAIL_PRESET,
+  MICROSOFT_OUTLOOK_MAIL_PRESET,
+  MICROSOFT_OUTLOOK_CALENDAR_PRESET,
+  MICROSOFT_OUTLOOK_CONTACTS_PRESET,
+  MICROSOFT_ONEDRIVE_PRESET
+];
+function providerPresetById(id) {
+  return CORE_PROVIDER_PRESETS.find((preset) => preset.id === id);
+}
+function providerDomainForPreset(preset) {
+  return new URL(preset.baseUrl).hostname.toLowerCase();
+}
+function integrationFeaturesForPreset(presetId) {
+  return presetId ? providerPresetById(presetId)?.features ?? [] : [];
+}
+function filterOpenApiDocumentForPreset(document, preset) {
+  if (!preset.pathPrefixes?.length) return document;
+  if (!isRecord3(document.paths)) {
+    throw new IntegrationProtocolError("openapi_paths", "OpenAPI document has no paths object");
+  }
+  const paths = Object.fromEntries(
+    Object.entries(document.paths).filter(
+      ([path]) => preset.pathPrefixes.some((prefix) => path === prefix || path.startsWith(`${prefix}/`))
+    )
+  );
+  if (Object.keys(paths).length === 0) {
+    throw new IntegrationProtocolError(
+      "provider_preset_empty",
+      `${preset.name} did not match any operations in the supplied OpenAPI document`
+    );
+  }
+  return {
+    ...document,
+    paths,
+    ...preset.baseUrl ? { servers: [{ url: preset.baseUrl }] } : {}
+  };
+}
+function googleDiscoveryToOpenApi(discovery) {
+  if (!isRecord3(discovery)) {
+    throw new IntegrationProtocolError(
+      "google_discovery_shape",
+      "Google Discovery document is invalid"
+    );
+  }
+  const rootUrl = stringValue2(discovery.rootUrl) ?? stringValue2(discovery.baseUrl);
+  const servicePath = stringValue2(discovery.servicePath) ?? "";
+  if (!rootUrl || !URL.canParse(rootUrl)) {
+    throw new IntegrationProtocolError(
+      "google_discovery_server",
+      "Google Discovery document has no valid root URL"
+    );
+  }
+  const paths = {};
+  collectGoogleMethods(discovery, discovery.methods, paths);
+  collectGoogleResources(discovery, discovery.resources, paths);
+  if (Object.keys(paths).length === 0) {
+    throw new IntegrationProtocolError(
+      "google_discovery_empty",
+      "Google Discovery document exposes no methods"
+    );
+  }
+  const scopes = isRecord3(discovery.auth) && isRecord3(discovery.auth.oauth2) ? discovery.auth.oauth2.scopes : void 0;
+  const scopeMap = isRecord3(scopes) ? Object.fromEntries(
+    Object.entries(scopes).map(([scope, value]) => [
+      scope,
+      isRecord3(value) && typeof value.description === "string" ? value.description : ""
+    ])
+  ) : {};
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: stringValue2(discovery.title) ?? stringValue2(discovery.name) ?? "Google API",
+      description: stringValue2(discovery.description) ?? "Google Discovery API",
+      version: stringValue2(discovery.version) ?? "v1"
+    },
+    servers: [{ url: new URL(servicePath, rootUrl).toString() }],
+    paths,
+    components: {
+      schemas: Object.fromEntries(
+        Object.entries(isRecord3(discovery.schemas) ? discovery.schemas : {}).map(
+          ([name, schema]) => [name, convertGoogleSchema(schema)]
+        )
+      ),
+      securitySchemes: {
+        googleOAuth2: {
+          type: "oauth2",
+          flows: {
+            authorizationCode: {
+              authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+              tokenUrl: "https://oauth2.googleapis.com/token",
+              scopes: scopeMap
+            }
+          }
+        }
+      }
+    },
+    security: Object.keys(scopeMap).length > 0 ? [{ googleOAuth2: [] }] : []
+  };
+}
+function collectGoogleResources(document, value, paths) {
+  if (!isRecord3(value)) return;
+  for (const resource of Object.values(value)) {
+    if (!isRecord3(resource)) continue;
+    collectGoogleMethods(document, resource.methods, paths);
+    collectGoogleResources(document, resource.resources, paths);
+  }
+}
+function collectGoogleMethods(document, value, paths) {
+  if (!isRecord3(value)) return;
+  for (const [fallbackId, rawMethod] of Object.entries(value)) {
+    if (!isRecord3(rawMethod)) continue;
+    const path = stringValue2(rawMethod.path);
+    const httpMethod = stringValue2(rawMethod.httpMethod)?.toLowerCase();
+    if (!path || !httpMethod) continue;
+    const parameters = Object.entries(
+      isRecord3(rawMethod.parameters) ? rawMethod.parameters : {}
+    ).flatMap(([name, rawParameter]) => {
+      if (!isRecord3(rawParameter)) return [];
+      const location = rawParameter.location === "path" ? "path" : "query";
+      return [
+        {
+          name,
+          in: location,
+          required: location === "path" || rawParameter.required === true,
+          ...stringValue2(rawParameter.description) ? { description: stringValue2(rawParameter.description) } : {},
+          schema: convertGoogleSchema(rawParameter)
+        }
+      ];
+    });
+    const requestRef = isRecord3(rawMethod.request) ? stringValue2(rawMethod.request.$ref) : void 0;
+    const responseRef = isRecord3(rawMethod.response) ? stringValue2(rawMethod.response.$ref) : void 0;
+    const operation = {
+      operationId: stringValue2(rawMethod.id) ?? fallbackId,
+      summary: stringValue2(rawMethod.description) ?? stringValue2(rawMethod.id) ?? fallbackId,
+      description: stringValue2(rawMethod.description),
+      parameters,
+      responses: {
+        "200": {
+          description: "Successful response",
+          ...responseRef ? {
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/${escapeJsonPointer(responseRef)}` }
+              }
+            }
+          } : {}
+        }
+      },
+      ...Array.isArray(rawMethod.scopes) && rawMethod.scopes.length > 0 ? { security: [{ googleOAuth2: rawMethod.scopes }] } : {}
+    };
+    if (requestRef) {
+      operation.requestBody = {
+        required: true,
+        content: {
+          "application/json": {
+            schema: { $ref: `#/components/schemas/${escapeJsonPointer(requestRef)}` }
+          }
+        }
+      };
+    }
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const existing = isRecord3(paths[normalizedPath]) ? paths[normalizedPath] : {};
+    paths[normalizedPath] = { ...existing, [httpMethod]: operation };
+  }
+}
+function convertGoogleSchema(value, depth = 0) {
+  if (!isRecord3(value) || depth > 20) return {};
+  if (typeof value.$ref === "string") {
+    return { $ref: `#/components/schemas/${escapeJsonPointer(value.$ref)}` };
+  }
+  const result = {};
+  const type = stringValue2(value.type);
+  if (type) result.type = type === "any" ? void 0 : type;
+  for (const key of [
+    "description",
+    "format",
+    "pattern",
+    "minimum",
+    "maximum",
+    "default"
+  ]) {
+    if (value[key] !== void 0) result[key] = value[key];
+  }
+  if (Array.isArray(value.enum)) result.enum = value.enum;
+  if (isRecord3(value.properties)) {
+    result.type = result.type ?? "object";
+    result.properties = Object.fromEntries(
+      Object.entries(value.properties).map(([name, schema]) => [
+        name,
+        convertGoogleSchema(schema, depth + 1)
+      ])
+    );
+  }
+  if (value.items !== void 0) {
+    result.type = result.type ?? "array";
+    result.items = convertGoogleSchema(value.items, depth + 1);
+  }
+  if (value.additionalProperties !== void 0) {
+    result.additionalProperties = value.additionalProperties === true ? true : convertGoogleSchema(value.additionalProperties, depth + 1);
+  }
+  if (Array.isArray(value.required)) result.required = value.required;
+  return Object.fromEntries(Object.entries(result).filter(([, entry]) => entry !== void 0));
+}
+function escapeJsonPointer(value) {
+  return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export {
+  CORE_PROVIDER_PRESETS,
+  DEFAULT_INTEGRATION_RESPONSE_BYTES,
+  DEFAULT_INTEGRATION_TIMEOUT_MS,
+  GOOGLE_DRIVE_PRESET,
+  GOOGLE_GMAIL_PRESET,
+  GraphqlMcpServer,
+  IntegrationInvocationError,
+  IntegrationProtocolError,
+  MAX_INTEGRATION_SPEC_BYTES,
+  MAX_INTEGRATION_TOOLS,
+  MICROSOFT_GRAPH_BASE_URL,
+  MICROSOFT_GRAPH_OPENAPI_URL,
+  MICROSOFT_ONEDRIVE_PRESET,
+  MICROSOFT_OUTLOOK_CALENDAR_PRESET,
+  MICROSOFT_OUTLOOK_CONTACTS_PRESET,
+  MICROSOFT_OUTLOOK_MAIL_PRESET,
+  OpenApiMcpServer,
+  applyCredentialPlacements,
+  assertCredentialAudience,
+  canonicalJson,
+  compileGraphqlRevision,
+  compileOpenApiRevision,
+  createGraphqlMcpServer,
+  createOpenApiMcpServer,
+  createPinnedIntegrationTransport,
+  deriveMcpNamespace,
+  directIntegrationTransport,
+  discoverOpenApiAuth,
+  extractMcpToolManifest,
+  fetchGraphqlIntrospection,
+  fetchIntegrationSourceDocument,
+  fetchWithDeadline,
+  filterOpenApiDocumentForPreset,
+  googleDiscoveryToOpenApi,
+  immutableRevisionId,
+  integrationFeaturesForPreset,
+  invokeGraphqlOperation,
+  invokeOpenApiOperation,
+  parseOpenApiDocument,
+  providerDomainForPreset,
+  providerPresetById,
+  readIntegrationResponse,
+  sha256Hex,
+  stableToolId,
+  validateGraphqlSelection
+};
+//# sourceMappingURL=index.js.map