@oomol-lab/open-connector 1.9.1 → 1.9.2

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

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

package/src/providers/orbit/executors.js

@@ -0,0 +1,106 @@
+import { optionalRecord, optionalString, looseArray } from "../../core/cast.js";
+import { downloadUploadSource, requiredResponseRecord, isAbortLikeError, runProviderRequest, ProviderRequestError, providerInputError, providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { orbitActions } from "./actions.js";
+import { orbitRoutes } from "./routes.js";
+const baseUrl = "https://api.orbitsearch.com";
+async function request(apiKey, name, input, fetcher, parentSignal) {
+    const route = orbitRoutes[name];
+    let path = route.path;
+    const data = { ...input };
+    for (const field of route.pathFields) {
+        path = path.replace(`{${field}}`, encodeURIComponent(String(data[field])));
+        delete data[field];
+    }
+    const url = new URL(path, baseUrl);
+    for (const field of route.queryFields) {
+        if (data[field] !== undefined)
+            url.searchParams.set(field, String(data[field]));
+        delete data[field];
+    }
+    const idempotencyKey = optionalString(data.idempotencyKey);
+    delete data.idempotencyKey;
+    let body = route.body ? JSON.stringify(data) : undefined;
+    if (name === "detect_faces") {
+        const file = await downloadUploadSource({
+            url: String(data.imageUrl),
+            fieldName: "imageUrl",
+            fetcher,
+            maximumBytes: 25 * 1024 * 1024,
+            signal: parentSignal,
+        });
+        const mime = file.contentType?.split(";")[0]?.trim().toLowerCase();
+        if (!mime || !["image/jpeg", "image/png", "image/webp"].includes(mime))
+            throw providerInputError("imageUrl must return a JPG, PNG or WebP image");
+        const form = new FormData();
+        form.append("image", new Blob([new Uint8Array(file.bytes)], { type: mime }), `image.${mime === "image/jpeg" ? "jpg" : mime.split("/")[1]}`);
+        body = form;
+    }
+    return runProviderRequest({ label: "Orbit", signal: parentSignal }, async (signal) => {
+        const headers = new Headers({ authorization: `Bearer ${apiKey}`, accept: "application/json" });
+        if (body !== undefined && !(body instanceof FormData))
+            headers.set("content-type", "application/json");
+        if (idempotencyKey !== undefined)
+            headers.set("Idempotency-Key", idempotencyKey);
+        const response = await fetcher(url, { method: route.method, headers, body, signal });
+        const payload = await response.json().catch((error) => {
+            if (isAbortLikeError(error))
+                throw error;
+            return undefined;
+        });
+        if (!response.ok) {
+            const error = optionalRecord(optionalRecord(payload)?.error);
+            const code = optionalString(error?.code);
+            const message = optionalString(error?.message);
+            const detail = [code, message].filter(Boolean).join(": ");
+            throw new ProviderRequestError(response.status, `Orbit request failed (${response.status})${detail ? `: ${detail}` : ""}`, undefined, code === "invalid_api_key"
+                ? "authorization_failed"
+                : code === "missing_api_key_scope"
+                    ? "authorization_failed"
+                    : "provider_error");
+        }
+        return requiredResponseRecord(payload, "Orbit response");
+    });
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const data = values;
+    if (actionName === "get_batch_enrichment") {
+        const results = [];
+        for (const requestId of data.request_ids) {
+            results.push(await request(apiKey, "get_enrichment", { request_id: requestId }, fetcher, context.signal));
+        }
+        const status = results.some((result) => result.status !== "completed" && result.status !== "failed")
+            ? "running"
+            : results.some((result) => result.status === "failed")
+                ? "completed_with_errors"
+                : "completed";
+        return { status, results };
+    }
+    const result = await request(apiKey, actionName, data, fetcher, context.signal);
+    if (actionName === "batch_enrich") {
+        const children = looseArray(result.results);
+        const requestIds = children.map((child) => optionalString(optionalRecord(child)?.request_id));
+        if (!children.length || requestIds.some((id) => !id))
+            throw providerResponseError("Orbit batch response is missing child request IDs");
+        return { ...result, request_ids: requestIds };
+    }
+    return result;
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request(input.apiKey, "quote_population", {
+            population: { kind: "company", id: "1441", name: "Google" },
+            profile_depth: "partial",
+        }, fetcher, signal);
+        return { profile: { displayName: "Orbit API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("orbit", Object.fromEntries(orbitActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "orbit",
+    baseUrl: baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/orbit/routes.d.ts

@@ -0,0 +1,9 @@
+interface OrbitRoute {
+    path: string;
+    method: string;
+    pathFields: string[];
+    queryFields: string[];
+    body: boolean;
+}
+export declare const orbitRoutes: Record<string, OrbitRoute>;
+export {};

package/src/providers/orbit/routes.js

@@ -0,0 +1,170 @@
+export const orbitRoutes = {
+    search: {
+        path: "/v3/search",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    get_search: {
+        path: "/v3/search/{search_id}",
+        method: "GET",
+        pathFields: ["search_id"],
+        queryFields: [],
+        body: false,
+    },
+    quote_population: {
+        path: "/v3/search/populations/quote",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    search_population: {
+        path: "/v3/search/populations",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    batch_enrich: {
+        path: "/v3/enrich",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    read_profile: {
+        path: "/v3/enrich/{profile_id}",
+        method: "GET",
+        pathFields: ["profile_id"],
+        queryFields: ["format"],
+        body: false,
+    },
+    enrich_profile: {
+        path: "/v3/enrich/{profile_id}",
+        method: "POST",
+        pathFields: ["profile_id"],
+        queryFields: [],
+        body: true,
+    },
+    get_enrichment: {
+        path: "/v3/enrich/requests/{request_id}",
+        method: "GET",
+        pathFields: ["request_id"],
+        queryFields: [],
+        body: false,
+    },
+    create_watcher: {
+        path: "/v3/watchers",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    list_watchers: {
+        path: "/v3/watchers",
+        method: "GET",
+        pathFields: [],
+        queryFields: [],
+        body: false,
+    },
+    get_watcher: {
+        path: "/v3/watchers/{watcher_id}",
+        method: "GET",
+        pathFields: ["watcher_id"],
+        queryFields: [],
+        body: false,
+    },
+    update_watcher: {
+        path: "/v3/watchers/{watcher_id}",
+        method: "PATCH",
+        pathFields: ["watcher_id"],
+        queryFields: [],
+        body: true,
+    },
+    delete_watcher: {
+        path: "/v3/watchers/{watcher_id}",
+        method: "DELETE",
+        pathFields: ["watcher_id"],
+        queryFields: [],
+        body: false,
+    },
+    list_watcher_runs: {
+        path: "/v3/watchers/{watcher_id}/runs",
+        method: "GET",
+        pathFields: ["watcher_id"],
+        queryFields: ["limit"],
+        body: false,
+    },
+    create_webhook: {
+        path: "/v3/webhooks",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    list_webhooks: {
+        path: "/v3/webhooks",
+        method: "GET",
+        pathFields: [],
+        queryFields: [],
+        body: false,
+    },
+    delete_webhook: {
+        path: "/v3/webhooks/{webhook_id}",
+        method: "DELETE",
+        pathFields: ["webhook_id"],
+        queryFields: [],
+        body: false,
+    },
+    test_webhook: {
+        path: "/v3/webhooks/{webhook_id}/test",
+        method: "POST",
+        pathFields: ["webhook_id"],
+        queryFields: [],
+        body: true,
+    },
+    detect_faces: {
+        path: "/v3/faces/detect",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    search_face_index: {
+        path: "/v3/faces/index-search",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    bulk_search: {
+        path: "/v3/search/bulk",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    get_bulk_search: {
+        path: "/v3/search/bulk/{job_id}",
+        method: "GET",
+        pathFields: ["job_id"],
+        queryFields: [],
+        body: false,
+    },
+    get_bulk_results: {
+        path: "/v3/search/bulk/{job_id}/results",
+        method: "GET",
+        pathFields: ["job_id"],
+        queryFields: ["offset"],
+        body: false,
+    },
+    cancel_bulk_search: {
+        path: "/v3/search/bulk/{job_id}/cancel",
+        method: "POST",
+        pathFields: ["job_id"],
+        queryFields: [],
+        body: false,
+    },
+};

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

@@ -1,5 +1,7 @@
 import type { CredentialValidators, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 import { executors } from "./runtime.ts";
 export { executors };
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/pandadoc/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderProxy } from "../provider-runtime.js";
 import { executors, pandadocApiBaseUrl, validatePandadocCredential } from "./runtime.js";
+import { pandadocDocumentEvent } from "./trigger-on-document-event.js";
 export { executors };
 const service = "pandadoc";
 export const proxy = defineProviderProxy({
@@ -15,3 +16,4 @@ export const credentialValidators = {
         return validatePandadocCredential({ apiKey: input.apiKey, ...input.values }, fetcher);
     },
 };
+export const triggers = [pandadocDocumentEvent];

package/src/providers/pandadoc/trigger-on-document-event.d.ts

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

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

@@ -0,0 +1,33 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    key: "pandadoc.on_document_event",
+    provider: "pandadoc",
+    name: "on_document_event",
+    displayName: "Document Status Changed",
+    description: "Receives document status changes in the connected workspace, optionally only when the entire document is completed.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: { methods: ["POST"], body: { formats: ["json"], allowArray: true, allowEmpty: false }, successStatus: 200 },
+    configInputs: [
+        {
+            handle: "completedOnly",
+            jsonSchema: { type: "boolean", title: "Completed documents only" },
+            nullable: false,
+            value: true,
+        },
+    ],
+    outputs: [
+        {
+            handle: "events",
+            nullable: false,
+            jsonSchema: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: { event: s.string(), data: { type: "object" } },
+                    required: ["event", "data"],
+                },
+            },
+        },
+    ],
+};

package/src/providers/pandadoc/trigger-on-document-event.js

@@ -0,0 +1,96 @@
+import { TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { bytes, verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-document-event.definition.js";
+function webhook(value) {
+    if (!isJsonObject(value) ||
+        typeof value.uuid != "string" ||
+        !value.uuid ||
+        typeof value.shared_key != "string" ||
+        !value.shared_key)
+        throw new TransientIntegrationError("PandaDoc returned an invalid webhook identity or shared key.");
+    return { id: value.uuid, secret: value.shared_key };
+}
+export const pandadocDocumentEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const endpoint = "/public/v1/webhook-subscriptions";
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const found = [];
+                const result = await webhookRequest(context, { endpoint, method: "GET" });
+                if (!isJsonObject(result.data) || !Array.isArray(result.data.items))
+                    throw new TransientIntegrationError("PandaDoc returned an invalid webhook list.");
+                for (const item of result.data.items) {
+                    if (!isJsonObject(item) || typeof item.url != "string")
+                        throw new TransientIntegrationError("PandaDoc returned an invalid webhook.");
+                    if (item.url == context.endpointUrl)
+                        found.push(webhook(item));
+                }
+                return found;
+            },
+            async create() {
+                const result = await webhookRequest(context, {
+                    endpoint,
+                    method: "POST",
+                    body: {
+                        name: "OOMOL document status",
+                        url: context.endpointUrl,
+                        active: true,
+                        triggers: ["document_state_changed"],
+                        payload: ["metadata"],
+                    },
+                });
+                return webhook(result.data);
+            },
+            async align(id) {
+                await webhookRequest(context, {
+                    endpoint: `${endpoint}/${encodeURIComponent(id)}`,
+                    method: "PATCH",
+                    body: { url: context.endpointUrl, active: true, triggers: ["document_state_changed"], payload: ["metadata"] },
+                });
+            },
+            async remove(id) {
+                await webhookRequest(context, { endpoint: `${endpoint}/${encodeURIComponent(id)}`, method: "DELETE" });
+            },
+        });
+    },
+    async receive(context) {
+        const secret = context.state?.subscription.secret;
+        if (typeof secret != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        if (!(await verifyHexHmac(secret, [context.rawBody], context.query("signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        if (!Array.isArray(context.payload))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const events = [];
+        const identities = [];
+        for (const item of context.payload) {
+            if (!isJsonObject(item) || item.event != "document_state_changed")
+                continue;
+            const data = item.data;
+            if (!isJsonObject(data) ||
+                typeof data.id != "string" ||
+                !data.id ||
+                typeof data.status != "string" ||
+                typeof data.date_modified != "string" ||
+                !data.date_modified)
+                return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+            if (context.config.completedOnly === true && data.status != "document.completed")
+                continue;
+            events.push(item);
+            identities.push(JSON.stringify([data.id, data.status, data.date_modified]));
+        }
+        if (!events.length)
+            return { outcome: "ignored", reason: "No matching document status changes." };
+        // Derive deduplication identity from the signed body, not an unsigned delivery header.
+        const digest = await crypto.subtle.digest("SHA-256", bytes(JSON.stringify(identities.sort())));
+        return {
+            outcome: "event",
+            dedupeKey: Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join(""),
+            outputs: { events },
+        };
+    },
+};

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

@@ -1,5 +1,7 @@
 import type { CredentialValidators, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 import { executors } from "./runtime.ts";
 export { executors };
 export declare const credentialValidators: CredentialValidators;
 export declare const proxy: ProviderProxyExecutor;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/pipedrive/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderProxy } from "../provider-runtime.js";
 import { executors, validatePipedriveCredential } from "./runtime.js";
+import { pipedriveCrmEvent } from "./trigger-on-crm-event.js";
 export { executors };
 const service = "pipedrive";
 const apiOrigin = "https://api.pipedrive.com";
@@ -13,3 +14,4 @@ export const proxy = defineProviderProxy({
     baseUrl: apiOrigin,
     auth: { type: "api_key_header", name: "x-api-token" },
 });
+export const triggers = [pipedriveCrmEvent];

package/src/providers/pipedrive/trigger-on-crm-event.d.ts

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

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

@@ -0,0 +1,30 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const events = ["deal.created", "deal.stage_changed", "deal.status_changed", "person.created"];
+export const snapshot = {
+    key: "pipedrive.on_crm_event",
+    provider: "pipedrive",
+    name: "on_crm_event",
+    displayName: "Deal or Contact Event",
+    description: "Receives new deals or contacts, or actual changes to a deal stage or status using Pipedrive Webhooks v2.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "eventType",
+            jsonSchema: { type: "string", enum: events, title: "Event" },
+            nullable: false,
+            value: "deal.created",
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "objectId", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/pipedrive/trigger-on-crm-event.js

@@ -0,0 +1,101 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { sameSecret } from "../../triggers/signature.js";
+import { basicAuthorizationHeader } from "../provider-runtime.js";
+import { snapshot } from "./trigger-on-crm-event.definition.js";
+export const pipedriveCrmEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const current = await webhookRequest(context, { endpoint: "/v1/users/me", method: "GET" });
+        if (!isJsonObject(current.data) ||
+            current.data.success !== true ||
+            !isJsonObject(current.data.data) ||
+            !["string", "number"].includes(typeof current.data.data.company_id))
+            throw new TransientIntegrationError("Pipedrive returned no account identity.");
+        const companyId = String(current.data.data.company_id);
+        const event = String(context.config.eventType);
+        const entity = event == "person.created" ? "person" : "deal";
+        const action = event.endsWith(".created") ? "create" : "change";
+        const result = await reconcileManagedWebhook(context, {
+            async find() {
+                const response = await webhookRequest(context, { endpoint: "/v1/webhooks", method: "GET" });
+                if (!isJsonObject(response.data) || response.data.success !== true || !Array.isArray(response.data.data))
+                    throw new TransientIntegrationError("Pipedrive returned an invalid webhook list.");
+                const found = [];
+                for (const item of response.data.data) {
+                    if (!isJsonObject(item) || typeof item.subscription_url != "string")
+                        throw new TransientIntegrationError("Pipedrive returned an invalid webhook.");
+                    if (item.subscription_url != context.endpointUrl)
+                        continue;
+                    if (!["number", "string"].includes(typeof item.id) ||
+                        item.event_object != entity ||
+                        item.event_action != action ||
+                        item.version != "2.0")
+                        throw new PermanentIntegrationError("Pipedrive webhook event settings differ from this subscription.");
+                    found.push({ id: String(item.id), secret: context.callbackSecret });
+                }
+                return found;
+            },
+            async create() {
+                const response = await webhookRequest(context, {
+                    endpoint: "/v1/webhooks",
+                    method: "POST",
+                    body: {
+                        subscription_url: context.endpointUrl,
+                        event_action: action,
+                        event_object: entity,
+                        version: "2.0",
+                        http_auth_user: "oomol",
+                        http_auth_password: context.callbackSecret,
+                    },
+                });
+                if (!isJsonObject(response.data) ||
+                    response.data.success !== true ||
+                    !isJsonObject(response.data.data) ||
+                    !["number", "string"].includes(typeof response.data.data.id))
+                    throw new TransientIntegrationError("Pipedrive webhook creation returned no identity.");
+                return { id: String(response.data.data.id), secret: context.callbackSecret };
+            },
+            async remove(id) {
+                await webhookRequest(context, { endpoint: `/v1/webhooks/${encodeURIComponent(id)}`, method: "DELETE" });
+            },
+        });
+        if (context.active)
+            await context.state.saveSubscription({ ...context.state.subscription, companyId }, new Date(context.now.getTime() + 86_400_000));
+        return result;
+    },
+    receive(context) {
+        const expected = basicAuthorizationHeader(`oomol:${context.callbackSecret}`);
+        if (!sameSecret(context.header("authorization"), expected))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const companyId = context.state?.subscription.companyId;
+        if (typeof companyId != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) || !isJsonObject(body.meta) || !isJsonObject(body.data))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const meta = body.meta;
+        if (meta.version != "2.0" ||
+            String(meta.company_id) != companyId ||
+            String(meta.webhook_id) != context.state?.subscription.hookId)
+            return { outcome: "ignored", reason: "Pipedrive subscription or company does not match." };
+        const event = String(context.config.eventType);
+        if (meta.entity != (event == "person.created" ? "person" : "deal") ||
+            meta.action != (event.endsWith(".created") ? "create" : "change"))
+            return { outcome: "ignored", reason: "Pipedrive event does not match." };
+        if (!event.endsWith(".created")) {
+            const field = event == "deal.stage_changed" ? "stage_id" : "status";
+            if (!isJsonObject(body.previous) || !(field in body.previous) || body.previous[field] === body.data[field])
+                return { outcome: "ignored", reason: "The selected deal field did not change." };
+        }
+        if (typeof meta.id != "string" || !meta.id || !["number", "string"].includes(typeof meta.entity_id))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: meta.id,
+            outputs: { event, deliveryId: meta.id, objectId: String(meta.entity_id), body },
+        };
+    },
+};

package/src/providers/ploid/actions.d.ts

@@ -0,0 +1,16 @@
+import type { ActionDefinition, JsonSchema } from "../../core/types.ts";
+export interface PloidEndpoint {
+    name: string;
+    method: string;
+    path: string;
+    pathKeys: string[];
+    queryKeys: string[];
+    operationType: ActionDefinition["operationType"];
+    description: string;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+}
+declare const ploidEndpoints: PloidEndpoint[];
+export declare const ploidEndpointByName: Map<string, (typeof ploidEndpoints)[number]>;
+export declare const ploidActions: ActionDefinition[];
+export {};

package/src/providers/ploid/actions.js

@@ -0,0 +1,23 @@
+import { defineProviderAction } from "../../core/provider-definition.js";
+import definitions from "./endpoints.json" with { type: "json" };
+const actionLifecycles = {
+    start_dataset: { startActionId: "ploid.start_dataset", statusActionId: "ploid.get_dataset" },
+};
+const actionFollowUps = {
+    sync_people_search: ["ploid.get_set"],
+    get_person: ["ploid.get_person_run"],
+    create_dataset: ["ploid.get_dataset"],
+    start_dataset: ["ploid.get_dataset"],
+};
+const ploidEndpoints = definitions;
+export const ploidEndpointByName = new Map(ploidEndpoints.map((endpoint) => [endpoint.name, endpoint]));
+export const ploidActions = ploidEndpoints.map((endpoint) => defineProviderAction("ploid", {
+    name: endpoint.name,
+    description: endpoint.description,
+    operationType: endpoint.operationType,
+    requiredScopes: [],
+    inputSchema: endpoint.inputSchema,
+    outputSchema: endpoint.outputSchema,
+    asyncLifecycle: actionLifecycles[endpoint.name],
+    followUpActions: actionFollowUps[endpoint.name],
+}));