@tangle-network/agent-integrations 0.31.0 → 0.33.0

package/dist/registry.js

@@ -5,16 +5,16 @@ import {
   composeIntegrationRegistry,
   inferIntegrationSupportTier,
   summarizeIntegrationRegistry
-} from "./chunk-M2RFFAMB.js";
-import "./chunk-JCHD6L3B.js";
-import "./chunk-CDY2ETYT.js";
+} from "./chunk-XO2RSS6Y.js";
+import "./chunk-43VQSANC.js";
+import "./chunk-YPZORI3G.js";
 import "./chunk-H4XYLS7T.js";
-import "./chunk-S2MVWQYL.js";
-import "./chunk-VVC7U7W7.js";
+import "./chunk-RF3RH374.js";
+import "./chunk-7T5YTVER.js";
 import "./chunk-376UBTNB.js";
-import "./chunk-F4YILONK.js";
+import "./chunk-6N23S4JY.js";
 import "./chunk-2TW2QKGZ.js";
-import "./chunk-Q5X3QNHR.js";
+import "./chunk-NQ7OPDUM.js";
 export {
   buildDefaultIntegrationRegistry,
   canonicalConnectorId,

package/dist/runtime.d.ts

@@ -1,8 +1,137 @@
-export { h as InMemoryIntegrationGrantStore, j as IntegrationCapabilityBinding, k as IntegrationGrant, l as IntegrationGrantStore, m as IntegrationManifest, n as IntegrationManifestResolution, o as IntegrationRequirement, q as IntegrationRequirementMode, r as IntegrationRequirementResolution, u as IntegrationRequirementStatus, v as IntegrationRuntime, w as IntegrationRuntimeHub, x as IntegrationRuntimeOptions, y as IntegrationSandboxBundle, z as createIntegrationRuntime } from './registry.js';
-import './tangle-id-Dj0ipP4E.js';
-import './errors-Bg3_rxnQ.js';
-import './connect/index.js';
-import './middleware/index.js';
-import './connectors/index.js';
-import './connectors/adapters/index.js';
-import 'node:http';
+import { IntegrationToolDefinition } from './catalog.js';
+import { IntegrationRegistryEntry, IntegrationRegistry } from './registry.js';
+import { I as IntegrationActor, a as IssuedIntegrationCapability, b as IntegrationConnector, c as IntegrationConnection } from './core-types-D5Dc65Ud.js';
+import './types-XdpvaIzW.js';
+
+type IntegrationRequirementMode = 'read' | 'write' | 'trigger';
+type IntegrationRequirementStatus = 'ready' | 'missing_connection' | 'not_executable' | 'unknown_connector';
+interface IntegrationRequirement {
+    id: string;
+    connectorId: string;
+    reason: string;
+    mode: IntegrationRequirementMode;
+    requiredActions?: string[];
+    requiredTriggers?: string[];
+    requiredScopes?: string[];
+    optional?: boolean;
+}
+interface IntegrationManifest {
+    id: string;
+    title?: string;
+    owner?: IntegrationActor;
+    requirements: IntegrationRequirement[];
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationRequirementResolution {
+    requirement: IntegrationRequirement;
+    status: IntegrationRequirementStatus;
+    connector?: IntegrationConnector;
+    registryEntry?: IntegrationRegistryEntry;
+    connection?: IntegrationConnection;
+    missingScopes: string[];
+    missingActions: string[];
+    missingTriggers: string[];
+    message: string;
+}
+interface IntegrationManifestResolution {
+    manifest: IntegrationManifest;
+    owner: IntegrationActor;
+    ready: IntegrationRequirementResolution[];
+    missing: IntegrationRequirementResolution[];
+    optionalMissing: IntegrationRequirementResolution[];
+}
+interface IntegrationGrant {
+    id: string;
+    manifestId: string;
+    requirementId: string;
+    owner: IntegrationActor;
+    grantee: IntegrationActor;
+    connectionId: string;
+    connectorId: string;
+    scopes: string[];
+    allowedActions: string[];
+    allowedTriggers: string[];
+    status: 'active' | 'revoked';
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationGrantStore {
+    get(grantId: string): Promise<IntegrationGrant | undefined> | IntegrationGrant | undefined;
+    put(grant: IntegrationGrant): Promise<void> | void;
+    listByManifest(manifestId: string, grantee?: IntegrationActor): Promise<IntegrationGrant[]> | IntegrationGrant[];
+    listByGrantee(grantee: IntegrationActor): Promise<IntegrationGrant[]> | IntegrationGrant[];
+    listByIds?(grantIds: string[]): Promise<IntegrationGrant[]> | IntegrationGrant[];
+    delete?(grantId: string): Promise<void> | void;
+}
+interface IntegrationCapabilityBinding {
+    requirementId: string;
+    connectorId: string;
+    connectionId: string;
+    grantId: string;
+    scopes: string[];
+    allowedActions: string[];
+    allowedTriggers: string[];
+    capability: IssuedIntegrationCapability;
+}
+interface IntegrationSandboxBundle {
+    manifestId: string;
+    subject: IntegrationActor;
+    capabilities: IntegrationCapabilityBinding[];
+    connectors: IntegrationConnector[];
+    tools: IntegrationToolDefinition[];
+    expiresAt: string;
+}
+interface IntegrationRuntimeHub {
+    listRegistry(): Promise<IntegrationRegistry> | IntegrationRegistry;
+    listConnections(owner: IntegrationActor): Promise<IntegrationConnection[]> | IntegrationConnection[];
+    getConnection(connectionId: string): Promise<IntegrationConnection | undefined> | IntegrationConnection | undefined;
+    issueCapability(input: {
+        subject: IntegrationActor;
+        connectionId: string;
+        scopes: string[];
+        allowedActions: string[];
+        ttlMs: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<IssuedIntegrationCapability> | IssuedIntegrationCapability;
+}
+interface IntegrationRuntimeOptions {
+    hub: IntegrationRuntimeHub;
+    grants?: IntegrationGrantStore;
+    now?: () => Date;
+}
+declare class InMemoryIntegrationGrantStore implements IntegrationGrantStore {
+    private readonly grants;
+    get(grantId: string): IntegrationGrant | undefined;
+    put(grant: IntegrationGrant): void;
+    listByManifest(manifestId: string, grantee?: IntegrationActor): IntegrationGrant[];
+    listByGrantee(grantee: IntegrationActor): IntegrationGrant[];
+    listByIds(grantIds: string[]): IntegrationGrant[];
+    delete(grantId: string): void;
+}
+declare class IntegrationRuntime {
+    private readonly hub;
+    private readonly grants;
+    private readonly now;
+    constructor(options: IntegrationRuntimeOptions);
+    registry(): Promise<IntegrationRegistry>;
+    resolveManifest(manifest: IntegrationManifest, owner: IntegrationActor): Promise<IntegrationManifestResolution>;
+    createGrants(input: {
+        manifest: IntegrationManifest;
+        owner: IntegrationActor;
+        grantee: IntegrationActor;
+        metadata?: Record<string, unknown>;
+    }): Promise<IntegrationGrant[]>;
+    buildSandboxBundle(input: {
+        manifestId?: string;
+        grantIds?: string[];
+        owner: IntegrationActor;
+        subject: IntegrationActor;
+        ttlMs: number;
+        grantee?: IntegrationActor;
+    }): Promise<IntegrationSandboxBundle>;
+    private resolveBundleGrants;
+}
+declare function createIntegrationRuntime(options: IntegrationRuntimeOptions): IntegrationRuntime;
+
+export { InMemoryIntegrationGrantStore, type IntegrationCapabilityBinding, type IntegrationGrant, type IntegrationGrantStore, type IntegrationManifest, type IntegrationManifestResolution, type IntegrationRequirement, type IntegrationRequirementMode, type IntegrationRequirementResolution, type IntegrationRequirementStatus, IntegrationRuntime, type IntegrationRuntimeHub, type IntegrationRuntimeOptions, type IntegrationSandboxBundle, createIntegrationRuntime };

package/dist/runtime.js

@@ -2,16 +2,16 @@ import {
   InMemoryIntegrationGrantStore,
   IntegrationRuntime,
   createIntegrationRuntime
-} from "./chunk-M2RFFAMB.js";
-import "./chunk-JCHD6L3B.js";
-import "./chunk-CDY2ETYT.js";
+} from "./chunk-XO2RSS6Y.js";
+import "./chunk-43VQSANC.js";
+import "./chunk-YPZORI3G.js";
 import "./chunk-H4XYLS7T.js";
-import "./chunk-S2MVWQYL.js";
-import "./chunk-VVC7U7W7.js";
+import "./chunk-RF3RH374.js";
+import "./chunk-7T5YTVER.js";
 import "./chunk-376UBTNB.js";
-import "./chunk-F4YILONK.js";
+import "./chunk-6N23S4JY.js";
 import "./chunk-2TW2QKGZ.js";
-import "./chunk-Q5X3QNHR.js";
+import "./chunk-NQ7OPDUM.js";
 export {
   InMemoryIntegrationGrantStore,
   IntegrationRuntime,

package/dist/specs.d.ts

@@ -1,8 +1,208 @@
-export { a6 as ApiKeyAuthSpec, a7 as ConnectorAuthSpec, a8 as ConsoleStep, a9 as CredentialFieldSpec, aa as CredentialValidationInput, ab as CredentialValidationResult, ac as CustomAuthSpec, ad as HealthcheckPlan, ae as HealthcheckSpec, af as HmacAuthSpec, ag as INTEGRATION_FAMILIES, ah as IntegrationAuthMode, ai as IntegrationAuthSpec, aj as IntegrationFamilyId, ak as IntegrationFamilySpec, al as IntegrationLifecycleSpec, am as IntegrationPlannerHints, an as IntegrationSetupSpec, ao as IntegrationSpec, ap as IntegrationSpecStatus, aq as IntegrationSpecValidationIssue, ar as IntegrationSpecValidationResult, as as NoneAuthSpec, at as NormalizedPermission, au as OAuth2AuthSpec, av as PermissionDescriptor, aw as PostSetupCheck, ax as Quirk, ay as RenderSpecOptions, az as RenderedConsoleStep, aA as ScopeDescriptor, aB as assertValidIntegrationSpec, aC as buildHealthcheckPlan, aD as consoleStepsToText, aE as getIntegrationFamily, aF as getIntegrationSpec, aG as integrationSpecToConnector, aH as listExecutableIntegrationSpecs, aI as listIntegrationSpecs, aJ as renderAgentToolDescription, aK as renderConsoleSteps, aL as renderRunbookMarkdown, aM as resolveConnectorAuthSpec, aN as specAuthToConnectorAuth, aO as validateCredentialFormat, aP as validateCredentialSet, aQ as validateIntegrationSpec } from './registry.js';
-import './tangle-id-Dj0ipP4E.js';
-import './errors-Bg3_rxnQ.js';
-import './connect/index.js';
-import './middleware/index.js';
-import './connectors/index.js';
-import './connectors/adapters/index.js';
-import 'node:http';
+import { f as IntegrationActionRisk, g as IntegrationDataClass, d as IntegrationConnectorCategory, e as IntegrationConnectorAction, G as IntegrationConnectorTrigger, b as IntegrationConnector } from './core-types-D5Dc65Ud.js';
+import './types-XdpvaIzW.js';
+
+type IntegrationAuthMode = 'oauth2' | 'api_key' | 'hmac' | 'none' | 'custom';
+type IntegrationSpecStatus = 'catalog' | 'executable' | 'deprecated';
+type IntegrationFamilyId = 'google' | 'microsoft-graph' | 'atlassian' | 'salesforce' | 'hubspot' | 'slack' | 'notion' | 'standard-oauth2' | 'api-key' | 'hmac' | 'none';
+type NormalizedPermission = `${string}.read` | `${string}.write` | `${string}.delete` | `${string}.admin`;
+interface IntegrationSpec {
+    kind: string;
+    title: string;
+    category: IntegrationConnectorCategory;
+    status: IntegrationSpecStatus;
+    family: IntegrationFamilyId;
+    auth: IntegrationAuthSpec;
+    permissions: PermissionDescriptor[];
+    actions: IntegrationConnectorAction[];
+    triggers?: IntegrationConnectorTrigger[];
+    setup: IntegrationSetupSpec;
+    lifecycle?: IntegrationLifecycleSpec;
+    plannerHints?: IntegrationPlannerHints;
+    metadata?: Record<string, unknown>;
+}
+type IntegrationAuthSpec = OAuth2AuthSpec | ApiKeyAuthSpec | HmacAuthSpec | NoneAuthSpec | CustomAuthSpec;
+interface OAuth2AuthSpec {
+    mode: 'oauth2';
+    authorizationUrl: string;
+    tokenUrl: string;
+    clientIdEnv?: string;
+    clientSecretEnv?: string;
+    scopes: ScopeDescriptor[];
+    extraAuthParams?: Record<string, string>;
+    redirectUriTemplate: string;
+    pkce?: 'required' | 'supported' | 'unsupported';
+}
+interface ApiKeyAuthSpec {
+    mode: 'api_key';
+    credential: CredentialFieldSpec;
+    placement?: 'bearer' | 'header' | 'query' | 'basic';
+}
+interface HmacAuthSpec {
+    mode: 'hmac';
+    credential: CredentialFieldSpec;
+    signatureHeader?: string;
+}
+interface NoneAuthSpec {
+    mode: 'none';
+}
+interface CustomAuthSpec {
+    mode: 'custom';
+    description: string;
+}
+interface ScopeDescriptor {
+    normalized: NormalizedPermission;
+    providerScope: string;
+    title: string;
+    reason: string;
+    risk: IntegrationActionRisk;
+    dataClass: IntegrationDataClass;
+}
+interface PermissionDescriptor {
+    normalized: NormalizedPermission;
+    providerScopes: string[];
+    title: string;
+    risk: IntegrationActionRisk;
+    dataClass: IntegrationDataClass;
+    reason: string;
+}
+interface CredentialFieldSpec {
+    label: string;
+    description: string;
+    env?: string;
+    example?: string;
+    regex?: string;
+    secret: boolean;
+}
+interface ConsoleStep {
+    id: string;
+    title: string;
+    detail: string;
+    copyValue?: string;
+}
+interface Quirk {
+    id: string;
+    severity: 'info' | 'warning' | 'critical';
+    message: string;
+}
+interface PostSetupCheck {
+    id: string;
+    title: string;
+    detail: string;
+}
+interface HealthcheckSpec {
+    id: string;
+    level: 'client_config' | 'connection' | 'webhook' | 'static';
+    method?: 'GET' | 'POST';
+    url?: string;
+    expectedStatus?: number[];
+    description: string;
+}
+interface IntegrationSetupSpec {
+    consoleUrl?: string;
+    consoleSteps: ConsoleStep[];
+    credentialFields: CredentialFieldSpec[];
+    redirectUriTemplate?: string;
+    knownQuirks?: Quirk[];
+    postSetup?: PostSetupCheck[];
+    healthcheck?: HealthcheckSpec;
+}
+interface IntegrationLifecycleSpec {
+    supportsRefresh: boolean;
+    supportsRevoke: boolean;
+    supportsIncrementalAuth: boolean;
+    recommendedHealthcheckIntervalHours?: number;
+    freshnessSloMinutes?: number;
+}
+interface IntegrationPlannerHints {
+    useFor: string[];
+    avoidFor?: string[];
+    dataFreshness: 'realtime' | 'near_realtime' | 'eventual' | 'manual';
+    writeRisk: 'low' | 'medium' | 'high';
+}
+interface IntegrationFamilySpec {
+    id: IntegrationFamilyId;
+    title: string;
+    authMode: IntegrationAuthMode;
+    consoleUrl?: string;
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    redirectUriTemplate?: string;
+    credentialFields: CredentialFieldSpec[];
+    consoleSteps: ConsoleStep[];
+    knownQuirks?: Quirk[];
+    lifecycle: IntegrationLifecycleSpec;
+}
+interface IntegrationSpecValidationIssue {
+    path: string;
+    message: string;
+}
+interface IntegrationSpecValidationResult {
+    ok: boolean;
+    issues: IntegrationSpecValidationIssue[];
+}
+interface RenderSpecOptions {
+    host: string;
+    callbackPath?: string;
+}
+interface RenderedConsoleStep extends ConsoleStep {
+    detail: string;
+    copyValue?: string;
+}
+interface CredentialValidationInput {
+    field: CredentialFieldSpec;
+    value: string;
+}
+interface CredentialValidationResult {
+    ok: boolean;
+    field: string;
+    message?: string;
+}
+interface HealthcheckPlan {
+    kind: string;
+    healthcheck: HealthcheckSpec;
+    requires: Array<'client_id' | 'client_secret' | 'api_key' | 'hmac_secret' | 'connection_credentials'>;
+    message: string;
+}
+declare function specAuthToConnectorAuth(auth: IntegrationAuthSpec): IntegrationConnector['auth'];
+
+declare const INTEGRATION_FAMILIES: Record<IntegrationFamilyId, IntegrationFamilySpec>;
+declare function getIntegrationFamily(id: IntegrationFamilyId): IntegrationFamilySpec;
+
+declare function listIntegrationSpecs(): IntegrationSpec[];
+declare function getIntegrationSpec(kind: string): IntegrationSpec | undefined;
+/** Auth-driving descriptor the hub uses to start a connect flow per provider
+ *  instead of hard-coding scopes/auth kind. Derived from the spec catalog
+ *  ({@link getIntegrationSpec}); undefined when the kind is not in the
+ *  catalog. */
+interface ConnectorAuthSpec {
+    kind: string;
+    authKind: 'oauth2' | 'api_key' | 'none' | 'custom';
+    /** Provider scopes to request in the authorization grant. Empty for
+     *  api_key / none / custom. */
+    requestedScopes: string[];
+    /** OAuth-only: authorization + token endpoints and PKCE posture. Present
+     *  only when authKind === 'oauth2'. */
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    pkce?: 'required' | 'supported' | 'unsupported';
+    redirectUriTemplate?: string;
+    clientIdEnv?: string;
+    clientSecretEnv?: string;
+    extraAuthParams?: Record<string, string>;
+}
+declare function resolveConnectorAuthSpec(kind: string): ConnectorAuthSpec | undefined;
+declare function listExecutableIntegrationSpecs(): IntegrationSpec[];
+declare function integrationSpecToConnector(spec: IntegrationSpec, providerId?: string): IntegrationConnector;
+
+declare function renderConsoleSteps(spec: IntegrationSpec, options: RenderSpecOptions): RenderedConsoleStep[];
+declare function renderRunbookMarkdown(spec: IntegrationSpec, options: RenderSpecOptions): string;
+declare function renderAgentToolDescription(spec: IntegrationSpec): string;
+declare function buildHealthcheckPlan(spec: IntegrationSpec): HealthcheckPlan;
+declare function consoleStepsToText(steps: ConsoleStep[]): string;
+
+declare function validateIntegrationSpec(spec: IntegrationSpec): IntegrationSpecValidationResult;
+declare function assertValidIntegrationSpec(spec: IntegrationSpec): void;
+declare function validateCredentialFormat(field: CredentialFieldSpec, value: string): CredentialValidationResult;
+declare function validateCredentialSet(spec: IntegrationSpec, values: Record<string, string>): CredentialValidationResult[];
+
+export { type ApiKeyAuthSpec, type ConnectorAuthSpec, type ConsoleStep, type CredentialFieldSpec, type CredentialValidationInput, type CredentialValidationResult, type CustomAuthSpec, type HealthcheckPlan, type HealthcheckSpec, type HmacAuthSpec, INTEGRATION_FAMILIES, type IntegrationAuthMode, type IntegrationAuthSpec, type IntegrationFamilyId, type IntegrationFamilySpec, type IntegrationLifecycleSpec, type IntegrationPlannerHints, type IntegrationSetupSpec, type IntegrationSpec, type IntegrationSpecStatus, type IntegrationSpecValidationIssue, type IntegrationSpecValidationResult, type NoneAuthSpec, type NormalizedPermission, type OAuth2AuthSpec, type PermissionDescriptor, type PostSetupCheck, type Quirk, type RenderSpecOptions, type RenderedConsoleStep, type ScopeDescriptor, assertValidIntegrationSpec, buildHealthcheckPlan, consoleStepsToText, getIntegrationFamily, getIntegrationSpec, integrationSpecToConnector, listExecutableIntegrationSpecs, listIntegrationSpecs, renderAgentToolDescription, renderConsoleSteps, renderRunbookMarkdown, resolveConnectorAuthSpec, specAuthToConnectorAuth, validateCredentialFormat, validateCredentialSet, validateIntegrationSpec };

package/dist/specs.js

@@ -16,7 +16,7 @@ import {
   validateCredentialFormat,
   validateCredentialSet,
   validateIntegrationSpec
-} from "./chunk-VVC7U7W7.js";
+} from "./chunk-7T5YTVER.js";
 export {
   INTEGRATION_FAMILIES,
   assertValidIntegrationSpec,

package/dist/tangle-catalog-runtime-2HddXxoM.d.ts

@@ -0,0 +1,242 @@
+import { d as IntegrationConnectorCategory, b as IntegrationConnector, f as IntegrationActionRisk, c as IntegrationConnection, j as IntegrationActionRequest, S as StartAuthRequest, l as StartAuthResult, C as CompleteAuthRequest, k as IntegrationActionResult, m as IntegrationProvider, n as IntegrationSecretStore, e as IntegrationConnectorAction } from './core-types-D5Dc65Ud.js';
+import { a as ConnectorCredentials } from './types-XdpvaIzW.js';
+
+interface ActivepiecesCatalogEntry {
+    id: string;
+    title: string;
+    description: string;
+    npmPackage?: string;
+    version?: string;
+    category: IntegrationConnectorCategory;
+    auth: IntegrationConnector['auth'];
+    authFields?: ActivepiecesCatalogAuthField[];
+    domains: string[];
+    actions: Array<{
+        id: string;
+        title: string;
+        risk: IntegrationActionRisk;
+        upstreamName?: string;
+    }>;
+    triggers: Array<{
+        id: string;
+        title: string;
+        upstreamName?: string;
+    }>;
+    source: {
+        repository: string;
+        path: string;
+        license: 'MIT';
+    };
+}
+interface ActivepiecesCatalogAuthField {
+    key: string;
+    label: string;
+    required: boolean;
+    secret: boolean;
+    kind: 'text' | 'number' | 'boolean' | 'select' | 'object' | 'unknown';
+    description?: string;
+}
+declare function listActivepiecesCatalogEntries(): ActivepiecesCatalogEntry[];
+declare function buildActivepiecesConnectors(options?: {
+    providerId?: string;
+    includeCatalogActions?: boolean;
+    executable?: boolean;
+}): IntegrationConnector[];
+
+interface ActivepiecesExecutorInvocation {
+    connection: IntegrationConnection;
+    request: IntegrationActionRequest;
+    connector: IntegrationConnector;
+    catalogEntry: ActivepiecesCatalogEntry;
+    piece: {
+        id: string;
+        npmPackage?: string;
+        version?: string;
+        actionId: string;
+        upstreamActionName?: string;
+    };
+}
+interface ActivepiecesExecutorProviderOptions {
+    id?: string;
+    connectors?: IntegrationConnector[];
+    startAuth?: (request: StartAuthRequest) => Promise<StartAuthResult> | StartAuthResult;
+    completeAuth?: (request: CompleteAuthRequest) => Promise<IntegrationConnection> | IntegrationConnection;
+    executeAction: (invocation: ActivepiecesExecutorInvocation) => Promise<IntegrationActionResult> | IntegrationActionResult;
+}
+declare function createActivepiecesExecutorProvider(options: ActivepiecesExecutorProviderOptions): IntegrationProvider;
+
+declare const ACTIVEPIECES_RUNTIME_SIGNATURE_HEADER = "x-tangle-activepieces-signature";
+declare const TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER = "x-tangle-catalog-signature";
+interface TangleCatalogRuntimeActionRequest {
+    id: string;
+    input: unknown;
+    idempotencyKey?: string;
+    dryRun?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface TangleCatalogRuntimePiece {
+    id: string;
+    packageName?: string;
+    version?: string;
+    actionId: string;
+    upstreamActionName?: string;
+}
+interface TangleCatalogHttpExecutorOptions {
+    endpoint: string;
+    path?: string;
+    signatureHeader?: string;
+    secret?: string;
+    fetchImpl?: typeof fetch;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    requestId?: () => string;
+}
+interface TangleCatalogHttpExecutorInvocation extends Omit<ActivepiecesExecutorInvocation, 'catalogEntry' | 'piece'> {
+    catalogEntry: unknown;
+    piece: TangleCatalogRuntimePiece;
+}
+/**
+ * @deprecated Use the Tangle catalog runtime types. This name is kept only for
+ * compatibility with the upstream catalog ingestion backend.
+ */
+interface ActivepiecesRuntimeRequest {
+    version: 1;
+    requestId: string;
+    providerId: string;
+    connection: IntegrationConnection;
+    connector: Pick<IntegrationConnector, 'id' | 'title' | 'auth' | 'scopes' | 'metadata'>;
+    piece: ActivepiecesExecutorInvocation['piece'];
+    action: TangleCatalogRuntimeActionRequest;
+}
+/**
+ * @deprecated Use `TangleCatalogHttpExecutorOptions`.
+ */
+type ActivepiecesHttpExecutorOptions = TangleCatalogHttpExecutorOptions;
+/**
+ * @deprecated Use `createTangleCatalogHttpExecutor`.
+ */
+declare function createActivepiecesHttpExecutor(options: ActivepiecesHttpExecutorOptions): ActivepiecesExecutorProviderOptions['executeAction'];
+/**
+ * @deprecated Use `buildTangleCatalogRuntimeRequest`.
+ */
+declare function buildActivepiecesRuntimeRequest(invocation: ActivepiecesExecutorInvocation, requestId?: string): ActivepiecesRuntimeRequest;
+/**
+ * @deprecated Use `signTangleCatalogRuntimeRequest`.
+ */
+declare function signActivepiecesRuntimeRequest(serializedBody: string, secret: string): string;
+/**
+ * @deprecated Use `verifyTangleCatalogRuntimeSignature`.
+ */
+declare function verifyActivepiecesRuntimeSignature(serializedBody: string, signature: string | null | undefined, secret: string): boolean;
+interface TangleCatalogRuntimeRequest {
+    version: 1;
+    requestId: string;
+    providerId: string;
+    connection: IntegrationConnection;
+    connector: Pick<IntegrationConnector, 'id' | 'title' | 'auth' | 'scopes' | 'metadata'>;
+    piece: TangleCatalogRuntimePiece;
+    action: TangleCatalogRuntimeActionRequest;
+}
+declare function createTangleCatalogHttpExecutor(options: TangleCatalogHttpExecutorOptions): (invocation: TangleCatalogHttpExecutorInvocation) => Promise<IntegrationActionResult>;
+declare function buildTangleCatalogRuntimeRequest(invocation: TangleCatalogHttpExecutorInvocation, requestId?: string): TangleCatalogRuntimeRequest;
+declare const signTangleCatalogRuntimeRequest: typeof signActivepiecesRuntimeRequest;
+declare const verifyTangleCatalogRuntimeSignature: typeof verifyActivepiecesRuntimeSignature;
+
+interface TangleCatalogRuntimeInvocation {
+    request: TangleCatalogRuntimeRequest;
+    connection: IntegrationConnection;
+    connector: IntegrationConnector;
+    action: IntegrationConnectorAction;
+}
+interface TangleCatalogRuntimeHandlerOptions {
+    secret?: string;
+    requireSignature?: boolean;
+    signatureHeader?: string;
+    connectors?: IntegrationConnector[];
+    maxBodyBytes?: number;
+    executeAction: (invocation: TangleCatalogRuntimeInvocation) => Promise<IntegrationActionResult> | IntegrationActionResult;
+}
+interface TangleCatalogInstalledPackageExecutorOptions {
+    moduleLoader?: (packageName: string) => Promise<unknown> | unknown;
+    actionAliases?: Record<string, Record<string, string>>;
+    allowFuzzyActionMatch?: boolean;
+    resolveAuth?: (connection: IntegrationConnection) => Promise<unknown> | unknown;
+    beforeRun?: (invocation: TangleCatalogRuntimeInvocation) => Promise<void> | void;
+}
+interface TangleCatalogAuthResolverOptions {
+    secrets: IntegrationSecretStore;
+    mapCredentials?: (input: {
+        connection: IntegrationConnection;
+        credentials: ConnectorCredentials;
+        connectorId: string;
+    }) => unknown;
+}
+interface TangleCatalogHttpAuthResolverOptions {
+    endpoint: string;
+    secret: string;
+    path?: string;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    headers?: Record<string, string>;
+    requestId?: () => string;
+}
+interface TangleCatalogHttpAuthResolverRequest {
+    version: 1;
+    requestId: string;
+    providerId: string;
+    connectorId: string;
+    connectionId: string;
+    secretRef?: IntegrationConnection['secretRef'];
+}
+interface TangleCatalogRuntimeModuleAction {
+    name?: string;
+    displayName?: string;
+    run?: (context: {
+        auth: unknown;
+        propsValue: unknown;
+        input: unknown;
+        connection: IntegrationConnection;
+        request: TangleCatalogRuntimeRequest;
+    }) => Promise<unknown> | unknown;
+}
+interface TangleCatalogRuntimeHttpRequest {
+    body: string | Uint8Array | TangleCatalogRuntimeRequest;
+    headers?: Headers | Record<string, string | string[] | undefined>;
+}
+interface TangleCatalogRuntimeHttpResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: IntegrationActionResult | {
+        ok: false;
+        action: string;
+        output: {
+            code: string;
+            message: string;
+        };
+    };
+}
+interface TangleCatalogRuntimePackageCoverageRow {
+    connectorId: string;
+    packageName: string;
+    packageInstalled: boolean;
+    packageLoads: boolean;
+    pieceExportFound: boolean;
+    actionMappingsVerified: number;
+    actionMappingsTotal: number;
+    triggerMappingsFound: number;
+    triggerMappingsTotal: number;
+    triggerHostingSupported: boolean;
+    error?: string;
+}
+interface TangleCatalogRuntimePackageCoverageOptions {
+    connectorIds?: string[];
+    moduleLoader?: (packageName: string) => Promise<unknown> | unknown;
+}
+declare function createTangleCatalogRuntimeHandler(options: TangleCatalogRuntimeHandlerOptions): (input: TangleCatalogRuntimeHttpRequest) => Promise<TangleCatalogRuntimeHttpResponse>;
+declare function createTangleCatalogInstalledPackageExecutor(options?: TangleCatalogInstalledPackageExecutorOptions): TangleCatalogRuntimeHandlerOptions['executeAction'];
+declare function auditTangleCatalogRuntimePackages(options?: TangleCatalogRuntimePackageCoverageOptions): Promise<TangleCatalogRuntimePackageCoverageRow[]>;
+declare function createTangleCatalogCredentialAuthResolver(options: TangleCatalogAuthResolverOptions): (connection: IntegrationConnection) => Promise<unknown>;
+declare function createTangleCatalogHttpAuthResolver(options: TangleCatalogHttpAuthResolverOptions): (connection: IntegrationConnection) => Promise<unknown>;
+declare function tangleCatalogAuthValue(credentials: ConnectorCredentials): unknown;
+
+export { type ActivepiecesCatalogEntry as A, createActivepiecesExecutorProvider as B, createActivepiecesHttpExecutor as C, createTangleCatalogCredentialAuthResolver as D, createTangleCatalogHttpAuthResolver as E, createTangleCatalogHttpExecutor as F, createTangleCatalogInstalledPackageExecutor as G, createTangleCatalogRuntimeHandler as H, listActivepiecesCatalogEntries as I, signActivepiecesRuntimeRequest as J, signTangleCatalogRuntimeRequest as K, tangleCatalogAuthValue as L, verifyActivepiecesRuntimeSignature as M, verifyTangleCatalogRuntimeSignature as N, type TangleCatalogHttpAuthResolverOptions as T, type TangleCatalogInstalledPackageExecutorOptions as a, ACTIVEPIECES_RUNTIME_SIGNATURE_HEADER as b, type ActivepiecesCatalogAuthField as c, type ActivepiecesExecutorInvocation as d, type ActivepiecesExecutorProviderOptions as e, type ActivepiecesHttpExecutorOptions as f, type ActivepiecesRuntimeRequest as g, TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER as h, type TangleCatalogAuthResolverOptions as i, type TangleCatalogHttpAuthResolverRequest as j, type TangleCatalogHttpExecutorInvocation as k, type TangleCatalogHttpExecutorOptions as l, type TangleCatalogRuntimeActionRequest as m, type TangleCatalogRuntimeHandlerOptions as n, type TangleCatalogRuntimeHttpRequest as o, type TangleCatalogRuntimeHttpResponse as p, type TangleCatalogRuntimeInvocation as q, type TangleCatalogRuntimeModuleAction as r, type TangleCatalogRuntimePackageCoverageOptions as s, type TangleCatalogRuntimePackageCoverageRow as t, type TangleCatalogRuntimePiece as u, type TangleCatalogRuntimeRequest as v, auditTangleCatalogRuntimePackages as w, buildActivepiecesConnectors as x, buildActivepiecesRuntimeRequest as y, buildTangleCatalogRuntimeRequest as z };