@tangle-network/agent-integrations 0.14.0 → 0.16.0

package/dist/index.d.ts

@@ -53,6 +53,393 @@ declare function summarizeIntegrationRegistry(registry: IntegrationRegistry): In
 declare function canonicalConnectorId(id: string, aliases?: Record<string, string>): string;
 declare function inferIntegrationSupportTier(connector: IntegrationConnector): IntegrationSupportTier;
 
+type IntegrationAuditEventType = 'connection.created' | 'connection.updated' | 'connection.revoked' | 'grant.created' | 'grant.revoked' | 'capability.issued' | 'action.invoked' | 'action.failed' | 'trigger.subscribed' | 'trigger.received' | 'workflow.installed' | 'approval.requested' | 'approval.resolved' | 'healthcheck.completed';
+interface IntegrationAuditEvent {
+    id: string;
+    type: IntegrationAuditEventType;
+    occurredAt: string;
+    actor?: IntegrationActor;
+    connectionId?: string;
+    providerId?: string;
+    connectorId?: string;
+    action?: string;
+    risk?: IntegrationConnectorAction['risk'];
+    dataClass?: IntegrationDataClass;
+    ok?: boolean;
+    message?: string;
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationAuditSink {
+    record(event: IntegrationAuditEvent): Promise<void> | void;
+}
+interface IntegrationAuditStore extends IntegrationAuditSink {
+    list(filter?: IntegrationAuditFilter): Promise<IntegrationAuditEvent[]> | IntegrationAuditEvent[];
+}
+interface IntegrationAuditFilter {
+    type?: IntegrationAuditEventType;
+    actor?: IntegrationActor;
+    connectionId?: string;
+    providerId?: string;
+    connectorId?: string;
+    action?: string;
+}
+declare class InMemoryIntegrationAuditStore implements IntegrationAuditStore {
+    private readonly events;
+    record(event: IntegrationAuditEvent): void;
+    list(filter?: IntegrationAuditFilter): IntegrationAuditEvent[];
+}
+declare function createIntegrationAuditEvent(input: Omit<IntegrationAuditEvent, 'id' | 'occurredAt'> & {
+    id?: string;
+    occurredAt?: string | Date;
+    now?: () => Date;
+}): IntegrationAuditEvent;
+declare function createAuditingActionGuard(options: {
+    sink: IntegrationAuditSink;
+    subject?: IntegrationActor;
+    now?: () => Date;
+    includeInputPreview?: boolean;
+}): IntegrationActionGuard;
+declare function sanitizeAuditConnection(connection: IntegrationConnection): Record<string, unknown>;
+
+type IntegrationApprovalStatus = 'pending' | 'approved' | 'denied' | 'expired';
+interface IntegrationApprovalRecord {
+    id: string;
+    request: IntegrationApprovalRequest;
+    status: IntegrationApprovalStatus;
+    requestedAt: string;
+    resolvedAt?: string;
+    resolvedBy?: IntegrationActor;
+    reason?: string;
+    expiresAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationApprovalStore {
+    get(approvalId: string): Promise<IntegrationApprovalRecord | undefined> | IntegrationApprovalRecord | undefined;
+    put(record: IntegrationApprovalRecord): Promise<void> | void;
+    list(filter?: IntegrationApprovalFilter): Promise<IntegrationApprovalRecord[]> | IntegrationApprovalRecord[];
+}
+interface IntegrationApprovalFilter {
+    status?: IntegrationApprovalStatus;
+    connectionId?: string;
+    connectorId?: string;
+    action?: string;
+    actor?: IntegrationActor;
+}
+interface ApprovalBackedPolicyOptions {
+    base: IntegrationPolicyEngine;
+    store: IntegrationApprovalStore;
+    audit?: IntegrationAuditSink;
+    now?: () => Date;
+    approvalTtlMs?: number;
+}
+declare class InMemoryIntegrationApprovalStore implements IntegrationApprovalStore {
+    private readonly records;
+    get(approvalId: string): IntegrationApprovalRecord | undefined;
+    put(record: IntegrationApprovalRecord): void;
+    list(filter?: IntegrationApprovalFilter): IntegrationApprovalRecord[];
+}
+declare class ApprovalBackedPolicyEngine implements IntegrationPolicyEngine {
+    private readonly base;
+    private readonly store;
+    private readonly audit;
+    private readonly now;
+    private readonly approvalTtlMs;
+    constructor(options: ApprovalBackedPolicyOptions);
+    decide(ctx: IntegrationGuardContext & {
+        subject: IntegrationActor;
+    }): Promise<IntegrationPolicyDecision>;
+    private findApprovedRecord;
+}
+declare function createApprovalBackedPolicyEngine(options: ApprovalBackedPolicyOptions): ApprovalBackedPolicyEngine;
+declare function resolveIntegrationApproval(input: {
+    store: IntegrationApprovalStore;
+    approvalId: string;
+    approved: boolean;
+    resolvedBy: IntegrationActor;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+    audit?: IntegrationAuditSink;
+    now?: () => Date;
+}): Promise<IntegrationApprovalRecord>;
+
+declare const CANONICAL_INTEGRATION_ACTIONS: {
+    readonly googleCalendarEventsList: "google-calendar.events.list";
+    readonly googleCalendarEventsCreate: "google-calendar.events.create";
+    readonly gmailMessagesSearch: "gmail.messages.search";
+    readonly gmailMessagesSend: "gmail.messages.send";
+    readonly googleDriveFilesSearch: "google-drive.files.search";
+    readonly googleDriveFilesRead: "google-drive.files.read";
+    readonly githubRepositoriesGet: "github.repositories.get";
+    readonly githubIssuesSearch: "github.issues.search";
+    readonly githubIssuesCreate: "github.issues.create";
+    readonly githubPullRequestsComment: "github.pull-requests.comment";
+    readonly slackChannelsList: "slack.channels.list";
+    readonly slackMessagesSearch: "slack.messages.search";
+    readonly slackMessagesPost: "slack.messages.post";
+    readonly providerHttpRequest: "provider.http.request";
+};
+type CanonicalIntegrationActionId = typeof CANONICAL_INTEGRATION_ACTIONS[keyof typeof CANONICAL_INTEGRATION_ACTIONS];
+interface CanonicalLaunchConnectorOptions {
+    providerId?: string;
+    includeProviderPassthrough?: boolean;
+}
+declare function buildCanonicalLaunchConnectors(options?: CanonicalLaunchConnectorOptions): IntegrationConnector[];
+declare function canonicalActionConnectorId(actionId: string): string | undefined;
+
+interface IntegrationToolDefinition {
+    name: string;
+    title: string;
+    description: string;
+    providerId: string;
+    connectorId: string;
+    connectorTitle: string;
+    category: IntegrationConnectorCategory;
+    action: IntegrationConnectorAction;
+    risk: IntegrationActionRisk;
+    dataClass: IntegrationDataClass;
+    requiredScopes: string[];
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    tags: string[];
+}
+interface IntegrationToolSearchFilters {
+    providerId?: string;
+    connectorId?: string;
+    category?: IntegrationConnectorCategory;
+    maxRisk?: IntegrationActionRisk;
+    dataClass?: IntegrationDataClass;
+    limit?: number;
+}
+interface IntegrationToolSearchResult {
+    tool: IntegrationToolDefinition;
+    score: number;
+    matched: string[];
+}
+interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: unknown;
+}
+declare function integrationToolName(providerId: string, connectorId: string, actionId: string): string;
+declare function parseIntegrationToolName(name: string): {
+    providerId: string;
+    connectorId: string;
+    actionId: string;
+};
+declare function buildIntegrationToolCatalog(connectors: IntegrationConnector[]): IntegrationToolDefinition[];
+declare function searchIntegrationTools(catalog: IntegrationToolDefinition[], query: string, filters?: IntegrationToolSearchFilters): IntegrationToolSearchResult[];
+declare function toMcpTools(tools: IntegrationToolDefinition[]): McpToolDefinition[];
+
+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[];
+    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[];
+    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[];
+    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;
+        subject: IntegrationActor;
+        ttlMs: number;
+        grantee?: IntegrationActor;
+    }): Promise<IntegrationSandboxBundle>;
+}
+declare function createIntegrationRuntime(options: IntegrationRuntimeOptions): IntegrationRuntime;
+
+declare const DEFAULT_INTEGRATION_BRIDGE_ENV = "TANGLE_INTEGRATION_BUNDLE";
+interface IntegrationBridgePayload {
+    version: 1;
+    manifestId: string;
+    subject: IntegrationSandboxBundle['subject'];
+    expiresAt: string;
+    tools: IntegrationBridgeToolBinding[];
+}
+interface IntegrationBridgeToolBinding {
+    name: string;
+    title: string;
+    connectorId: string;
+    connectionId: string;
+    action: string;
+    risk: string;
+    dataClass: string;
+    requiredScopes: string[];
+    capabilityToken: string;
+}
+declare function buildIntegrationBridgePayload(bundle: IntegrationSandboxBundle): IntegrationBridgePayload;
+declare function encodeIntegrationBridgePayload(payload: IntegrationBridgePayload): string;
+declare function decodeIntegrationBridgePayload(encoded: string): IntegrationBridgePayload;
+declare function buildIntegrationBridgeEnvironment(bundle: IntegrationSandboxBundle, options?: {
+    envVar?: string;
+}): Record<string, string>;
+declare function parseIntegrationBridgeEnvironment(env: Record<string, string | undefined>, options?: {
+    envVar?: string;
+}): IntegrationBridgePayload;
+declare function redactIntegrationBridgePayload(payload: IntegrationBridgePayload): IntegrationBridgePayload;
+
+interface TangleIntegrationsClientOptions {
+    endpoint: string;
+    bridge?: IntegrationBridgePayload;
+    env?: Record<string, string | undefined>;
+    envVar?: string;
+    fetchImpl?: typeof fetch;
+    getCapabilityToken?: (tool: IntegrationBridgeToolBinding) => string | Promise<string>;
+}
+interface TangleIntegrationInvokeInput<TInput = unknown> {
+    tool: string;
+    input?: TInput;
+    idempotencyKey?: string;
+    dryRun?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface TangleIntegrationInvokeResult<TOutput = unknown> {
+    status: 'ok' | 'approval_required' | 'failed';
+    action: string;
+    output?: TOutput;
+    approval?: unknown;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+declare class TangleIntegrationsClient {
+    private readonly endpoint;
+    private readonly bridge;
+    private readonly fetchImpl;
+    private readonly getCapabilityToken;
+    constructor(options: TangleIntegrationsClientOptions);
+    tools(): IntegrationBridgeToolBinding[];
+    findTool(toolOrAction: string): IntegrationBridgeToolBinding;
+    invoke<TOutput = unknown, TInput = unknown>(input: TangleIntegrationInvokeInput<TInput>): Promise<TangleIntegrationInvokeResult<TOutput>>;
+}
+declare function createTangleIntegrationsClient(options: TangleIntegrationsClientOptions): TangleIntegrationsClient;
+
+interface ConsentSummary {
+    title: string;
+    body: string;
+    bullets: string[];
+    primaryAction: string;
+    risk: 'read' | 'write' | 'destructive';
+    connectorIds: string[];
+}
+interface RenderConsentOptions {
+    appName?: string;
+    connectors?: IntegrationConnector[];
+}
+declare function renderConsentSummary(manifestOrResolution: IntegrationManifest | IntegrationManifestResolution, options?: RenderConsentOptions): ConsentSummary;
+declare function renderApprovalCopy(input: {
+    appName: string;
+    connectorTitle: string;
+    action: IntegrationConnectorAction;
+    approvalId?: string;
+}): ConsentSummary;
+
 /**
  * Connector primitives — the contract a concrete first-party integration
  * (Google Calendar, HubSpot, Stripe, ...) implements. Lower level than the
@@ -436,17 +823,387 @@ interface ConnectorManifestValidationResult {
 declare function validateConnectorManifest(manifest: ConnectorManifest): ConnectorManifestValidationResult;
 declare function assertValidConnectorManifest(manifest: ConnectorManifest): void;
 
-/**
- * Generic OAuth2 helper used by every oauth-shaped connector (Google
- * Calendar, Sheets, Drive, HubSpot, Salesforce, Zoom, ...).
- *
- * Everything PKCE-aware. Opaque-state CSRF guard. Refresh-token aware.
- * No connector-specific logic lives here — adapters hand a `clientId`,
- * `clientSecret`, `tokenUrl`, optional `extraAuthParams` and the rest is
- * mechanical.
- *
- * State and code_verifier are kept in a short-TTL flow store keyed by the
- * opaque `state` we round-trip through the provider. The default store is
+interface ConnectorAdapterProviderOptions {
+    id?: string;
+    kind?: IntegrationProviderKind;
+    adapters: ConnectorAdapter[];
+    resolveDataSource: (connection: IntegrationConnection) => Promise<ResolvedDataSource> | ResolvedDataSource;
+    now?: () => Date;
+}
+declare function createConnectorAdapterProvider(options: ConnectorAdapterProviderOptions): IntegrationProvider;
+declare function manifestToConnector(providerId: string, adapter: ConnectorAdapter): IntegrationConnector;
+
+interface IntegrationSecretStore {
+    get(ref: SecretRef): Promise<ConnectorCredentials | undefined> | ConnectorCredentials | undefined;
+    put(ref: SecretRef, credentials: ConnectorCredentials): Promise<void> | void;
+    delete?(ref: SecretRef): Promise<void> | void;
+}
+interface ConnectionCredentialResolverOptions {
+    secrets: IntegrationSecretStore;
+    connections?: IntegrationConnectionStore;
+    adapters?: ConnectorAdapter[];
+    now?: () => Date;
+    markConnectionError?: (connection: IntegrationConnection, error: Error) => Promise<void> | void;
+}
+declare class InMemoryIntegrationSecretStore implements IntegrationSecretStore {
+    private readonly secrets;
+    get(ref: SecretRef): ConnectorCredentials | undefined;
+    put(ref: SecretRef, credentials: ConnectorCredentials): void;
+    delete(ref: SecretRef): void;
+}
+declare function createConnectionCredentialResolver(options: ConnectionCredentialResolverOptions): (connection: IntegrationConnection) => Promise<ResolvedDataSource>;
+declare function resolveConnectionCredentials(input: IntegrationConnection, options: ConnectionCredentialResolverOptions): Promise<ConnectorCredentials>;
+declare function createCredentialBackedAdapterProvider(options: Omit<ConnectorAdapterProviderOptions, 'resolveDataSource'> & ConnectionCredentialResolverOptions): IntegrationProvider;
+declare function revokeConnection(input: {
+    connection: IntegrationConnection;
+    connections?: IntegrationConnectionStore;
+    secrets?: IntegrationSecretStore;
+    now?: () => Date;
+}): Promise<IntegrationConnection>;
+
+type IntegrationErrorCode = 'missing_connection' | 'missing_grant' | 'approval_required' | 'approval_denied' | 'connection_revoked' | 'connection_expired' | 'scope_missing' | 'action_denied' | 'action_not_found' | 'provider_rate_limited' | 'provider_auth_failed' | 'provider_unavailable' | 'provider_error' | 'capability_expired' | 'capability_invalid' | 'manifest_invalid' | 'passthrough_disabled' | 'input_invalid' | 'unknown';
+interface IntegrationUserAction {
+    type: 'connect' | 'reconnect' | 'approve' | 'retry' | 'contact_support' | 'change_request';
+    label: string;
+    connectorId?: string;
+    approvalId?: string;
+}
+declare class IntegrationRuntimeError extends Error {
+    readonly code: IntegrationErrorCode;
+    readonly status: number;
+    readonly userAction?: IntegrationUserAction;
+    readonly metadata?: Record<string, unknown>;
+    constructor(input: {
+        code: IntegrationErrorCode;
+        message: string;
+        status?: number;
+        userAction?: IntegrationUserAction;
+        metadata?: Record<string, unknown>;
+    });
+}
+interface NormalizedIntegrationError {
+    ok: false;
+    code: IntegrationErrorCode;
+    message: string;
+    status: number;
+    userAction?: IntegrationUserAction;
+    metadata?: Record<string, unknown>;
+}
+declare function normalizeIntegrationError(error: unknown): NormalizedIntegrationError;
+declare function statusForCode(code: IntegrationErrorCode): number;
+
+interface IntegrationWorkflowDefinition {
+    id: string;
+    title?: string;
+    manifest: IntegrationManifest;
+    trigger: {
+        requirementId: string;
+        triggerId: string;
+        targetUrl?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface InstalledIntegrationWorkflow {
+    id: string;
+    workflowId: string;
+    manifestId: string;
+    owner: IntegrationActor;
+    grantee: IntegrationActor;
+    triggerGrantId: string;
+    subscription: IntegrationTriggerSubscription;
+    status: 'active' | 'paused' | 'error';
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationWorkflowStore {
+    put(workflow: InstalledIntegrationWorkflow): Promise<void> | void;
+    get(id: string): Promise<InstalledIntegrationWorkflow | undefined> | InstalledIntegrationWorkflow | undefined;
+    list(): Promise<InstalledIntegrationWorkflow[]> | InstalledIntegrationWorkflow[];
+    listByWorkflow(workflowId: string): Promise<InstalledIntegrationWorkflow[]> | InstalledIntegrationWorkflow[];
+    listByOwner(owner: IntegrationActor): Promise<InstalledIntegrationWorkflow[]> | InstalledIntegrationWorkflow[];
+}
+interface IntegrationWorkflowRuntimeHub {
+    subscribeTrigger(connectionId: string, trigger: string, targetUrl?: string): Promise<IntegrationTriggerSubscription> | IntegrationTriggerSubscription;
+}
+interface IntegrationWorkflowRuntimeOptions {
+    runtime: IntegrationRuntime;
+    hub: IntegrationWorkflowRuntimeHub;
+    grants: IntegrationGrantStore;
+    store?: IntegrationWorkflowStore;
+    now?: () => Date;
+}
+declare class InMemoryIntegrationWorkflowStore implements IntegrationWorkflowStore {
+    private readonly workflows;
+    put(workflow: InstalledIntegrationWorkflow): void;
+    get(id: string): InstalledIntegrationWorkflow | undefined;
+    list(): InstalledIntegrationWorkflow[];
+    listByWorkflow(workflowId: string): InstalledIntegrationWorkflow[];
+    listByOwner(owner: IntegrationActor): InstalledIntegrationWorkflow[];
+}
+declare class IntegrationWorkflowRuntime {
+    private readonly runtime;
+    private readonly hub;
+    private readonly grants;
+    private readonly store;
+    private readonly now;
+    constructor(options: IntegrationWorkflowRuntimeOptions);
+    install(input: {
+        workflow: IntegrationWorkflowDefinition;
+        owner: IntegrationActor;
+        grantee: IntegrationActor;
+    }): Promise<InstalledIntegrationWorkflow>;
+    dispatchEvent<T = unknown>(event: IntegrationTriggerEvent<T>, handler: (input: {
+        event: IntegrationTriggerEvent<T>;
+        workflows: InstalledIntegrationWorkflow[];
+    }) => Promise<void> | void): Promise<{
+        matched: InstalledIntegrationWorkflow[];
+    }>;
+}
+declare function createIntegrationWorkflowRuntime(options: IntegrationWorkflowRuntimeOptions): IntegrationWorkflowRuntime;
+
+interface StoredIntegrationEvent {
+    id: string;
+    sourceId: string;
+    connectorId: string;
+    eventType: string;
+    providerEventId?: string;
+    receivedAt: string;
+    payload: Record<string, unknown>;
+    dispatchedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationEventStore {
+    put(event: StoredIntegrationEvent): Promise<void> | void;
+    hasProviderEvent(sourceId: string, providerEventId: string): Promise<boolean> | boolean;
+    list(): Promise<StoredIntegrationEvent[]> | StoredIntegrationEvent[];
+}
+interface IntegrationWebhookReceiverResult {
+    status: number;
+    body: unknown;
+    headers?: Record<string, string>;
+    received: StoredIntegrationEvent[];
+    duplicates: StoredIntegrationEvent[];
+}
+declare class InMemoryIntegrationEventStore implements IntegrationEventStore {
+    private readonly events;
+    private readonly providerIds;
+    put(event: StoredIntegrationEvent): void;
+    hasProviderEvent(sourceId: string, providerEventId: string): boolean;
+    list(): StoredIntegrationEvent[];
+}
+declare function receiveIntegrationWebhook(input: {
+    adapter: ConnectorAdapter;
+    source: ResolvedDataSource;
+    rawBody: string;
+    headers: Record<string, string | string[] | undefined>;
+    store: IntegrationEventStore;
+    workflowRuntime?: IntegrationWorkflowRuntime;
+    now?: () => Date;
+}): Promise<IntegrationWebhookReceiverResult>;
+declare function storedEventToTriggerEvent(event: StoredIntegrationEvent, source: ResolvedDataSource): IntegrationTriggerEvent;
+
+interface IntegrationIdempotencyRecord {
+    key: string;
+    requestHash: string;
+    result: IntegrationActionResult;
+    createdAt: string;
+}
+interface IntegrationIdempotencyStore {
+    get(key: string): Promise<IntegrationIdempotencyRecord | undefined> | IntegrationIdempotencyRecord | undefined;
+    put(record: IntegrationIdempotencyRecord): Promise<void> | void;
+}
+interface IntegrationRateLimitDecision {
+    allowed: boolean;
+    retryAfterMs?: number;
+    reason?: string;
+}
+interface IntegrationRateLimiter {
+    check(ctx: IntegrationGuardContext): Promise<IntegrationRateLimitDecision> | IntegrationRateLimitDecision;
+}
+declare class InMemoryIntegrationIdempotencyStore implements IntegrationIdempotencyStore {
+    private readonly records;
+    get(key: string): IntegrationIdempotencyRecord | undefined;
+    put(record: IntegrationIdempotencyRecord): void;
+}
+declare class DefaultIntegrationActionGuard implements IntegrationActionGuard {
+    private readonly idempotency;
+    private readonly audit;
+    private readonly rateLimiter;
+    private readonly now;
+    constructor(options?: {
+        idempotency?: IntegrationIdempotencyStore;
+        audit?: IntegrationAuditSink;
+        rateLimiter?: IntegrationRateLimiter;
+        now?: () => Date;
+    });
+    invokeAction(ctx: IntegrationGuardContext, proceed: () => Promise<IntegrationActionResult>): Promise<IntegrationActionResult>;
+    private writeIdempotency;
+}
+declare function createDefaultIntegrationActionGuard(options?: ConstructorParameters<typeof DefaultIntegrationActionGuard>[0]): DefaultIntegrationActionGuard;
+
+type IntegrationHealthcheckStatus = 'healthy' | 'degraded' | 'unhealthy' | 'unknown';
+interface IntegrationHealthcheckCheck {
+    id: string;
+    status: IntegrationHealthcheckStatus;
+    message: string;
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationHealthcheckResult {
+    connectionId: string;
+    providerId: string;
+    connectorId: string;
+    status: IntegrationHealthcheckStatus;
+    checkedAt: string;
+    checks: IntegrationHealthcheckCheck[];
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationHealthcheckStore {
+    put(result: IntegrationHealthcheckResult): Promise<void> | void;
+    get(connectionId: string): Promise<IntegrationHealthcheckResult | undefined> | IntegrationHealthcheckResult | undefined;
+    list(): Promise<IntegrationHealthcheckResult[]> | IntegrationHealthcheckResult[];
+}
+declare class InMemoryIntegrationHealthcheckStore implements IntegrationHealthcheckStore {
+    private readonly results;
+    put(result: IntegrationHealthcheckResult): void;
+    get(connectionId: string): IntegrationHealthcheckResult | undefined;
+    list(): IntegrationHealthcheckResult[];
+}
+declare function runIntegrationHealthcheck(input: {
+    connection: IntegrationConnection;
+    connector?: IntegrationConnector;
+    registry?: IntegrationRegistry;
+    test?: (connection: IntegrationConnection, connector: IntegrationConnector) => Promise<IntegrationActionResult | boolean> | IntegrationActionResult | boolean;
+    audit?: IntegrationAuditSink;
+    now?: () => Date;
+}): Promise<IntegrationHealthcheckResult>;
+declare function runIntegrationHealthchecks(input: {
+    connections: IntegrationConnection[];
+    registry?: IntegrationRegistry;
+    store?: IntegrationHealthcheckStore;
+    audit?: IntegrationAuditSink;
+    now?: () => Date;
+    test?: (connection: IntegrationConnection, connector: IntegrationConnector) => Promise<IntegrationActionResult | boolean> | IntegrationActionResult | boolean;
+}): Promise<IntegrationHealthcheckResult[]>;
+declare function healthcheckRequest(action?: string): IntegrationActionRequest;
+
+interface ManifestValidationIssue {
+    path: string;
+    message: string;
+}
+interface ManifestValidationResult {
+    ok: boolean;
+    issues: ManifestValidationIssue[];
+}
+interface InferIntegrationRequirementsOptions {
+    manifestId: string;
+    title?: string;
+    tools: Array<string | {
+        action: string;
+        reason?: string;
+        mode?: IntegrationRequirementMode;
+        connectorId?: string;
+        scopes?: string[];
+    }>;
+    metadata?: Record<string, unknown>;
+}
+interface MissingRequirementExplanation {
+    requirementId: string;
+    connectorId: string;
+    status: string;
+    message: string;
+    userAction: 'connect' | 'enable' | 'ignore_optional';
+}
+declare function validateIntegrationManifest(manifest: IntegrationManifest): ManifestValidationResult;
+declare function assertValidIntegrationManifest(manifest: IntegrationManifest): void;
+declare function inferIntegrationManifestFromTools(options: InferIntegrationRequirementsOptions): IntegrationManifest;
+declare function explainMissingRequirements(resolution: IntegrationManifestResolution): MissingRequirementExplanation[];
+declare function calendarExercisePlannerManifest(id?: string): IntegrationManifest;
+
+interface ProviderHttpRequestInput {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+    body?: unknown;
+}
+interface ProviderPassthroughPolicy {
+    enabled: boolean;
+    allowedMethods?: ProviderHttpRequestInput['method'][];
+    allowedPathPrefixes?: string[];
+    maxBodyBytes?: number;
+}
+declare const PROVIDER_PASSTHROUGH_ACTION: "provider.http.request";
+declare function validateProviderPassthroughRequest(input: ProviderHttpRequestInput, policy: ProviderPassthroughPolicy): void;
+
+type IntegrationPolicyEffect = 'allow' | 'require_approval' | 'deny';
+interface IntegrationPolicyRule {
+    id: string;
+    effect: IntegrationPolicyEffect;
+    reason: string;
+    providerId?: string;
+    connectorId?: string;
+    action?: string;
+    maxRisk?: IntegrationActionRisk;
+    risk?: IntegrationActionRisk;
+    dataClass?: IntegrationDataClass;
+}
+interface StaticIntegrationPolicyOptions {
+    rules?: IntegrationPolicyRule[];
+    defaultReadEffect?: IntegrationPolicyEffect;
+    defaultWriteEffect?: IntegrationPolicyEffect;
+    defaultDestructiveEffect?: IntegrationPolicyEffect;
+    now?: () => Date;
+}
+interface IntegrationApprovalResolution {
+    approvalId: string;
+    approved: boolean;
+    resolvedBy: string;
+    resolvedAt: string;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+declare class StaticIntegrationPolicyEngine implements IntegrationPolicyEngine {
+    private readonly rules;
+    private readonly defaultReadEffect;
+    private readonly defaultWriteEffect;
+    private readonly defaultDestructiveEffect;
+    private readonly now;
+    constructor(options?: StaticIntegrationPolicyOptions);
+    decide(ctx: IntegrationGuardContext & {
+        subject: {
+            type: string;
+            id: string;
+        };
+    }): IntegrationPolicyDecision;
+    private defaultEffect;
+}
+declare function createDefaultIntegrationPolicyEngine(options?: Omit<StaticIntegrationPolicyOptions, 'rules'>): StaticIntegrationPolicyEngine;
+declare function buildApprovalRequest(ctx: IntegrationGuardContext & {
+    subject: {
+        type: string;
+        id: string;
+    };
+}, reason: string, requestedAt: Date): IntegrationApprovalRequest;
+declare function redactApprovalRequest(request: IntegrationApprovalRequest): IntegrationApprovalRequest;
+
+interface PlatformIntegrationPolicyPresetOptions extends Omit<StaticIntegrationPolicyOptions, 'defaultReadEffect' | 'defaultWriteEffect' | 'defaultDestructiveEffect'> {
+    allowWritesWithoutApproval?: boolean;
+    allowDestructiveActions?: boolean;
+    allowProviderPassthrough?: boolean;
+}
+declare function createPlatformIntegrationPolicyPreset(options?: PlatformIntegrationPolicyPresetOptions): StaticIntegrationPolicyEngine;
+
+/**
+ * Generic OAuth2 helper used by every oauth-shaped connector (Google
+ * Calendar, Sheets, Drive, HubSpot, Salesforce, Zoom, ...).
+ *
+ * Everything PKCE-aware. Opaque-state CSRF guard. Refresh-token aware.
+ * No connector-specific logic lives here — adapters hand a `clientId`,
+ * `clientSecret`, `tokenUrl`, optional `extraAuthParams` and the rest is
+ * mechanical.
+ *
+ * State and code_verifier are kept in a short-TTL flow store keyed by the
+ * opaque `state` we round-trip through the provider. The default store is
  * in-memory for local/dev and tests. Production deployments should inject a
  * durable store backed by KV/Redis/D1/etc. so callbacks can land on any worker.
  */
@@ -1032,115 +1789,20 @@ declare const asanaConnector: ConnectorAdapter;
 
 declare const salesforceConnector: ConnectorAdapter;
 
-interface IntegrationToolDefinition {
-    name: string;
-    title: string;
-    description: string;
-    providerId: string;
-    connectorId: string;
-    connectorTitle: string;
-    category: IntegrationConnectorCategory;
-    action: IntegrationConnectorAction;
-    risk: IntegrationActionRisk;
-    dataClass: IntegrationDataClass;
-    requiredScopes: string[];
-    inputSchema?: unknown;
-    outputSchema?: unknown;
-    tags: string[];
+interface IntegrationInvocationEnvelope {
+    kind: 'integration.invocation';
+    capabilityToken: string;
+    toolName: string;
+    action: string;
+    input?: unknown;
+    idempotencyKey: string;
+    dryRun?: boolean;
+    metadata?: Record<string, unknown>;
 }
-interface IntegrationToolSearchFilters {
-    providerId?: string;
-    connectorId?: string;
-    category?: IntegrationConnectorCategory;
-    maxRisk?: IntegrationActionRisk;
-    dataClass?: IntegrationDataClass;
-    limit?: number;
-}
-interface IntegrationToolSearchResult {
-    tool: IntegrationToolDefinition;
-    score: number;
-    matched: string[];
-}
-interface McpToolDefinition {
-    name: string;
-    description: string;
-    inputSchema: unknown;
-}
-declare function integrationToolName(providerId: string, connectorId: string, actionId: string): string;
-declare function parseIntegrationToolName(name: string): {
-    providerId: string;
-    connectorId: string;
-    actionId: string;
-};
-declare function buildIntegrationToolCatalog(connectors: IntegrationConnector[]): IntegrationToolDefinition[];
-declare function searchIntegrationTools(catalog: IntegrationToolDefinition[], query: string, filters?: IntegrationToolSearchFilters): IntegrationToolSearchResult[];
-declare function toMcpTools(tools: IntegrationToolDefinition[]): McpToolDefinition[];
-
-type IntegrationPolicyEffect = 'allow' | 'require_approval' | 'deny';
-interface IntegrationPolicyRule {
-    id: string;
-    effect: IntegrationPolicyEffect;
-    reason: string;
-    providerId?: string;
-    connectorId?: string;
-    action?: string;
-    maxRisk?: IntegrationActionRisk;
-    risk?: IntegrationActionRisk;
-    dataClass?: IntegrationDataClass;
-}
-interface StaticIntegrationPolicyOptions {
-    rules?: IntegrationPolicyRule[];
-    defaultReadEffect?: IntegrationPolicyEffect;
-    defaultWriteEffect?: IntegrationPolicyEffect;
-    defaultDestructiveEffect?: IntegrationPolicyEffect;
-    now?: () => Date;
-}
-interface IntegrationApprovalResolution {
-    approvalId: string;
-    approved: boolean;
-    resolvedBy: string;
-    resolvedAt: string;
-    reason?: string;
-    metadata?: Record<string, unknown>;
-}
-declare class StaticIntegrationPolicyEngine implements IntegrationPolicyEngine {
-    private readonly rules;
-    private readonly defaultReadEffect;
-    private readonly defaultWriteEffect;
-    private readonly defaultDestructiveEffect;
-    private readonly now;
-    constructor(options?: StaticIntegrationPolicyOptions);
-    decide(ctx: IntegrationGuardContext & {
-        subject: {
-            type: string;
-            id: string;
-        };
-    }): IntegrationPolicyDecision;
-    private defaultEffect;
-}
-declare function createDefaultIntegrationPolicyEngine(options?: Omit<StaticIntegrationPolicyOptions, 'rules'>): StaticIntegrationPolicyEngine;
-declare function buildApprovalRequest(ctx: IntegrationGuardContext & {
-    subject: {
-        type: string;
-        id: string;
-    };
-}, reason: string, requestedAt: Date): IntegrationApprovalRequest;
-declare function redactApprovalRequest(request: IntegrationApprovalRequest): IntegrationApprovalRequest;
-
-interface IntegrationInvocationEnvelope {
-    kind: 'integration.invocation';
-    capabilityToken: string;
-    toolName: string;
-    action: string;
-    input?: unknown;
-    idempotencyKey: string;
-    dryRun?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface IntegrationInvocationEnvelopeValidationOptions {
-    connectors?: IntegrationConnector[];
-    maxInputBytes?: number;
-    requireKnownTool?: boolean;
+interface IntegrationInvocationEnvelopeValidationOptions {
+    connectors?: IntegrationConnector[];
+    maxInputBytes?: number;
+    requireKnownTool?: boolean;
 }
 type NormalizedIntegrationResult = {
     status: 'ok';
@@ -1158,6 +1820,12 @@ type NormalizedIntegrationResult = {
     error: string;
     metadata?: Record<string, unknown>;
 };
+interface IntegrationSandboxHostHub {
+    invokeWithCapability(token: string, request: InvokeWithCapabilityRequest): Promise<IntegrationActionResult> | IntegrationActionResult;
+}
+interface IntegrationSandboxHostOptions extends IntegrationInvocationEnvelopeValidationOptions {
+    hub: IntegrationSandboxHostHub;
+}
 declare function buildIntegrationInvocationEnvelope(input: {
     capabilityToken: string;
     toolName: string;
@@ -1173,16 +1841,12 @@ declare function redactInvocationEnvelope(envelope: IntegrationInvocationEnvelop
 };
 declare function redactCapability(capability: IntegrationCapability): IntegrationCapability;
 declare function normalizeIntegrationResult(result: IntegrationActionResult): NormalizedIntegrationResult;
-
-interface ConnectorAdapterProviderOptions {
-    id?: string;
-    kind?: IntegrationProviderKind;
-    adapters: ConnectorAdapter[];
-    resolveDataSource: (connection: IntegrationConnection) => Promise<ResolvedDataSource> | ResolvedDataSource;
-    now?: () => Date;
+declare function dispatchIntegrationInvocation(envelope: IntegrationInvocationEnvelope, options: IntegrationSandboxHostOptions): Promise<NormalizedIntegrationResult>;
+declare class IntegrationSandboxHost {
+    private readonly options;
+    constructor(options: IntegrationSandboxHostOptions);
+    dispatch(envelope: IntegrationInvocationEnvelope): Promise<NormalizedIntegrationResult>;
 }
-declare function createConnectorAdapterProvider(options: ConnectorAdapterProviderOptions): IntegrationProvider;
-declare function manifestToConnector(providerId: string, adapter: ConnectorAdapter): IntegrationConnector;
 
 interface ImportCatalogOptions {
     providerId: string;
@@ -1329,200 +1993,6 @@ interface ActivepiecesPieceOverride {
 declare const ACTIVEPIECES_OVERRIDES: Record<string, ActivepiecesPieceOverride>;
 declare function getActivepiecesOverride(id: string): ActivepiecesPieceOverride | undefined;
 
-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[];
-    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[];
-    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[];
-    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;
-        subject: IntegrationActor;
-        ttlMs: number;
-        grantee?: IntegrationActor;
-    }): Promise<IntegrationSandboxBundle>;
-}
-declare function createIntegrationRuntime(options: IntegrationRuntimeOptions): IntegrationRuntime;
-
-interface IntegrationWorkflowDefinition {
-    id: string;
-    title?: string;
-    manifest: IntegrationManifest;
-    trigger: {
-        requirementId: string;
-        triggerId: string;
-        targetUrl?: string;
-    };
-    metadata?: Record<string, unknown>;
-}
-interface InstalledIntegrationWorkflow {
-    id: string;
-    workflowId: string;
-    manifestId: string;
-    owner: IntegrationActor;
-    grantee: IntegrationActor;
-    triggerGrantId: string;
-    subscription: IntegrationTriggerSubscription;
-    status: 'active' | 'paused' | 'error';
-    createdAt: string;
-    metadata?: Record<string, unknown>;
-}
-interface IntegrationWorkflowStore {
-    put(workflow: InstalledIntegrationWorkflow): Promise<void> | void;
-    get(id: string): Promise<InstalledIntegrationWorkflow | undefined> | InstalledIntegrationWorkflow | undefined;
-    list(): Promise<InstalledIntegrationWorkflow[]> | InstalledIntegrationWorkflow[];
-    listByWorkflow(workflowId: string): Promise<InstalledIntegrationWorkflow[]> | InstalledIntegrationWorkflow[];
-    listByOwner(owner: IntegrationActor): Promise<InstalledIntegrationWorkflow[]> | InstalledIntegrationWorkflow[];
-}
-interface IntegrationWorkflowRuntimeHub {
-    subscribeTrigger(connectionId: string, trigger: string, targetUrl?: string): Promise<IntegrationTriggerSubscription> | IntegrationTriggerSubscription;
-}
-interface IntegrationWorkflowRuntimeOptions {
-    runtime: IntegrationRuntime;
-    hub: IntegrationWorkflowRuntimeHub;
-    grants: IntegrationGrantStore;
-    store?: IntegrationWorkflowStore;
-    now?: () => Date;
-}
-declare class InMemoryIntegrationWorkflowStore implements IntegrationWorkflowStore {
-    private readonly workflows;
-    put(workflow: InstalledIntegrationWorkflow): void;
-    get(id: string): InstalledIntegrationWorkflow | undefined;
-    list(): InstalledIntegrationWorkflow[];
-    listByWorkflow(workflowId: string): InstalledIntegrationWorkflow[];
-    listByOwner(owner: IntegrationActor): InstalledIntegrationWorkflow[];
-}
-declare class IntegrationWorkflowRuntime {
-    private readonly runtime;
-    private readonly hub;
-    private readonly grants;
-    private readonly store;
-    private readonly now;
-    constructor(options: IntegrationWorkflowRuntimeOptions);
-    install(input: {
-        workflow: IntegrationWorkflowDefinition;
-        owner: IntegrationActor;
-        grantee: IntegrationActor;
-    }): Promise<InstalledIntegrationWorkflow>;
-    dispatchEvent<T = unknown>(event: IntegrationTriggerEvent<T>, handler: (input: {
-        event: IntegrationTriggerEvent<T>;
-        workflows: InstalledIntegrationWorkflow[];
-    }) => Promise<void> | void): Promise<{
-        matched: InstalledIntegrationWorkflow[];
-    }>;
-}
-declare function createIntegrationWorkflowRuntime(options: IntegrationWorkflowRuntimeOptions): IntegrationWorkflowRuntime;
-
 type IntegrationCoveragePriority = 'tier_0' | 'tier_1' | 'tier_2' | 'long_tail';
 interface IntegrationCoverageSpec {
     id: string;
@@ -2026,4 +2496,4 @@ declare function createHttpIntegrationProvider(options: HttpIntegrationProviderO
 declare function signCapability(capability: IntegrationCapability, secret: string): string;
 declare function verifyCapabilityToken(token: string, secret: string): IntegrationCapability;
 
-export { ACTIVEPIECES_OVERRIDES, type ActivepiecesCatalogEntry, type ActivepiecesPieceOverride, type ApiKeyAuthSpec, type AuthSpec, type CASStrategy, type Capability, type CapabilityClass, type CapabilityMutation, type CapabilityMutationResult, type CapabilityParameterSchema, type CapabilityRead, type CapabilityReadResult, type CompleteAuthRequest, type ComposeIntegrationRegistryOptions, type ConnectorAdapter, type ConnectorAdapterProviderOptions, type ConnectorCredentials, type ConnectorInvocation, type ConnectorManifest, type ConnectorManifestValidationIssue, type ConnectorManifestValidationResult, type ConsistencyModel, type ConsoleStep, type CredentialFieldSpec, type CredentialValidationInput, type CredentialValidationResult, CredentialsExpired, type CustomAuthSpec, DEFAULT_SIGNATURE_TOLERANCE_SECONDS, type DataSourceMetadata, type EventHandlerResult, type ExchangeCodeInput, type GatewayCatalogAction, type GatewayCatalogEntry, type GatewayCatalogProviderOptions, type GatewayCatalogTrigger, type GenericHmacVerifyOptions, type GoogleCalendarOptions, type GoogleSheetsOptions, type GraphqlOperationSpec, type HealthcheckPlan, type HealthcheckSpec, type HmacAuthSpec, type HttpIntegrationProviderOptions, type HubSpotOptions, INTEGRATION_FAMILIES, type ImportCatalogOptions, InMemoryConnectionStore, InMemoryIntegrationGrantStore, InMemoryIntegrationWorkflowStore, InMemoryOAuthFlowStore, type InboundEvent, type InstalledIntegrationWorkflow, type IntegrationActionGuard, type IntegrationActionPack, type IntegrationActionRequest, type IntegrationActionResult, type IntegrationActionRisk, type IntegrationActor, type IntegrationApprovalRequest, type IntegrationApprovalResolution, type IntegrationAuthMode, type IntegrationAuthSpec, type IntegrationCapability, type IntegrationCapabilityBinding, type IntegrationCatalogSource, type IntegrationConnection, type IntegrationConnectionStore, type IntegrationConnector, type IntegrationConnectorAction, type IntegrationConnectorCategory, type IntegrationConnectorTrigger, type IntegrationCoveragePriority, type IntegrationCoverageSpec, type IntegrationDataClass, IntegrationError, type IntegrationFamilyId, type IntegrationFamilySpec, type IntegrationGrant, type IntegrationGrantStore, type IntegrationGuardContext, IntegrationHub, type IntegrationHubOptions, type IntegrationInvocationEnvelope, type IntegrationInvocationEnvelopeValidationOptions, type IntegrationLifecycleSpec, type IntegrationManifest, type IntegrationManifestResolution, type IntegrationPlannerHints, type IntegrationPolicyDecision, type IntegrationPolicyEffect, type IntegrationPolicyEngine, type IntegrationPolicyRule, type IntegrationProvider, type IntegrationProviderKind, type IntegrationRegistry, type IntegrationRegistryConflict, type IntegrationRegistryEntry, type IntegrationRegistrySourceRef, type IntegrationRegistrySummary, type IntegrationRequirement, type IntegrationRequirementMode, type IntegrationRequirementResolution, type IntegrationRequirementStatus, IntegrationRuntime, type IntegrationRuntimeHub, type IntegrationRuntimeOptions, type IntegrationSandboxBundle, type IntegrationSetupSpec, type IntegrationSpec, type IntegrationSpecStatus, type IntegrationSpecValidationIssue, type IntegrationSpecValidationResult, type IntegrationSupportTier, type IntegrationToolDefinition, type IntegrationToolSearchFilters, type IntegrationToolSearchResult, type IntegrationTriggerEvent, type IntegrationTriggerSubscription, type IntegrationWorkflowDefinition, IntegrationWorkflowRuntime, type IntegrationWorkflowRuntimeHub, type IntegrationWorkflowRuntimeOptions, type IntegrationWorkflowStore, type InvokeWithCapabilityRequest, type IssueCapabilityRequest, type IssuedIntegrationCapability, type McpCatalog, type McpCatalogTool, type McpToolDefinition, type MicrosoftCalendarOptions, type NoneAuthSpec, type NormalizedIntegrationResult, type NormalizedPermission, type NotionDatabaseOptions, type OAuth2AuthSpec, type OAuthFlowStore, type OAuthTokens, type OpenApiDocument, type OpenApiOperation, type ParsedStripeSignatureHeader, type PendingOAuthFlow, type PermissionDescriptor, type PostSetupCheck, type Quirk, type RateLimitSpec, type RefreshInput, type RenderSpecOptions, type RenderedConsoleStep, type ResolvedDataSource, ResourceContention, type RestConnectorSpec, type RestCredentialPlacement, type RestOperationSpec, type RestRequestSpec, type ScopeDescriptor, type SecretRef, type SlackOptions, type SlackVerifyOptions, type StartAuthRequest, type StartAuthResult, type StartOAuthInput, type StartOAuthOutput, StaticIntegrationPolicyEngine, type StaticIntegrationPolicyOptions, type StripeVerifyOptions, type TwilioVerifyOptions, _resetPendingFlowsForTests, airtableConnector, asanaConnector, assertValidConnectorManifest, assertValidIntegrationSpec, buildActivepiecesConnectors, buildApprovalRequest, buildDefaultIntegrationRegistry, buildHealthcheckPlan, buildIntegrationCoverageConnectors, buildIntegrationInvocationEnvelope, buildIntegrationToolCatalog, canonicalConnectorId, composeIntegrationRegistry, consoleStepsToText, consumePendingFlow, createConnectorAdapterProvider, createDefaultIntegrationPolicyEngine, createGatewayCatalogProvider, createHttpIntegrationProvider, createIntegrationRuntime, createIntegrationWorkflowRuntime, createMockIntegrationProvider, declarativeRestConnector, exchangeAuthorizationCode, firstHeader, getActivepiecesOverride, getIntegrationFamily, getIntegrationSpec, githubConnector, gitlabConnector, googleCalendar, googleSheets, hubspot, importGraphqlConnector, importMcpConnector, importOpenApiConnector, inferIntegrationSupportTier, integrationCoverageChecklistMarkdown, integrationSpecToConnector, integrationToolName, invocationRequestFromEnvelope, listActivepiecesCatalogEntries, listExecutableIntegrationSpecs, listIntegrationCoverageSpecs, listIntegrationSpecs, manifestToConnector, microsoftCalendar, normalizeGatewayCatalog, normalizeIntegrationResult, notionDatabase, parseIntegrationToolName, parseStripeSignatureHeader, redactApprovalRequest, redactCapability, redactInvocationEnvelope, refreshAccessToken, renderAgentToolDescription, renderConsoleSteps, renderRunbookMarkdown, salesforceConnector, sanitizeConnection, searchIntegrationTools, signCapability, slack, slackEventsConnector, specAuthToConnectorAuth, startOAuthFlow, stripePackConnector, stripeWebhookReceiverConnector, summarizeIntegrationRegistry, toMcpTools, twilioSmsConnector, validateConnectorManifest, validateCredentialFormat, validateCredentialSet, validateIntegrationInvocationEnvelope, validateIntegrationSpec, verifyCapabilityToken, verifyHmacSignature, verifySlackSignature, verifyStripeSignature, verifyTwilioSignature, webhookConnector };
+export { ACTIVEPIECES_OVERRIDES, type ActivepiecesCatalogEntry, type ActivepiecesPieceOverride, type ApiKeyAuthSpec, ApprovalBackedPolicyEngine, type ApprovalBackedPolicyOptions, type AuthSpec, CANONICAL_INTEGRATION_ACTIONS, type CASStrategy, type CanonicalIntegrationActionId, type CanonicalLaunchConnectorOptions, type Capability, type CapabilityClass, type CapabilityMutation, type CapabilityMutationResult, type CapabilityParameterSchema, type CapabilityRead, type CapabilityReadResult, type CompleteAuthRequest, type ComposeIntegrationRegistryOptions, type ConnectionCredentialResolverOptions, type ConnectorAdapter, type ConnectorAdapterProviderOptions, type ConnectorCredentials, type ConnectorInvocation, type ConnectorManifest, type ConnectorManifestValidationIssue, type ConnectorManifestValidationResult, type ConsentSummary, type ConsistencyModel, type ConsoleStep, type CredentialFieldSpec, type CredentialValidationInput, type CredentialValidationResult, CredentialsExpired, type CustomAuthSpec, DEFAULT_INTEGRATION_BRIDGE_ENV, DEFAULT_SIGNATURE_TOLERANCE_SECONDS, type DataSourceMetadata, DefaultIntegrationActionGuard, type EventHandlerResult, type ExchangeCodeInput, type GatewayCatalogAction, type GatewayCatalogEntry, type GatewayCatalogProviderOptions, type GatewayCatalogTrigger, type GenericHmacVerifyOptions, type GoogleCalendarOptions, type GoogleSheetsOptions, type GraphqlOperationSpec, type HealthcheckPlan, type HealthcheckSpec, type HmacAuthSpec, type HttpIntegrationProviderOptions, type HubSpotOptions, INTEGRATION_FAMILIES, type ImportCatalogOptions, InMemoryConnectionStore, InMemoryIntegrationApprovalStore, InMemoryIntegrationAuditStore, InMemoryIntegrationEventStore, InMemoryIntegrationGrantStore, InMemoryIntegrationHealthcheckStore, InMemoryIntegrationIdempotencyStore, InMemoryIntegrationSecretStore, InMemoryIntegrationWorkflowStore, InMemoryOAuthFlowStore, type InboundEvent, type InferIntegrationRequirementsOptions, type InstalledIntegrationWorkflow, type IntegrationActionGuard, type IntegrationActionPack, type IntegrationActionRequest, type IntegrationActionResult, type IntegrationActionRisk, type IntegrationActor, type IntegrationApprovalFilter, type IntegrationApprovalRecord, type IntegrationApprovalRequest, type IntegrationApprovalResolution, type IntegrationApprovalStatus, type IntegrationApprovalStore, type IntegrationAuditEvent, type IntegrationAuditEventType, type IntegrationAuditFilter, type IntegrationAuditSink, type IntegrationAuditStore, type IntegrationAuthMode, type IntegrationAuthSpec, type IntegrationBridgePayload, type IntegrationBridgeToolBinding, type IntegrationCapability, type IntegrationCapabilityBinding, type IntegrationCatalogSource, type IntegrationConnection, type IntegrationConnectionStore, type IntegrationConnector, type IntegrationConnectorAction, type IntegrationConnectorCategory, type IntegrationConnectorTrigger, type IntegrationCoveragePriority, type IntegrationCoverageSpec, type IntegrationDataClass, IntegrationError, type IntegrationErrorCode, type IntegrationEventStore, type IntegrationFamilyId, type IntegrationFamilySpec, type IntegrationGrant, type IntegrationGrantStore, type IntegrationGuardContext, type IntegrationHealthcheckCheck, type IntegrationHealthcheckResult, type IntegrationHealthcheckStatus, type IntegrationHealthcheckStore, IntegrationHub, type IntegrationHubOptions, type IntegrationIdempotencyRecord, type IntegrationIdempotencyStore, type IntegrationInvocationEnvelope, type IntegrationInvocationEnvelopeValidationOptions, type IntegrationLifecycleSpec, type IntegrationManifest, type IntegrationManifestResolution, type IntegrationPlannerHints, type IntegrationPolicyDecision, type IntegrationPolicyEffect, type IntegrationPolicyEngine, type IntegrationPolicyRule, type IntegrationProvider, type IntegrationProviderKind, type IntegrationRateLimitDecision, type IntegrationRateLimiter, type IntegrationRegistry, type IntegrationRegistryConflict, type IntegrationRegistryEntry, type IntegrationRegistrySourceRef, type IntegrationRegistrySummary, type IntegrationRequirement, type IntegrationRequirementMode, type IntegrationRequirementResolution, type IntegrationRequirementStatus, IntegrationRuntime, IntegrationRuntimeError, type IntegrationRuntimeHub, type IntegrationRuntimeOptions, type IntegrationSandboxBundle, IntegrationSandboxHost, type IntegrationSandboxHostHub, type IntegrationSandboxHostOptions, type IntegrationSecretStore, type IntegrationSetupSpec, type IntegrationSpec, type IntegrationSpecStatus, type IntegrationSpecValidationIssue, type IntegrationSpecValidationResult, type IntegrationSupportTier, type IntegrationToolDefinition, type IntegrationToolSearchFilters, type IntegrationToolSearchResult, type IntegrationTriggerEvent, type IntegrationTriggerSubscription, type IntegrationUserAction, type IntegrationWebhookReceiverResult, type IntegrationWorkflowDefinition, IntegrationWorkflowRuntime, type IntegrationWorkflowRuntimeHub, type IntegrationWorkflowRuntimeOptions, type IntegrationWorkflowStore, type InvokeWithCapabilityRequest, type IssueCapabilityRequest, type IssuedIntegrationCapability, type ManifestValidationIssue, type ManifestValidationResult, type McpCatalog, type McpCatalogTool, type McpToolDefinition, type MicrosoftCalendarOptions, type MissingRequirementExplanation, type NoneAuthSpec, type NormalizedIntegrationError, type NormalizedIntegrationResult, type NormalizedPermission, type NotionDatabaseOptions, type OAuth2AuthSpec, type OAuthFlowStore, type OAuthTokens, type OpenApiDocument, type OpenApiOperation, PROVIDER_PASSTHROUGH_ACTION, type ParsedStripeSignatureHeader, type PendingOAuthFlow, type PermissionDescriptor, type PlatformIntegrationPolicyPresetOptions, type PostSetupCheck, type ProviderHttpRequestInput, type ProviderPassthroughPolicy, type Quirk, type RateLimitSpec, type RefreshInput, type RenderConsentOptions, type RenderSpecOptions, type RenderedConsoleStep, type ResolvedDataSource, ResourceContention, type RestConnectorSpec, type RestCredentialPlacement, type RestOperationSpec, type RestRequestSpec, type ScopeDescriptor, type SecretRef, type SlackOptions, type SlackVerifyOptions, type StartAuthRequest, type StartAuthResult, type StartOAuthInput, type StartOAuthOutput, StaticIntegrationPolicyEngine, type StaticIntegrationPolicyOptions, type StoredIntegrationEvent, type StripeVerifyOptions, type TangleIntegrationInvokeInput, type TangleIntegrationInvokeResult, TangleIntegrationsClient, type TangleIntegrationsClientOptions, type TwilioVerifyOptions, _resetPendingFlowsForTests, airtableConnector, asanaConnector, assertValidConnectorManifest, assertValidIntegrationManifest, assertValidIntegrationSpec, buildActivepiecesConnectors, buildApprovalRequest, buildCanonicalLaunchConnectors, buildDefaultIntegrationRegistry, buildHealthcheckPlan, buildIntegrationBridgeEnvironment, buildIntegrationBridgePayload, buildIntegrationCoverageConnectors, buildIntegrationInvocationEnvelope, buildIntegrationToolCatalog, calendarExercisePlannerManifest, canonicalActionConnectorId, canonicalConnectorId, composeIntegrationRegistry, consoleStepsToText, consumePendingFlow, createApprovalBackedPolicyEngine, createAuditingActionGuard, createConnectionCredentialResolver, createConnectorAdapterProvider, createCredentialBackedAdapterProvider, createDefaultIntegrationActionGuard, createDefaultIntegrationPolicyEngine, createGatewayCatalogProvider, createHttpIntegrationProvider, createIntegrationAuditEvent, createIntegrationRuntime, createIntegrationWorkflowRuntime, createMockIntegrationProvider, createPlatformIntegrationPolicyPreset, createTangleIntegrationsClient, declarativeRestConnector, decodeIntegrationBridgePayload, dispatchIntegrationInvocation, encodeIntegrationBridgePayload, exchangeAuthorizationCode, explainMissingRequirements, firstHeader, getActivepiecesOverride, getIntegrationFamily, getIntegrationSpec, githubConnector, gitlabConnector, googleCalendar, googleSheets, healthcheckRequest, hubspot, importGraphqlConnector, importMcpConnector, importOpenApiConnector, inferIntegrationManifestFromTools, inferIntegrationSupportTier, integrationCoverageChecklistMarkdown, integrationSpecToConnector, integrationToolName, invocationRequestFromEnvelope, listActivepiecesCatalogEntries, listExecutableIntegrationSpecs, listIntegrationCoverageSpecs, listIntegrationSpecs, manifestToConnector, microsoftCalendar, normalizeGatewayCatalog, normalizeIntegrationError, normalizeIntegrationResult, notionDatabase, parseIntegrationBridgeEnvironment, parseIntegrationToolName, parseStripeSignatureHeader, receiveIntegrationWebhook, redactApprovalRequest, redactCapability, redactIntegrationBridgePayload, redactInvocationEnvelope, refreshAccessToken, renderAgentToolDescription, renderApprovalCopy, renderConsentSummary, renderConsoleSteps, renderRunbookMarkdown, resolveConnectionCredentials, resolveIntegrationApproval, revokeConnection, runIntegrationHealthcheck, runIntegrationHealthchecks, salesforceConnector, sanitizeAuditConnection, sanitizeConnection, searchIntegrationTools, signCapability, slack, slackEventsConnector, specAuthToConnectorAuth, startOAuthFlow, statusForCode, storedEventToTriggerEvent, stripePackConnector, stripeWebhookReceiverConnector, summarizeIntegrationRegistry, toMcpTools, twilioSmsConnector, validateConnectorManifest, validateCredentialFormat, validateCredentialSet, validateIntegrationInvocationEnvelope, validateIntegrationManifest, validateIntegrationSpec, validateProviderPassthroughRequest, verifyCapabilityToken, verifyHmacSignature, verifySlackSignature, verifyStripeSignature, verifyTwilioSignature, webhookConnector };