@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/vectorshift/runtime.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent, requiredResponseRecord } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, requiredResponseRecord, providerInputError, } from "../provider-runtime.js";
 export const vectorshiftApiBaseUrl = "https://api.vectorshift.ai/v1";
 const listPipelinesPath = "/pipelines";
 const fetchPipelinePath = "/pipeline";
@@ -149,11 +149,11 @@ function createVectorshiftError(response, payload, phase) {
     if (response.status === 429)
         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 (response.status >= 400 && response.status < 500)
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     return new ProviderRequestError(response.status || 502, message);
 }
 function readErrorMessage(payload) {

package/src/providers/venafitlsprotectcloud/runtime.js

@@ -1,11 +1,10 @@
 import { createHash } from "node:crypto";
 import { optionalInteger, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { defineProviderExecutors, providerInputError, ProviderRequestError, providerUserAgent, requireApiKeyCredential, } from "../provider-runtime.js";
+import { defineProviderExecutors, providerInputError, ProviderRequestError, providerUserAgent, requireApiKeyCredential, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const venafiCloudBaseUrls = {
     us: "https://api.venafi.cloud",
     eu: "https://api.venafi.eu",
 };
-const requestTimeoutMs = 30_000;
 export async function validateVenafiCloudCredential(input, fetcher, signal) {
     const apiKey = requiredString(input.apiKey, "apiKey", providerInputError);
     const region = readRegion(input.region);
@@ -101,7 +100,7 @@ async function requestVenafiCloud(input) {
             "tppl-api-key": input.apiKey,
             "user-agent": providerUserAgent,
         },
-        signal: input.signal ?? AbortSignal.timeout(requestTimeoutMs),
+        signal: input.signal ?? AbortSignal.timeout(defaultProviderRequestTimeoutMs),
     });
     const payload = await readPayload(response);
     if (!response.ok)

package/src/providers/venafitlsprotectdatacenter/runtime.js

@@ -1,8 +1,7 @@
 import { createHash } from "node:crypto";
 import { optionalRecord, optionalString, requiredString } from "../../core/cast.js";
 import { assertPublicHttpUrl, encodePathSegment, isPrivateNetworkAccessAllowed } from "../../core/request.js";
-import { defineProviderExecutors, providerInputError, ProviderRequestError, providerUserAgent, requireCustomCredential, } from "../provider-runtime.js";
-const requestTimeoutMs = 30_000;
+import { defineProviderExecutors, providerInputError, ProviderRequestError, providerUserAgent, requireCustomCredential, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export async function validateVenafiDatacenterCredential(values, fetcher, signal) {
     const credentials = readCredentials(values);
     await getAccessToken(credentials, fetcher, "validate", signal);
@@ -121,7 +120,7 @@ async function guardedRequest(url, fetcher, init, phase, signal) {
             "user-agent": providerUserAgent,
             ...init.headers,
         },
-        signal: signal ?? AbortSignal.timeout(requestTimeoutMs),
+        signal: signal ?? AbortSignal.timeout(defaultProviderRequestTimeoutMs),
     });
     const text = await response.text();
     let payload = {};

package/src/providers/vercel/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/vercel/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderExecutors, defineProviderProxy, requireApiKeyCredential } from "../provider-runtime.js";
 import { readVercelTeamScope, validateVercelCredential, vercelActionHandlers, vercelApiBaseUrl } from "./runtime.js";
+import { vercelDeploymentEvent } from "./trigger-on-deployment-event.js";
 const service = "vercel";
 const vercelProxyUserAgent = "oomol-connector/1.0 (+https://oomol.com)";
 export const executors = defineProviderExecutors({
@@ -29,3 +30,4 @@ export const credentialValidators = {
         return validateVercelCredential(input, fetcher);
     },
 };
+export const triggers = [vercelDeploymentEvent];

package/src/providers/vercel/trigger-on-deployment-event.d.ts

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

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

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

package/src/providers/vercel/trigger-on-deployment-event.definition.js

@@ -0,0 +1,41 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const events = ["deployment.ready", "deployment.error"];
+export const snapshot = {
+    key: "vercel.on_deployment_event",
+    provider: "vercel",
+    name: "on_deployment_event",
+    displayName: "Deployment Ready or Failed",
+    description: "Receives successful and failed deployments for a Vercel project.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "teamId",
+            jsonSchema: { type: "string", minLength: 1, maxLength: 256, title: "Team ID" },
+            nullable: false,
+        },
+        {
+            handle: "projectId",
+            jsonSchema: { type: "string", minLength: 1, maxLength: 256, title: "Project ID" },
+            nullable: false,
+        },
+        {
+            handle: "environment",
+            jsonSchema: { type: "string", enum: ["all", "production", "preview"], title: "Environment" },
+            nullable: false,
+            value: "all",
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "deploymentId", jsonSchema: s.string(), nullable: false },
+        { handle: "projectId", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/vercel/trigger-on-deployment-event.js

@@ -0,0 +1,102 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot, events } from "./trigger-on-deployment-event.definition.js";
+export const vercelDeploymentEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const query = { teamId: String(context.config.teamId) };
+        const remove = async (id) => {
+            await webhookRequest(context, { endpoint: `/v1/webhooks/${encodeURIComponent(id)}`, method: "DELETE", query });
+        };
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const result = await webhookRequest(context, { endpoint: "/v1/webhooks", method: "GET", query });
+                if (!Array.isArray(result.data) ||
+                    result.data.some((item) => !isJsonObject(item) || typeof item.url != "string" || typeof item.id != "string"))
+                    throw new TransientIntegrationError("Vercel returned an invalid webhook list.");
+                const matches = result.data.filter((item) => isJsonObject(item) && item.url == context.endpointUrl);
+                if (matches.length > 1)
+                    throw new PermanentIntegrationError("Multiple Vercel webhooks match this subscription. Remove duplicates before retrying.");
+                const found = [];
+                for (const item of matches) {
+                    const id = item.id;
+                    if (item.ownerId != context.config.teamId ||
+                        !Array.isArray(item.projectIds) ||
+                        item.projectIds.length != 1 ||
+                        item.projectIds[0] != context.config.projectId ||
+                        !Array.isArray(item.events) ||
+                        item.events.length != events.length ||
+                        !events.every((event) => item.events.includes(event)))
+                        throw new PermanentIntegrationError("The Vercel webhook scope differs from this subscription. Restore its project and event settings.");
+                    const state = context.state;
+                    if (state.subscription.hookId == id && typeof state.subscription.secret == "string") {
+                        found.push({ id, secret: state.subscription.secret });
+                    }
+                    else {
+                        // Vercel only returns the secret on creation. Remove the owned orphan before recreating it.
+                        await remove(id);
+                        await state.saveSubscription({}, context.now);
+                    }
+                }
+                return found;
+            },
+            async create() {
+                const result = await webhookRequest(context, {
+                    endpoint: "/v1/webhooks",
+                    method: "POST",
+                    query,
+                    body: { url: context.endpointUrl, events: [...events], projectIds: [context.config.projectId] },
+                });
+                const data = result.data;
+                if (!isJsonObject(data) ||
+                    typeof data.id != "string" ||
+                    !data.id ||
+                    typeof data.secret != "string" ||
+                    !data.secret)
+                    throw new TransientIntegrationError("Vercel webhook creation returned no identity or secret.");
+                return { id: data.id, secret: data.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-vercel-signature"), "SHA-1")))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) || typeof body.type != "string" || !events.includes(body.type))
+            return { outcome: "ignored", reason: "Vercel event does not match." };
+        const payload = body.payload;
+        if (!isJsonObject(payload) ||
+            !isJsonObject(payload.team) ||
+            payload.team.id != context.config.teamId ||
+            !isJsonObject(payload.project) ||
+            payload.project.id != context.config.projectId)
+            return { outcome: "ignored", reason: "Vercel project or Team does not match." };
+        if ((context.config.environment == "production" && payload.target != "production") ||
+            (context.config.environment == "preview" && payload.target !== null))
+            return { outcome: "ignored", reason: "Vercel environment does not match." };
+        if (typeof body.id != "string" ||
+            !body.id ||
+            !isJsonObject(payload.deployment) ||
+            typeof payload.deployment.id != "string" ||
+            !payload.deployment.id)
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: body.id,
+            outputs: {
+                event: body.type,
+                deliveryId: body.id,
+                deploymentId: payload.deployment.id,
+                projectId: payload.project.id,
+                body: payload,
+            },
+        };
+    },
+};

package/src/providers/vida/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent, runProviderRequest } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, runProviderRequest, providerInputError, } from "../provider-runtime.js";
 export const vidaApiBaseUrl = "https://api.vida.dev";
 export const vidaActionHandlers = {
     get_account(input, fetcher, apiKey) {
@@ -60,7 +60,7 @@ export const vidaActionHandlers = {
 export async function validateVidaCredential(input, fetcher) {
     const payload = await requestVidaJson({
         path: "/api/v2/account",
-        apiKey: requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message)),
+        apiKey: requiredString(input.apiKey, "apiKey", providerInputError),
         params: {},
         fetcher,
         phase: "validate",
@@ -81,7 +81,7 @@ export async function executeVidaAction(input, fetcher) {
     if (!handler) {
         throw new ProviderRequestError(500, `vida action is not implemented yet: ${input.actionName}`);
     }
-    return handler(input.input, fetcher, requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message)));
+    return handler(input.input, fetcher, requiredString(input.apiKey, "apiKey", providerInputError));
 }
 function buildTargetAccountParams(input) {
     return compactObject({
@@ -136,7 +136,7 @@ function createVidaError(status, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && (status === 401 || status === 403)) {
         return new ProviderRequestError(status, message);

package/src/providers/vonage/runtime.js

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import { optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { providerInputError, ProviderRequestError, providerUserAgent, readProviderJsonBody, runProviderRequest, } from "../provider-runtime.js";
+import { providerInputError, ProviderRequestError, providerUserAgent, readProviderJsonBody, runProviderRequest, providerResponseError, } from "../provider-runtime.js";
 export const vonageApiBaseUrl = "https://rest.nexmo.com";
 export const vonageReportsApiBaseUrl = "https://api.nexmo.com";
 const invalidInputSmsStatuses = new Set(["2", "3", "6", "7", "12", "15", "17", "22", "23", "29", "33"]);
@@ -212,8 +212,8 @@ function mapSmsError(status, message) {
     if (["4", "8", "11", "14", "32"].includes(status))
         return new ProviderRequestError(401, text);
     if (invalidInputSmsStatuses.has(status))
-        return new ProviderRequestError(400, text);
-    return new ProviderRequestError(502, text);
+        return providerInputError(text);
+    return providerResponseError(text);
 }
 function requireResponseRecord(value, label) {
     const record = optionalRecord(value);

package/src/providers/walmart_marketplace/runtime.js

@@ -1,6 +1,6 @@
 import { optionalNumber as asOptionalNumber, optionalString as asOptionalString } from "../../core/cast.js";
 import { randomUUIDv7 } from "../../core/uuid-v7.js";
-import { ProviderRequestError, providerUserAgent as connectorUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent as connectorUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const walmartMarketplaceApiBaseUrl = "https://marketplace.walmartapis.com";
 const tokenPath = "/v3/token";
 const serviceName = "Walmart Marketplace";
@@ -179,17 +179,17 @@ function mapWalmartError(status, payload, phase) {
         structuredError ??
         `walmart marketplace request failed with HTTP ${status}`;
     if (status === 401) {
-        return phase === "validate" ? new ProviderRequestError(400, message) : new ProviderRequestError(401, message);
+        return phase === "validate" ? providerInputError(message) : new ProviderRequestError(401, message);
     }
     if (status === 403) {
-        return phase === "validate" ? new ProviderRequestError(400, message) : new ProviderRequestError(403, message);
+        return phase === "validate" ? providerInputError(message) : new ProviderRequestError(403, message);
     }
     if (status === 429)
         return new ProviderRequestError(429, message);
     if (status === 400 || status === 404 || status === 409) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function normalizeItemList(payload) {
     const record = requireRecord(payload, "item list");

package/src/providers/weatherapi/executors.js

@@ -1,8 +1,7 @@
 import { compactObject, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "weatherapi";
 const weatherapiApiBaseUrl = "https://api.weatherapi.com/v1/";
-const weatherapiDefaultRequestTimeoutMs = 30_000;
 const weatherapiValidationQuery = "London";
 const weatherapiActionHandlers = {
     async search_locations(input, context) {
@@ -151,7 +150,7 @@ export const credentialValidators = {
 };
 async function weatherapiRequestJson(path, apiKey, params, context, phase) {
     const url = weatherapiRequestUrl(path, apiKey, params);
-    const timeout = createProviderTimeout(context.signal, weatherapiDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(context.signal);
     let response;
     let payload;
     try {
@@ -163,7 +162,7 @@ async function weatherapiRequestJson(path, apiKey, params, context, phase) {
     }
     catch (error) {
         if (timeout.didTimeout() && isAbortLikeError(error)) {
-            throw new ProviderRequestError(502, `WeatherAPI ${path} request timed out after ${Math.max(1, Math.ceil(weatherapiDefaultRequestTimeoutMs / 1000))} seconds`);
+            throw new ProviderRequestError(502, `WeatherAPI ${path} request timed out after ${Math.max(1, Math.ceil(defaultProviderRequestTimeoutMs / 1000))} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error ? `WeatherAPI request failed: ${error.message}` : "WeatherAPI request failed");
     }

package/src/providers/web_of_science/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString, rawStringOrNull } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredInputString, setSearchParams, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredInputString, setSearchParams, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const webOfScienceApiBaseUrl = "https://api.clarivate.com/apis/wos-starter/v1";
 export const webOfScienceActionHandlers = {
     async search_documents(input, context) {
@@ -121,10 +121,10 @@ function createWebOfScienceError(status, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && (status === 401 || status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "validate" && status >= 400 && status < 500) {
-        return new ProviderRequestError(502, message);
+        return providerResponseError(message);
     }
     if (status === 401 || status === 403) {
         return new ProviderRequestError(status, message);
@@ -217,7 +217,7 @@ function readStringArray(value) {
 function requireResponseRecord(value, message) {
     const record = optionalRecord(value);
     if (!record) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return record;
 }

package/src/providers/web_of_science_expanded/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString, optionalStringOrNull, requiredString, } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, readProviderJsonBody, setSearchParams, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, readProviderJsonBody, setSearchParams, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const webOfScienceExpandedApiBaseUrl = "https://wos-api.clarivate.com/api/wos";
 export const webOfScienceExpandedActionHandlers = {
     async search_documents(input, context) {
@@ -40,7 +40,7 @@ export const webOfScienceExpandedActionHandlers = {
             query: compactObject({
                 databaseId: optionalString(input.database) ?? "WOS",
                 lang: normalizeLanguage(input.language),
-                uniqueId: requiredString(input.uid, "uid", (message) => new ProviderRequestError(400, message)),
+                uniqueId: requiredString(input.uid, "uid", providerInputError),
                 count: String(limit),
                 firstRecord: String(firstRecord),
                 sortField: optionalString(input.sortField),
@@ -125,7 +125,7 @@ async function executeRelatedDocumentRequest(path, input, context) {
         query: compactObject({
             databaseId: database,
             lang: normalizeLanguage(input.language),
-            uniqueId: requiredString(input.uid, "uid", (message) => new ProviderRequestError(400, message)),
+            uniqueId: requiredString(input.uid, "uid", providerInputError),
             edition: optionalString(input.edition),
             publishTimeSpan: optionalString(input.publishTimeSpan),
             modifiedTimeSpan: optionalString(input.modifiedTimeSpan),
@@ -145,7 +145,7 @@ function buildSearchParams(input, options) {
     return compactObject({
         databaseId: database,
         lang: normalizeLanguage(input.language),
-        usrQuery: requiredString(input.query, "query", (message) => new ProviderRequestError(400, message)),
+        usrQuery: requiredString(input.query, "query", providerInputError),
         edition: optionalString(input.edition),
         publishTimeSpan: optionalString(input.publishTimeSpan),
         loadTimeSpan: optionalString(input.loadTimeSpan),
@@ -218,10 +218,10 @@ function createWebOfScienceExpandedError(status, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && (status === 401 || status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "validate" && status >= 400 && status < 500) {
-        return new ProviderRequestError(502, message);
+        return providerResponseError(message);
     }
     if (status === 401 || status === 403) {
         return new ProviderRequestError(status, message);
@@ -368,7 +368,7 @@ function readRecordArray(value) {
 }
 function requireRecordArray(value, message) {
     if (!Array.isArray(value)) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return value.map((item) => requireRecord(item, message));
 }
@@ -401,14 +401,14 @@ function readOptionalStringArray(value) {
 function requireRecord(value, message) {
     const record = optionalRecord(value);
     if (!record) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return record;
 }
 function readRequiredResponseString(value, message) {
     const normalized = optionalString(value);
     if (!normalized) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return normalized;
 }

package/src/providers/webex/runtime.js

@@ -1,5 +1,5 @@
 import { optionalRecord as asOptionalObject, optionalString as asOptionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError } from "../provider-runtime.js";
 export const webexApiBaseUrl = "https://webexapis.com/v1";
 const requestDescriptors = {
     list_people: {
@@ -255,12 +255,12 @@ async function mapWebexError(response) {
         return new ProviderRequestError(403, message);
     }
     if (response.status === 404) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 423 || response.status === 429 || response.status >= 500) {
         return new ProviderRequestError(response.status === 429 ? 429 : 502, message);
     }
-    return new ProviderRequestError(400, message);
+    return providerInputError(message);
 }
 function readNextPageUrl(link) {
     if (!link) {

package/src/providers/webinarjam/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 export const webinarjamApiBaseUrl = "https://api.webinarjam.com/webinarjam";
 export const webinarjamActionHandlers = {
     async list_webinars(_input, context) {
@@ -183,7 +183,7 @@ function createWebinarjamError(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(response.status, message);
@@ -203,12 +203,12 @@ function readProviderStatusError(payload) {
 }
 function mapWebinarjamProviderStatusError(message, phase) {
     if (phase === "validate") {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (message.toLowerCase().includes("api")) {
         return new ProviderRequestError(401, message);
     }
-    return new ProviderRequestError(400, message);
+    return providerInputError(message);
 }
 function readWebinarjamMessage(payload) {
     if (typeof payload === "string" && payload.trim()) {

package/src/providers/webscraping_ai/runtime.js

@@ -170,7 +170,7 @@ function readTargetUrl(value) {
     const rawUrl = requiredInputString(value, "url");
     const url = assertPublicHttpUrl(rawUrl, {
         fieldName: "url",
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
     });
     if (url.username || url.password) {
         throw new ProviderRequestError(400, "url must not include credentials");
@@ -210,13 +210,13 @@ async function createWebscrapingAiError(response, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && response.status === 403) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && response.status === 403) {
         return new ProviderRequestError(403, message);
     }
     if (response.status === 400) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 504) {
         return new ProviderRequestError(504, message);

package/src/providers/webvizio/runtime.js

@@ -1,8 +1,7 @@
 import { optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerInputError, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerInputError, ProviderRequestError, providerUserAgent, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const webvizioApiBaseUrl = "https://app.webvizio.com/api/v1";
 const webvizioWebhookPath = "/webhook";
-const webvizioDefaultRequestTimeoutMs = 30_000;
 export const webvizioActionHandlers = {
     async create_rest_hook_subscription(input, context) {
         const url = requiredString(input.url, "url", providerInputError);
@@ -39,7 +38,7 @@ export async function validateWebvizioCredential(apiKey, _fetcher, _signal) {
     };
 }
 async function requestWebvizioJson(input, context) {
-    const timeout = createProviderTimeout(context.signal, webvizioDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(context.signal);
     try {
         const response = await context.fetcher(buildWebvizioUrl(input.path), {
             method: input.method,
@@ -56,7 +55,7 @@ async function requestWebvizioJson(input, context) {
         if (error instanceof ProviderRequestError)
             throw error;
         throw new ProviderRequestError(timeout.didTimeout() || isAbortLikeError(error) ? 504 : 502, timeout.didTimeout() || isAbortLikeError(error)
-            ? `Webvizio request timed out after ${Math.max(1, Math.ceil(webvizioDefaultRequestTimeoutMs / 1000))} seconds`
+            ? `Webvizio request timed out after ${Math.max(1, Math.ceil(defaultProviderRequestTimeoutMs / 1000))} seconds`
             : error instanceof Error
                 ? `Webvizio request failed: ${error.message}`
                 : "Webvizio request failed");

package/src/providers/wecom_bot/smart-runtime.js

@@ -3,10 +3,9 @@ import { createHash, randomUUID } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
-import { createProviderTimeout, providerUserAgent, ProviderRequestError, requiredResponseRecord, } from "../provider-runtime.js";
+import { createProviderTimeout, providerUserAgent, ProviderRequestError, requiredResponseRecord, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const wecomMcpConfigUrl = "https://qyapi.weixin.qq.com/cgi-bin/aibot/cli/get_mcp_config";
 const wecomSmartBotHelpUrl = "https://open.work.weixin.qq.com/help2/pc/cat?doc_id=21677";
-const wecomSmartBotRequestTimeoutMs = 30_000;
 const wecomSmartBotMediaTimeoutMs = 120_000;
 const wecomMcpConfigCacheTtlMs = 10 * 60_000;
 const wecomMcpConfigCacheMaxEntries = 128;
@@ -200,7 +199,7 @@ async function fetchWecomMcpConfig(credential, fetcher) {
             bind_source: 1,
             cli_version: providerUserAgent,
         }),
-    }, fetcher, wecomSmartBotRequestTimeoutMs);
+    }, fetcher, defaultProviderRequestTimeoutMs);
     const payload = requiredResponseRecord(response.payload, "WeCom MCP config response");
     const errcode = readInteger(payload.errcode) ?? 0;
     if (!response.ok || errcode !== 0) {
@@ -287,7 +286,7 @@ async function callWecomTool(category, toolName, argumentsValue, runtime) {
     }
 }
 async function callWecomToolAtEndpoint(endpoint, toolName, argumentsValue, fetcher) {
-    const payload = await sendWecomMcpRequest(endpoint, "tools/call", { name: toolName, arguments: argumentsValue }, fetcher, toolName === "get_msg_media" ? wecomSmartBotMediaTimeoutMs : wecomSmartBotRequestTimeoutMs);
+    const payload = await sendWecomMcpRequest(endpoint, "tools/call", { name: toolName, arguments: argumentsValue }, fetcher, toolName === "get_msg_media" ? wecomSmartBotMediaTimeoutMs : defaultProviderRequestTimeoutMs);
     const result = requiredResponseRecord(payload.result, `WeCom ${toolName} MCP result`);
     if (result.isError === true) {
         throw new ProviderRequestError(502, readMcpContentMessage(result.content) ?? `WeCom ${toolName} failed`);
@@ -310,7 +309,7 @@ async function callWecomToolAtEndpoint(endpoint, toolName, argumentsValue, fetch
     }
     return normalizeWecomBusinessResult(parsed, toolName);
 }
-async function sendWecomMcpRequest(endpoint, method, params, fetcher, timeoutMs = wecomSmartBotRequestTimeoutMs) {
+async function sendWecomMcpRequest(endpoint, method, params, fetcher, timeoutMs = defaultProviderRequestTimeoutMs) {
     const response = await fetchWecomJson(endpoint, {
         method: "POST",
         headers: { accept: "application/json", "content-type": "application/json" },

package/src/providers/wecom_mcp/runtime.js

@@ -5,9 +5,8 @@ import { createHash } from "node:crypto";
 import { optionalRecord, requiredString } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
 import { withMcpClient } from "../mcp-client.js";
-import { providerUserAgent, ProviderRequestError, toProviderExecutionError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, toProviderExecutionError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const wecomMcpHost = "qyapi.weixin.qq.com";
-const wecomRequestTimeoutMs = 30_000;
 const wecomToolIntervalMs = 1_000;
 const maximumTrackedRateLimitKeys = 1_024;
 class InMemoryWeComMcpRateLimiter {
@@ -137,7 +136,7 @@ export async function callWeComTool(context, input) {
             name: toolName,
             arguments: argumentsValue,
         }, {
-            timeout: wecomRequestTimeoutMs,
+            timeout: defaultProviderRequestTimeoutMs,
             signal: context.signal,
         });
         return normalizeWeComMcpToolResult(toolName, toolResult);
@@ -147,7 +146,7 @@ export async function callWeComTool(context, input) {
 async function discoverWeComTools(context) {
     return withWeComMcpClient(context, async (client) => {
         const result = await client.listTools({}, {
-            timeout: wecomRequestTimeoutMs,
+            timeout: defaultProviderRequestTimeoutMs,
             signal: context.signal,
         });
         return result.tools.map((tool) => {