@oomol-lab/open-connector 1.7.0 → 1.8.0

package/src/providers/aisa/executors.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, readProviderJsonBody, runProviderRequest, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, runProviderRequest, } from "../provider-runtime.js";
 const service = "aisa";
 const aisaApiOrigin = "https://api.aisa.one";
 function dataForSeoRoute(path, body) {
@@ -215,9 +215,10 @@ const aisaActionRoutes = {
         query: { woeid: "woeid", count: "count" },
     },
     enrich_apollo_person: {
-        path: "/apis/v2/apollo/people/match",
+        path: "/apis/v1/apollo/people/match",
         method: "POST",
-        query: {
+        query: {},
+        body: {
             firstName: "first_name",
             lastName: "last_name",
             name: "name",
@@ -230,7 +231,7 @@ const aisaActionRoutes = {
         },
     },
     enrich_apollo_people: {
-        path: "/apis/v2/apollo/people/bulk_match",
+        path: "/apis/v1/apollo/people/bulk_match",
         method: "POST",
         query: {},
         body: { people: "details" },
@@ -238,16 +239,16 @@ const aisaActionRoutes = {
         bodyKeyAliases: { personId: "id" },
     },
     enrich_apollo_organization: {
-        path: "/apis/v2/apollo/organizations/enrich",
+        path: "/apis/v1/apollo/organizations/enrich",
         query: { domain: "domain" },
     },
     enrich_apollo_organizations: {
-        path: "/apis/v2/apollo/organizations/bulk_enrich",
+        path: "/apis/v1/apollo/organizations/bulk_enrich",
         method: "POST",
         query: { domains: "domains[]" },
     },
     search_apollo_people: {
-        path: "/apis/v2/apollo/mixed_people/api_search",
+        path: "/apis/v1/apollo/mixed_people/api_search",
         method: "POST",
         query: {
             titles: "person_titles[]",
@@ -264,7 +265,7 @@ const aisaActionRoutes = {
         },
     },
     search_apollo_organizations: {
-        path: "/apis/v2/apollo/mixed_companies/search",
+        path: "/apis/v1/apollo/mixed_companies/search",
         method: "POST",
         query: {
             domains: "q_organization_domains_list[]",
@@ -278,17 +279,17 @@ const aisaActionRoutes = {
         },
     },
     get_apollo_organization: {
-        path: "/apis/v2/apollo/organizations/{organizationId}",
+        path: "/apis/v1/apollo/organizations/{organizationId}",
         pathParams: { organizationId: "organizationId" },
         query: {},
     },
     get_apollo_job_postings: {
-        path: "/apis/v2/apollo/organizations/{organizationId}/job_postings",
+        path: "/apis/v1/apollo/organizations/{organizationId}/job_postings",
         pathParams: { organizationId: "organizationId" },
         query: { page: "page", perPage: "per_page" },
     },
     search_apollo_company_news: {
-        path: "/apis/v2/apollo/news_articles/search",
+        path: "/apis/v1/apollo/news_articles/search",
         method: "POST",
         query: {
             organizationIds: "organization_ids[]",
@@ -510,46 +511,105 @@ const aisaActionRoutes = {
         query: {},
         body: { profileUrl: "profile_url" },
     },
+    get_semrush_domain_overview: {
+        path: "/apis/v1/semrush/domain-overview",
+        query: { domain: "domain", database: "database" },
+        response: {
+            type: "semicolon",
+            header: "optional",
+            columns: ["Database", "Domain", "Rank", "OrganicKeywords", "OrganicTraffic", "OrganicCost", "AdwordsKeywords"],
+        },
+    },
+    get_semrush_organic_results: {
+        path: "/apis/v1/semrush/keyword-organic-results",
+        query: { phrase: "phrase", database: "database" },
+        response: { type: "semicolon", header: "required" },
+    },
+    get_semrush_domain_organic_keywords: {
+        path: "/apis/v1/semrush/domain-organic-keywords",
+        query: { domain: "domain", database: "database" },
+        response: { type: "semicolon", header: "required" },
+    },
+    get_semrush_organic_competitors: {
+        path: "/apis/v1/semrush/domain-organic-competitors",
+        query: { domain: "domain", database: "database" },
+        response: { type: "semicolon", header: "required" },
+    },
+    get_semrush_url_organic_keywords: {
+        path: "/apis/v1/semrush/url-organic-keywords",
+        query: { url: "url", database: "database" },
+        response: { type: "semicolon", header: "required" },
+    },
+    get_semrush_backlink_anchors: {
+        path: "/apis/v1/semrush/backlink-anchors",
+        query: { target: "target", targetType: "target_type" },
+        response: { type: "semicolon", header: "required" },
+    },
+    get_semrush_indexed_pages: {
+        path: "/apis/v1/semrush/indexed-pages",
+        query: { target: "target", targetType: "target_type" },
+        response: { type: "semicolon", header: "required" },
+    },
     get_semrush_keyword_overview: {
         path: "/apis/v1/semrush/keyword-overview",
         query: { phrase: "phrase", database: "database" },
+        response: {
+            type: "semicolon",
+            header: "optional",
+            columns: ["Keyword", "SearchVolume", "CPC", "Competition", "NumberOfResults"],
+        },
+        omitQueryDefaults: { database: "us" },
     },
     get_semrush_keyword_difficulty: {
         path: "/apis/v1/semrush/keyword-difficulty",
         query: { phrases: "phrase", database: "database" },
         joined: { phrases: ";" },
+        response: { type: "semicolon", header: "required" },
     },
     get_semrush_broad_match_keywords: {
         path: "/apis/v1/semrush/broad-match-keywords",
         query: { phrase: "phrase", database: "database" },
+        response: { type: "semicolon", header: "required" },
     },
     get_semrush_question_keywords: {
         path: "/apis/v1/semrush/question-keywords",
         query: { phrase: "phrase", database: "database" },
+        response: { type: "semicolon", header: "required" },
     },
     get_semrush_domain_rank_history: {
         path: "/apis/v1/semrush/domain-rank-history",
         query: { domain: "domain", database: "database" },
+        response: { type: "semicolon", header: "required" },
     },
     compare_semrush_domains: {
         path: "/apis/v1/semrush/domain-vs-domain",
         query: { comparison: "domains", database: "database" },
+        response: { type: "semicolon", header: "required" },
     },
     get_semrush_backlinks_overview: {
         path: "/apis/v1/semrush/backlinks-overview",
         query: { target: "target" },
+        response: {
+            type: "semicolon",
+            header: "optional",
+            columns: ["ascore", "total_backlinks", "referring_domains", "referring_urls", "referring_ips"],
+            headerAliases: [["ascore", "total", "domains_num", "urls_num", "ips_num"]],
+        },
     },
     get_semrush_backlinks: {
         path: "/apis/v1/semrush/backlinks",
         query: { target: "target", targetType: "target_type" },
+        response: { type: "semicolon", header: "required" },
     },
     get_semrush_referring_domains: {
         path: "/apis/v1/semrush/referring-domains",
         query: { target: "target", targetType: "target_type" },
+        response: { type: "semicolon", header: "required" },
     },
     get_semrush_backlink_competitors: {
         path: "/apis/v1/semrush/backlink-competitors",
         query: { target: "target", targetType: "target_type" },
+        response: { type: "semicolon", header: "required" },
     },
     get_stock_price_snapshot: {
         path: "/apis/v1/financial/prices/snapshot",
@@ -756,14 +816,14 @@ function camelToSnakeCase(value) {
     }
     return output;
 }
-function buildAisaQuery(input, mapping, commaSeparated, joined, fixed) {
+function buildAisaQuery(input, mapping, commaSeparated, joined, fixed, omitDefaults) {
     const query = new URLSearchParams();
     for (const [name, value] of Object.entries(fixed)) {
         query.set(name, value);
     }
     for (const [inputName, queryName] of Object.entries(mapping)) {
         const value = input[inputName];
-        if (value == null) {
+        if (value == null || value === omitDefaults[inputName]) {
             continue;
         }
         const queryNames = typeof queryName === "string" ? [queryName] : queryName;
@@ -796,7 +856,7 @@ function buildAisaQuery(input, mapping, commaSeparated, joined, fixed) {
 }
 const handlers = Object.fromEntries(Object.entries(aisaActionRoutes).map(([name, route]) => [
     name,
-    (input, context) => requestAisaJson(buildAisaPath(route.path, input, route.pathParams), buildAisaQuery(input, route.query, route.commaSeparated ?? [], route.joined ?? {}, route.fixedQuery ?? {}), context, route.method ?? "GET", buildAisaBody(input, route)),
+    (input, context) => requestAisa(buildAisaPath(route.path, input, route.pathParams), buildAisaQuery(input, route.query, route.commaSeparated ?? [], route.joined ?? {}, route.fixedQuery ?? {}, route.omitQueryDefaults ?? {}), context, route.method ?? "GET", buildAisaBody(input, route), "execute", route.response),
 ]));
 export const executors = defineApiKeyProviderExecutors(service, handlers, {
     skipDnsValidation: true,
@@ -805,11 +865,15 @@ export const proxy = defineProviderProxy({
     service,
     baseUrl: aisaApiOrigin,
     auth: { type: "bearer" },
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json, text/plain;q=0.9, */*;q=0.8");
+    },
     skipDnsValidation: true,
 });
 export const credentialValidators = {
     async apiKey(input, { fetcher, signal }) {
-        const payload = optionalRecord(await requestAisaJson("/v1/credits/balance", new URLSearchParams(), { apiKey: input.apiKey, fetcher, signal }, "GET", undefined, "validate"));
+        const payload = optionalRecord(await requestAisa("/v1/credits/balance", new URLSearchParams(), { apiKey: input.apiKey, fetcher, signal }, "GET", undefined, "validate"));
         if (!payload)
             throw new ProviderRequestError(502, "AIsa balance response must be an object");
         return {
@@ -819,11 +883,14 @@ export const credentialValidators = {
         };
     },
 };
-async function requestAisaJson(path, query, context, method, body, phase = "execute") {
+async function requestAisa(path, query, context, method, body, phase = "execute", responseFormat) {
     return runProviderRequest({ signal: context.signal, label: "AIsa" }, async (signal) => {
         const url = new URL(path, aisaApiOrigin);
         url.search = query.toString();
-        const headers = new Headers({ accept: "application/json", authorization: `Bearer ${context.apiKey}` });
+        const headers = new Headers({
+            accept: responseFormat ? "text/plain, application/json;q=0.9" : "application/json",
+            authorization: `Bearer ${context.apiKey}`,
+        });
         if (body !== undefined)
             headers.set("content-type", "application/json");
         const response = await context.fetcher(url, {
@@ -832,19 +899,126 @@ async function requestAisaJson(path, query, context, method, body, phase = "exec
             signal,
             body: body === undefined ? undefined : JSON.stringify(body),
         });
-        const payload = await readProviderJsonBody(response, {
-            emptyBody: null,
-            invalidJsonMessage: "AIsa returned invalid JSON",
-        });
+        const payload = await readAisaPayload(response, responseFormat);
         if (!response.ok)
             throw createAisaError(response, payload, phase);
         return payload;
     });
 }
+async function readAisaPayload(response, responseFormat) {
+    const text = await response.text();
+    if (text.trim() === "") {
+        return response.ok && responseFormat?.type === "semicolon" ? createSemicolonOutput(text, responseFormat) : null;
+    }
+    if (response.ok && responseFormat?.type === "semicolon") {
+        return createSemicolonOutput(text, responseFormat);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        if (!response.ok) {
+            return text;
+        }
+        throw new ProviderRequestError(502, "AIsa returned invalid JSON");
+    }
+}
+function createSemicolonOutput(rawText, responseFormat) {
+    const records = isEmptySemrushReport(rawText) ? [] : parseSemicolonRecords(rawText);
+    const columns = responseFormat.header === "required" ? (records.shift() ?? []) : [...(responseFormat.columns ?? [])];
+    const acceptedHeaders = [columns, ...(responseFormat.headerAliases ?? [])];
+    if (responseFormat.header === "optional" &&
+        records[0] &&
+        acceptedHeaders.some((header) => columnsMatch(records[0], header))) {
+        records.shift();
+    }
+    return { rawText, columns, rows: records };
+}
+function isEmptySemrushReport(rawText) {
+    const message = rawText.trim();
+    if (!message.startsWith("ERROR ")) {
+        return false;
+    }
+    const separatorIndex = message.indexOf(" :: ");
+    const code = separatorIndex === -1 ? undefined : message.slice(6, separatorIndex).trim();
+    // Semrush code 50 means no matching data.
+    if (code === "50")
+        return true;
+    const detail = separatorIndex === -1 ? message : message.slice(separatorIndex + 4).trim();
+    throw new ProviderRequestError(502, code ? `Semrush error ${code}: ${detail}` : `Semrush error: ${detail}`);
+}
+function columnsMatch(values, columns) {
+    return (values.length === columns.length &&
+        values.every((value, index) => normalizeColumnName(value) === normalizeColumnName(columns[index])));
+}
+function normalizeColumnName(value) {
+    let output = "";
+    for (const character of value.toLowerCase()) {
+        const code = character.charCodeAt(0);
+        if ((code >= 48 && code <= 57) || (code >= 97 && code <= 122)) {
+            output += character;
+        }
+    }
+    return output;
+}
+function parseSemicolonRecords(text) {
+    const records = [];
+    let record = [];
+    let field = "";
+    let quoted = false;
+    const commitField = () => {
+        record.push(field);
+        field = "";
+    };
+    const commitRecord = () => {
+        commitField();
+        records.push(record);
+        record = [];
+    };
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index];
+        if (quoted) {
+            if (character !== '"') {
+                field += character;
+                continue;
+            }
+            if (text[index + 1] === '"') {
+                field += '"';
+                index += 1;
+                continue;
+            }
+            quoted = false;
+            continue;
+        }
+        if (character === '"' && field === "") {
+            quoted = true;
+        }
+        else if (character === ";") {
+            commitField();
+        }
+        else if (character === "\n") {
+            commitRecord();
+        }
+        else if (character !== "\r") {
+            field += character;
+        }
+    }
+    commitRecord();
+    while (records.length > 0 && records.at(-1)?.every((value) => value === "")) {
+        records.pop();
+    }
+    if (records[0]?.[0]?.charCodeAt(0) === 0xfeff) {
+        records[0][0] = records[0][0].slice(1);
+    }
+    return records;
+}
 function createAisaError(response, payload, phase) {
-    const error = optionalRecord(optionalRecord(payload)?.error);
+    const errorValue = optionalRecord(payload)?.error;
+    const error = optionalRecord(errorValue);
     const code = optionalString(error?.code);
     const message = optionalString(error?.message) ??
+        optionalString(errorValue) ??
+        optionalString(payload) ??
         optionalString(optionalRecord(payload)?.message) ??
         `AIsa request failed with status ${response.status}`;
     if (response.status === 429)

package/src/providers/cal/actions.js

@@ -270,7 +270,11 @@ const createBookingInputSchema = s.object("Input payload for creating a Cal.com
     guests: s.stringArray("Additional guest email addresses."),
     meetingUrl: s.string("The meeting URL to attach to the booking."),
     location: rawObject("The location payload for the booking."),
-    metadata: rawObject("Additional metadata to attach to the booking."),
+    metadata: s.optional({
+        ...s.record("Additional booking metadata: at most 50 keys, each up to 40 characters, with string values up to 500 characters.", s.string("A metadata value, up to 500 characters.", { maxLength: 500 })),
+        maxProperties: 50,
+        propertyNames: s.string("A metadata key, up to 40 characters.", { maxLength: 40 }),
+    }),
     lengthInMinutes: s.positiveInteger("The requested booking duration in minutes."),
     routing: rawObject("Routing metadata for round-robin or collective bookings."),
     emailVerificationCode: s.string("The email verification code for protected bookings."),

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

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/enormail/executors.js

@@ -0,0 +1,97 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { encodePathSegment } from "../../core/request.js";
+import { basicAuthorizationHeader, defineApiKeyProviderExecutors, defineProviderProxy, providerResponseError, ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const baseUrl = "https://api.enormail.eu/api/1.0";
+async function request(endpoint, query, context) {
+    const url = new URL(`${baseUrl}/${endpoint}.json`);
+    for (const [key, value] of Object.entries(query)) {
+        if (value != null)
+            url.searchParams.set(key, String(value));
+    }
+    return runProviderRequest({ label: "Enormail", signal: context.signal }, async (signal) => {
+        const response = await context.fetcher(url, {
+            signal,
+            headers: {
+                authorization: basicAuthorizationHeader(`${context.apiKey}:`),
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+            },
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Enormail returned invalid JSON (HTTP ${response.status})`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        if (!response.ok) {
+            const error = optionalRecord(payload);
+            const message = optionalString(error?.message) ?? optionalString(error?.Message) ?? optionalString(error?.error);
+            throw new ProviderRequestError(response.status, `Enormail HTTP ${response.status}${message ? `: ${message}` : ""}`, { providerCode: error?.code }, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return payload;
+    });
+}
+function resourceId(value, fieldName) {
+    const id = requiredInputString(value, fieldName);
+    if (id === "." || id === "..")
+        throw new ProviderRequestError(400, "Invalid Enormail resource ID");
+    return encodePathSegment(id);
+}
+export const executors = defineApiKeyProviderExecutors("enormail", {
+    async get_account(_input, context) {
+        return requiredResponseRecord(await request("account", {}, context), "Enormail account");
+    },
+    async list_senders(_input, context) {
+        const senders = await request("account/senders", {}, context);
+        if (!Array.isArray(senders))
+            throw providerResponseError("Enormail returned an invalid collection");
+        return { senders };
+    },
+    async list_lists(input, context) {
+        const lists = await request("lists", { page: input.page }, context);
+        if (!Array.isArray(lists))
+            throw providerResponseError("Enormail returned an invalid collection");
+        return { lists };
+    },
+    async get_list(input, context) {
+        return requiredResponseRecord(await request(`lists/${resourceId(input.listid, "listid")}`, {}, context), "Enormail response");
+    },
+    async list_contacts(input, context) {
+        return requiredResponseRecord(await request(`contacts/${resourceId(input.listid, "listid")}/${input.state}`, { page: input.page }, context), "Enormail response");
+    },
+    async get_contact(input, context) {
+        return requiredResponseRecord(await request(`contacts/${resourceId(input.listid, "listid")}`, { email: input.email }, context), "Enormail response");
+    },
+    async list_mailings(input, context) {
+        return requiredResponseRecord(await request(`mailings/${input.state}`, { page: input.page }, context), "Enormail response");
+    },
+    async get_mailing_stats(input, context) {
+        return requiredResponseRecord(await request(`mailings/${resourceId(input.mailingid, "mailingid")}/stats`, {}, context), "Enormail response");
+    },
+}, { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const account = requiredResponseRecord(await request("account", {}, { apiKey: input.apiKey, fetcher, signal }), "Enormail account");
+        const name = [optionalString(account.firstname), optionalString(account.lastname)].filter(Boolean).join(" ").trim();
+        return {
+            profile: {
+                accountId: optionalString(account.id),
+                displayName: name || optionalString(account.email) || "Enormail Account",
+            },
+            grantedScopes: [],
+            metadata: { accountId: optionalString(account.id), apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "enormail",
+    baseUrl,
+    auth: { type: "api_key_basic", suffix: ":" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor, TransitFileWriter } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlerSubset } from "../provider-runtime.ts";
 interface FeishuAppBotCredential {
     appId: string;
@@ -16,4 +18,5 @@ export declare const feishuAppBotActionHandlers: ProviderActionHandlerSubset<"fe
 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/feishu_app_bot/executors.js

@@ -27,6 +27,7 @@ import { createFeishuWhiteboardActionHandlers } from "../feishu/shared/whiteboar
 import { createFeishuWikiActionHandlers } from "../feishu/shared/wiki-runtime.js";
 import { createProviderProxyUrl, defineProviderExecutors, getProviderActionHandler, mapProviderActionHandlers, normalizeProviderProxyHeaders, providerFetch, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireCustomCredential, requiredInputString, toProviderProxyError, } from "../provider-runtime.js";
 import { feishuAppBotActions, feishuAppBotProviderScopes } from "./actions.js";
+import { feishuEvents } from "./trigger-on-event.js";
 const service = "feishu_app_bot";
 const feishuOpenBaseUrl = "https://open.feishu.cn/open-apis";
 const feishuRequestTimeoutMs = 30_000;
@@ -1047,3 +1048,4 @@ function createFeishuRequestSignal(parent) {
 function isAbortError(error) {
     return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
 }
+export const triggers = [...feishuEvents];

package/src/providers/feishu_app_bot/trigger-config.d.ts

@@ -0,0 +1 @@
+export declare function feishuResourceKind(events: readonly string[]): "document" | "calendar" | "approval" | undefined;

package/src/providers/feishu_app_bot/trigger-config.js

@@ -0,0 +1,10 @@
+export function feishuResourceKind(events) {
+    if (events.length == 0)
+        return;
+    if (events.every((event) => event.startsWith("drive.file.")))
+        return "document";
+    if (events.every((event) => event == "calendar.calendar.event.changed_v4"))
+        return "calendar";
+    if (events.every((event) => ["approval_instance", "approval_task", "approval_cc", "approval"].includes(event)))
+        return "approval";
+}

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

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

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

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

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

@@ -0,0 +1,63 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const additionalSnapshot0 = {
+    key: "feishu_app_bot.on_event",
+    provider: "feishu_app_bot",
+    name: "on_event",
+    displayName: "Application Event",
+    description: "Receives selected Feishu application events through a shared event source.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "sourceId",
+            jsonSchema: { ...s.string({ pattern: "^source_[0-9a-f]{32}$" }), title: "Event source" },
+            nullable: false,
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                ...s.array(s.string({ pattern: "^[a-z][a-z0-9_.]{0,127}$" }), {
+                    minItems: 1,
+                    maxItems: 200,
+                    uniqueItems: true,
+                }),
+                title: "Event types",
+            },
+            nullable: false,
+        },
+        {
+            handle: "chatIds",
+            jsonSchema: {
+                ...s.array(s.string({ minLength: 1, maxLength: 256 }), { maxItems: 100, uniqueItems: true }),
+                title: "Chat IDs",
+            },
+            nullable: true,
+            description: "Leave empty to receive events from all chats available to the source.",
+        },
+        {
+            handle: "resource",
+            jsonSchema: {
+                ...s.object({
+                    kind: s.stringEnum(["document", "calendar", "approval"]),
+                    id: s.string({ minLength: 1, maxLength: 256 }),
+                    documentType: s.stringEnum(["doc", "docx", "sheet", "bitable", "file", "folder"]),
+                }, { additionalProperties: false, required: ["kind", "id"] }),
+                title: "Resource subscription",
+            },
+            nullable: true,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "appId", jsonSchema: s.string(), nullable: false },
+        { handle: "tenantKey", jsonSchema: s.string(), nullable: false },
+        { handle: "occurredAt", jsonSchema: s.string(), nullable: true },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/feishu_app_bot/trigger-on-event.js

@@ -0,0 +1,29 @@
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { additionalSnapshot0 } from "./trigger-on-event.definition.js";
+import { feishuSubscriptions, feishuResponse } from "./trigger-subscriptions.js";
+export const feishuEvents = [
+    {
+        eventSource: "feishu",
+        resources: { subscriptions: (config) => feishuSubscriptions(config, "feishu_app_bot"), response: feishuResponse },
+        snapshot: additionalSnapshot0,
+        receive(context) {
+            if (context.eventSourceId !== context.config.sourceId)
+                return { outcome: "respond", status: 404, body: "", contentType: "text/plain" };
+            const payload = context.payload;
+            if (!isJsonObject(payload) ||
+                typeof payload.deliveryId !== "string" ||
+                payload.deliveryId.length === 0 ||
+                typeof payload.event !== "string" ||
+                typeof payload.appId !== "string" ||
+                typeof payload.tenantKey !== "string" ||
+                (payload.occurredAt != null && typeof payload.occurredAt !== "string") ||
+                !isJsonObject(payload.body))
+                throw new PermanentIntegrationError("Invalid Feishu shared event payload.");
+            return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+        },
+        async reconcile() {
+            throw new PermanentIntegrationError("This deployment does not support shared Feishu event sources.");
+        },
+    },
+];

package/src/providers/feishu_app_bot/trigger-subscriptions.d.ts

@@ -0,0 +1,5 @@
+import type { ResourceSubscription } from "../../triggers/common/integration.ts";
+import type { ConnectorProxyResult } from "../../triggers/common/proxy.ts";
+import type { JsonValue } from "../../triggers/common/types.ts";
+export declare function feishuSubscriptions(config: Readonly<Record<string, JsonValue>>, provider: string): readonly ResourceSubscription[];
+export declare function feishuResponse(result: ConnectorProxyResult): Readonly<Record<string, JsonValue>>;