@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/asana/trigger-on-task-event.js

@@ -0,0 +1,160 @@
+import { PermanentIntegrationError, 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-task-event.definition.js";
+export const asanaTaskEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const projectId = String(context.config.projectId);
+        const selected = context.config.eventTypes;
+        if (selected.includes("task.field_changed") && typeof context.config.customFieldId != "string")
+            throw new PermanentIntegrationError("Select a custom field for task field changes.");
+        const project = await webhookRequest(context, {
+            endpoint: `/projects/${encodeURIComponent(projectId)}`,
+            method: "GET",
+            query: { opt_fields: "workspace.gid" },
+        });
+        if (!isJsonObject(project.data) ||
+            !isJsonObject(project.data.data) ||
+            !isJsonObject(project.data.data.workspace) ||
+            typeof project.data.data.workspace.gid != "string")
+            throw new TransientIntegrationError("Asana returned no project workspace.");
+        const workspace = project.data.data.workspace.gid;
+        const remove = async (id) => {
+            await webhookRequest(context, { endpoint: `/webhooks/${encodeURIComponent(id)}`, method: "DELETE" });
+        };
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const found = [];
+                const query = {
+                    workspace,
+                    resource: projectId,
+                    limit: 100,
+                    opt_fields: "gid,target,resource.gid",
+                };
+                const seen = new Set();
+                for (let page = 0; page < 100; page++) {
+                    const response = await webhookRequest(context, { endpoint: "/webhooks", method: "GET", query });
+                    if (!isJsonObject(response.data) || !Array.isArray(response.data.data))
+                        throw new TransientIntegrationError("Asana returned an invalid webhook list.");
+                    for (const item of response.data.data) {
+                        if (!isJsonObject(item) || typeof item.target != "string" || typeof item.gid != "string")
+                            throw new TransientIntegrationError("Asana returned an invalid webhook.");
+                        if (item.target != context.endpointUrl)
+                            continue;
+                        if (!isJsonObject(item.resource) || item.resource.gid != projectId)
+                            throw new PermanentIntegrationError("Asana webhook project does not match.");
+                        found.push({
+                            id: item.gid,
+                            secret: context.state?.subscription.hookId == item.gid && typeof context.state.subscription.secret == "string"
+                                ? context.state.subscription.secret
+                                : "",
+                        });
+                    }
+                    const next = response.data.next_page;
+                    if (next == null)
+                        break;
+                    if (!isJsonObject(next) || typeof next.offset != "string" || seen.has(next.offset))
+                        throw new TransientIntegrationError("Asana webhook pagination did not advance.");
+                    seen.add(next.offset);
+                    query.offset = next.offset;
+                    if (page == 99)
+                        throw new PermanentIntegrationError("The Asana webhook list exceeds 10000 entries.");
+                }
+                if (found.length == 1 && !found[0].secret && context.active) {
+                    // Recover the unique owned orphan by deleting it before recreating its unreadable secret.
+                    await remove(found[0].id);
+                    await context.state.saveSubscription({}, context.now);
+                    return [];
+                }
+                return found;
+            },
+            async create() {
+                const response = await webhookRequest(context, {
+                    endpoint: "/webhooks",
+                    method: "POST",
+                    body: {
+                        data: {
+                            resource: projectId,
+                            target: context.endpointUrl,
+                            filters: [
+                                { resource_type: "task", action: "added" },
+                                { resource_type: "task", action: "changed", fields: ["completed", "custom_fields"] },
+                            ],
+                        },
+                    },
+                });
+                if (!isJsonObject(response.data) ||
+                    !isJsonObject(response.data.data) ||
+                    typeof response.data.data.gid != "string" ||
+                    typeof response.data["X-Hook-Secret"] != "string" ||
+                    !response.data["X-Hook-Secret"])
+                    throw new TransientIntegrationError("Asana webhook creation returned no identity or signing secret.");
+                return { id: response.data.data.gid, secret: response.data["X-Hook-Secret"] };
+            },
+            remove,
+        });
+    },
+    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.header("x-hook-signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) || !Array.isArray(payload.events))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const events = [];
+        const identities = [];
+        const selected = context.config.eventTypes;
+        for (const item of payload.events) {
+            if (!isJsonObject(item) || !isJsonObject(item.resource) || item.resource.resource_type != "task")
+                continue;
+            if (typeof item.resource.gid != "string" || typeof item.created_at != "string")
+                return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+            let event;
+            if (item.action == "added" && isJsonObject(item.parent) && item.parent.gid == context.config.projectId)
+                event = "task.added";
+            if (item.action == "changed" && isJsonObject(item.change)) {
+                if (item.change.field == "completed")
+                    event = "task.completed";
+                if (item.change.field == "custom_fields" &&
+                    isJsonObject(item.change.new_value) &&
+                    item.change.new_value.gid == context.config.customFieldId)
+                    event = "task.field_changed";
+            }
+            if (!event || !selected.includes(event))
+                continue;
+            const response = await context.connector.execute({
+                endpoint: `/tasks/${encodeURIComponent(item.resource.gid)}`,
+                method: "GET",
+                query: { opt_fields: "gid,name,completed,memberships.project.gid,custom_fields" },
+            }, context.signal);
+            if (response.status == 404)
+                continue;
+            if (response.status < 200 || response.status >= 300)
+                throw new TransientIntegrationError(`Asana task lookup failed (HTTP ${response.status}).`);
+            if (!isJsonObject(response.data) ||
+                !isJsonObject(response.data.data) ||
+                !Array.isArray(response.data.data.memberships))
+                throw new TransientIntegrationError("Asana returned invalid task details.");
+            const task = response.data.data;
+            if (!task.memberships.some((member) => isJsonObject(member) && isJsonObject(member.project) && member.project.gid == context.config.projectId))
+                continue;
+            if (event == "task.completed" && task.completed !== true)
+                continue;
+            events.push({ event, task, change: item });
+            identities.push(JSON.stringify(item));
+        }
+        if (!events.length)
+            return { outcome: "ignored", reason: "No matching project task changes." };
+        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: { projectId: context.config.projectId, events },
+        };
+    },
+};

package/src/providers/auth0_management/runtime.js

@@ -1,8 +1,7 @@
 import { compactObject, objectArray, optionalBoolean, optionalIntegerLike, optionalRecord, optionalString, stringArray, } from "../../core/cast.js";
-import { providerInputError, ProviderRequestError, providerUserAgent, requiredInputString, } from "../provider-runtime.js";
+import { providerInputError, ProviderRequestError, providerUserAgent, requiredInputString, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const auth0ApiSegment = "api/v2";
 const auth0CredentialHelpUrl = "https://auth0.com/docs/api/management/v2";
-const auth0ManagementRequestTimeoutMs = 30_000;
 export const auth0ManagementActionHandlers = {
     list_users(input, context) {
         return listUsers(input, context);
@@ -284,7 +283,7 @@ async function listRoleUsers(input, context) {
     };
 }
 async function requestAuth0ManagementJson(input) {
-    const timeoutSignal = AbortSignal.timeout(auth0ManagementRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const signal = input.signal ? AbortSignal.any([input.signal, timeoutSignal]) : timeoutSignal;
     let response;
     try {

package/src/providers/autoblogger/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalNumber, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, providerUserAgent, ProviderRequestError, readProviderProxyErrorMessage, readProviderProxyResponse, requireApiKeyCredential, requiredInputString, toProviderProxyError, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, providerUserAgent, ProviderRequestError, readProviderProxyErrorMessage, readProviderProxyResponse, requireApiKeyCredential, requiredInputString, toProviderProxyError, providerInputError, } from "../provider-runtime.js";
 const service = "autoblogger";
 const autobloggerApiBaseUrl = "https://dash.autoblogging.ai/api/v1";
 const articlesPath = "/articles";
@@ -219,7 +219,7 @@ async function readAutobloggerPayload(response) {
 function createAutobloggerError(status, payload, phase) {
     const message = readErrorMessage(payload) ?? `autoblogger request failed with ${status}`;
     if (status === 400 || status === 404) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     else if (status === 401 || looksLikeAuthError(payload)) {
         return new ProviderRequestError(phase === "validate" ? 401 : 400, message);
@@ -245,7 +245,7 @@ function readErrorMessage(payload) {
         : undefined;
 }
 function readDashboardEmail(value) {
-    return requiredString(value, "dashboardEmail", (message) => new ProviderRequestError(400, message));
+    return requiredString(value, "dashboardEmail", providerInputError);
 }
 function requiredResponseString(value, fieldName) {
     return requiredString(value, fieldName, () => new ProviderRequestError(502, `autoblogger response missing ${fieldName}`));

package/src/providers/baidu_maps/runtime.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError, readProviderTextBody } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, readProviderTextBody, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const baiduMapsApiBaseUrl = "https://api.map.baidu.com";
 export const baiduMapsValidationPath = "/reverse_geocoding/v3/";
 // Errors mapped from Baidu Maps `status` field to ProviderRequestError codes.
@@ -464,7 +464,7 @@ function normalizeBaiduMapsError(response, payload, phase) {
             return new ProviderRequestError(429, message);
         }
         if (baiduMapsInputStatuses.has(status)) {
-            return new ProviderRequestError(400, message);
+            return providerInputError(message);
         }
         if (baiduMapsAuthStatuses.has(status)) {
             return new ProviderRequestError(phase === "validate" ? 400 : 401, message);
@@ -472,7 +472,7 @@ function normalizeBaiduMapsError(response, payload, phase) {
         // A non-zero Baidu status we don't specifically classify. Baidu returns
         // HTTP 200 even for errors, so `response.status` is 200 here and would be
         // misclassified as a client error; surface an explicit upstream failure.
-        return new ProviderRequestError(502, message);
+        return providerResponseError(message);
     }
     // No numeric Baidu status: fall back to the HTTP status when it is itself an
     // error, otherwise treat the unexpected body as an upstream failure.

package/src/providers/baidu_netdisk/runtime-mcp.js

@@ -4,11 +4,10 @@ import { SdkError, SdkErrorCode } from "@modelcontextprotocol/client";
 import { posix } from "node:path";
 import { compactObject, optionalInteger, optionalString } from "../../core/cast.js";
 import { withMcpClient } from "../mcp-client.js";
-import { ProviderRequestError } from "../provider-runtime.js";
+import { ProviderRequestError, defaultProviderRequestTimeoutMs } from "../provider-runtime.js";
 import { baiduNetdiskFileCategories, baiduNetdiskListTypes, baiduNetdiskSemanticMatchSources, isBaiduNetdiskAbsolutePath, } from "./actions.js";
 import { normalizeBaiduNetdiskError, parseBaiduNetdiskJson } from "./runtime.js";
 const baiduNetdiskMcpEndpoint = new URL("https://mcp-pan.baidu.com/sse");
-const requestTimeoutMs = 30_000;
 const baiduNetdiskListToolByType = {
     all: "file_list",
     document: "file_doc_list",
@@ -44,7 +43,7 @@ const semanticSourceByCode = new Map([
 ]);
 export async function verifyBaiduNetdiskMcpConnection(accessToken, fetcher) {
     await withBaiduNetdiskMcpClient(accessToken, fetcher, async (client) => {
-        const result = await client.listTools({}, { timeout: requestTimeoutMs });
+        const result = await client.listTools({}, { timeout: defaultProviderRequestTimeoutMs });
         const toolsByName = new Map(result.tools.map((tool) => [tool.name, tool]));
         for (const toolName of requiredToolNames) {
             const tool = toolsByName.get(toolName);
@@ -175,7 +174,7 @@ export async function withBaiduNetdiskMcpClient(accessToken, fetcher, run) {
 }
 async function callBaiduNetdiskMcpTool(name, args, phase, context) {
     return withBaiduNetdiskMcpClient(context.accessToken, context.fetcher, async (client) => {
-        const result = await client.callTool({ name, arguments: args }, { timeout: requestTimeoutMs });
+        const result = await client.callTool({ name, arguments: args }, { timeout: defaultProviderRequestTimeoutMs });
         let payload;
         try {
             payload =

package/src/providers/bark/executors.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
 import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
-import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireApiKeyCredential, toProviderProxyError, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireApiKeyCredential, toProviderProxyError, providerInputError, } from "../provider-runtime.js";
 const service = "bark";
 const barkDefaultBaseUrl = "https://api.day.app";
 const barkSuccessCode = 200;
@@ -203,7 +203,7 @@ function parseBarkPushUrl(value, allowPrivateNetwork) {
         url = assertPublicHttpUrl(value, {
             fieldName: "Bark push URL",
             allowPrivateNetwork,
-            createError: (message) => new ProviderRequestError(400, message),
+            createError: providerInputError,
         });
     }
     catch (error) {
@@ -233,7 +233,7 @@ function normalizeBarkBaseUrl(value, allowPrivateNetwork = isPrivateNetworkAcces
     const url = assertPublicHttpUrl(candidate, {
         fieldName: "Bark baseUrl",
         allowPrivateNetwork,
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
     });
     if (url.protocol !== "https:" && !allowPrivateNetwork) {
         throw new ProviderRequestError(400, "Bark baseUrl must use https");
@@ -332,10 +332,10 @@ function readBarkErrorMessage(payload) {
 }
 function mapBarkHttpError(status, message, phase) {
     if (status === 401 || status === 403 || (phase === "validate" && status === 404)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 400 || status === 404 || status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 429) {
         return new ProviderRequestError(429, message);

package/src/providers/bitrise/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const bitriseApiBaseUrl = "https://api.bitrise.io/v0.1";
 export const bitriseActionHandlers = {
     list_apps(input, context) {
@@ -16,7 +16,7 @@ export const bitriseActionHandlers = {
     },
 };
 export async function validateBitriseCredential(input, fetcher, signal) {
-    const apiKey = requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message));
+    const apiKey = requiredString(input.apiKey, "apiKey", providerInputError);
     const profilePayload = await requestBitriseJson({
         apiKey,
         path: "/me",
@@ -190,7 +190,7 @@ function createBitriseError(response, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (response.status >= 500) {
-        return new ProviderRequestError(502, message);
+        return providerResponseError(message);
     }
     if (phase === "validate" && (response.status === 401 || response.status === 403)) {
         return new ProviderRequestError(response.status, message);

package/src/providers/bouncer/executors.js

@@ -1,8 +1,7 @@
 import { compactObject, optionalBoolean, optionalNumber, optionalRecord, optionalString, requiredString, stringArray, } from "../../core/cast.js";
-import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, ProviderRequestError, providerUserAgent, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "bouncer";
 const bouncerApiBaseUrl = "https://api.usebouncer.com";
-const bouncerDefaultRequestTimeoutMs = 30_000;
 export const bouncerActionHandlers = {
     get_credits(_input, context) {
         return requestBouncerCredits({
@@ -171,7 +170,7 @@ async function requestBouncerVerifyEmail(input) {
         phase: input.phase,
         query: {
             email: input.email,
-            timeout: String(bouncerDefaultRequestTimeoutMs / 1000),
+            timeout: String(defaultProviderRequestTimeoutMs / 1000),
         },
     });
     return normalizeBouncerVerifyEmail(payload, "/v1.1/email/verify");
@@ -340,7 +339,7 @@ async function requestBouncerJson(input) {
             url.searchParams.set(key, value);
         }
     }
-    const timeout = createProviderTimeout(input.signal, bouncerDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.signal);
     try {
         const headers = {
             accept: "application/json",

package/src/providers/browse_ai/runtime.js

@@ -1,7 +1,6 @@
 import { compactObject, optionalBoolean, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const browseAiApiBaseUrl = "https://api.browse.ai/v2/";
-const browseAiDefaultRequestTimeoutMs = 30_000;
 export const browseAiActionHandlers = {
     async list_robots(_input, context) {
         const payload = await requestBrowseAiJson({
@@ -143,7 +142,7 @@ export async function validateBrowseAiCredential(apiKey, fetcher, signal) {
     };
 }
 async function requestBrowseAiJson(input) {
-    const timeout = createProviderTimeout(input.signal, browseAiDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.signal);
     const url = new URL(input.path, browseAiApiBaseUrl);
     for (const [key, value] of Object.entries(input.query ?? {})) {
         if (value !== undefined) {
@@ -171,7 +170,7 @@ async function requestBrowseAiJson(input) {
     }
     catch (error) {
         if (timeout.didTimeout() && isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `browse_ai ${url.pathname} request timed out after ${Math.max(1, Math.ceil(browseAiDefaultRequestTimeoutMs / 1000))} seconds`);
+            throw new ProviderRequestError(504, `browse_ai ${url.pathname} request timed out after ${Math.max(1, Math.ceil(defaultProviderRequestTimeoutMs / 1000))} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error ? `Browse AI request failed: ${error.message}` : "Browse AI request failed");
     }

package/src/providers/browserstack/executors.js

@@ -1,9 +1,8 @@
 import { Buffer } from "node:buffer";
 import { compactObject, optionalInteger, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, readProviderJsonBody, requireApiKeyCredential, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, readProviderJsonBody, requireApiKeyCredential, providerInputError, providerResponseError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "browserstack";
 const browserstackApiBaseUrl = "https://api.browserstack.com";
-const browserstackDefaultRequestTimeoutMs = 30_000;
 export const browserstackActionHandlers = {
     list_builds(input, context) {
         return listBuilds(input, context);
@@ -131,7 +130,7 @@ async function requestBrowserstackJson(input) {
             url.searchParams.set(key, String(value));
         }
     }
-    const timeout = createProviderTimeout(input.context.signal, browserstackDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.context.signal);
     try {
         const response = await input.context.fetcher(url, {
             method: input.method,
@@ -154,7 +153,7 @@ async function requestBrowserstackJson(input) {
             throw error;
         }
         if (timeout.didTimeout()) {
-            throw new ProviderRequestError(504, `BrowserStack request timed out after ${browserstackDefaultRequestTimeoutMs}ms`);
+            throw new ProviderRequestError(504, `BrowserStack request timed out after ${defaultProviderRequestTimeoutMs}ms`);
         }
         throw error;
     }
@@ -180,9 +179,9 @@ function mapBrowserstackError(status, payload) {
         return new ProviderRequestError(401, message);
     }
     if (status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function readErrorMessage(payload) {
     if (typeof payload === "string" && payload.trim()) {
@@ -198,7 +197,7 @@ function requireUsername(value) {
     return requiredString(value, "username", (message) => new ProviderRequestError(400, `browserstack ${message}`));
 }
 function requireInputString(input, fieldName) {
-    return requiredString(input[fieldName], fieldName, (message) => new ProviderRequestError(400, message));
+    return requiredString(input[fieldName], fieldName, providerInputError);
 }
 function readWrappedObjectArray(payload, key, context) {
     if (!Array.isArray(payload)) {

package/src/providers/buildkite/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, requiredInputString, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, requiredInputString, providerInputError, } from "../provider-runtime.js";
 export const buildkiteApiBaseUrl = "https://api.buildkite.com/v2";
 export const buildkiteActionHandlers = {
     get_current_access_token(input, context) {
@@ -328,10 +328,10 @@ async function toBuildkiteError(response, phase, notFoundAsInvalidInput) {
         return new ProviderRequestError(phase === "validate" ? 400 : 403, message);
     }
     if (response.status === 404 && notFoundAsInvalidInput) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 429) {
         return new ProviderRequestError(429, message);

package/src/providers/bunnycdn/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { isAbortLikeError, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { isAbortLikeError, ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const bunnyApiBaseUrl = "https://api.bunny.net";
 const validationPath = "/pullzone";
 export const bunnycdnActionHandlers = {
@@ -170,7 +170,7 @@ function normalizePullZoneListPayload(payload) {
 function sanitizePullZone(value, message) {
     const record = optionalRecord(value);
     if (!record) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return removeBunnyCertificateKeys(record);
 }
@@ -197,7 +197,7 @@ function createBunnyError(response, payload, phase) {
         response.statusText ??
         `bunnycdn request failed with status ${response.status}`;
     if (phase === "validate" && (response.status === 400 || response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status, message);
 }

package/src/providers/businessmap/runtime.js

@@ -1,6 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
-const businessmapDefaultRequestTimeoutMs = 30_000;
+import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const businessmapValidationPath = "/workspaces";
 export const businessmapActionHandlers = {
     async list_workspaces(input, context) {
@@ -186,7 +185,7 @@ export function normalizeBusinessmapAccountUrl(value) {
     };
 }
 async function requestBusinessmapJson(input) {
-    const timeout = createProviderTimeout(input.signal, businessmapDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.signal);
     try {
         const response = await input.fetcher(buildBusinessmapUrl(input), {
             method: input.method ?? "GET",
@@ -210,7 +209,7 @@ async function requestBusinessmapJson(input) {
             throw error;
         }
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `Businessmap request timed out after ${Math.max(1, Math.ceil(businessmapDefaultRequestTimeoutMs / 1000))} seconds`);
+            throw new ProviderRequestError(504, `Businessmap request timed out after ${Math.max(1, Math.ceil(defaultProviderRequestTimeoutMs / 1000))} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error ? `Businessmap request failed: ${error.message}` : "Businessmap request failed");
     }
@@ -251,10 +250,10 @@ async function readBusinessmapPayload(response) {
 function createBusinessmapError(response, payload, mode, notFoundAsInvalidInput) {
     const message = extractBusinessmapErrorMessage(payload) ?? `Businessmap request failed with ${response.status}`;
     if (mode === "validate" && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (notFoundAsInvalidInput && response.status === 404) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status, message);
 }
@@ -328,7 +327,7 @@ function omitKeys(input, keys) {
 }
 function requireNonEmptyObject(input, message) {
     if (Object.keys(input).length === 0) {
-        throw new ProviderRequestError(400, message);
+        throw providerInputError(message);
     }
 }
 function requirePositiveInteger(value, fieldName) {

package/src/providers/buttondown/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError } from "../provider-runtime.js";
 export const buttondownApiBaseUrl = "https://api.buttondown.com/v1/";
 export const buttondownActionHandlers = {
     get_account(_input, context) {
@@ -236,7 +236,7 @@ function createButtondownError(response, payload, phase) {
     const status = response.status;
     const message = extractErrorMessage(payload) ?? `Buttondown request failed with status ${status}`;
     if (phase === "validate" && (status === 401 || status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status, message);
 }

package/src/providers/byteforms/runtime.js

@@ -1,5 +1,5 @@
 import { optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError } from "../provider-runtime.js";
 export const byteformsApiBaseUrl = "https://api.forms.bytesuite.io";
 const validationPath = "/api/form";
 export const byteformsActionHandlers = {
@@ -124,7 +124,7 @@ function readCursor(cursor) {
 async function createByteformsError(response, mode) {
     const message = await readByteformsErrorMessage(response);
     if (mode === "validate" && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status, message);
 }

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

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

package/src/providers/calendly/executors.js

@@ -1,5 +1,6 @@
 import { defineBearerProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { calendlyActionHandlers, calendlyApiOrigin, validateCalendlyCredential } from "./runtime.js";
+import { calendlyBookingEvent } from "./trigger-on-booking-event.js";
 const service = "calendly";
 export const executors = defineBearerProviderExecutors(service, calendlyActionHandlers);
 export const proxy = defineProviderProxy({
@@ -15,3 +16,4 @@ export const credentialValidators = {
         return validateCalendlyCredential(input.accessToken, fetcher, signal);
     },
 };
+export const triggers = [calendlyBookingEvent];

package/src/providers/calendly/runtime.js

@@ -1,5 +1,5 @@
 import { booleanString, compactObject, optionalBoolean, optionalNumber, optionalRecord, optionalString, } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerResponseError } from "../provider-runtime.js";
 export const calendlyApiOrigin = "https://api.calendly.com";
 const calendlyValidationPath = "/users/me";
 export const calendlyActionHandlers = {
@@ -854,7 +854,7 @@ function createCalendlyTransportError(error, phase) {
     if (isAbortError(error)) {
         return new ProviderRequestError(504, message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function isAbortError(error) {
     return error instanceof DOMException && error.name === "AbortError";

package/src/providers/calendly/trigger-on-booking-event.d.ts

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

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

@@ -0,0 +1,5 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const events: readonly ["invitee.created", "invitee.canceled"];
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};