@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/slack/runtime.js

@@ -1,6 +1,6 @@
-import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
+import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, optionalStringArray, requiredString, } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
-import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
 import { slackConversationTypes } from "./constants.js";
 export const slackApiBaseUrl = "https://slack.com/api";
 const slackFileUrlMaxBytes = 100 * 1024 * 1024;
@@ -196,7 +196,8 @@ async function slackGetChannelMessages(input, context) {
         url.searchParams.set("cursor", String(input.cursor));
     }
     applySlackHistoryWindow(url, input);
-    return readSlackMessagePage(await slackGetJson(url, context), "conversations.history");
+    const includeRaw = applySlackIncludeRaw(url, input);
+    return readSlackMessagePage(await slackGetJson(url, context), "conversations.history", includeRaw);
 }
 async function slackConversationsMembers(input, context) {
     const url = slackApiUrl("conversations.members");
@@ -214,6 +215,7 @@ async function slackConversationsMembers(input, context) {
     };
 }
 async function slackSearchMessages(input, context) {
+    const includeRaw = input.includeRaw === true;
     const query = requiredString(input.query, "query", (message) => new ProviderRequestError(400, message));
     if (input.page != null && input.cursor != null) {
         throw new ProviderRequestError(400, "page and cursor cannot be used together");
@@ -244,7 +246,7 @@ async function slackSearchMessages(input, context) {
     const payload = await slackGetJson(url, context);
     return {
         query: optionalString(payload.query) ?? query,
-        matches: (payload.messages?.matches ?? []).map((match) => normalizeSearchMessageMatch(match)),
+        matches: (payload.messages?.matches ?? []).map((match) => normalizeSearchMessageMatch(match, includeRaw)),
         total: typeof payload.messages?.total === "number" ? payload.messages.total : 0,
         pagination: payload.messages?.pagination ?? {},
         paging: payload.messages?.paging ?? {},
@@ -318,7 +320,8 @@ async function slackGetThread(input, context) {
         url.searchParams.set("cursor", String(input.cursor));
     }
     applySlackHistoryWindow(url, input);
-    return readSlackMessagePage(await slackGetJson(url, context), "conversations.replies");
+    const includeRaw = applySlackIncludeRaw(url, input);
+    return readSlackMessagePage(await slackGetJson(url, context), "conversations.replies", includeRaw);
 }
 async function slackListConversations(input, context) {
     const url = slackApiUrl("conversations.list");
@@ -651,7 +654,7 @@ async function slackFormRequestJson(context, method, body) {
 async function readSlackResponseJson(response) {
     const payload = (optionalRecord(await response.json().catch(() => undefined)) ?? {});
     if (!response.ok) {
-        throw slackHttpError(response.status, payload, response.headers.get("retry-after"));
+        throw slackHttpError(response, payload);
     }
     assertSlackPayload(payload);
     // Preserve HTTP/Slack failures (including Retry-After) above, but require
@@ -844,6 +847,15 @@ function normalizeConversation(conversation) {
         purpose: typeof purpose?.value === "string" ? purpose.value : null,
         userId: optionalString(conversation.user),
         locale: optionalString(conversation.locale),
+        created: optionalInteger(conversation.created),
+        updated: optionalInteger(conversation.updated),
+        creatorId: optionalString(conversation.creator),
+        isShared: optionalBoolean(conversation.is_shared),
+        isExtShared: optionalBoolean(conversation.is_ext_shared),
+        isOrgShared: optionalBoolean(conversation.is_org_shared),
+        contextTeamId: optionalString(conversation.context_team_id),
+        lastRead: optionalString(conversation.last_read),
+        unreadCount: optionalInteger(conversation.unread_count),
     });
 }
 /**
@@ -863,13 +875,27 @@ function applySlackHistoryWindow(url, input) {
         url.searchParams.set("inclusive", String(input.inclusive));
     }
 }
+/**
+ * Apply the shared `includeRaw` opt-in of `conversations.history` /
+ * `conversations.replies` and report whether it is on. Only a literal `true`
+ * opts in. Slack leaves message metadata out of both methods unless the
+ * request sets `include_all_metadata`, and `raw` promises the whole record, so
+ * opting in asks for it too.
+ */
+function applySlackIncludeRaw(url, input) {
+    const includeRaw = input.includeRaw === true;
+    if (includeRaw) {
+        url.searchParams.set("include_all_metadata", "true");
+    }
+    return includeRaw;
+}
 /**
  * Read one `conversations.history` / `conversations.replies` page. A page whose
  * list is missing or whose rows are not objects is rejected rather than
  * flattened into an empty result, so a broken upstream response cannot pass
  * for the documented end of a walk.
  */
-function readSlackMessagePage(payload, method) {
+function readSlackMessagePage(payload, method, includeRaw = false) {
     if (payload.has_more !== undefined && typeof payload.has_more !== "boolean") {
         throw slackResponseError(`${method} has_more`);
     }
@@ -879,7 +905,7 @@ function readSlackMessagePage(payload, method) {
             if (!record) {
                 throw slackResponseError(`${method} message`);
             }
-            return normalizeSlackMessage(record);
+            return normalizeSlackMessage(record, includeRaw);
         }),
         hasMore: payload.has_more ?? false,
         nextCursor: readSlackNextCursor(payload, method),
@@ -927,8 +953,13 @@ function requireSlackId(value, label) {
  * missing value stays distinguishable from an empty one. `userId` is the one
  * exception kept for compatibility: it stays `""` on a message with no
  * author, where `botId` / `username` carry the identity instead.
+ *
+ * `files`, `attachments`, `blocks` and `metadata` stay out of the row: they
+ * are unbounded nested payloads on a row read in bulk. With `includeRaw` the
+ * whole untouched record rides along under `raw` for a consumer that needs
+ * them, or any other field this normalizer does not model.
  */
-function normalizeSlackMessage(message) {
+function normalizeSlackMessage(message, includeRaw = false) {
     const edited = optionalRecord(message.edited) ?? {};
     const reactions = Array.isArray(message.reactions) ? message.reactions : undefined;
     return compactObject({
@@ -943,13 +974,16 @@ function normalizeSlackMessage(message) {
         clientMsgId: optionalString(message.client_msg_id),
         text: typeof message.text === "string" ? message.text : "",
         editedTs: optionalString(edited.ts),
+        editedUserId: optionalString(edited.user),
         threadTs: optionalString(message.thread_ts),
         parentUserId: optionalString(message.parent_user_id),
         replyCount: optionalInteger(message.reply_count),
         replyUsersCount: optionalInteger(message.reply_users_count),
+        replyUserIds: optionalStringArray(message.reply_users),
         latestReply: optionalString(message.latest_reply),
         isLocked: optionalBoolean(message.is_locked),
         reactions: reactions?.map((reaction) => normalizeSlackReaction(optionalRecord(reaction) ?? {})),
+        raw: includeRaw ? message : undefined,
     });
 }
 function normalizeSlackReaction(reaction) {
@@ -959,7 +993,7 @@ function normalizeSlackReaction(reaction) {
         userIds: Array.isArray(reaction.users) ? reaction.users.map((user) => String(user)) : undefined,
     });
 }
-function normalizeSearchMessageMatch(match) {
+function normalizeSearchMessageMatch(match, includeRaw = false) {
     const channel = optionalRecord(match.channel) ?? {};
     return compactObject({
         matchId: optionalString(match.iid),
@@ -972,6 +1006,7 @@ function normalizeSearchMessageMatch(match) {
         permalink: optionalString(match.permalink),
         teamId: optionalString(match.team),
         type: optionalString(match.type),
+        raw: includeRaw ? match : undefined,
     });
 }
 function normalizeUser(user) {
@@ -986,6 +1021,14 @@ function normalizeUser(user) {
         isAdmin: typeof user.is_admin === "boolean" ? user.is_admin : null,
         isOwner: typeof user.is_owner === "boolean" ? user.is_owner : null,
         locale: optionalString(user.locale),
+        email: optionalString(profile.email),
+        tz: optionalString(user.tz),
+        tzOffset: optionalInteger(user.tz_offset),
+        updated: optionalInteger(user.updated),
+        teamId: optionalString(user.team_id),
+        isRestricted: optionalBoolean(user.is_restricted),
+        isUltraRestricted: optionalBoolean(user.is_ultra_restricted),
+        isAppUser: optionalBoolean(user.is_app_user),
     });
 }
 function normalizeFile(file) {
@@ -1037,17 +1080,11 @@ function formatSlackPayloadError(payload) {
     }
     return `${error}: ${details.join("; ")}`;
 }
-function slackHttpError(status, payload, retryAfter) {
-    const message = payload.error ? formatSlackPayloadError(payload) : `slack request failed with ${status}`;
-    if (status === 429 && retryAfter !== null && /^\d+$/.test(retryAfter)) {
-        const retryAfterSeconds = Number(retryAfter);
-        if (Number.isSafeInteger(retryAfterSeconds)) {
-            // The action envelope carries provider details; retain pacing so callers
-            // can resume the same page without guessing when this workspace may retry.
-            return new ProviderRequestError(status, message, { ...payload, retryAfterSeconds });
-        }
-    }
-    return new ProviderRequestError(status, message, payload);
+function slackHttpError(response, payload) {
+    const message = payload.error ? formatSlackPayloadError(payload) : `slack request failed with ${response.status}`;
+    // The action envelope carries provider details; retain pacing so callers
+    // can resume the same page without guessing when this workspace may retry.
+    return new ProviderRequestError(response.status, message, withRetryAfterSeconds(response, payload));
 }
 function slackResponseError(message) {
     return new ProviderRequestError(502, `slack response is invalid: ${message}`);

package/src/providers/slack/trigger-on-message-posted.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const slackMessagePosted: PollDefinition;

package/src/providers/slack/trigger-on-message-posted.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "poll";
+};

package/src/providers/slack/trigger-on-message-posted.definition.js

@@ -0,0 +1,80 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const defaultPageSize = 15;
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "channelId",
+            jsonSchema: s.string({ pattern: "^[CDG][A-Z0-9]{2,31}$" }),
+            nullable: false,
+            description: "Slack conversation ID to watch, e.g. C0122KQ70S7E.",
+        },
+        {
+            handle: "fromUserIds",
+            jsonSchema: s.array(s.string({ pattern: "^[UW][A-Z0-9]{2,31}$" })),
+            nullable: false,
+            value: [],
+            description: "Only trigger on messages written by these Slack user IDs. Empty means any author.",
+        },
+        {
+            handle: "ignoreUserIds",
+            jsonSchema: s.array(s.string({ pattern: "^[UW][A-Z0-9]{2,31}$" })),
+            nullable: false,
+            value: [],
+            description: "Never trigger on messages written by these Slack user IDs.",
+        },
+        {
+            handle: "includeBotMessages",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Also trigger on messages posted by bots and apps.",
+        },
+        {
+            handle: "includeSystemMessages",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Also trigger on Slack system notices.",
+        },
+        {
+            handle: "maxMessagesPerPoll",
+            jsonSchema: s.integer({ maximum: 100, minimum: 1 }),
+            nullable: false,
+            value: defaultPageSize,
+            description: "Maximum number of messages processed per poll.",
+        },
+        {
+            handle: "textContains",
+            jsonSchema: s.string(),
+            nullable: false,
+            value: "",
+            description: "Only trigger when message text contains this string, case-insensitively.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Polls one Slack conversation and triggers when a new message is posted to it.",
+    displayName: "New Channel Message",
+    key: "slack.on_message_posted",
+    name: "on_message_posted",
+    outputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.object({
+                botId: { type: ["string", "null"] },
+                channelId: s.string(),
+                files: s.array(s.object({ id: s.string(), mimetype: s.string(), name: s.string() }, { additionalProperties: false, required: ["id", "name", "mimetype"] })),
+                messageTs: s.string(),
+                subtype: { type: ["string", "null"] },
+                text: s.string(),
+                threadTs: { type: ["string", "null"] },
+                userId: { type: ["string", "null"] },
+            }, {
+                additionalProperties: false,
+                required: ["channelId", "messageTs", "threadTs", "userId", "botId", "subtype", "text", "files"],
+            })),
+            nullable: false,
+        },
+    ],
+    provider: "slack",
+    type: "poll",
+};

package/src/providers/slack/trigger-on-message-posted.js

@@ -0,0 +1,176 @@
+import { HttpRequestError } from "../../server/api/http-utils.js";
+import { eventsPollOutputs, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-message-posted.definition.js";
+const seedBackoffMs = 60_000;
+const plainSubtypes = new Set(["file_share", "thread_broadcast", "me_message", "bot_message"]);
+const credentialErrors = new Set([
+    "invalid_auth",
+    "not_authed",
+    "token_revoked",
+    "token_expired",
+    "account_inactive",
+    "two_factor_setup_required",
+]);
+const permanentErrors = new Set([
+    "channel_not_found",
+    "not_in_channel",
+    "not_allowed_token_type",
+    "access_denied",
+    "channel_is_limited_access",
+    "ekm_access_denied",
+    "enterprise_is_restricted",
+    "no_permission",
+    "team_access_not_granted",
+    "invalid_ts_oldest",
+    "invalid_ts_latest",
+    "method_deprecated",
+    "deprecated_endpoint",
+    "accesslimited",
+]);
+export const slackMessagePosted = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null) {
+            return { checkpoint: { lastTs: await seed(context, config.channelId) }, events: [] };
+        }
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const history = await fetchHistory(context, config, checkpoint);
+        const messages = timedMessages(history);
+        const events = [];
+        let filtered = 0;
+        for (const entry of messages.toReversed()) {
+            if (!matches(entry.message, config)) {
+                filtered += 1;
+                continue;
+            }
+            events.push(event(entry, config.channelId));
+        }
+        return { checkpoint: nextCheckpoint(checkpoint, history, messages), events, filtered };
+    },
+};
+function resolveConfig(value) {
+    return {
+        channelId: value.channelId,
+        fromUserIds: value.fromUserIds,
+        ignoreUserIds: value.ignoreUserIds,
+        includeBotMessages: value.includeBotMessages,
+        includeSystemMessages: value.includeSystemMessages,
+        maxMessagesPerPoll: value.maxMessagesPerPoll,
+        textContains: value.textContains,
+    };
+}
+async function seed(context, channelId) {
+    const result = await slackGet(context, { channel: channelId, limit: 1 });
+    success(result, "baseline history fetch");
+    const ts = result.data.messages?.[0]?.ts;
+    return ts != null && validTs(ts) ? ts : `${Math.floor((context.now.getTime() - seedBackoffMs) / 1000)}.000000`;
+}
+function readCheckpoint(value) {
+    const checkpoint = value;
+    if (typeof checkpoint.lastTs != "string" || checkpoint.lastTs.length == 0) {
+        throw new PermanentPollError("Slack checkpoint lastTs is missing.");
+    }
+    const drainLatest = checkpoint.drainLatest;
+    const pendingHighTs = checkpoint.pendingHighTs;
+    if (drainLatest == null && pendingHighTs == null)
+        return { lastTs: checkpoint.lastTs };
+    if (typeof drainLatest != "string" ||
+        drainLatest.length == 0 ||
+        typeof pendingHighTs != "string" ||
+        pendingHighTs.length == 0) {
+        throw new PermanentPollError("Slack checkpoint drain fields are incomplete.");
+    }
+    return { drainLatest, lastTs: checkpoint.lastTs, pendingHighTs };
+}
+async function fetchHistory(context, config, checkpoint) {
+    const result = await slackGet(context, {
+        channel: config.channelId,
+        inclusive: "false",
+        latest: checkpoint.drainLatest,
+        limit: config.maxMessagesPerPoll,
+        oldest: checkpoint.lastTs,
+    });
+    success(result, "history list");
+    return result.data;
+}
+async function slackGet(context, query) {
+    try {
+        return await context.connector.execute({
+            endpoint: "/conversations.history",
+            method: "GET",
+            query: Object.fromEntries(Object.entries(query).filter((entry) => entry[1] != null)),
+        }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError("Slack proxy request failed.", { cause });
+    }
+}
+function success(result, operation) {
+    const body = result.data != null && typeof result.data === "object" && !Array.isArray(result.data)
+        ? result.data
+        : {};
+    if (result.status >= 200 && result.status < 300 && body.ok === true)
+        return;
+    const code = typeof body.error == "string" ? body.error : "";
+    if (code === "missing_scope")
+        throw new HttpRequestError("scope_missing", "Slack history permission is missing for the selected conversation", 403);
+    if (credentialErrors.has(code))
+        throw new PollConnectionError(`Slack ${operation} rejected with ${code}.`);
+    if (permanentErrors.has(code))
+        throw new PermanentPollError(`Slack ${operation} rejected with ${code}.`);
+    throw new TransientPollError(`Slack ${operation} failed with ${code || `status ${result.status}`}.`);
+}
+function timedMessages(history) {
+    return (history.messages ?? []).flatMap((message) => message.ts != null && validTs(message.ts) ? [{ message, ts: message.ts }] : []);
+}
+function nextCheckpoint(checkpoint, history, messages) {
+    const newestTs = messages[0]?.ts;
+    const oldestTs = messages.at(-1)?.ts;
+    if (history.has_more === true) {
+        if (newestTs == null || oldestTs == null)
+            throw new TransientPollError("Slack history reports has_more without a usable timestamp.");
+        return {
+            drainLatest: oldestTs,
+            lastTs: checkpoint.lastTs,
+            pendingHighTs: checkpoint.pendingHighTs ?? newestTs,
+        };
+    }
+    if (checkpoint.pendingHighTs != null)
+        return { lastTs: checkpoint.pendingHighTs };
+    return { lastTs: newestTs ?? checkpoint.lastTs };
+}
+function matches(message, config) {
+    if (!config.includeBotMessages && (message.bot_id != null || message.subtype == "bot_message"))
+        return false;
+    if (!config.includeSystemMessages && message.subtype != null && !plainSubtypes.has(message.subtype))
+        return false;
+    if (config.fromUserIds.length > 0 && (message.user == null || !config.fromUserIds.includes(message.user)))
+        return false;
+    if (message.user != null && config.ignoreUserIds.includes(message.user))
+        return false;
+    return (config.textContains.length == 0 || (message.text ?? "").toLowerCase().includes(config.textContains.toLowerCase()));
+}
+function event(entry, channelId) {
+    return {
+        dedupeKey: `${channelId}:${entry.ts}`,
+        payload: {
+            botId: entry.message.bot_id ?? null,
+            channelId,
+            files: (entry.message.files ?? []).map((file) => ({
+                id: file.id ?? "",
+                mimetype: file.mimetype ?? "",
+                name: file.name ?? "",
+            })),
+            messageTs: entry.ts,
+            subtype: entry.message.subtype ?? null,
+            text: entry.message.text ?? "",
+            threadTs: entry.message.thread_ts ?? null,
+            userId: entry.message.user ?? null,
+        },
+    };
+}
+function validTs(value) {
+    return /^\d+(?:\.\d+)?$/.test(value) && !Number.isNaN(new Date(Math.round(Number(value) * 1000)).getTime());
+}

package/src/providers/slickdeals/runtime.js

@@ -155,7 +155,7 @@ async function requestSlickdealsJson(input) {
                 authorization: `Bearer ${input.token}`,
                 "user-agent": providerUserAgent,
             },
-            redirect: "error",
+            redirect: "manual",
             signal,
         });
         const payload = await readPayload(response);

package/src/providers/sorftime_mcp/executors.js

@@ -45,7 +45,7 @@ export const proxy = defineProviderProxy({
     baseUrl: sorftimeMcpEndpoint,
     auth: { type: "api_key_authorization", prefix: "Bearer " },
     skipDnsValidation: true,
-    redirect: "error",
+    redirect: "manual",
     timeoutMs: requestTimeoutMs,
     allowedEndpoint(endpoint) {
         const url = new URL(endpoint, sorftimeMcpEndpoint);
@@ -79,7 +79,7 @@ function withSorftimeClient(context, run) {
             authorization: `Bearer ${context.apiKey}`,
             "user-agent": providerUserAgent,
         },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: mapSorftimeError,
     }, run);

package/src/providers/spotify/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerInputError, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
 export const spotifyApiBaseUrl = "https://api.spotify.com/v1/";
 export const spotifyActionHandlers = {
     get_current_user_profile(_input, deps) {
@@ -131,9 +131,7 @@ export const spotifyActionHandlers = {
             query: {
                 market: optionalString(input.market),
                 limit: stringifyOptionalInteger(input.limit),
-                seed_artists: joinStringArray(input.seedArtists),
-                seed_tracks: joinStringArray(input.seedTracks),
-                seed_genres: joinStringArray(input.seedGenres),
+                ...buildRecommendationSeedQuery(input),
             },
         });
     },
@@ -761,6 +759,19 @@ function buildPagingQuery(input, extraQuery) {
         ...(extraQuery ?? {}),
     };
 }
+// Spotify takes 1 to 5 seed values in any combination of seed_artists, seed_tracks, and seed_genres.
+function buildRecommendationSeedQuery(input) {
+    const query = {
+        seed_artists: joinStringArray(input.seedArtists),
+        seed_tracks: joinStringArray(input.seedTracks),
+        seed_genres: joinStringArray(input.seedGenres),
+    };
+    const seedCount = [input.seedArtists, input.seedTracks, input.seedGenres].reduce((count, seeds) => count + (Array.isArray(seeds) ? seeds.length : 0), 0);
+    if (seedCount < 1 || seedCount > 5) {
+        throw providerInputError(`get_recommendations needs 1 to 5 seeds across seedArtists, seedTracks, and seedGenres; received ${seedCount}`);
+    }
+    return query;
+}
 function buildPlaybackQuery(input) {
     return {
         market: optionalString(input.market),

package/src/providers/stripe/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { ApiKeyProviderContext } from "../provider-runtime.ts";
 type StripeActionContext = ApiKeyProviderContext;
@@ -7,4 +9,5 @@ export declare const stripeActionHandlers: ProviderActionHandlers<"stripe", Stri
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/stripe/executors.js

@@ -1,5 +1,6 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
 import { ProviderRequestError, defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, requiredResponseRecord, } from "../provider-runtime.js";
+import { stripeEvent } from "./trigger-on-event.js";
 const service = "stripe";
 const stripeApiBaseUrl = "https://api.stripe.com";
 const stripeApiVersion = "2024-06-20";
@@ -289,3 +290,4 @@ function mapStripeError(status, message) {
     }
     return new ProviderRequestError(502, message, status);
 }
+export const triggers = [stripeEvent];

package/src/providers/stripe/trigger-on-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const stripeEvent: IntegrationDefinition;

package/src/providers/stripe/trigger-on-event.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/stripe/trigger-on-event.definition.js

@@ -0,0 +1,43 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "apiVersion",
+            jsonSchema: s.string({ maxLength: 40 }),
+            nullable: false,
+            value: "",
+        },
+        {
+            handle: "events",
+            jsonSchema: s.array(s.string({ maxLength: 120, pattern: "^(\\*|[a-z0-9_]+(?:\\.[a-z0-9_]+)+)$" }), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+            nullable: false,
+        },
+        {
+            handle: "includeConnectedAccounts",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected Stripe events happen on the connected account.",
+    displayName: "Account Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "stripe.on_event",
+    name: "on_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "eventId", jsonSchema: s.string(), nullable: false },
+        { handle: "livemode", jsonSchema: s.boolean(), nullable: false },
+    ],
+    provider: "stripe",
+    type: "integration",
+};