@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/surf/shared-schemas.d.ts

@@ -0,0 +1,18 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const orderSchema: JsonSchema;
+export declare const financialPeriodLimitSchema: JsonSchema;
+export declare const endDateSchema: JsonSchema;
+export declare const evmWalletAddressSchema: JsonSchema;
+export declare const polymarketConditionIdSchema: JsonSchema;
+export declare const conditionIdSchema: JsonSchema;
+export declare const fromSchema: JsonSchema;
+export declare const metaSchema: JsonSchema;
+export declare const projectSearchQuerySchema: JsonSchema;
+export declare const dataSchema: JsonSchema;
+export declare const exchangeMarketTypeSchema: JsonSchema;
+export declare const kalshiTickerSchema: JsonSchema;
+export declare const timeRangeSchema: JsonSchema;
+export declare const projectIdSchema: JsonSchema;
+export declare const objectResponseSchema: JsonSchema;
+export declare const arrayResponseSchema: JsonSchema;
+export declare const sqlJobResponseSchema: JsonSchema;

package/src/providers/surf/shared-schemas.js

@@ -0,0 +1,37 @@
+import { s } from "../../core/json-schema.js";
+export const orderSchema = s.withExamples(s.withEnum(s.string('Sort order Default: "desc".'), ["asc", "desc"]), ["desc"]);
+export const financialPeriodLimitSchema = s.integer("Maximum financial periods to return Default: 5.", {
+    minimum: 1,
+    maximum: 100,
+});
+export const endDateSchema = s.withExamples(s.string("Inclusive latest period end date in YYYY-MM-DD format"), ["2024-12-31"]);
+export const evmWalletAddressSchema = s.string("Wallet address: a 0x EVM address or an ENS name (e.g. vitalik.eth). Solana addresses are not supported.");
+export const polymarketConditionIdSchema = s.withExamples(s.string("Polymarket condition ID"), [
+    "0x6fefc0438c7598b23531457c8c60541990d0786bd4bd9dfc3eabc8d95c291092",
+]);
+export const conditionIdSchema = s.withExamples(s.string("Market condition identifier"), [
+    "0x6fefc0438c7598b23531457c8c60541990d0786bd4bd9dfc3eabc8d95c291092",
+]);
+export const fromSchema = s.withExamples(s.string("Start of time range. Accepts Unix seconds (`1704067200`) or date string (`2024-01-01`)"), ["2024-01-01"]);
+export const metaSchema = s.object("Upstream response metadata, including pagination cursors, limits, and credits when supplied.", {}, { required: [], additionalProperties: true });
+export const projectSearchQuerySchema = s.withExamples(s.string("Fuzzy entity name search. Only use when 'id' is not available. May return unexpected results for ambiguous names."), ["ethereum"]);
+export const dataSchema = s.nullable(s.array("Upstream result data, preserving all provider fields.", {
+    description: "Upstream result item, preserving all provider fields.",
+}));
+export const exchangeMarketTypeSchema = s.withExamples(s.withEnum(s.string('Market type: spot for spot trading, swap/perpetual/perp for perpetual contracts Default: "spot".'), ["spot", "swap", "perpetual", "perp"]), ["spot"]);
+export const kalshiTickerSchema = s.withExamples(s.string("Market ticker identifier. Use GET /v1/prediction-market/kalshi/markets or GET /v1/search/prediction-market?platform=kalshi&q={keyword} to discover valid tickers."), ["KXBTC2026250-27JAN01-250000"]);
+export const timeRangeSchema = s.withExamples(s.withEnum(s.string('Window of history to return: `7d`, `30d`, `90d`, `180d`, or `1y`. This endpoint uses `time_range` only — it does NOT accept `interval`. Default: "30d".'), ["7d", "30d", "90d", "180d", "1y"]), ["30d"]);
+export const projectIdSchema = s.withExamples(s.string("Surf project UUID. PREFERRED — always use this when available from a previous response (e.g. project_id from /fund/portfolio or id from /search/project). Takes priority over q."), ["25c6612a-395c-4974-94eb-3b5f9f4b2ed7"]);
+export const objectResponseSchema = s.object("Surf response with the original provider envelope and fields.", {
+    $schema: s.string("Response JSON Schema URL."),
+    data: s.object("Upstream result data, preserving all provider fields.", {}, { required: [], additionalProperties: true }),
+    meta: metaSchema,
+}, { required: [], additionalProperties: true });
+export const arrayResponseSchema = s.object("Surf response with the original provider envelope and fields.", { $schema: s.string("Response JSON Schema URL."), data: dataSchema, meta: metaSchema }, { required: [], additionalProperties: true });
+export const sqlJobResponseSchema = s.object("Surf response with the original provider envelope and fields.", {
+    $schema: s.string("Response JSON Schema URL."),
+    data: s.object("Upstream result data, preserving all provider fields.", {}, { required: [], additionalProperties: true }),
+    meta: metaSchema,
+    job_id: s.string("Asynchronous SQL job identifier, promoted from data.job_id."),
+    status: s.string("Asynchronous SQL job state, promoted from data.status."),
+}, { required: [], additionalProperties: true });

package/src/providers/survey_monkey/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString, requiredRecord } from "../../core/cast.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 import { mapSurveyMonkeyProviderScopes } from "./scopes.js";
 const surveyMonkeyApiBaseUrls = [
     "https://api.surveymonkey.com",
@@ -461,14 +461,14 @@ function mapSurveyMonkeyError(status, payload, phase) {
     }
     if (status === 403) {
         if (phase === "validate") {
-            return new ProviderRequestError(400, message);
+            return providerInputError(message);
         }
         if (errorId === "1014")
             return new ProviderRequestError(403, message);
         if (errorId === "1017")
             return new ProviderRequestError(429, message);
         if (errorId === "1018")
-            return new ProviderRequestError(502, message);
+            return providerResponseError(message);
         return new ProviderRequestError(403, message);
     }
     if (status === 400 || status === 404 || status === 422) {

package/src/providers/taiga/runtime.js

@@ -1,6 +1,6 @@
 import { optionalRecord, optionalString, requiredString } from "../../core/cast.js";
 import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
-import { createProviderTimeout, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, providerResponseError, } from "../provider-runtime.js";
 export const taigaActionHandlers = {
     list_projects: actionHandler("list_projects"),
     get_project: actionHandler("get_project"),
@@ -240,13 +240,13 @@ function requireObject(value, label) {
 function createTaigaError(response, phase) {
     const message = `Taiga request failed with status ${response.status}`;
     if (response.status == 400)
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     if (response.status == 401 || response.status == 403) {
         return new ProviderRequestError(phase == "validate" ? 400 : response.status, message);
     }
     if (response.status == 404)
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     if (response.status == 409 || response.status == 429)
         return new ProviderRequestError(response.status, message);
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }

package/src/providers/talenox/executors.js

@@ -1,5 +1,5 @@
 import { optionalRawString, optionalRecord, positiveInteger } from "../../core/cast.js";
-import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const service = "talenox";
 const talenoxApiBaseUrl = "https://api.talenox.com/api/v2";
 const talenoxValidationPath = "/company_settings";
@@ -154,9 +154,9 @@ function mapTalenoxError(status, payload, phase) {
         return new ProviderRequestError(status, message);
     }
     if (status === 400 || status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function readErrorMessage(payload) {
     const body = optionalRecord(payload);
@@ -183,5 +183,5 @@ function readObjectArrayPayload(value, resourceName) {
     return value.map((item) => readObjectPayload(item, resourceName));
 }
 function readPositiveId(value, fieldName) {
-    return positiveInteger(value, fieldName, (message) => new ProviderRequestError(400, message));
+    return positiveInteger(value, fieldName, providerInputError);
 }

package/src/providers/tally/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 triggers: readonly IntegrationDefinition[];
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;

package/src/providers/tally/executors.js

@@ -1,6 +1,8 @@
 import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { tallyActionHandlers, tallyApiBaseUrl, validateTallyCredential } from "./runtime.js";
+import { tallyFormResponse } from "./trigger-on-form-response.js";
 const service = "tally";
+export const triggers = [tallyFormResponse];
 export const executors = defineApiKeyProviderExecutors(service, tallyActionHandlers);
 export const proxy = defineProviderProxy({
     service,

package/src/providers/tally/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const tallyApiBaseUrl = "https://api.tally.so";
 export const tallyActionHandlers = {
     list_forms(input, context) {
@@ -93,7 +93,7 @@ async function readTallyJson(response, message) {
         return (await response.json());
     }
     catch {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
 }
 async function readTallyError(response) {
@@ -111,7 +111,7 @@ function mapTallyError(status, message, phase) {
     if (status === 429)
         return new ProviderRequestError(429, message);
     if (phase === "validate" && (status === 401 || status === 403))
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     if (phase === "execute" && (status === 401 || status === 403))
         return new ProviderRequestError(status, message);
     if (status === 400 || status === 404 || status === 422)

package/src/providers/tally/trigger-on-form-response.d.ts

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

package/src/providers/tally/trigger-on-form-response.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/tally/trigger-on-form-response.definition.js

@@ -0,0 +1,54 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "formId",
+            jsonSchema: { ...s.string({ minLength: 1, maxLength: 128 }), title: "Form" },
+            nullable: false,
+            description: "Choose a form accessible to this Connection.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Receives new Tally form submissions through a signed, automatically managed webhook.",
+    displayName: "Form Response",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 200,
+    },
+    key: "tally.on_form_response",
+    name: "on_form_response",
+    outputs: [
+        {
+            handle: "response",
+            nullable: false,
+            jsonSchema: {
+                type: "object",
+                properties: {
+                    eventId: s.string(),
+                    createdAt: s.string(),
+                    formId: s.string(),
+                    submissionId: s.string(),
+                    responseId: s.string(),
+                    fields: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                key: s.string(),
+                                type: s.string(),
+                                label: { type: ["string", "null"] },
+                                value: {},
+                                options: { type: "array", items: { type: "object" } },
+                            },
+                            required: ["key", "type", "label", "value"],
+                        },
+                    },
+                },
+                required: ["eventId", "createdAt", "formId", "submissionId", "responseId", "fields"],
+            },
+        },
+    ],
+    provider: "tally",
+    type: "integration",
+};

package/src/providers/tally/trigger-on-form-response.js

@@ -0,0 +1,166 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { bytes, verifyBase64Hmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-form-response.definition.js";
+export const tallyFormResponse = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async configOptions(context) {
+        if (context.field != "formId")
+            throw new PermanentIntegrationError("Unknown Tally configuration field.");
+        const options = [];
+        for (let page = 1; page <= 100; page++) {
+            const result = await request(context, { endpoint: "/forms", method: "GET", query: { page, limit: 100 } });
+            success(result);
+            const data = pageData(result.data, "items", page);
+            for (const form of data.items) {
+                if (!isJsonObject(form) || !nonempty(form.id) || typeof form.name != "string")
+                    throw new TransientIntegrationError("Tally returned an invalid form.");
+                options.push({ value: form.id, label: form.name || form.id });
+            }
+            if (!data.hasMore)
+                return options;
+        }
+        throw new PermanentIntegrationError("The Tally form list exceeds 10000 entries.");
+    },
+    async receive(context) {
+        // Tally signs the parsed JSON serialization rather than transport whitespace.
+        if (!(await verifyBase64Hmac(context.callbackSecret, [bytes(JSON.stringify(context.payload))], context.header("tally-signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) || payload.eventType != "FORM_RESPONSE")
+            return { outcome: "ignored", reason: "Tally event is not a form response." };
+        const data = payload.data;
+        if (!isJsonObject(data) || data.formId != context.config.formId)
+            return { outcome: "ignored", reason: "Tally form does not match this subscription." };
+        if (!nonempty(payload.eventId) ||
+            !nonempty(payload.createdAt) ||
+            !nonempty(data.submissionId) ||
+            !nonempty(data.responseId) ||
+            !Array.isArray(data.fields) ||
+            data.fields.some((field) => !isJsonObject(field) ||
+                !nonempty(field.key) ||
+                !nonempty(field.type) ||
+                (field.label !== null && typeof field.label != "string") ||
+                !("value" in field) ||
+                ("options" in field &&
+                    (!Array.isArray(field.options) || field.options.some((option) => !isJsonObject(option))))))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: payload.eventId,
+            outputs: { response: { ...data, eventId: payload.eventId, createdAt: payload.createdAt } },
+        };
+    },
+    async reconcile(context) {
+        const state = context.state;
+        if (state == null)
+            throw new PermanentIntegrationError("Tally subscription state is missing.");
+        const formId = context.config.formId;
+        if (!nonempty(formId))
+            throw new PermanentIntegrationError("Choose a Tally form.");
+        let hookId = nonempty(state.subscription.hookId) ? state.subscription.hookId : undefined;
+        if (hookId == null) {
+            for (let page = 1; page <= 100; page++) {
+                const result = await request(context, { endpoint: "/webhooks", method: "GET", query: { page, limit: 100 } });
+                success(result);
+                const data = pageData(result.data, "webhooks", page);
+                for (const hook of data.items) {
+                    if (!isJsonObject(hook) || !nonempty(hook.id) || !nonempty(hook.formId) || typeof hook.url != "string")
+                        throw new TransientIntegrationError("Tally returned an invalid webhook.");
+                    if (hook.formId == formId && hook.url == context.endpointUrl) {
+                        if (hookId != null)
+                            throw new PermanentIntegrationError("Multiple Tally webhooks match this subscription. Remove duplicates before retrying.");
+                        hookId = hook.id;
+                    }
+                }
+                if (!data.hasMore)
+                    break;
+                if (page == 100)
+                    throw new PermanentIntegrationError("The Tally webhook list exceeds 10000 entries.");
+            }
+        }
+        if (!context.active) {
+            if (hookId != null) {
+                const result = await request(context, {
+                    endpoint: `/webhooks/${encodeURIComponent(hookId)}`,
+                    method: "DELETE",
+                });
+                if (result.status != 404)
+                    success(result);
+            }
+            else if (state.subscription.creating === true) {
+                throw new PermanentIntegrationError("Tally webhook creation has an uncertain outcome. Verify the remote subscription before cleanup.");
+            }
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        if (hookId == null) {
+            if (state.subscription.creating === true)
+                throw new PermanentIntegrationError("Tally webhook creation has an uncertain outcome. Retry after verifying the remote subscription.");
+            await state.saveSubscription({ creating: true }, context.now);
+            const result = await request(context, {
+                endpoint: "/webhooks",
+                method: "POST",
+                body: {
+                    formId,
+                    url: context.endpointUrl,
+                    eventTypes: ["FORM_RESPONSE"],
+                    signingSecret: context.callbackSecret,
+                },
+            });
+            if (result.status >= 400 && result.status < 500)
+                await state.saveSubscription({}, context.now);
+            success(result);
+            if (!isJsonObject(result.data) || !nonempty(result.data.id))
+                throw new TransientIntegrationError("Tally webhook creation returned no identity.");
+            hookId = result.data.id;
+        }
+        await state.saveSubscription({ hookId }, context.now);
+        const aligned = await request(context, {
+            endpoint: `/webhooks/${encodeURIComponent(hookId)}`,
+            method: "PATCH",
+            body: {
+                url: context.endpointUrl,
+                eventTypes: ["FORM_RESPONSE"],
+                signingSecret: context.callbackSecret,
+                isEnabled: true,
+            },
+        });
+        if (aligned.status == 404) {
+            await state.saveSubscription({}, context.now);
+            return { outcome: "pending" };
+        }
+        success(aligned);
+        await state.saveSubscription({ hookId }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function nonempty(value) {
+    return typeof value == "string" && value.length > 0;
+}
+function pageData(value, field, page) {
+    if (!isJsonObject(value) ||
+        !Array.isArray(value[field]) ||
+        typeof value.hasMore != "boolean" ||
+        value.page !== page ||
+        (value.hasMore && value[field].length == 0))
+        throw new TransientIntegrationError("Tally returned an invalid page.");
+    return { items: value[field], hasMore: value.hasMore };
+}
+async function request(context, input) {
+    context.signal?.throwIfAborted();
+    const result = await context.connector.execute(input, context.signal);
+    context.signal?.throwIfAborted();
+    return result;
+}
+function success(result) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status >= 400 && result.status < 500 && result.status != 429)
+        throw new PermanentIntegrationError(`Tally rejected the subscription request (HTTP ${result.status}). Check form access and API key permissions.`);
+    throw new TransientIntegrationError(`Tally subscription request failed (HTTP ${result.status}).`);
+}
+function later(now) {
+    return new Date(now.getTime() + 24 * 60 * 60 * 1000);
+}

package/src/providers/tavily/runtime.js

@@ -1,7 +1,6 @@
 import { compactObject, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const tavilyApiBaseUrl = "https://api.tavily.com";
-const defaultTimeoutMs = 30_000;
 export const tavilyActionHandlers = {
     search(input, context) {
         return tavilyRequest(context, { method: "POST", path: "/search", body: input });
@@ -62,7 +61,7 @@ async function tavilyRequest(context, input) {
     }
 }
 async function tavilyRawRequest(context, input) {
-    const timeout = createProviderTimeout(context.signal, defaultTimeoutMs);
+    const timeout = createProviderTimeout(context.signal);
     try {
         return await context.fetcher(new URL(input.path, tavilyApiBaseUrl), {
             method: input.method ?? "POST",
@@ -77,7 +76,7 @@ async function tavilyRawRequest(context, input) {
     }
     catch (error) {
         if (timeout.didTimeout() && isAbortLikeError(error)) {
-            throw new ProviderRequestError(502, `Tavily request timed out after ${Math.ceil(defaultTimeoutMs / 1000)} seconds`);
+            throw new ProviderRequestError(502, `Tavily request timed out after ${Math.ceil(defaultProviderRequestTimeoutMs / 1000)} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error ? `Tavily request failed: ${error.message}` : "Tavily request failed", error);
     }

package/src/providers/teamcamp/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, requiredInputString, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, requiredInputString, providerInputError, } from "../provider-runtime.js";
 const service = "teamcamp";
 const teamcampApiBaseUrl = "https://api.teamcamp.app/v1.0";
 export const teamcampActionHandlers = {
@@ -187,7 +187,7 @@ function createTeamcampError(response, payload, _phase, notFoundAsInvalidInput =
         response.status === 401 ||
         response.status === 403 ||
         (response.status === 404 && notFoundAsInvalidInput)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 500, message);
 }

package/src/providers/teamtailor/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, requiredInputString, requiredResponseRecord, setSearchParams, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, requiredInputString, requiredResponseRecord, setSearchParams, providerInputError, } from "../provider-runtime.js";
 const service = "teamtailor";
 const teamtailorEuApiBaseUrl = "https://api.teamtailor.com";
 const teamtailorNaApiBaseUrl = "https://api.na.teamtailor.com";
@@ -219,7 +219,7 @@ function mapTeamtailorError(response, payload, phase, notFoundAsInvalidInput) {
         return new ProviderRequestError(phase === "validate" ? 400 : 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/telegram/executors.js

@@ -1,10 +1,9 @@
 import { optionalBoolean, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, ProviderRequestError, requireApiKeyCredential, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, ProviderRequestError, requireApiKeyCredential, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 import { telegramUpdate } from "./trigger-on-update.js";
 const service = "telegram";
 const telegramApiBaseUrl = "https://api.telegram.org";
-const telegramDefaultRequestTimeoutMs = 30_000;
 export const telegramActionHandlers = {
     async get_me(_input, context) {
         return normalizeTelegramUser(await telegramRequest({
@@ -702,7 +701,7 @@ async function telegramRequest(input) {
     const timeoutHandle = setTimeout(() => {
         timedOut = true;
         controller.abort();
-    }, telegramDefaultRequestTimeoutMs);
+    }, defaultProviderRequestTimeoutMs);
     const abortFromContext = () => controller.abort();
     input.context.signal?.addEventListener("abort", abortFromContext, { once: true });
     let response;
@@ -716,7 +715,7 @@ async function telegramRequest(input) {
     }
     catch (error) {
         if (timedOut && isAbortLikeError(error)) {
-            throw new ProviderRequestError(502, `telegram ${input.method} request timed out after ${Math.ceil(telegramDefaultRequestTimeoutMs / 1000)} seconds`);
+            throw new ProviderRequestError(502, `telegram ${input.method} request timed out after ${Math.ceil(defaultProviderRequestTimeoutMs / 1000)} seconds`);
         }
         const message = error instanceof Error && error.message.trim() !== "" ? error.message : "request failed";
         throw new ProviderRequestError(502, `telegram ${input.method} request failed: ${message}`);
@@ -766,10 +765,10 @@ function buildTelegramError(input) {
         return new ProviderRequestError(429, message);
     }
     if (input.phase === "validate" && status === 401) {
-        return new ProviderRequestError(400, description);
+        return providerInputError(description);
     }
     if (status === 400 || status === 404 || status === 409) {
-        return new ProviderRequestError(400, description);
+        return providerInputError(description);
     }
     return new ProviderRequestError(status || 500, description);
 }
@@ -1134,7 +1133,7 @@ function validateTelegramUrl(value, fieldName) {
     }
     return assertPublicHttpUrl(text, {
         fieldName,
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
     }).toString();
 }
 function validateEditMessageTarget(input) {

package/src/providers/teltel/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalNumber, optionalRecord, optionalString, optionalStringOrNull, } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, requiredInputString, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, requiredInputString, providerInputError, } from "../provider-runtime.js";
 const service = "teltel";
 const teltelApiBaseUrl = "https://api.teltel.io/v2";
 export const teltelActionHandlers = {
@@ -149,7 +149,7 @@ function createTeltelError(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);
     }
     return new ProviderRequestError(response.status || 500, message);
 }

package/src/providers/templated/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, providerInputError, } from "../provider-runtime.js";
 const service = "templated";
 const templatedApiBaseUrl = "https://api.templated.io/v1";
 export const templatedActionHandlers = {
@@ -212,10 +212,10 @@ function createTemplatedError(response, payload, phase, notFoundAsInvalidInput =
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && response.status === 401) {
-        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 || 500, message);
 }

package/src/providers/tencent_docs/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBooleanOrNull, optionalInteger, optionalRecord, optionalString, } from "../../core/cast.js";
-import { ProviderRequestError } from "../provider-runtime.js";
+import { ProviderRequestError, providerInputError, providerResponseError } from "../provider-runtime.js";
 const tencentDocsUserInfoUrl = "https://docs.qq.com/oauth/v2/userinfo";
 export const tencentDocsApiBaseUrl = "https://docs.qq.com";
 export const tencentDocsActionHandlers = {
@@ -405,7 +405,7 @@ function mapTencentDocsBusinessError(ret, message, status) {
 }
 function mapTencentDocsHttpError(status, message) {
     if (status === 400) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 401 || status === 403) {
         return new ProviderRequestError(status, message);
@@ -536,7 +536,7 @@ function normalizeNullableInteger(value) {
 function requireString(value, message) {
     const stringValue = optionalString(value);
     if (!stringValue) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return stringValue;
 }
@@ -549,7 +549,7 @@ function requireActionInputString(value, fieldName) {
 }
 function requireRecord(value, message) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return value;
 }

package/src/providers/tencent_maps/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 const tencentMapsApiBaseUrl = "https://apis.map.qq.com";
 const tencentMapsValidationPath = "/ws/district/v1/list";
 const tencentMapsAuthStatuses = new Set([110, 111, 112, 113, 190, 199]);
@@ -402,11 +402,11 @@ function normalizeTencentMapsError(response, payload, phase) {
             return new ProviderRequestError(429, message);
         }
         if (tencentMapsInputStatuses.has(status)) {
-            return new ProviderRequestError(400, message);
+            return providerInputError(message);
         }
         if (tencentMapsAuthStatuses.has(status)) {
             if (phase === "validate") {
-                return new ProviderRequestError(400, message);
+                return providerInputError(message);
             }
             return new ProviderRequestError(401, message);
         }

package/src/providers/textcortex/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString, requiredRecord } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 export const textcortexApiBaseUrl = "https://api.textcortex.com/v1";
 const textcortexApiOrigin = "https://api.textcortex.com";
 export async function validateTextcortexCredential(context) {
@@ -159,10 +159,10 @@ function createTextcortexError(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 (response.status === 400 || response.status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 502, message);
 }