@oomol-lab/open-connector 1.9.2 → 1.9.3

package/src/providers/glyphic/runtime.js

@@ -1,7 +1,6 @@
 import { compactObject, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const glyphicApiBaseUrl = "https://api.glyphic.ai";
-const glyphicRequestTimeoutMs = 30_000;
 export const glyphicActionHandlers = {
     async list_calls(input, context) {
         const payload = await requestGlyphicJson({
@@ -99,7 +98,7 @@ async function requestGlyphicArray(path, context, label) {
     return readResponseArray(payload, label);
 }
 async function requestGlyphicJson(input, context, mode) {
-    const timeout = createProviderTimeout(context.signal, glyphicRequestTimeoutMs);
+    const timeout = createProviderTimeout(context.signal);
     try {
         const response = await context.fetcher(buildGlyphicUrl(input.path, input.query), {
             method: input.method,
@@ -121,7 +120,7 @@ async function requestGlyphicJson(input, context, mode) {
             throw error;
         }
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `Glyphic request timed out after ${glyphicRequestTimeoutMs / 1000} seconds`);
+            throw new ProviderRequestError(504, `Glyphic request timed out after ${defaultProviderRequestTimeoutMs / 1000} seconds`);
         }
         const message = error instanceof Error && error.message.trim() ? error.message : "request failed";
         throw new ProviderRequestError(502, `Glyphic request failed: ${message}`);

package/src/providers/gmail/executors.js

@@ -2,7 +2,7 @@ import { format as schemaFormat } from "@cfworker/json-schema";
 import { looseArray, optionalBoolean, optionalNumberLike, optionalRawString, optionalRecord, optionalString, } from "../../core/cast.js";
 import { encodePathSegment } from "../../core/request.js";
 import { googleBearerProxyAuth, googleServiceAccountValidator, resolveGoogleAccessToken, } from "../googledrive/runtime-auth.js";
-import { defineProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, readProviderErrorTextBody, readProviderJsonBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { defineProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, readProviderErrorTextBody, readProviderJsonBody, readRetryAfterSeconds, requiredInputString, requiredResponseRecord, runProviderRequest, providerRequestErrorCode, withRetryAfterSeconds, } from "../provider-runtime.js";
 import { decodeGmailAttachment } from "./attachment-stream.js";
 import { gmailMaxMimeBytes } from "./limits.js";
 import { assertMatchingReplySubject, buildRecipients, normalizeGmailMessage, normalizeMessageId, normalizeThreadId, readHeader, resolveReplyHeaders, summarizeGmailMessage, } from "./message.js";
@@ -13,6 +13,16 @@ import { gmailMessageReceived } from "./trigger-on-message-received.js";
 const service = "gmail";
 const gmailApiBaseUrl = "https://gmail.googleapis.com/gmail/v1";
 const detailHydrationBatchSize = 10;
+// Hydration fans out one detail request per listed id, which can exceed Gmail's per-user quota.
+// The retry below keeps hydrated rows and paces the rest instead of discarding the page.
+// Six attempts let the backoff climb 1, 2, 4, 8, 16 s (about 31 s of waiting per message at most),
+// long enough for the moving average to drain, without retrying one message forever.
+const hydrationMaxAttempts = 6;
+const hydrationBaseBackoffMs = 1_000;
+// Total time one action may spend waiting out rate limits. It stays well below the few minutes a
+// caller typically allows one action call, so a persistent limit still comes back as rate_limited
+// (which the caller can pace) rather than as a client-side timeout.
+const hydrationRetryBudgetMs = 120_000;
 // Attachments may reach Gmail's 25 MB cap, and the base64 JSON envelope is a third larger again;
 // the default 30 s request budget covers fetch, decode, and disk write, so give this transfer longer.
 const attachmentDownloadTimeoutMs = 120_000;
@@ -49,11 +59,11 @@ export const gmailActionHandlers = {
             })),
         };
     },
-    list_threads(input, { userId, accessToken, fetcher }) {
-        return listThreads(input, userId, accessToken, fetcher);
+    list_threads(input, { userId, accessToken, fetcher, signal }) {
+        return listThreads(input, userId, accessToken, fetcher, signal);
     },
-    fetch_emails(input, { userId, accessToken, fetcher }) {
-        return fetchEmails(input, userId, accessToken, fetcher);
+    fetch_emails(input, { userId, accessToken, fetcher, signal }) {
+        return fetchEmails(input, userId, accessToken, fetcher, signal);
     },
     async get_message(input, { userId, accessToken, fetcher }) {
         const message = await getMessageResource(userId, normalizeMessageId(input.messageId), accessToken, fetcher, "full");
@@ -92,8 +102,8 @@ export const gmailActionHandlers = {
     create_email_draft(input, context) {
         return createEmailDraft(input, context);
     },
-    list_drafts(input, { userId, accessToken, fetcher }) {
-        return listDrafts(input, userId, accessToken, fetcher);
+    list_drafts(input, { userId, accessToken, fetcher, signal }) {
+        return listDrafts(input, userId, accessToken, fetcher, signal);
     },
     get_draft(input, { userId, accessToken, fetcher }) {
         return getDraft(input, userId, accessToken, fetcher);
@@ -233,7 +243,7 @@ export const credentialValidators = {
     },
     customCredential: googleServiceAccountValidator(service, gmailOAuthScopes),
 };
-async function fetchEmails(input, userId, accessToken, fetcher) {
+async function fetchEmails(input, userId, accessToken, fetcher, signal) {
     const detail = trimmedString(input.detail) || "summary";
     const url = new URL(gmailUserUrl(userId, "messages"));
     const query = trimmedString(input.query);
@@ -265,7 +275,7 @@ async function fetchEmails(input, userId, accessToken, fetcher) {
     }
     const includeFullMessage = detail === "full";
     const format = includeFullMessage ? "full" : "metadata";
-    const hydrated = await hydrateInBatches(messages, (message) => getMessageResource(userId, message.id, accessToken, fetcher, format));
+    const hydrated = await hydrateInBatches(messages, (message) => getMessageResource(userId, message.id, accessToken, fetcher, format), signal);
     return {
         messages: hydrated.map((message) => includeFullMessage ? normalizeGmailMessage(message) : summarizeGmailMessage(message)),
         nextPageToken: payload.nextPageToken ?? null,
@@ -285,7 +295,7 @@ async function fetchMessagesByThreadId(input, userId, accessToken, fetcher) {
         messages: (thread.messages ?? []).map((message) => normalizeGmailMessage(message)),
     };
 }
-async function listThreads(input, userId, accessToken, fetcher) {
+async function listThreads(input, userId, accessToken, fetcher, signal) {
     const url = new URL(gmailUserUrl(userId, "threads"));
     const query = trimmedString(input.query);
     if (query) {
@@ -300,7 +310,7 @@ async function listThreads(input, userId, accessToken, fetcher) {
     const payload = await fetchJson(url.toString(), accessToken, fetcher);
     const threads = payload.threads ?? [];
     if (input.verbose === true) {
-        const hydrated = await hydrateInBatches(threads, (thread) => getThreadResource(userId, thread.id, accessToken, fetcher, "full"));
+        const hydrated = await hydrateInBatches(threads, (thread) => getThreadResource(userId, thread.id, accessToken, fetcher, "full"), signal);
         return {
             threads: hydrated.map((thread) => ({
                 threadId: thread.id,
@@ -465,7 +475,7 @@ function latestReplyMessage(thread) {
         throw providerInputError("thread has no non-draft messages to reply to");
     return latest;
 }
-async function listDrafts(input, userId, accessToken, fetcher) {
+async function listDrafts(input, userId, accessToken, fetcher, signal) {
     const url = new URL(gmailUserUrl(userId, "drafts"));
     if (input.pageToken != null) {
         url.searchParams.set("pageToken", String(input.pageToken));
@@ -476,7 +486,7 @@ async function listDrafts(input, userId, accessToken, fetcher) {
     const payload = await fetchJson(url.toString(), accessToken, fetcher);
     const drafts = payload.drafts ?? [];
     if (input.verbose === true) {
-        const hydrated = await hydrateInBatches(drafts, (draft) => getDraftResource(userId, draft.id, accessToken, fetcher, "full"));
+        const hydrated = await hydrateInBatches(drafts, (draft) => getDraftResource(userId, draft.id, accessToken, fetcher, "full"), signal);
         return {
             drafts: hydrated.map((draft) => ({
                 id: draft.id,
@@ -780,14 +790,94 @@ function normalizeThread(thread) {
         messages: (thread.messages ?? []).map((message) => normalizeGmailMessage(message)),
     };
 }
-async function hydrateInBatches(items, hydrate, batchSize = detailHydrationBatchSize) {
-    const hydrated = [];
-    for (let index = 0; index < items.length; index += batchSize) {
-        const batch = items.slice(index, index + batchSize);
-        hydrated.push(...(await Promise.all(batch.map((item) => hydrate(item)))));
+/**
+ * Hydrate every item, in order, or fail the whole call: a caller advances its page cursor on
+ * success, so a partial page must never look complete.
+ *
+ * Items run in batches of up to `detailHydrationBatchSize`. A per-user rate limit on one item
+ * keeps every row already hydrated and requeues only the limited items; the batch width halves
+ * (down to 1) and the next batch waits out `Retry-After` or an exponential, jittered backoff.
+ * Each clean batch widens the next one by a single item again. When an item runs out of
+ * attempts, or the next wait would overrun the action's retry budget, the rate-limit error
+ * with the longest `Retry-After` is thrown unchanged, so the action still reports `rate_limited`.
+ * Any other error rejects immediately, exactly like the plain batch it replaces.
+ */
+async function hydrateInBatches(items, hydrate, signal) {
+    const hydrated = new Array(items.length);
+    const attempts = new Array(items.length).fill(0);
+    const deadline = Date.now() + hydrationRetryBudgetMs;
+    let pending = items.map((_item, index) => index);
+    let width = detailHydrationBatchSize;
+    while (pending.length > 0) {
+        const batch = pending.slice(0, width);
+        const outcomes = await Promise.all(batch.map(async (index) => {
+            attempts[index] += 1;
+            try {
+                hydrated[index] = await hydrate(items[index]);
+                return undefined;
+            }
+            catch (error) {
+                if (isRetryableGmailRateLimit(error))
+                    return error;
+                throw error;
+            }
+        }));
+        const limited = batch.filter((_index, position) => outcomes[position] !== undefined);
+        pending = [...limited, ...pending.slice(batch.length)];
+        if (limited.length === 0) {
+            width = Math.min(detailHydrationBatchSize, width + 1);
+            continue;
+        }
+        // Surface the error carrying the longest Retry-After so the caller can pace the connection.
+        const pacingError = outcomes
+            .filter((error) => error !== undefined)
+            .reduce((longest, error) => (gmailRetryAfterMs(error) > gmailRetryAfterMs(longest) ? error : longest));
+        const attempt = Math.max(...limited.map((index) => attempts[index]));
+        if (attempt >= hydrationMaxAttempts)
+            throw pacingError;
+        const delayMs = hydrationRetryDelayMs(attempt, gmailRetryAfterMs(pacingError));
+        if (Date.now() + delayMs > deadline)
+            throw pacingError;
+        width = Math.max(1, Math.floor(width / 2));
+        await sleepFor(delayMs, signal);
     }
     return hydrated;
 }
+/**
+ * A rate limit worth waiting out inside this action: whatever the runtime reports as `rate_limited`
+ * (any 429, and the 403 rate-limit reasons `readGmailError` labels), except an exhausted daily or
+ * project quota, which stays `rate_limited` but does not recover within one action.
+ */
+function isRetryableGmailRateLimit(error) {
+    return (error instanceof GmailRequestError && !error.quotaExhausted && providerRequestErrorCode(error) === "rate_limited");
+}
+function gmailRetryAfterMs(error) {
+    return (optionalNumberLike(optionalRecord(error.details)?.retryAfterSeconds) ?? 0) * 1_000;
+}
+/** Honour the upstream `Retry-After` when present, else equal-jitter exponential backoff. */
+function hydrationRetryDelayMs(attempt, retryAfterMs) {
+    if (retryAfterMs > 0)
+        return retryAfterMs;
+    const backoffMs = hydrationBaseBackoffMs * 2 ** (attempt - 1);
+    return backoffMs / 2 + Math.random() * (backoffMs / 2);
+}
+function sleepFor(delayMs, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, delayMs);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
 function buildLabelPayload(input) {
     return Object.fromEntries(Object.entries(input).filter(([key, value]) => key !== "userId" && key !== "labelId" && value !== undefined));
 }
@@ -864,12 +954,18 @@ async function assertGmailResponse(response) {
     }
     throw await readGmailError(response);
 }
-const gmailQuotaReasons = new Set([
-    "rateLimitExceeded",
-    "userRateLimitExceeded",
-    "dailyLimitExceeded",
-    "quotaExceeded",
-]);
+// Gmail answers both of these with a 403, which would otherwise read as an authorization failure.
+// Per-user rate limits clear within seconds; exhausted daily or project quotas do not.
+const gmailRateLimitReasons = new Set(["rateLimitExceeded", "userRateLimitExceeded"]);
+const gmailExhaustedQuotaReasons = new Set(["dailyLimitExceeded", "quotaExceeded"]);
+/** A Gmail API failure that also records whether the upstream reason was an exhausted quota. */
+class GmailRequestError extends ProviderRequestError {
+    quotaExhausted;
+    constructor(status, message, details, code, quotaExhausted) {
+        super(status, message, details, code);
+        this.quotaExhausted = quotaExhausted;
+    }
+}
 async function readGmailError(response) {
     const text = await readProviderErrorTextBody(response, "gmail error response");
     let error;
@@ -879,8 +975,10 @@ async function readGmailError(response) {
     catch {
         // A malformed response must not expose its raw body or change status classification.
     }
-    const rateLimited = response.status === 403 &&
-        looseArray(error?.errors).some((entry) => gmailQuotaReasons.has(optionalString(optionalRecord(entry)?.reason) ?? ""));
-    return new ProviderRequestError(response.status, optionalString(error?.message) ?? `gmail request failed with ${response.status}`, withRetryAfterSeconds(response), rateLimited ? "rate_limited" : undefined);
+    const reasons = looseArray(error?.errors).flatMap((entry) => optionalString(optionalRecord(entry)?.reason) ?? []);
+    const quotaExhausted = reasons.some((reason) => gmailExhaustedQuotaReasons.has(reason));
+    const rateLimited = response.status === 403 && (quotaExhausted || reasons.some((reason) => gmailRateLimitReasons.has(reason)));
+    const retryAfterSeconds = rateLimited ? readRetryAfterSeconds(response.headers) : undefined;
+    return new GmailRequestError(response.status, optionalString(error?.message) ?? `gmail request failed with ${response.status}`, retryAfterSeconds === undefined ? withRetryAfterSeconds(response) : { retryAfterSeconds }, rateLimited ? "rate_limited" : undefined, quotaExhausted);
 }
 export const triggers = [gmailMessageReceived];

package/src/providers/gong/runtime.js

@@ -2,9 +2,8 @@ import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, requiredInputString, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, requiredInputString, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const gongDefaultApiBaseUrl = "https://api.gong.io";
-const gongDefaultTimeoutMs = 30_000;
 const gongCredentialHelpUrl = "https://help.gong.io/docs/receive-access-to-the-api";
 export const gongActionHandlers = {
     list_users(input, context) {
@@ -115,7 +114,7 @@ export async function validateGongCredential(input, fetcher, signal) {
     };
 }
 async function requestGongJson(input) {
-    const timeout = createProviderTimeout(input.context.signal, gongDefaultTimeoutMs);
+    const timeout = createProviderTimeout(input.context.signal);
     try {
         const response = await input.context.fetcher(buildGongUrl(input.context.apiBaseUrl, input.path, input.query), {
             method: input.method,
@@ -134,7 +133,7 @@ async function requestGongJson(input) {
             throw error;
         }
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `Gong ${input.path} request timed out after ${gongDefaultTimeoutMs / 1000} seconds`);
+            throw new ProviderRequestError(504, `Gong ${input.path} request timed out after ${defaultProviderRequestTimeoutMs / 1000} seconds`);
         }
         const message = error instanceof Error && error.message.trim() ? error.message : "request failed";
         throw new ProviderRequestError(502, `Gong ${input.path} request failed: ${message}`);
@@ -158,7 +157,7 @@ export function normalizeGongApiBaseUrl(value) {
     }
     assertPublicHttpUrl(url.toString(), {
         fieldName: "apiBaseUrl",
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
     });
     url.search = "";
     url.hash = "";
@@ -214,10 +213,10 @@ function mapGongHttpError(status, message, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && [400, 401, 403].includes(status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if ([400, 404].includes(status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if ([401, 403].includes(status)) {
         return new ProviderRequestError(status, message);

package/src/providers/googlecalendar/runtime-shared.js

@@ -1,8 +1,7 @@
 import { optionalRecord, optionalString as asOptionalString, pickOptionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError, withRetryAfterSeconds } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, withRetryAfterSeconds, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const googlecalendarApiBaseUrl = "https://www.googleapis.com/calendar/v3";
 const service = "googlecalendar";
-const googleDefaultRequestTimeoutMs = 30_000;
 export async function googlecalendarJsonRequest(url, input) {
     try {
         const response = await googlecalendarRequest(url, input);
@@ -50,7 +49,7 @@ export async function googlecalendarRequest(url, input) {
         };
         const response = await googleFetchWithTimeout(target.toString(), {
             fetcher: input.fetcher,
-            timeoutMs: googleDefaultRequestTimeoutMs,
+            timeoutMs: defaultProviderRequestTimeoutMs,
             init: requestInit,
         });
         await assertGoogleResponse(response);
@@ -95,7 +94,7 @@ function maybeRewriteSyncTokenError(error, syncTokenAware) {
     return error;
 }
 async function googleFetchWithTimeout(url, input) {
-    const timeoutMs = input.timeoutMs ?? googleDefaultRequestTimeoutMs;
+    const timeoutMs = input.timeoutMs ?? defaultProviderRequestTimeoutMs;
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
         return input.fetcher(url, input.init);
     }

package/src/providers/googledrive/runtime-request.js

@@ -1,7 +1,6 @@
 import { looseArray, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const defaultService = "googledrive";
-const googleDefaultRequestTimeoutMs = 30_000;
 export async function googleJsonRequest(url, input) {
     const response = await googleRequest(url, input);
     return (await response.json());
@@ -41,7 +40,7 @@ export async function googleRequest(url, input) {
             : headers,
         ...(input.rawBody != null ? { body: input.rawBody } : hasJsonBody ? { body: JSON.stringify(input.body) } : {}),
     };
-    const timeoutMs = input.timeoutMs ?? googleDefaultRequestTimeoutMs;
+    const timeoutMs = input.timeoutMs ?? defaultProviderRequestTimeoutMs;
     const timeout = createProviderTimeout(input.signal, timeoutMs);
     let response;
     try {

package/src/providers/googlesheets/runtime-shared.js

@@ -1,8 +1,7 @@
 import { compactObject, objectArray, optionalBoolean, optionalIntegerLike, optionalRecord, optionalString as optionalTrimmedString, pickOptionalBoolean, pickOptionalInteger, pickOptionalString, requiredRecord, stringArray, } from "../../core/cast.js";
-import { isAbortLikeError, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { isAbortLikeError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export { compactObject, optionalBoolean, optionalIntegerLike as asOptionalInteger, optionalRecord as asOptionalObject, pickOptionalBoolean, pickOptionalInteger, pickOptionalString, };
 const service = "googlesheets";
-const googleDefaultRequestTimeoutMs = 30_000;
 export async function googleJsonRequest(url, input) {
     const response = await googleRequest(url, input);
     return (await response.json());
@@ -44,7 +43,7 @@ export async function googleRequest(url, input) {
     };
     const response = await googleFetchWithTimeout(target.toString(), {
         fetcher: input.fetcher,
-        timeoutMs: input.timeoutMs ?? googleDefaultRequestTimeoutMs,
+        timeoutMs: input.timeoutMs ?? defaultProviderRequestTimeoutMs,
         init: requestInit,
     });
     await assertGoogleResponse(response);
@@ -141,7 +140,7 @@ export function asStringArray(value) {
     return stringArray(value, "string array", (message) => new ProviderRequestError(400, message));
 }
 async function googleFetchWithTimeout(url, input) {
-    const timeoutMs = input.timeoutMs ?? googleDefaultRequestTimeoutMs;
+    const timeoutMs = input.timeoutMs ?? defaultProviderRequestTimeoutMs;
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
         return input.fetcher(url, input.init);
     }

package/src/providers/gorgias/runtime.js

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import { optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 const gorgiasValidationPath = "/api/account";
 export const gorgiasActionHandlers = {
     async get_account(_input, context) {
@@ -202,16 +202,16 @@ async function readGorgiasPayload(response) {
 function createGorgiasError(response, payload, phase, notFoundAsInvalidInput) {
     const message = extractGorgiasErrorMessage(payload) ?? `Gorgias request failed with ${response.status}`;
     if (phase === "validate" && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 401 || response.status === 403) {
         return new ProviderRequestError(response.status, message);
     }
     if (response.status === 404 && notFoundAsInvalidInput) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 400 || response.status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 429) {
         return new ProviderRequestError(429, message);

package/src/providers/gotify/executors.js

@@ -1,9 +1,8 @@
 import { createHash } from "node:crypto";
 import { compactObject, optionalInteger, optionalRawString, optionalRecord, optionalString, requiredRecord, requiredString, } from "../../core/cast.js";
 import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
-import { createProviderFetch, createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, readProviderJsonBody, requireApiKeyCredential, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, readProviderJsonBody, requireApiKeyCredential, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "gotify";
-const gotifyRequestTimeoutMs = 30_000;
 export const gotifyActionHandlers = {
     async send_message(input, context) {
         const payload = await requestGotifyJson({
@@ -110,11 +109,11 @@ export const credentialValidators = {
     },
 };
 function normalizeGotifyBaseUrl(value, allowPrivateNetwork = isPrivateNetworkAccessAllowed()) {
-    const rawValue = requiredString(value, "baseUrl", (message) => new ProviderRequestError(400, message));
+    const rawValue = requiredString(value, "baseUrl", providerInputError);
     const url = assertPublicHttpUrl(rawValue, {
         fieldName: "baseUrl",
         allowPrivateNetwork,
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
     });
     if (url.username || url.password) {
         throw new ProviderRequestError(400, "baseUrl must not include username or password");
@@ -124,7 +123,7 @@ function normalizeGotifyBaseUrl(value, allowPrivateNetwork = isPrivateNetworkAcc
     return url.toString().replace(/\/+$/u, "");
 }
 async function requestGotifyJson(input) {
-    const timeout = createProviderTimeout(input.context.signal, gotifyRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.context.signal);
     try {
         const headers = {
             accept: "application/json",
@@ -157,7 +156,7 @@ async function requestGotifyJson(input) {
             throw error;
         }
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `Gotify ${input.path} request timed out after ${Math.ceil(gotifyRequestTimeoutMs / 1000)} seconds`);
+            throw new ProviderRequestError(504, `Gotify ${input.path} request timed out after ${Math.ceil(defaultProviderRequestTimeoutMs / 1000)} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error
             ? `Gotify ${input.path} request failed: ${error.message}`
@@ -219,10 +218,10 @@ function readGotifyErrorMessage(payload) {
 }
 function mapGotifyHttpError(status, message, phase) {
     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(400, message);
+        return providerInputError(message);
     }
     if (status === 429) {
         return new ProviderRequestError(429, message);

package/src/providers/greenhouse/executors.js

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import { optionalInteger, 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 = "greenhouse";
 const greenhouseBaseUrl = "https://harvest.greenhouse.io/v1";
 const validationPath = "/users";
@@ -200,13 +200,13 @@ async function mapGreenhouseError(response, phase) {
         ? `Greenhouse API request failed: ${detail}`
         : `Greenhouse API request failed with HTTP ${response.status}`;
     if (phase === "validate" && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 401 || response.status === 403) {
         return new ProviderRequestError(401, 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);

package/src/providers/gumloop/executors.js

@@ -1,9 +1,8 @@
 import { compactObject, objectArray, optionalRecord, optionalString, requiredRecord, requiredString, } from "../../core/cast.js";
-import { defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerResponseError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, } from "../provider-runtime.js";
+import { defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerResponseError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "gumloop";
 const gumloopApiBaseUrl = "https://api.gumloop.com/api/v1";
 const gumloopValidationPath = "/list_saved_items";
-const gumloopDefaultRequestTimeoutMs = 30_000;
 export const gumloopActionHandlers = {
     list_saved_flows(input, context) {
         return listGumloopSavedFlows(input, context);
@@ -231,7 +230,7 @@ async function killGumloopFlowRun(input, context) {
 }
 async function requestGumloopJson(options) {
     const hasJsonBody = options.body !== undefined;
-    const timeoutSignal = AbortSignal.timeout(gumloopDefaultRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
     try {
         const response = await options.fetcher(buildGumloopUrl(options.path, options.query), {

package/src/providers/gumroad/executors.js

@@ -1,9 +1,8 @@
 import { optionalInteger, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "gumroad";
 const gumroadApiBaseUrl = "https://api.gumroad.com/v2";
 const gumroadValidationPath = "/user";
-const gumroadRequestTimeoutMs = 30_000;
 export const gumroadActionHandlers = {
     get_current_user(_input, context) {
         return requestGumroad({
@@ -180,7 +179,7 @@ async function requestGumroad(input) {
     else {
         headers["content-type"] = "application/x-www-form-urlencoded;charset=UTF-8";
     }
-    const timeoutSignal = AbortSignal.timeout(gumroadRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const signal = input.signal ? AbortSignal.any([input.signal, timeoutSignal]) : timeoutSignal;
     try {
         const response = await input.fetcher(url, {

package/src/providers/habitica/executors.js

@@ -1,9 +1,8 @@
 import { compactObject, looseArray, optionalBoolean, optionalBooleanOrNull, optionalInteger, optionalNumber, optionalRecord, optionalRawString, optionalString, rawStringOrNull, requiredRecord, requiredString, } from "../../core/cast.js";
-import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, isAbortLikeError, normalizeProviderProxyHeaders, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, requireApiKeyCredential, requiredInputString, toProviderProxyError, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, isAbortLikeError, normalizeProviderProxyHeaders, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, requireApiKeyCredential, requiredInputString, toProviderProxyError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "habitica";
 const habiticaApiBaseUrl = "https://habitica.com/api/v3";
 const habiticaFetch = createProviderFetch({ skipDnsValidation: true });
-const habiticaDefaultRequestTimeoutMs = 30_000;
 export const habiticaActionHandlers = {
     get_user_profile(input, context) {
         return getUserProfile(input, context);
@@ -295,7 +294,7 @@ async function deleteTag(input, context) {
     };
 }
 async function requestHabitica(input) {
-    const timeoutSignal = AbortSignal.timeout(habiticaDefaultRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const signal = input.signal ? AbortSignal.any([input.signal, timeoutSignal]) : timeoutSignal;
     try {
         const response = await input.fetcher(buildHabiticaUrl(input.path, input.query), {

package/src/providers/hackerrank_work/executors.js

@@ -1,8 +1,7 @@
 import { optionalIntegerLike, optionalRawString, optionalRecord, requiredString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "hackerrank_work";
 const hackerrankWorkApiBaseUrl = "https://www.hackerrank.com/x/api/v3";
-const hackerrankWorkDefaultRequestTimeoutMs = 30_000;
 export const hackerrankWorkActionHandlers = {
     async list_tests(input, context) {
         const payload = await requestHackerrankWorkJson("/tests", context, {
@@ -93,7 +92,7 @@ export const credentialValidators = {
     },
 };
 async function requestHackerrankWorkJson(path, context, query, mode) {
-    const timeoutSignal = AbortSignal.timeout(hackerrankWorkDefaultRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const signal = context.signal ? AbortSignal.any([context.signal, timeoutSignal]) : timeoutSignal;
     try {
         const response = await context.fetcher(buildHackerrankWorkUrl(path, query), {

package/src/providers/harvest/executors.js

@@ -1,12 +1,11 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, isAbortLikeError, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requiredResponseRecord, toProviderProxyError, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, isAbortLikeError, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requiredResponseRecord, toProviderProxyError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 import { harvestOAuthScopes } from "./scopes.js";
 const service = "harvest";
 const harvestApiBaseUrl = "https://api.harvestapp.com";
 const harvestAccountsUrl = "https://id.getharvest.com/api/v2/accounts";
 const harvestFetch = createProviderFetch({ skipDnsValidation: true });
 const harvestValidationPath = "/v2/users/me";
-const harvestRequestTimeoutMs = 30_000;
 export const harvestActionHandlers = {
     get_current_user(_input, context) {
         return getCurrentUser(context);
@@ -407,7 +406,7 @@ async function requestHarvest(input) {
         headers.set("Content-Type", "application/json");
         body = JSON.stringify(input.body);
     }
-    const timeoutSignal = AbortSignal.timeout(harvestRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const signal = input.signal ? AbortSignal.any([input.signal, timeoutSignal]) : timeoutSignal;
     try {
         const response = await input.fetcher(url, {
@@ -470,7 +469,7 @@ async function fetchHarvestCurrentAccount(credential, fetcher, signal) {
     };
 }
 async function requestHarvestAccounts(accessToken, fetcher, signal) {
-    const timeoutSignal = AbortSignal.timeout(harvestRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const resolvedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
     try {
         const response = await fetcher(harvestAccountsUrl, {