@tangle-network/agent-integrations 0.33.1 → 0.33.2

package/dist/{chunk-XO2RSS6Y.js → chunk-C4CGT5JE.js}

@@ -5,7 +5,10 @@ import {
 import {
   integrationSpecToConnector,
   listIntegrationSpecs
-} from "./chunk-7T5YTVER.js";
+} from "./chunk-53NQJZAT.js";
+import {
+  adapters_exports
+} from "./chunk-DT3H3NIW.js";
 
 // src/activepieces-catalog.ts
 import { readFileSync } from "fs";
@@ -199,7 +202,7 @@ function dataClassFor(category) {
 }
 
 // src/index.ts
-import { createHmac as createHmac2, randomUUID as randomUUID5, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHmac, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
 
 // src/core-error.ts
 var IntegrationError = class extends Error {
@@ -232,10 +235,10 @@ function createConnectorAdapterProvider(options) {
           "connector_not_found"
         );
       }
-      const auth = adapter.manifest.auth;
-      if (auth.kind !== "oauth2") {
+      const auth = oauthManifestAuth(adapter.manifest.auth);
+      if (!auth) {
         throw new IntegrationError(
-          `Connector ${request.connectorId} does not support OAuth2 authorization (auth kind: ${auth.kind}).`,
+          `Connector ${request.connectorId} does not support OAuth2 authorization (auth kind: ${adapter.manifest.auth.kind}).`,
           "auth_not_supported"
         );
       }
@@ -283,10 +286,10 @@ function createConnectorAdapterProvider(options) {
           "connector_not_found"
         );
       }
-      const auth = adapter.manifest.auth;
-      if (auth.kind !== "oauth2") {
+      const auth = oauthManifestAuth(adapter.manifest.auth);
+      if (!auth) {
         throw new IntegrationError(
-          `Connector ${request.connectorId} does not support OAuth2 authorization (auth kind: ${auth.kind}).`,
+          `Connector ${request.connectorId} does not support OAuth2 authorization (auth kind: ${adapter.manifest.auth.kind}).`,
           "auth_not_supported"
         );
       }
@@ -437,13 +440,14 @@ function createConnectorAdapterCatalogSource(options) {
 }
 function manifestToConnector(providerId, adapter) {
   const manifest = adapter.manifest;
+  const primaryAuth = primaryManifestAuth(manifest.auth);
   return {
     id: manifest.kind,
     providerId,
     title: manifest.displayName,
     category: mapCategory(manifest.category),
-    auth: mapAuth(manifest.auth.kind),
-    scopes: manifest.auth.kind === "oauth2" ? manifest.auth.scopes : [],
+    auth: mapAuth(primaryAuth.kind),
+    scopes: primaryAuth.kind === "oauth2" ? primaryAuth.scopes : [],
     actions: manifest.capabilities.filter((capability) => capability.class === "read" || capability.class === "mutation").map((capability) => ({
       id: capability.name,
       title: titleFromName(capability.name),
@@ -457,7 +461,9 @@ function manifestToConnector(providerId, adapter) {
     metadata: {
       source: "first-party-adapter",
       supportTier: "firstPartyExecutable",
-      executable: true
+      executable: true,
+      authOptions: manifest.auth.kind === "one_of" ? manifest.auth.options.map((auth) => auth.kind) : [manifest.auth.kind],
+      preferredAuth: manifest.auth.kind === "one_of" ? manifest.auth.preferred : manifest.auth.kind
     }
   };
 }
@@ -508,11 +514,21 @@ function mutationResultToAction(request, result) {
   };
 }
 function mapAuth(kind) {
+  if (kind === "one_of") return "custom";
   if (kind === "oauth2") return "oauth2";
   if (kind === "api-key") return "api_key";
   if (kind === "none") return "none";
   return "custom";
 }
+function primaryManifestAuth(auth) {
+  if (auth.kind !== "one_of") return auth;
+  return auth.options.find((option) => option.kind === auth.preferred) ?? auth.options[0];
+}
+function oauthManifestAuth(auth) {
+  if (auth.kind === "oauth2") return auth;
+  if (auth.kind !== "one_of") return void 0;
+  return auth.options.find((option) => option.kind === "oauth2");
+}
 function mapCategory(category) {
   if (category === "comms") return "chat";
   if (category === "spreadsheet") return "database";
@@ -2638,620 +2654,6 @@ function createActivepiecesExecutorProvider(options) {
   });
 }
 
-// src/activepieces-runtime.ts
-import { createHmac, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
-var ACTIVEPIECES_RUNTIME_SIGNATURE_HEADER = "x-tangle-activepieces-signature";
-var TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER = "x-tangle-catalog-signature";
-function createActivepiecesHttpExecutor(options) {
-  const endpoint = options.endpoint.replace(/\/$/, "");
-  const path = options.path ?? "/v1/activepieces/actions/invoke";
-  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-  const signatureHeader = options.signatureHeader ?? ACTIVEPIECES_RUNTIME_SIGNATURE_HEADER;
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const requestId = options.requestId ?? (() => `apexec_${randomUUID3()}`);
-  return async (invocation) => {
-    const body = buildActivepiecesRuntimeRequest(invocation, requestId());
-    const serialized = JSON.stringify(body);
-    const response = await fetchImpl(`${endpoint}${normalizedPath}`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...options.headers,
-        ...options.secret ? { [signatureHeader]: signActivepiecesRuntimeRequest(serialized, options.secret) } : {}
-      },
-      body: serialized,
-      signal: AbortSignal.timeout(options.timeoutMs ?? 3e4)
-    });
-    const parsed = await response.json().catch(() => void 0);
-    if (!response.ok) {
-      return parsed ?? {
-        ok: false,
-        action: invocation.request.action,
-        output: { message: `Activepieces runtime returned HTTP ${response.status}.` }
-      };
-    }
-    return parsed ?? {
-      ok: false,
-      action: invocation.request.action,
-      output: { message: "Activepieces runtime returned an empty response." }
-    };
-  };
-}
-function buildActivepiecesRuntimeRequest(invocation, requestId = `apexec_${randomUUID3()}`) {
-  return {
-    version: 1,
-    requestId,
-    providerId: invocation.connection.providerId,
-    connection: invocation.connection,
-    connector: {
-      id: invocation.connector.id,
-      title: invocation.connector.title,
-      auth: invocation.connector.auth,
-      scopes: invocation.connector.scopes,
-      metadata: invocation.connector.metadata
-    },
-    piece: invocation.piece,
-    action: {
-      id: invocation.request.action,
-      input: invocation.request.input,
-      idempotencyKey: invocation.request.idempotencyKey,
-      dryRun: invocation.request.dryRun,
-      metadata: invocation.request.metadata
-    }
-  };
-}
-function signActivepiecesRuntimeRequest(serializedBody, secret) {
-  return `sha256=${createHmac("sha256", secret).update(serializedBody).digest("hex")}`;
-}
-function verifyActivepiecesRuntimeSignature(serializedBody, signature, secret) {
-  if (!signature) return false;
-  const expected = signActivepiecesRuntimeRequest(serializedBody, secret);
-  const left = Buffer.from(signature);
-  const right = Buffer.from(expected);
-  return left.length === right.length && timingSafeEqual(left, right);
-}
-function createTangleCatalogHttpExecutor(options) {
-  const endpoint = options.endpoint.replace(/\/$/, "");
-  const path = options.path ?? "/v1/integration-catalog/actions/invoke";
-  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-  const signatureHeader = options.signatureHeader ?? TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER;
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const requestId = options.requestId ?? (() => `tcat_${randomUUID3()}`);
-  return async (invocation) => {
-    const body = buildTangleCatalogRuntimeRequest(invocation, requestId());
-    const serialized = JSON.stringify(body);
-    const response = await fetchImpl(`${endpoint}${normalizedPath}`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...options.headers,
-        ...options.secret ? { [signatureHeader]: signTangleCatalogRuntimeRequest(serialized, options.secret) } : {}
-      },
-      body: serialized,
-      signal: AbortSignal.timeout(options.timeoutMs ?? 3e4)
-    });
-    const parsed = await response.json().catch(() => void 0);
-    if (!response.ok) {
-      return parsed ?? {
-        ok: false,
-        action: invocation.request.action,
-        output: { message: `Tangle catalog runtime returned HTTP ${response.status}.` }
-      };
-    }
-    return parsed ?? {
-      ok: false,
-      action: invocation.request.action,
-      output: { message: "Tangle catalog runtime returned an empty response." }
-    };
-  };
-}
-function buildTangleCatalogRuntimeRequest(invocation, requestId = `tcat_${randomUUID3()}`) {
-  return {
-    version: 1,
-    requestId,
-    providerId: invocation.connection.providerId,
-    connection: invocation.connection,
-    connector: {
-      id: invocation.connector.id,
-      title: invocation.connector.title,
-      auth: invocation.connector.auth,
-      scopes: invocation.connector.scopes,
-      metadata: invocation.connector.metadata
-    },
-    piece: invocation.piece,
-    action: {
-      id: invocation.request.action,
-      input: invocation.request.input,
-      idempotencyKey: invocation.request.idempotencyKey,
-      dryRun: invocation.request.dryRun,
-      metadata: invocation.request.metadata
-    }
-  };
-}
-var signTangleCatalogRuntimeRequest = signActivepiecesRuntimeRequest;
-var verifyTangleCatalogRuntimeSignature = verifyActivepiecesRuntimeSignature;
-
-// src/tangle-catalog-runtime.ts
-import { randomUUID as randomUUID4 } from "crypto";
-function createTangleCatalogRuntimeHandler(options) {
-  const connectors = options.connectors ?? buildTangleIntegrationCatalogConnectors({
-    includeCatalogActions: true,
-    executable: true
-  });
-  const byConnector = new Map(connectors.map((connector) => [connector.id, connector]));
-  const requireSignature = options.requireSignature ?? Boolean(options.secret);
-  const signatureHeader = options.signatureHeader ?? TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER;
-  const maxBodyBytes = options.maxBodyBytes ?? 1e6;
-  return async function handleTangleCatalogRuntimeRequest(input) {
-    const serialized = serializeBody(input.body);
-    if (Buffer.byteLength(serialized, "utf8") > maxBodyBytes) {
-      return errorResponse(413, "unknown", "payload_too_large", "Tangle catalog runtime request is too large.");
-    }
-    if (requireSignature) {
-      if (!options.secret) {
-        return errorResponse(500, "unknown", "runtime_misconfigured", "Tangle catalog runtime secret is not configured.");
-      }
-      const signature = readHeader(input.headers, signatureHeader);
-      if (!verifyTangleCatalogRuntimeSignature(serialized, signature, options.secret)) {
-        return errorResponse(401, "unknown", "signature_invalid", "Tangle catalog runtime signature is invalid.");
-      }
-    }
-    const parsed = parseRuntimeRequest(serialized);
-    if (!parsed.ok) return parsed.response;
-    const request = parsed.request;
-    if (request.providerId !== request.connection.providerId) {
-      return errorResponse(400, request.action.id, "provider_mismatch", "Request providerId does not match connection providerId.");
-    }
-    const connector = byConnector.get(request.connector.id);
-    if (!connector) {
-      return errorResponse(404, request.action.id, "connector_not_found", `Connector ${request.connector.id} is not in the Tangle catalog runtime.`);
-    }
-    if (request.connection.connectorId !== connector.id) {
-      return errorResponse(400, request.action.id, "connector_mismatch", "Connection connectorId does not match runtime connector.");
-    }
-    if (request.connection.providerId !== connector.providerId) {
-      return errorResponse(400, request.action.id, "provider_mismatch", "Connection providerId does not match runtime connector.");
-    }
-    const action = connector.actions.find((candidate) => candidate.id === request.action.id);
-    if (!action) {
-      return errorResponse(404, request.action.id, "action_not_found", `Action ${request.action.id} is not defined by connector ${connector.id}.`);
-    }
-    const result = await options.executeAction({
-      request,
-      connection: request.connection,
-      connector,
-      action
-    });
-    return {
-      status: result.ok ? 200 : 502,
-      headers: { "content-type": "application/json" },
-      body: result
-    };
-  };
-}
-function createTangleCatalogInstalledPackageExecutor(options = {}) {
-  const packageByConnector = new Map(
-    listActivepiecesCatalogEntries().filter((entry) => entry.npmPackage).map((entry) => [entry.id, entry.npmPackage])
-  );
-  const moduleCache = /* @__PURE__ */ new Map();
-  return async (invocation) => {
-    await options.beforeRun?.(invocation);
-    const packageName = packageByConnector.get(invocation.connector.id);
-    if (!packageName) {
-      return runtimeFailure(invocation.action.id, "runtime_not_available", `No installed runtime package is known for connector ${invocation.connector.id}.`);
-    }
-    if (invocation.request.piece.packageName && invocation.request.piece.packageName !== packageName) {
-      return runtimeFailure(
-        invocation.action.id,
-        "runtime_package_mismatch",
-        `Runtime package ${invocation.request.piece.packageName} does not match catalog package ${packageName}.`
-      );
-    }
-    const loaded = await loadRuntimeModule(packageName, options.moduleLoader, moduleCache);
-    if (!loaded.ok) {
-      return runtimeFailure(invocation.action.id, "runtime_not_installed", loaded.message);
-    }
-    const piece = findPieceExport(loaded.module, invocation.connector.id);
-    if (!piece) {
-      return runtimeFailure(invocation.action.id, "runtime_invalid", `Runtime package ${packageName} does not export a recognizable piece for ${invocation.connector.id}.`);
-    }
-    const action = findRuntimeAction(piece, invocation, options.actionAliases, options.allowFuzzyActionMatch ?? false);
-    if (!action?.run) {
-      return runtimeFailure(invocation.action.id, "action_not_implemented", `Runtime package ${packageName} does not expose executable action ${invocation.action.id}.`);
-    }
-    try {
-      const output = await action.run({
-        auth: await options.resolveAuth?.(invocation.connection),
-        propsValue: invocation.request.action.input,
-        input: invocation.request.action.input,
-        connection: invocation.connection,
-        request: invocation.request
-      });
-      return {
-        ok: true,
-        action: invocation.action.id,
-        output
-      };
-    } catch (error) {
-      return runtimeFailure(
-        invocation.action.id,
-        "runtime_action_failed",
-        error instanceof Error ? error.message : "Runtime action failed."
-      );
-    }
-  };
-}
-async function auditTangleCatalogRuntimePackages(options = {}) {
-  const only = options.connectorIds ? new Set(options.connectorIds) : void 0;
-  const rows = [];
-  const moduleCache = /* @__PURE__ */ new Map();
-  const entries = listActivepiecesCatalogEntries().filter((entry) => entry.npmPackage && (!only || only.has(entry.id)));
-  for (const entry of entries) {
-    const packageName = entry.npmPackage;
-    const base = {
-      connectorId: entry.id,
-      packageName,
-      actionMappingsTotal: entry.actions.length,
-      triggerMappingsTotal: entry.triggers.length
-    };
-    const loaded = await loadRuntimeModule(packageName, options.moduleLoader, moduleCache);
-    if (!loaded.ok) {
-      rows.push({
-        ...base,
-        packageInstalled: false,
-        packageLoads: false,
-        pieceExportFound: false,
-        actionMappingsVerified: 0,
-        triggerMappingsFound: 0,
-        triggerHostingSupported: false,
-        error: loaded.message
-      });
-      continue;
-    }
-    const piece = findPieceExport(loaded.module, entry.id);
-    const actions = piece?.actions ?? [];
-    const triggers = piece?.triggers ?? [];
-    rows.push({
-      ...base,
-      packageInstalled: true,
-      packageLoads: true,
-      pieceExportFound: Boolean(piece),
-      actionMappingsVerified: entry.actions.filter((action) => hasRuntimeName(actions, [
-        action.id,
-        action.title,
-        action.upstreamName
-      ], entry.id)).length,
-      triggerMappingsFound: entry.triggers.filter((trigger2) => hasRuntimeName(triggers, [
-        trigger2.id,
-        trigger2.title,
-        trigger2.upstreamName
-      ], entry.id)).length,
-      triggerHostingSupported: entry.triggers.length === 0 || triggers.length > 0
-    });
-  }
-  return rows;
-}
-function createTangleCatalogCredentialAuthResolver(options) {
-  return async function resolveTangleCatalogAuth(connection) {
-    if (!connection.secretRef) return void 0;
-    const credentials = await options.secrets.get(connection.secretRef);
-    if (!credentials) throw new Error(`Secret ${connection.secretRef.provider}/${connection.secretRef.id} not found.`);
-    return options.mapCredentials?.({
-      connection,
-      credentials,
-      connectorId: connection.connectorId
-    }) ?? tangleCatalogAuthValue(credentials);
-  };
-}
-function createTangleCatalogHttpAuthResolver(options) {
-  const endpoint = options.endpoint.replace(/\/$/, "");
-  const path = options.path ?? "/v1/integration-catalog/credentials/resolve";
-  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const requestId = options.requestId ?? (() => `tcat_auth_${randomUUID4()}`);
-  return async function resolveTangleCatalogHttpAuth(connection) {
-    const body = {
-      version: 1,
-      requestId: requestId(),
-      providerId: connection.providerId,
-      connectorId: connection.connectorId,
-      connectionId: connection.id,
-      secretRef: connection.secretRef
-    };
-    const serialized = JSON.stringify(body);
-    const response = await fetchImpl(`${endpoint}${normalizedPath}`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...options.headers,
-        [TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER]: signTangleCatalogRuntimeRequest(serialized, options.secret)
-      },
-      body: serialized,
-      signal: AbortSignal.timeout(options.timeoutMs ?? 1e4)
-    });
-    const parsed = await response.json().catch(() => void 0);
-    if (!response.ok) {
-      throw new Error(parsed?.error?.message ?? `Credential resolver returned HTTP ${response.status}.`);
-    }
-    if (parsed && "auth" in parsed) return parsed.auth;
-    if (parsed?.credentials) return tangleCatalogAuthValue(parsed.credentials);
-    return void 0;
-  };
-}
-function tangleCatalogAuthValue(credentials) {
-  if (credentials.kind === "none") return void 0;
-  if (credentials.kind === "api-key") return credentials.apiKey;
-  if (credentials.kind === "hmac") return credentials.secret;
-  if (credentials.kind === "custom") return credentials.values;
-  return {
-    access_token: credentials.accessToken,
-    refresh_token: credentials.refreshToken,
-    expires_at: credentials.expiresAt
-  };
-}
-function serializeBody(body) {
-  if (typeof body === "string") return body;
-  if (body instanceof Uint8Array) return new TextDecoder().decode(body);
-  return JSON.stringify(body);
-}
-async function loadRuntimeModule(packageName, moduleLoader, moduleCache) {
-  try {
-    const load = moduleLoader ?? ((name) => import(name));
-    const promise = moduleCache.get(packageName) ?? Promise.resolve(load(packageName));
-    moduleCache.set(packageName, promise);
-    return { ok: true, module: await promise };
-  } catch (error) {
-    return {
-      ok: false,
-      message: error instanceof Error ? `Runtime package ${packageName} could not be loaded: ${error.message}` : `Runtime package ${packageName} could not be loaded.`
-    };
-  }
-}
-function findPieceExport(moduleValue, connectorId) {
-  const mod = moduleValue && typeof moduleValue === "object" ? moduleValue : {};
-  const values = [
-    mod.default,
-    mod[camel(connectorId)],
-    mod[connectorId],
-    ...Object.values(mod)
-  ];
-  for (const value of values) {
-    const resolved = resolvePiece(value);
-    if (resolved) return resolved;
-  }
-  return void 0;
-}
-function resolvePiece(value) {
-  if (!value || typeof value !== "object" && typeof value !== "function") return void 0;
-  const candidate = value;
-  const ctorName = candidate.constructor?.name;
-  const looksLikePiece = ctorName === "Piece" || "_actions" in candidate || "_triggers" in candidate || "actions" in candidate || "triggers" in candidate;
-  if (!looksLikePiece) return void 0;
-  const actions = readPieceMembers(candidate, "_actions", "actions");
-  const triggers = readPieceMembers(candidate, "_triggers", "triggers");
-  if (!actions && !triggers) return void 0;
-  return { actions: actions ?? [], triggers: triggers ?? [] };
-}
-function readPieceMembers(piece, privateKey, publicKey) {
-  const raw = coerceMemberCollection(piece[privateKey]) ?? coerceMemberCollection(readPublicMember(piece, publicKey));
-  if (!raw) return void 0;
-  return raw.filter((member) => Boolean(member) && typeof member === "object");
-}
-function readPublicMember(piece, key) {
-  const value = piece[key];
-  if (typeof value !== "function") return value;
-  try {
-    return value.call(piece);
-  } catch {
-    return void 0;
-  }
-}
-function coerceMemberCollection(value) {
-  if (Array.isArray(value)) return value;
-  if (value && typeof value === "object") return Object.values(value);
-  return void 0;
-}
-function hasRuntimeName(members, candidates, connectorId) {
-  const expected = normalizeNameSet(candidates, connectorId);
-  return members.some((member) => {
-    const names = normalizeNameSet([member.name, member.displayName], connectorId);
-    for (const name of names) if (expected.has(name)) return true;
-    return false;
-  });
-}
-function findRuntimeAction(piece, invocation, aliases = {}, allowFuzzyActionMatch = false) {
-  const actions = piece.actions;
-  const explicit = aliases[invocation.connector.id]?.[invocation.action.id];
-  if (explicit) {
-    const exact = actions.find((action) => action.name === explicit || action.displayName === explicit);
-    if (exact) return exact;
-  }
-  const connectorId = invocation.connector.id;
-  const candidates = normalizeNameSet([
-    invocation.action.id,
-    invocation.action.title,
-    invocation.request.piece.upstreamActionName,
-    explicit
-  ], connectorId);
-  for (const action of actions) {
-    const names = normalizeNameSet([action.name, action.displayName], connectorId);
-    for (const name of names) if (candidates.has(name)) return action;
-  }
-  void allowFuzzyActionMatch;
-  return void 0;
-}
-function normalizeNameSet(values, connectorId) {
-  const out = /* @__PURE__ */ new Set();
-  const conn = comparable(connectorId);
-  for (const value of values) {
-    if (!value) continue;
-    for (const variant of nameVariants(comparable(value), conn)) {
-      if (variant) out.add(variant);
-    }
-  }
-  return out;
-}
-function nameVariants(cmp, conn) {
-  const base = [cmp, cmp.replace(/(action|trigger)$/, "")];
-  const variants = [];
-  for (const value of base) {
-    variants.push(value);
-    if (conn && value.startsWith(conn) && value.length > conn.length) {
-      variants.push(value.slice(conn.length));
-    }
-  }
-  return variants;
-}
-function runtimeFailure(action, code, message) {
-  return {
-    ok: false,
-    action,
-    output: { code, message }
-  };
-}
-function comparable(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
-}
-function camel(value) {
-  return value.replace(/[-_.]+([a-z0-9])/g, (_, char) => char.toUpperCase());
-}
-function parseRuntimeRequest(serialized) {
-  try {
-    const request = JSON.parse(serialized);
-    if (request.version !== 1) {
-      return { ok: false, response: errorResponse(400, request.action?.id ?? "unknown", "version_invalid", "Unsupported Tangle catalog runtime request version.") };
-    }
-    if (!request.connection || !request.connector || !request.action?.id) {
-      return { ok: false, response: errorResponse(400, request.action?.id ?? "unknown", "request_invalid", "Tangle catalog runtime request is missing required fields.") };
-    }
-    return { ok: true, request };
-  } catch {
-    return { ok: false, response: errorResponse(400, "unknown", "json_invalid", "Tangle catalog runtime request body is not valid JSON.") };
-  }
-}
-function readHeader(headers, name) {
-  if (!headers) return void 0;
-  if (headers instanceof Headers) return headers.get(name) ?? void 0;
-  const wanted = name.toLowerCase();
-  for (const [key, value] of Object.entries(headers)) {
-    if (key.toLowerCase() !== wanted) continue;
-    if (Array.isArray(value)) return value[0];
-    return value;
-  }
-  return void 0;
-}
-function errorResponse(status, action, code, message) {
-  return {
-    status,
-    headers: { "content-type": "application/json" },
-    body: {
-      ok: false,
-      action,
-      output: { code, message }
-    }
-  };
-}
-
-// src/tangle-catalog-runtime-server.ts
-import { createServer } from "http";
-function createTangleCatalogRuntimeNodeRequestListener(options) {
-  const path = options.path ?? "/v1/integration-catalog/actions/invoke";
-  const maxBodyBytes = options.maxBodyBytes ?? 1e6;
-  const resolveAuth = options.executor?.resolveAuth ?? (options.authResolver ? createTangleCatalogHttpAuthResolver(options.authResolver) : void 0);
-  const runtime = createTangleCatalogRuntimeHandler({
-    secret: options.secret,
-    requireSignature: options.requireSignature,
-    maxBodyBytes,
-    executeAction: createTangleCatalogInstalledPackageExecutor({
-      ...options.executor,
-      resolveAuth
-    })
-  });
-  return async function tangleCatalogRuntimeNodeRequestListener(request, response) {
-    try {
-      const url = new URL(request.url ?? "/", "http://localhost");
-      if (request.method === "GET" && url.pathname === "/health") {
-        writeJson(response, 200, { ok: true });
-        return;
-      }
-      if (request.method !== "POST" || url.pathname !== path) {
-        writeJson(response, 404, {
-          ok: false,
-          error: { code: "not_found", message: "Tangle catalog runtime route not found." }
-        });
-        return;
-      }
-      const body = await readBody(request, maxBodyBytes);
-      const result = await runtime({
-        body,
-        headers: request.headers
-      });
-      writeJson(response, result.status, result.body, result.headers);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Tangle catalog runtime request failed.";
-      options.onLog?.({ level: "error", message });
-      writeJson(response, message === "payload_too_large" ? 413 : 500, {
-        ok: false,
-        action: "unknown",
-        output: {
-          code: message === "payload_too_large" ? "payload_too_large" : "runtime_request_failed",
-          message: message === "payload_too_large" ? "Tangle catalog runtime request is too large." : message
-        }
-      });
-    }
-  };
-}
-async function startTangleCatalogRuntimeNodeServer(options) {
-  const host = options.host ?? "0.0.0.0";
-  const port = options.port ?? 4109;
-  const listener = createTangleCatalogRuntimeNodeRequestListener(options);
-  const server = createServer(listener);
-  await new Promise((resolve2, reject) => {
-    server.once("error", reject);
-    server.listen(port, host, () => {
-      server.off("error", reject);
-      resolve2();
-    });
-  });
-  const address = server.address();
-  const actualPort = typeof address === "object" && address ? address.port : port;
-  const urlHost = host === "0.0.0.0" ? "127.0.0.1" : host;
-  return {
-    server,
-    url: `http://${urlHost}:${actualPort}`,
-    close: () => new Promise((resolve2, reject) => {
-      server.close((error) => {
-        if (error) reject(error);
-        else resolve2();
-      });
-    })
-  };
-}
-function readBody(request, maxBodyBytes) {
-  return new Promise((resolve2, reject) => {
-    const chunks = [];
-    let bytes = 0;
-    request.on("data", (chunk) => {
-      bytes += chunk.byteLength;
-      if (bytes > maxBodyBytes) {
-        reject(new Error("payload_too_large"));
-        request.destroy();
-        return;
-      }
-      chunks.push(chunk);
-    });
-    request.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
-    request.on("error", reject);
-  });
-}
-function writeJson(response, status, body, headers = {}) {
-  response.writeHead(status, {
-    "content-type": "application/json",
-    ...headers
-  });
-  response.end(JSON.stringify(body));
-}
-
 // src/catalog-freshness.ts
 var ACTIVEPIECES_PUBLIC_CATALOG_URL = "https://www.activepieces.com/pieces";
 function parseCount(value) {
@@ -3819,7 +3221,7 @@ var IntegrationHub = class {
     assertScopes(connection, request.scopes);
     const now = this.now();
     const capability = {
-      id: `cap_${randomUUID5()}`,
+      id: `cap_${randomUUID3()}`,
       subject: request.subject,
       connectionId: request.connectionId,
       scopes: unique6(request.scopes),
@@ -4057,12 +3459,12 @@ function assertScopes(connection, requiredScopes2) {
   if (missing2.length > 0) throw new IntegrationError(`Missing integration scopes: ${missing2.join(", ")}`, "scope_denied");
 }
 function hmac(payload, secret) {
-  return createHmac2("sha256", secret).update(payload).digest("base64url");
+  return createHmac("sha256", secret).update(payload).digest("base64url");
 }
 function constantTimeEqual(a, b) {
   const left = Buffer.from(a);
   const right = Buffer.from(b);
-  return left.length === right.length && timingSafeEqual2(left, right);
+  return left.length === right.length && timingSafeEqual(left, right);
 }
 function base64UrlEncode2(value) {
   return Buffer.from(value, "utf8").toString("base64url");
@@ -4116,30 +3518,27 @@ function createCatalogExecutorProvider(options) {
 // src/tangle-catalog.ts
 var TANGLE_INTEGRATIONS_CATALOG_PROVIDER_ID = "tangle-catalog";
 var TANGLE_INTEGRATIONS_CATALOG_SOURCE = "tangle-integrations-catalog";
-var NATIVE_ADAPTER_IDS = /* @__PURE__ */ new Set([
-  "google-calendar",
-  "google-sheets",
-  "microsoft-calendar",
-  "hubspot",
-  "slack",
-  "notion-database",
-  "twilio-sms",
-  "stripe-pack",
-  "webhook",
-  "stripe",
-  "slack-inbound",
-  "github",
-  "gitlab",
-  "airtable",
-  "asana",
-  "salesforce"
-]);
+function listTangleNativeAdapterIds() {
+  const ids = /* @__PURE__ */ new Set();
+  for (const value of Object.values(adapters_exports)) {
+    if (isConnectorAdapter(value)) {
+      ids.add(value.manifest.kind);
+    }
+  }
+  return [...ids].sort();
+}
+function isConnectorAdapter(value) {
+  return Boolean(
+    value && typeof value === "object" && "manifest" in value && value.manifest && typeof value.manifest.kind === "string"
+  );
+}
 function listTangleIntegrationCatalogEntries() {
   return listActivepiecesCatalogEntries().map((entry) => sanitizeEntry(entry));
 }
 function listTangleIntegrationContracts() {
+  const nativeAdapterIds = new Set(listTangleNativeAdapterIds());
   return listActivepiecesCatalogEntries().map((entry) => {
-    const nativeAdapter = NATIVE_ADAPTER_IDS.has(entry.id);
+    const nativeAdapter = nativeAdapterIds.has(entry.id);
     return {
       id: entry.id,
       title: entry.title,
@@ -4176,7 +3575,8 @@ function listTangleIntegrationContracts() {
   });
 }
 function listTangleIntegrationCatalogRuntimePackages() {
-  return listActivepiecesCatalogEntries().filter((entry) => Boolean(entry.npmPackage)).map((entry) => ({
+  const nativeAdapterIds = new Set(listTangleNativeAdapterIds());
+  return listActivepiecesCatalogEntries().filter((entry) => Boolean(entry.npmPackage) && !nativeAdapterIds.has(entry.id)).map((entry) => ({
     connectorId: entry.id,
     packageName: entry.npmPackage,
     version: entry.version
@@ -4341,7 +3741,7 @@ function sanitizeConnector(connector, providerId) {
       source: TANGLE_INTEGRATIONS_CATALOG_SOURCE,
       providerId,
       executable: metadata.executable,
-      runtime: "tangle-catalog-runtime",
+      runtime: "native-adapter-backlog",
       catalogOnly: metadata.catalogOnly,
       supportTier: metadata.supportTier,
       catalogActionCount: metadata.catalogActionCount,
@@ -4403,7 +3803,7 @@ function buildDefaultIntegrationRegistry(options = {}) {
         source: "tangle-integrations-catalog",
         providerId: "tangle-catalog",
         executable: connector.metadata?.executable,
-        runtime: "tangle-catalog-runtime",
+        runtime: "native-adapter-backlog",
         catalogOnly: connector.metadata?.catalogOnly,
         supportTier: connector.metadata?.supportTier,
         catalogActionCount: connector.metadata?.catalogActionCount,
@@ -4798,18 +4198,9 @@ export {
   ACTIVEPIECES_PUBLIC_CATALOG_URL,
   extractActivepiecesPublicPieceCount,
   auditIntegrationCatalogFreshness,
-  ACTIVEPIECES_RUNTIME_SIGNATURE_HEADER,
-  TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER,
-  createActivepiecesHttpExecutor,
-  buildActivepiecesRuntimeRequest,
-  signActivepiecesRuntimeRequest,
-  verifyActivepiecesRuntimeSignature,
-  createTangleCatalogHttpExecutor,
-  buildTangleCatalogRuntimeRequest,
-  signTangleCatalogRuntimeRequest,
-  verifyTangleCatalogRuntimeSignature,
   TANGLE_INTEGRATIONS_CATALOG_PROVIDER_ID,
   TANGLE_INTEGRATIONS_CATALOG_SOURCE,
+  listTangleNativeAdapterIds,
   listTangleIntegrationCatalogEntries,
   listTangleIntegrationContracts,
   listTangleIntegrationCatalogRuntimePackages,
@@ -4897,14 +4288,6 @@ export {
   importMcpConnector,
   createGatewayCatalogProvider,
   normalizeGatewayCatalog,
-  createTangleCatalogRuntimeHandler,
-  createTangleCatalogInstalledPackageExecutor,
-  auditTangleCatalogRuntimePackages,
-  createTangleCatalogCredentialAuthResolver,
-  createTangleCatalogHttpAuthResolver,
-  tangleCatalogAuthValue,
-  createTangleCatalogRuntimeNodeRequestListener,
-  startTangleCatalogRuntimeNodeServer,
   InMemoryIntegrationGrantStore,
   IntegrationRuntime,
   createIntegrationRuntime,
@@ -4919,4 +4302,4 @@ export {
   signCapability,
   verifyCapabilityToken
 };
-//# sourceMappingURL=chunk-XO2RSS6Y.js.map
+//# sourceMappingURL=chunk-C4CGT5JE.js.map