@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/sentry/runtime.js

@@ -1,8 +1,6 @@
-import { compactObject, looseArray, optionalRawString, rawStringOrNull } from "../../core/cast.js";
+import { compactObject, looseArray, optionalRawString, optionalStringArray, rawStringOrNull } from "../../core/cast.js";
 import { ProviderRequestError } from "../provider-runtime.js";
-import { sentryProviderScopes } from "./scopes.js";
 export const sentryApiBaseUrl = "https://sentry.io/api/0/";
-const sentryCurrentUserUrl = `${sentryApiBaseUrl}users/me/`;
 export const sentryActionHandlers = {
     list_organization_integrations(input, context) {
         return sentryListOrganizationIntegrations(input, context.accessToken, context.fetcher);
@@ -63,8 +61,9 @@ export const sentryActionHandlers = {
     },
 };
 export async function validateSentryCredential(accessToken, fetcher) {
-    const { payload } = await requestSentryJson(accessToken, sentryCurrentUserUrl, fetcher, {}, "validate");
-    const user = asRecord(payload);
+    const { payload } = await requestSentryJson(accessToken, sentryApiBaseUrl, fetcher, {}, "validate");
+    const payloadRecord = asRecord(payload);
+    const user = asRecord(payloadRecord?.user);
     if (!user) {
         throw new ProviderRequestError(502, "sentry current user payload is invalid");
     }
@@ -78,9 +77,9 @@ export async function validateSentryCredential(accessToken, fetcher) {
             accountId: userId,
             displayName,
         },
-        grantedScopes: sentryProviderScopes,
+        grantedScopes: optionalStringArray(asRecord(payloadRecord?.auth)?.scopes) ?? [],
         metadata: compactObject({
-            validationEndpoint: "/users/me/",
+            validationEndpoint: "/",
             userId,
             username: optionalRawString(user.username),
             email: optionalRawString(user.email),

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

@@ -1,4 +1,7 @@
 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";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/shopify/executors.js

@@ -2,6 +2,7 @@ import { optionalRecord, optionalString } from "../../core/cast.js";
 import { defineProviderExecutors, defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
 import { buildShopifyRestApiBaseUrl, normalizeShopDomain, shopifyActionHandlers, validateShopifyCredential, } from "./runtime.js";
 import { shopifyReadContentScope } from "./scopes.js";
+import { shopifyShopEvent } from "./trigger-on-shop-event.js";
 const service = "shopify";
 export const executors = defineProviderExecutors({
     service,
@@ -62,3 +63,4 @@ function parseShopifyScopes(value) {
         .map((scope) => scope.trim())
         .filter(Boolean);
 }
+export const triggers = [shopifyShopEvent];

package/src/providers/shopify/trigger-on-shop-event.d.ts

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

package/src/providers/shopify/trigger-on-shop-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/shopify/trigger-on-shop-event.definition.js

@@ -0,0 +1,214 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const topics = [
+    "app/scopes_update",
+    "app/uninstalled",
+    "app_purchases_one_time/update",
+    "app_subscriptions/approaching_capped_amount",
+    "app_subscriptions/update",
+    "bulk_operations/finish",
+    "carts/create",
+    "carts/update",
+    "channels/delete",
+    "checkout_and_accounts_configurations/update",
+    "checkouts/create",
+    "checkouts/delete",
+    "checkouts/update",
+    "collection_listings/add",
+    "collection_listings/remove",
+    "collection_listings/update",
+    "collection_publications/create",
+    "collection_publications/delete",
+    "collection_publications/update",
+    "collections/create",
+    "collections/delete",
+    "collections/update",
+    "companies/create",
+    "companies/delete",
+    "companies/update",
+    "company_contact_roles/assign",
+    "company_contact_roles/revoke",
+    "company_contacts/create",
+    "company_contacts/delete",
+    "company_contacts/update",
+    "company_locations/create",
+    "company_locations/delete",
+    "company_locations/update",
+    "customer.joined_segment",
+    "customer.left_segment",
+    "customer.tags_added",
+    "customer.tags_removed",
+    "customer_account_settings/update",
+    "customer_groups/create",
+    "customer_groups/delete",
+    "customer_groups/update",
+    "customers/create",
+    "customers/delete",
+    "customers/disable",
+    "customers/enable",
+    "customers/purchasing_summary",
+    "customers/update",
+    "customers_email_marketing_consent/update",
+    "customers_marketing_consent/update",
+    "delivery_promise_settings/update",
+    "disputes/create",
+    "disputes/update",
+    "domains/create",
+    "domains/destroy",
+    "domains/update",
+    "draft_orders/create",
+    "draft_orders/delete",
+    "draft_orders/update",
+    "fulfillment_events/create",
+    "fulfillment_events/delete",
+    "fulfillment_holds/added",
+    "fulfillment_holds/released",
+    "fulfillment_orders/cancellation_request_accepted",
+    "fulfillment_orders/cancellation_request_rejected",
+    "fulfillment_orders/cancellation_request_submitted",
+    "fulfillment_orders/cancelled",
+    "fulfillment_orders/fulfillment_request_accepted",
+    "fulfillment_orders/fulfillment_request_rejected",
+    "fulfillment_orders/fulfillment_request_submitted",
+    "fulfillment_orders/fulfillment_service_failed_to_complete",
+    "fulfillment_orders/hold_released",
+    "fulfillment_orders/line_items_prepared_for_local_delivery",
+    "fulfillment_orders/line_items_prepared_for_pickup",
+    "fulfillment_orders/manually_reported_progress_stopped",
+    "fulfillment_orders/merged",
+    "fulfillment_orders/moved",
+    "fulfillment_orders/order_routing_complete",
+    "fulfillment_orders/placed_on_hold",
+    "fulfillment_orders/progress_reported",
+    "fulfillment_orders/rescheduled",
+    "fulfillment_orders/scheduled_fulfillment_order_ready",
+    "fulfillment_orders/split",
+    "fulfillments/create",
+    "fulfillments/update",
+    "inventory_items/create",
+    "inventory_items/delete",
+    "inventory_items/update",
+    "inventory_levels/connect",
+    "inventory_levels/disconnect",
+    "inventory_levels/update",
+    "locales/create",
+    "locales/destroy",
+    "locales/update",
+    "locations/activate",
+    "locations/create",
+    "locations/deactivate",
+    "locations/delete",
+    "locations/update",
+    "machine_translation_batch/completed",
+    "metafield_definitions/create",
+    "metafield_definitions/delete",
+    "metafield_definitions/update",
+    "order_transactions/create",
+    "orders/cancelled",
+    "orders/create",
+    "orders/delete",
+    "orders/edited",
+    "orders/fulfilled",
+    "orders/link_requested",
+    "orders/paid",
+    "orders/partially_fulfilled",
+    "orders/risk_assessment_changed",
+    "orders/shopify_protect_eligibility_changed",
+    "orders/updated",
+    "payment_schedules/due",
+    "payment_terms/create",
+    "payment_terms/delete",
+    "payment_terms/update",
+    "product_feeds/create",
+    "product_feeds/full_sync",
+    "product_feeds/full_sync_finish",
+    "product_feeds/incremental_sync",
+    "product_feeds/update",
+    "product_listings/add",
+    "product_listings/remove",
+    "product_listings/update",
+    "product_publications/create",
+    "product_publications/delete",
+    "product_publications/update",
+    "products/create",
+    "products/delete",
+    "products/update",
+    "profiles/create",
+    "profiles/delete",
+    "profiles/update",
+    "publications/delete",
+    "refunds/create",
+    "returns/approve",
+    "returns/cancel",
+    "returns/close",
+    "returns/decline",
+    "returns/process",
+    "returns/reopen",
+    "returns/request",
+    "returns/update",
+    "reverse_deliveries/attach_deliverable",
+    "reverse_fulfillment_orders/dispose",
+    "scheduled_product_listings/add",
+    "scheduled_product_listings/remove",
+    "scheduled_product_listings/update",
+    "segments/create",
+    "segments/delete",
+    "segments/update",
+    "selling_plan_groups/create",
+    "selling_plan_groups/delete",
+    "selling_plan_groups/update",
+    "shop/update",
+    "subscription_billing_attempts/challenged",
+    "subscription_billing_attempts/failure",
+    "subscription_billing_attempts/success",
+    "subscription_billing_cycle_edits/create",
+    "subscription_billing_cycle_edits/delete",
+    "subscription_billing_cycle_edits/update",
+    "subscription_billing_cycles/skip",
+    "subscription_billing_cycles/unskip",
+    "subscription_contracts/activate",
+    "subscription_contracts/cancel",
+    "subscription_contracts/create",
+    "subscription_contracts/expire",
+    "subscription_contracts/fail",
+    "subscription_contracts/pause",
+    "subscription_contracts/update",
+    "tax_partners/update",
+    "tax_summaries/create",
+    "tender_transactions/create",
+    "themes/create",
+    "themes/delete",
+    "themes/publish",
+    "themes/update",
+    "variants/in_stock",
+    "variants/out_of_stock",
+];
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "topics",
+            jsonSchema: s.array(s.stringEnum(topics), { maxItems: 20, minItems: 1, uniqueItems: true }),
+            nullable: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected Shopify webhook topics occur in the connected store.",
+    displayName: "Store Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "shopify.on_shop_event",
+    name: "on_shop_event",
+    outputs: [
+        { handle: "apiVersion", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "eventId", jsonSchema: s.string(), nullable: false },
+        { handle: "shopDomain", jsonSchema: s.string(), nullable: false },
+        { handle: "topic", jsonSchema: s.string(), nullable: false },
+        { handle: "triggeredAt", jsonSchema: s.string(), nullable: false },
+        { handle: "webhookId", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "shopify",
+    type: "integration",
+};

package/src/providers/shopify/trigger-on-shop-event.js

@@ -0,0 +1,165 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { sameSecret } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-shop-event.definition.js";
+export const shopifyShopEvent = {
+    initialState: { checkpoint: null, subscription: {} },
+    snapshot,
+    receive(context) {
+        if (!sameSecret(context.query("open_flow_callback"), context.callbackSecret)) {
+            return { body: "", contentType: "text/plain", outcome: "respond", status: 404 };
+        }
+        const topic = context.header("x-shopify-topic")?.trim();
+        if (!topic)
+            return { outcome: "ignored", reason: "Shopify topic header is missing." };
+        if (!configuredTopics(context.config).includes(topic))
+            return { outcome: "ignored", reason: "Shopify topic is not subscribed." };
+        const webhookId = context.header("x-shopify-webhook-id") ?? "";
+        return {
+            dedupeKey: webhookId.length == 0 ? undefined : webhookId,
+            outcome: "event",
+            outputs: {
+                apiVersion: context.header("x-shopify-api-version") ?? "",
+                body: context.payload,
+                eventId: context.header("x-shopify-event-id") ?? "",
+                shopDomain: context.header("x-shopify-shop-domain") ?? "",
+                topic,
+                triggeredAt: context.header("x-shopify-triggered-at") ?? "",
+                webhookId,
+            },
+        };
+    },
+    async reconcile(context) {
+        const state = requireState(context.state);
+        const subscriptions = await list(context);
+        if (subscriptions == null) {
+            if (!context.active)
+                return { outcome: "ready" };
+            throw new PermanentIntegrationError("The Shopify store or webhook resource is unavailable.");
+        }
+        if (!context.active) {
+            for (const id of subscriptions.values())
+                await remove(context, id);
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        const wanted = configuredTopics(context.config);
+        const ids = [];
+        const created = [];
+        try {
+            for (const topic of wanted) {
+                const existing = subscriptions.get(topic);
+                if (existing != null)
+                    ids.push(existing);
+                else {
+                    const subscription = await create(context, topic);
+                    ids.push(subscription.id);
+                    if (subscription.created)
+                        created.push(subscription.id);
+                }
+            }
+        }
+        catch (cause) {
+            await Promise.allSettled(created.map((id) => remove(context, id)));
+            throw cause;
+        }
+        for (const [topic, id] of subscriptions)
+            if (!wanted.includes(topic))
+                await remove(context, id);
+        await state.saveSubscription({ webhookIds: ids }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function configuredTopics(value) {
+    return [...new Set(value.topics)];
+}
+async function create(context, topic) {
+    const address = callbackUrl(context);
+    const result = await request(context, "subscription create", {
+        body: { webhook: { address, format: "json", topic } },
+        endpoint: "/webhooks.json",
+        method: "POST",
+    });
+    if (result.status == 422) {
+        const subscriptions = await list(context);
+        const winner = subscriptions?.get(topic);
+        if (winner != null)
+            return { created: false, id: winner };
+    }
+    success(result, "subscription create");
+    const id = normalizeId(record(record(result.data)?.webhook)?.id);
+    if (id == null)
+        throw new TransientIntegrationError("Shopify subscription response is missing its ID.");
+    return { created: true, id };
+}
+async function list(context) {
+    const address = callbackUrl(context);
+    const result = await request(context, "subscription list", {
+        endpoint: "/webhooks.json",
+        method: "GET",
+        query: { address, limit: 250 },
+    });
+    if (result.status == 404)
+        return null;
+    success(result, "subscription list");
+    const raw = record(result.data)?.webhooks;
+    const subscriptions = new Map();
+    if (!Array.isArray(raw))
+        return subscriptions;
+    for (const item of raw) {
+        const value = record(item);
+        const id = normalizeId(value?.id);
+        if (value?.address === address && typeof value.topic == "string" && id != null)
+            subscriptions.set(value.topic, id);
+    }
+    return subscriptions;
+}
+function callbackUrl(context) {
+    const url = new URL(context.endpointUrl);
+    url.searchParams.set("open_flow_callback", context.callbackSecret);
+    return url.href;
+}
+async function remove(context, id) {
+    const result = await request(context, "subscription delete", {
+        endpoint: `/webhooks/${encodeURIComponent(id)}.json`,
+        method: "DELETE",
+    });
+    if (result.status != 404)
+        success(result, "subscription delete");
+}
+async function request(context, operation, value) {
+    try {
+        return await context.connector.execute(value, context.signal);
+    }
+    catch (cause) {
+        if (cause instanceof IntegrationConnectionError)
+            throw cause;
+        throw new TransientIntegrationError(`Shopify ${operation} request failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 401 || result.status == 403)
+        throw new IntegrationConnectionError(`Shopify ${operation} rejected the Connection.`);
+    if ([402, 404, 422, 423, 501].includes(result.status))
+        throw new PermanentIntegrationError(`Shopify ${operation} rejected the subscription.`);
+    throw new TransientIntegrationError(`Shopify ${operation} failed with status ${result.status}.`);
+}
+function normalizeId(value) {
+    if (typeof value == "string")
+        return value.trim().length == 0 ? null : value;
+    return typeof value == "number" && Number.isFinite(value) ? String(value) : null;
+}
+function requireState(value) {
+    if (value == null)
+        throw new PermanentIntegrationError("Shopify Integration state is missing.");
+    return value;
+}
+function later(now) {
+    return new Date(now.getTime() + 30 * 24 * 60 * 60 * 1_000);
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/slack/actions.js

@@ -50,6 +50,16 @@ const messageContentProperties = {
     unfurlMedia: s.boolean({ description: "Whether Slack should unfurl media in the message." }),
     metadata: s.unknownObject("Slack message metadata to attach to the message."),
 };
+// Shared by `conversations.history` and `conversations.replies`: opt in to
+// the untouched vendor record. Off by default so the row read in bulk stays
+// lean. Opting in also asks Slack for message metadata, which it leaves out
+// unless the request sets `include_all_metadata`.
+const includeRawProperties = {
+    includeRaw: s.boolean({
+        description: "When true, each returned message also carries the untouched Slack record under raw, including its blocks, attachments, files and message metadata. Defaults to false.",
+    }),
+};
+const rawMessageSchema = s.unknownObject("The untouched Slack record, exactly as the Slack API returned it. Present only when includeRaw is true.");
 const slackReactionSchema = s.looseObject({
     name: s.string({ description: "The emoji name of the reaction." }),
     count: s.integer({ description: "How many users added this reaction." }),
@@ -60,9 +70,10 @@ const slackReactionSchema = s.looseObject({
 // Only fields the executor actually normalizes are declared. The object is
 // loose, but that permits extras it does NOT make them appear: the executor
 // builds each row explicitly, so an undeclared Slack field is simply not
-// emitted. Deliberately absent: `blocks`, `attachments` and `files`. Those
-// are unbounded nested payloads on a row shape that ETL reads in bulk, and
-// each wants its own normalized contract rather than a raw passthrough.
+// emitted. Deliberately absent: `blocks`, `attachments`, `files` and
+// `metadata`. Those are unbounded nested payloads on a row shape that ETL
+// reads in bulk, so they stay out of the default row; a caller that needs
+// them passes includeRaw and reads them from `raw`, the untouched record.
 const slackMessageSchema = s.looseObject({
     ts: s.string({ description: "The message timestamp identifier." }),
     type: s.string({ description: "The Slack message type, normally 'message'." }),
@@ -77,15 +88,20 @@ const slackMessageSchema = s.looseObject({
     clientMsgId: s.string({ description: "The client-generated message identifier when Slack returns one." }),
     text: s.string({ description: "The text content of the message." }),
     editedTs: s.string({ description: "The timestamp of the most recent edit, when the message was edited." }),
+    editedUserId: s.string({ description: "The user ID of the most recent editor, when the message was edited." }),
     threadTs: s.string({
         description: "The timestamp of the thread parent. Equal to ts on a thread parent, and absent on a message that is not in a thread.",
     }),
     parentUserId: s.string({ description: "The author of the thread parent, on a threaded reply." }),
     replyCount: s.integer({ description: "The number of replies to this thread parent." }),
     replyUsersCount: s.integer({ description: "The number of distinct users who replied to this thread parent." }),
+    replyUserIds: s.array(s.string({ description: "A Slack user ID." }), {
+        description: "Up to five user IDs of people who replied to this thread parent. Slack caps this list; use replyUsersCount for the total.",
+    }),
     latestReply: s.string({ description: "The timestamp of the most recent reply to this thread parent." }),
     isLocked: s.boolean({ description: "Whether the thread is locked." }),
     reactions: s.array(slackReactionSchema, { description: "Reaction summaries attached to the message." }),
+    raw: rawMessageSchema,
 }, { description: "A Slack message record." });
 const searchMessageMatchSchema = s.looseObject({
     matchId: s.string({ description: "Slack's search result item identifier." }),
@@ -98,6 +114,7 @@ const searchMessageMatchSchema = s.looseObject({
     permalink: s.string({ description: "A Slack permalink for the matching message." }),
     teamId: s.string({ description: "The Slack team ID returned for the match." }),
     type: s.string({ description: "The Slack result type." }),
+    raw: rawMessageSchema,
 }, { description: "A normalized Slack message search match." });
 const conversationSchema = s.object({
     channelId: s.string({ description: "The unique identifier of the conversation." }),
@@ -113,6 +130,21 @@ const conversationSchema = s.object({
     purpose: s.nullable(s.string({ description: "The conversation purpose." })),
     userId: s.string({ description: "The linked user identifier for IM conversations." }),
     locale: s.string({ description: "The locale returned by Slack when requested." }),
+    created: s.integer({ description: "Creation time as a Unix timestamp in seconds when Slack provides it." }),
+    updated: s.integer({
+        description: "Last settings update time, passed through as Slack returns it. Slack documents epoch milliseconds for channels (unlike created) and a Unix timestamp for legacy IM and MPIM objects.",
+    }),
+    creatorId: s.string({ description: "The user who created the conversation when Slack provides it." }),
+    isShared: s.boolean({ description: "Whether the conversation is shared with another workspace." }),
+    isExtShared: s.boolean({ description: "Whether the conversation is shared with an external organization." }),
+    isOrgShared: s.boolean({
+        description: "Whether the conversation is shared between workspaces of the same Enterprise organization.",
+    }),
+    contextTeamId: s.string({
+        description: "The ID of the workspace the conversation is within when Slack provides it.",
+    }),
+    lastRead: s.string({ description: "The last-read message timestamp when Slack provides it." }),
+    unreadCount: s.integer({ description: "The unread message count when Slack provides it." }),
 }, {
     required: ["channelId", "name", "type", "isArchived", "isPrivate", "isMember", "topic", "purpose"],
     description: "A normalized Slack conversation record.",
@@ -127,6 +159,18 @@ const userSchema = s.object({
     isAdmin: s.nullable(s.boolean({ description: "Whether the user is an admin." })),
     isOwner: s.nullable(s.boolean({ description: "Whether the user is an owner." })),
     locale: s.string({ description: "The locale returned by Slack when requested." }),
+    email: s.string({
+        description: "The profile email. Slack returns it only when the token holds the users:read.email scope.",
+    }),
+    tz: s.string({ description: "The user's time zone identifier when Slack provides it." }),
+    tzOffset: s.integer({ description: "The user's UTC offset in seconds when Slack provides it." }),
+    updated: s.integer({ description: "When the user object was last updated, as a Unix timestamp in seconds." }),
+    teamId: s.string({ description: "The user's team ID when Slack provides it." }),
+    isRestricted: s.boolean({
+        description: "Whether the user is a guest. Single-channel guests also set isUltraRestricted.",
+    }),
+    isUltraRestricted: s.boolean({ description: "Whether the user is a single-channel guest." }),
+    isAppUser: s.boolean({ description: "Whether the user is an authorized user of the calling app." }),
 }, {
     required: ["userId", "username", "realName", "displayName", "isBot", "isDeleted", "isAdmin", "isOwner"],
     description: "A normalized Slack user record.",
@@ -188,6 +232,7 @@ export const slackActions = [
                 description: "The Slack pagination cursor from a previous page. Omit for the first page.",
             }),
             ...historyWindowProperties,
+            ...includeRawProperties,
         }, { required: ["channelId"], description: "Input parameters for reading Slack conversation history." }),
         outputSchema: s.object({
             messages: s.array(slackMessageSchema, { description: "The list of messages in the conversation." }),
@@ -242,6 +287,9 @@ export const slackActions = [
             sort: searchSortSchema,
             sortDir: sortDirectionSchema,
             teamId: s.string({ description: "The encoded team ID to search when using an org-level token." }),
+            includeRaw: s.boolean({
+                description: "When true, each returned match also carries the untouched Slack search match under raw, including any blocks, attachments and files. Defaults to false.",
+            }),
         }, { required: ["query"], description: "Input parameters for searching Slack messages." }),
         outputSchema: s.object({
             query: s.string({ description: "The search query Slack executed." }),
@@ -323,6 +371,7 @@ export const slackActions = [
                 description: "The Slack pagination cursor from a previous page. Omit for the first page.",
             }),
             ...historyWindowProperties,
+            ...includeRawProperties,
         }, { required: ["channelId", "threadTs"], description: "Input parameters for reading a Slack thread." }),
         outputSchema: s.object({
             messages: s.array(slackMessageSchema, { description: "The list of messages in the thread." }),

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

@@ -1,4 +1,7 @@
 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";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/slack/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderProxy } from "../provider-runtime.js";
 import { defineSlackProviderExecutors, slackActionHandlers, slackApiBaseUrl, slackCredentialValidators, } from "./runtime.js";
+import { slackMessagePosted } from "./trigger-on-message-posted.js";
 const service = "slack";
 export const executors = defineSlackProviderExecutors(service, "user", slackActionHandlers);
 export const proxy = defineProviderProxy({
@@ -9,3 +10,4 @@ export const proxy = defineProviderProxy({
     skipDnsValidation: true,
 });
 export const credentialValidators = slackCredentialValidators;
+export const triggers = [slackMessagePosted];