@oomol-lab/open-connector 1.9.1 → 1.9.3

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/otter_ai/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, providerInputError, } from "../provider-runtime.js";
 const service = "otter_ai";
 const otterAiApiBaseUrl = "https://api.otter.ai";
 const otterAiValidationPath = "/v1/workspace";
@@ -171,7 +171,7 @@ function otterAiError(status, message, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && (status === 401 || status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 400 || status === 404 || status === 422) {
         return new ProviderRequestError(status, message);

package/src/providers/oura/runtime.js

@@ -180,7 +180,7 @@ function mapOuraError(input) {
         return new ProviderRequestError(input.phase === "validate" ? 400 : 401, message);
     }
     if (input.status === 400 || input.status === 422 || (input.status === 404 && input.notFoundAsInvalidInput)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(input.status, message);
 }

package/src/providers/paddle/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerUserAgent, providerInputError, } from "../provider-runtime.js";
 const service = "paddle";
 const paddleApiBaseUrl = "https://api.paddle.com";
 const paddleValidationPath = "/products";
@@ -203,13 +203,13 @@ function createPaddleError(response, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && (response.status === 401 || response.status === 403)) {
         return new ProviderRequestError(401, message);
     }
     if (phase === "execute" && [400, 404, 422].includes(response.status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 500, message);
 }

package/src/providers/pagerduty/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalIntegerLike, optionalString, requiredString, } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError } from "../provider-runtime.js";
 export const pagerDutyApiBaseUrl = "https://api.pagerduty.com";
 const pagerDutyAcceptHeader = "application/vnd.pagerduty+json;version=2";
 export const pagerDutyActionHandlers = {
@@ -241,7 +241,7 @@ function mapPagerDutyError(response, payload, phase, notFoundAsInvalidInput) {
         return new ProviderRequestError(response.status, message);
     }
     if (response.status === 404 && notFoundAsInvalidInput) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 429) {
         return new ProviderRequestError(429, message);

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/paradym/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, looseArray, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const paradymApiBaseUrl = "https://api.paradym.id";
 export const paradymActionHandlers = {
     list_projects(input, context) {
@@ -277,15 +277,15 @@ function unwrapParadymData(payload) {
 function mapParadymError(status, payload, mode) {
     const message = readErrorMessage(payload) ?? `Paradym API request failed with status ${status}`;
     if (status === 401 || status === 403) {
-        return mode === "validate" ? new ProviderRequestError(400, message) : new ProviderRequestError(401, message);
+        return mode === "validate" ? providerInputError(message) : new ProviderRequestError(401, message);
     }
     if (status === 400 || status === 404 || status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 429) {
         return new ProviderRequestError(429, message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function readErrorMessage(payload) {
     const body = optionalRecord(payload);

package/src/providers/parallel/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalString, requiredString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const parallelApiBaseUrl = "https://api.parallel.ai";
 export const parallelActionHandlers = {
     async search(input, context) {
@@ -174,7 +174,7 @@ function mapParallelHttpError(status, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 408) {
         return new ProviderRequestError(504, message);
@@ -182,7 +182,7 @@ function mapParallelHttpError(status, payload, phase) {
     if (status === 401 || status === 403 || status === 404 || status === 422) {
         return new ProviderRequestError(status === 404 ? 404 : 400, message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function readParallelErrorMessage(payload) {
     const record = asRecord(payload);

package/src/providers/partner_stack_partner/runtime.js

@@ -193,7 +193,7 @@ function createPartnerStackTransportError(error) {
     const message = error instanceof Error && error.message.trim()
         ? `PartnerStack Partner request failed: ${error.message}`
         : "PartnerStack Partner request failed";
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function extractErrorMessage(payload) {
     if (typeof payload === "string") {

package/src/providers/payrexx/runtime.js

@@ -1,7 +1,6 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalString, requiredString, } from "../../core/cast.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const payrexxApiBaseUrl = "https://api.payrexx.com/v1.16";
-const requestTimeoutMs = 30_000;
 export const payrexxActionHandlers = {
     async list_payment_providers(input, fetcher) {
         const payload = await requestPayrexxJson({
@@ -88,7 +87,7 @@ export const payrexxActionHandlers = {
     },
 };
 export async function validatePayrexxCredential(input, fetcher) {
-    const apiKey = requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message));
+    const apiKey = requiredString(input.apiKey, "apiKey", providerInputError);
     const instance = requireInputString(input.instance, "instance");
     const payload = await requestPayrexxJson({
         path: "/PaymentProvider/",
@@ -134,7 +133,7 @@ async function requestPayrexxJson(input) {
         }
         headers.set("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
     }
-    const timeout = createProviderTimeout(undefined, requestTimeoutMs);
+    const timeout = createProviderTimeout(undefined);
     try {
         const response = await input.fetcher(url, {
             method: input.method,
@@ -152,7 +151,7 @@ async function requestPayrexxJson(input) {
         if (error instanceof ProviderRequestError)
             throw error;
         if (timeout.didTimeout() && isAbortError(error)) {
-            throw new ProviderRequestError(502, `payrexx request timed out after ${Math.ceil(requestTimeoutMs / 1000)} seconds`);
+            throw new ProviderRequestError(502, `payrexx request timed out after ${Math.ceil(defaultProviderRequestTimeoutMs / 1000)} seconds`);
         }
         throw new ProviderRequestError(502, readErrorMessage(error));
     }
@@ -180,7 +179,7 @@ function normalizePayrexxError(response, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && response.status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 401 ||
         response.status === 403 ||

package/src/providers/permit_io/runtime.js

@@ -1,5 +1,5 @@
 import { optionalInteger, optionalString, recordOrEmpty } from "../../core/cast.js";
-import { createProviderTimeout, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { createProviderTimeout, providerUserAgent, ProviderRequestError, providerInputError, } from "../provider-runtime.js";
 export const permitIoApiBaseUrl = "https://api.permit.io";
 export const permitIoActionHandlers = {
     list_users(input, context) {
@@ -160,7 +160,7 @@ function permitIoError(response, payload, phase) {
         return new ProviderRequestError(phase === "validate" ? 400 : response.status, message);
     }
     if (response.status === 404 || response.status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 429) {
         return new ProviderRequestError(429, message);