@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/simla/runtime.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const simlaValidationPath = "/api/credentials";
 export const simlaActionHandlers = {
     list_orders(input, context) {
@@ -65,7 +65,7 @@ export function normalizeSimlaApiBaseUrl(input) {
     }
     const parsed = assertPublicHttpUrl(raw, {
         fieldName: "apiBaseUrl",
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
     });
     if (parsed.protocol !== "https:") {
         throw new ProviderRequestError(400, "apiBaseUrl must use https");
@@ -369,15 +369,15 @@ function mapSimlaError(input) {
         return new ProviderRequestError(429, message);
     }
     if (input.status === 404 && input.notFoundAsInvalidInput) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (input.status === 401 || input.status === 403) {
         return new ProviderRequestError(input.mode === "validate" ? 400 : 401, message);
     }
     if (input.status >= 400 && input.status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function extractSimlaErrorMessage(payload) {
     const errorMsg = optionalString(payload.errorMsg);

package/src/providers/simplybook_me/executors.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { createProviderTimeout, defineProviderExecutors, providerUserAgent, ProviderRequestError, readProviderJsonBody, requireApiKeyCredential, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, providerUserAgent, ProviderRequestError, readProviderJsonBody, requireApiKeyCredential, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const service = "simplybook_me";
 const simplybookMeApiBaseUrl = "https://user-api.simplybook.me";
 const simplybookMeLoginUrl = `${simplybookMeApiBaseUrl}/login`;
@@ -167,9 +167,9 @@ function mapJsonRpcError(error) {
         return new ProviderRequestError(401, message);
     }
     if (code === -32602 || code === -32080 || code === -32085 || code === -32001) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function mapHttpError(status, message) {
     if (status === 429) {
@@ -193,7 +193,7 @@ function requireCompanyLogin(value) {
 function requireObjectPayload(value, message) {
     const record = optionalRecord(value);
     if (!record) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return record;
 }
@@ -205,12 +205,12 @@ function normalizeObjectList(value, message) {
 }
 function normalizeIntegerList(value, message) {
     if (!Array.isArray(value)) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return value.map((item) => {
         const parsed = Number(item);
         if (!Number.isInteger(parsed)) {
-            throw new ProviderRequestError(502, message);
+            throw providerResponseError(message);
         }
         return parsed;
     });

package/src/providers/sitespeakai/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError, requiredResponseRecord } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, requiredResponseRecord, providerInputError, } from "../provider-runtime.js";
 export const sitespeakaiApiBaseUrl = "https://api.sitespeak.ai";
 export const sitespeakaiApiVersion = "v1";
 export const sitespeakaiActionHandlers = {
@@ -166,13 +166,13 @@ function createSitespeakaiError(response, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && (response.status === 401 || response.status === 403)) {
         return new ProviderRequestError(401, message);
     }
     if (response.status === 400 || response.status === 404 || response.status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 500, message);
 }

package/src/providers/slack/runtime.d.ts

@@ -2,11 +2,16 @@ import type { CredentialValidators, ProviderExecutors } from "../../core/types.t
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { OAuthProviderContext } from "../provider-runtime.ts";
 export declare const slackApiBaseUrl = "https://slack.com/api";
-type SlackActionContext = Omit<OAuthProviderContext, "providerSecret" | "tokenType">;
+interface SlackActionContext extends Omit<OAuthProviderContext, "providerSecret" | "tokenType"> {
+    /** Stored OAuth response metadata; empty for API-key credentials. */
+    metadata: Record<string, unknown>;
+}
 type SlackOAuthTokenKind = "bot" | "user";
 export type SlackActionHandler = (input: Record<string, unknown>, context: SlackActionContext) => Promise<unknown>;
 /** Build Slack executors that reject credentials issued for the other authorization path. */
 export declare function defineSlackProviderExecutors(service: "slack" | "slackbot", tokenKind: SlackOAuthTokenKind, handlers: Record<string, SlackActionHandler>): ProviderExecutors;
 export declare const slackActionHandlers: ProviderActionHandlers<"slack", SlackActionHandler>;
 export declare const slackCredentialValidators: CredentialValidators;
+/** Read the workspace and installer from stored OAuth metadata. */
+export declare function slackbotInstallationHandler(_input: Record<string, unknown>, context: SlackActionContext): Promise<unknown>;
 export {};

package/src/providers/slack/runtime.js

@@ -12,11 +12,13 @@ export function defineSlackProviderExecutors(service, tokenKind, handlers) {
         async createContext(context, fetcher) {
             const credential = await context.getCredential(service);
             let accessToken;
+            let metadata = {};
             if (credential?.authType === "oauth2") {
                 if (readSlackTokenKind(credential.accessToken, credential.metadata) != tokenKind) {
                     throw new ProviderRequestError(401, `Reconnect ${service} with ${tokenKind} authorization before running its actions.`);
                 }
                 accessToken = credential.accessToken;
+                metadata = credential.metadata;
             }
             else if (credential?.authType === "api_key") {
                 // A pasted token was authorized by no OAuth flow, so the user/bot flow
@@ -31,6 +33,7 @@ export function defineSlackProviderExecutors(service, tokenKind, handlers) {
             const providerContext = {
                 accessToken,
                 fetcher,
+                metadata,
                 signal: context.signal,
             };
             if (context.transitFiles) {
@@ -176,6 +179,24 @@ async function slackGetCurrentUser(context) {
     const identity = readSlackAuthTestIdentity(await slackAuthTest(context));
     return { teamId: identity.teamId, userId: identity.userId, isBot: identity.botId !== undefined };
 }
+/** Read the workspace and installer from stored OAuth metadata. */
+export async function slackbotInstallationHandler(_input, context) {
+    const team = optionalRecord(context.metadata.team);
+    const authedUser = optionalRecord(context.metadata.authed_user);
+    const teamId = optionalString(team?.id);
+    const authedUserId = optionalString(authedUser?.id);
+    const botUserId = optionalString(context.metadata.bot_user_id);
+    if (!teamId || !authedUserId || !botUserId) {
+        return null;
+    }
+    return {
+        teamId,
+        teamName: optionalString(team?.name) ?? null,
+        authedUserId,
+        botUserId,
+        appId: optionalString(context.metadata.app_id) ?? null,
+    };
+}
 async function slackListChannels(input, context) {
     const url = slackApiUrl("conversations.list");
     if (input.limit != null) {

package/src/providers/slackbot/actions.js

@@ -1,7 +1,8 @@
+import { s } from "../../core/json-schema.js";
 import { defineProviderAction } from "../../core/provider-definition.js";
 import { slackActions } from "../slack/actions.js";
 const service = "slackbot";
-export const slackbotActions = slackActions
+const sharedActions = slackActions
     .filter((action) => action.name != "search_messages" && action.name != "search_context" && action.name != "get_current_user")
     .map((action) => defineProviderAction(service, {
     name: action.name,
@@ -11,3 +12,18 @@ export const slackbotActions = slackActions
     inputSchema: action.inputSchema,
     outputSchema: action.outputSchema,
 }));
+const getInstallation = defineProviderAction(service, {
+    name: "get_installation",
+    operationType: "read",
+    description: "Get the workspace and authorizing user from stored OAuth metadata. This information is available only for OAuth connections. Returns null for API-key connections or incomplete OAuth metadata. OAuth credentials may be refreshed before execution.",
+    requiredScopes: [],
+    inputSchema: s.object({}),
+    outputSchema: s.nullable(s.object({
+        teamId: s.nonEmptyString("The Slack workspace ID the app was installed in."),
+        teamName: s.nullable(s.string({ description: "The workspace display name, when the install carried one." })),
+        authedUserId: s.nonEmptyString("The Slack user ID of the person who approved the install."),
+        botUserId: s.nonEmptyString("The Slack user ID of the app's bot user."),
+        appId: s.nullable(s.string({ description: "The Slack app ID, when the install carried one." })),
+    }, { required: ["teamId", "teamName", "authedUserId", "botUserId", "appId"] })),
+});
+export const slackbotActions = [...sharedActions, getInstallation];

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

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

package/src/providers/slackbot/executors.js

@@ -1,8 +1,11 @@
 import { getProviderActionHandler, mapProviderActionHandlers } from "../provider-runtime.js";
-import { defineSlackProviderExecutors, slackActionHandlers, slackCredentialValidators } from "../slack/runtime.js";
+import { defineSlackProviderExecutors, slackActionHandlers, slackbotInstallationHandler, slackCredentialValidators, } from "../slack/runtime.js";
 import { slackbotActions } from "./actions.js";
+import { slackBotEvents } from "./trigger-on-event.js";
 const service = "slackbot";
 const slackbotActionHandlers = mapProviderActionHandlers(service, slackbotActions, (action) => {
+    if (action.name === "get_installation")
+        return slackbotInstallationHandler;
     const handler = getProviderActionHandler(slackActionHandlers, action.name);
     if (!handler) {
         throw new Error(`Missing shared Slack handler for action: ${action.name}`);
@@ -11,3 +14,4 @@ const slackbotActionHandlers = mapProviderActionHandlers(service, slackbotAction
 });
 export const executors = defineSlackProviderExecutors(service, "bot", slackbotActionHandlers);
 export const credentialValidators = slackCredentialValidators;
+export const triggers = [slackBotEvents];

package/src/providers/slackbot/trigger-on-event.d.ts

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

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

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/slackbot/trigger-on-event.definition.js

@@ -0,0 +1,57 @@
+export const snapshot = {
+    key: "slackbot.on_event",
+    provider: "slackbot",
+    name: "on_event",
+    displayName: "Mention or Direct Message",
+    description: "Receives user mentions and new direct messages through a shared Slack application event source. Slack Connect events are excluded.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "sourceId",
+            jsonSchema: { type: "string", pattern: "^source_[0-9a-f]{32}$", title: "Event source" },
+            nullable: false,
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", enum: ["app_mention", "message.im"] },
+                minItems: 1,
+                maxItems: 2,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["app_mention", "message.im"],
+        },
+        {
+            handle: "channelIds",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", minLength: 1 },
+                maxItems: 100,
+                uniqueItems: true,
+                title: "Channel IDs",
+            },
+            nullable: true,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "appId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "teamId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "channel", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "user", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "text", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "ts", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "threadTs", jsonSchema: { type: "string" }, nullable: true },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/slackbot/trigger-on-event.js

@@ -0,0 +1,23 @@
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { slackApplication } from "../../triggers/sources/slack.js";
+import { snapshot } from "./trigger-on-event.definition.js";
+export const slackBotEvents = {
+    snapshot,
+    eventSource: "slack",
+    source: slackApplication,
+    receive(context) {
+        if (context.eventSourceId !== context.config.sourceId)
+            return { outcome: "respond", status: 404, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) ||
+            typeof payload.deliveryId !== "string" ||
+            !payload.deliveryId ||
+            !isJsonObject(payload.body))
+            throw new PermanentIntegrationError("Invalid shared Slack event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Slack event sources.");
+    },
+};

package/src/providers/slickdeals/runtime.js

@@ -1,7 +1,6 @@
 import { optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, defaultProviderRequestTimeoutMs } from "../provider-runtime.js";
 export const slickdealsApiBaseUrl = "https://api-syn.slickdeals.net/sdapi/syndication/1";
-const slickdealsRequestTimeoutMs = 30_000;
 export const slickdealsActionHandlers = {
     async list_articles(input, { apiKey: token, fetcher, signal }) {
         const payload = await requestSlickdealsJson({
@@ -145,7 +144,7 @@ function toQueryRecord(input) {
     return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, value]));
 }
 async function requestSlickdealsJson(input) {
-    const timeoutSignal = AbortSignal.timeout(slickdealsRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const signal = input.signal ? AbortSignal.any([input.signal, timeoutSignal]) : timeoutSignal;
     try {
         const response = await input.fetcher(buildSlickdealsUrl(input.path, input.query), {

package/src/providers/smartsuite/runtime.js

@@ -1,6 +1,6 @@
 import { optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
 import { jsonObject } from "../../core/request.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const smartsuiteApiBaseUrl = "https://app.smartsuite.com/api/v1";
 export async function validateSmartsuiteCredential(input, fetcher) {
     const workspaceId = readWorkspaceId(input);
@@ -173,9 +173,9 @@ function createSmartsuiteError(response, payload, phase) {
         return new ProviderRequestError(phase === "validate" ? 400 : 401, message);
     }
     if (400 <= response.status && response.status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function readWorkspaceId(input) {
     return readRequiredString(input?.workspaceId, "workspaceId");

package/src/providers/sonarcloud/runtime.js

@@ -1,5 +1,5 @@
 import { objectArray, optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredRecord, requiredStringArray, } from "../../core/cast.js";
-import { providerInputError, providerUserAgent, ProviderRequestError, readProviderTextBody, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+import { providerInputError, providerUserAgent, ProviderRequestError, readProviderTextBody, requiredInputString, runProviderRequest, providerResponseError, } from "../provider-runtime.js";
 import { sonarCloudAllowedApiBaseUrls, sonarCloudDefaultApiBaseUrl } from "./constants.js";
 const maxResponseBytes = 10 * 1024 * 1024;
 export const sonarCloudActionHandlers = {
@@ -152,7 +152,7 @@ function createSonarCloudError(status, payload, phase) {
     if (status === 429)
         return new ProviderRequestError(429, message);
     if (phase === "validate" && status >= 400 && status < 500)
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     if (status >= 400 && status < 500)
         return new ProviderRequestError(status, message);
     return new ProviderRequestError(status || 502, message);
@@ -335,15 +335,15 @@ function stringifyOptionalBoolean(value) {
     return booleanValue === undefined ? undefined : String(booleanValue);
 }
 function readProviderRecord(value, message) {
-    return requiredRecord(value, "response", () => new ProviderRequestError(502, message));
+    return requiredRecord(value, "response", () => providerResponseError(message));
 }
 function readProviderRecords(value, message) {
-    return objectArray(value, "response", () => new ProviderRequestError(502, message));
+    return objectArray(value, "response", () => providerResponseError(message));
 }
 function readProviderString(value, message) {
     const stringValue = optionalString(value);
     if (stringValue === undefined)
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     return stringValue;
 }
 function providerError(message) {

package/src/providers/sorftime/runtime.js

@@ -1,6 +1,6 @@
 import { gunzipSync, inflateRawSync, inflateSync } from "node:zlib";
 import { compactObject, optionalInteger, optionalNumber, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const sorftimeApiBaseUrl = "https://cli.sorftime.com/api/";
 const endpointByActionName = {
     get_product_details: "ProductRequest",
@@ -42,7 +42,7 @@ export async function validateSorftimeCredential(input, fetcher) {
         endpoint: "RequestStreamMonth",
         domain: 1,
         body: {},
-        apiKey: requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message)),
+        apiKey: requiredString(input.apiKey, "apiKey", providerInputError),
         fetcher,
         phase: "validate",
     });
@@ -171,7 +171,7 @@ function requireStartWhenEnd(input, start, end) {
 }
 function requireOrdered(input, start, end, message = `${start} must not be later than ${end}`) {
     if (typeof input[start] === "string" && typeof input[end] === "string" && input[start] > input[end]) {
-        throw new ProviderRequestError(400, message);
+        throw providerInputError(message);
     }
 }
 function buildSorftimeBody(actionName, input) {
@@ -463,23 +463,23 @@ function createSorftimeHttpError(response, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (response.status === 401 || response.status === 403) {
-        return phase === "validate" ? new ProviderRequestError(400, message) : new ProviderRequestError(401, message);
+        return phase === "validate" ? providerInputError(message) : new ProviderRequestError(401, message);
     }
     if (phase === "execute" && [400, 404, 422].includes(response.status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 502, message);
 }
 function createSorftimeBusinessError(code, message, phase) {
     const detail = message ?? `Sorftime request failed with code ${code}`;
     if (phase === "validate") {
-        return new ProviderRequestError(400, detail);
+        return providerInputError(detail);
     }
     if ([500, 501, 502].includes(code)) {
         return new ProviderRequestError(429, detail);
     }
     if ([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 97].includes(code)) {
-        return new ProviderRequestError(400, detail);
+        return providerInputError(detail);
     }
     if ([4, 694].includes(code)) {
         return new ProviderRequestError(402, detail);
@@ -490,7 +490,7 @@ function createSorftimeBusinessError(code, message, phase) {
     if ([400, 401, 402].includes(code)) {
         return new ProviderRequestError(403, detail);
     }
-    return new ProviderRequestError(502, detail);
+    return providerResponseError(detail);
 }
 function extractSorftimeMessage(payload) {
     if (!payload) {

package/src/providers/spider/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { createProviderTimeout, providerUserAgent, ProviderRequestError, providerInputError, } from "../provider-runtime.js";
 export const spiderApiBaseUrl = "https://api.spider.cloud";
 const requestTimeoutMs = 60_000;
 export const spiderActionHandlers = {
@@ -99,7 +99,7 @@ function createSpiderError(status, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 401 || status === 403) {
         return new ProviderRequestError(401, message);

package/src/providers/splunk_http_event_collector/runtime.js

@@ -1,8 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { compactObject, optionalInteger, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
 import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
-const splunkHecRequestTimeoutMs = 30_000;
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const splunkHttpEventCollectorActionHandlers = {
     send_event(input, fetcher) {
         const channel = optionalString(input.input.channel);
@@ -45,7 +44,7 @@ export const splunkHttpEventCollectorActionHandlers = {
     },
 };
 export async function validateSplunkHttpEventCollectorCredential(input, fetcher) {
-    const credential = resolveCredential(requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message)), input.baseUrl);
+    const credential = resolveCredential(requiredString(input.apiKey, "apiKey", providerInputError), input.baseUrl);
     await requestSplunkHec({
         credential,
         path: "/services/collector/event",
@@ -78,7 +77,7 @@ export async function executeSplunkHttpEventCollectorAction(input, fetcher) {
     return handler(input, fetcher);
 }
 async function requestSplunkHec(input) {
-    const timeout = createProviderTimeout(undefined, splunkHecRequestTimeoutMs);
+    const timeout = createProviderTimeout(undefined);
     const url = buildSplunkHecUrl(input.credential.baseUrl, input.path, input.query);
     try {
         const headers = {
@@ -118,7 +117,7 @@ async function requestSplunkHec(input) {
             throw error;
         }
         if (timeout.didTimeout()) {
-            throw new ProviderRequestError(504, `Splunk HEC request timed out after ${Math.ceil(splunkHecRequestTimeoutMs / 1000)} seconds`);
+            throw new ProviderRequestError(504, `Splunk HEC 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, `Splunk HEC request failed: ${message}`);
@@ -147,7 +146,7 @@ export function normalizeSplunkHecBaseUrl(value, allowPrivateNetwork = isPrivate
     }
     const url = assertPublicHttpUrl(rawValue, {
         fieldName: "baseUrl",
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
         allowPrivateNetwork,
     });
     if (url.protocol !== "https:") {
@@ -200,13 +199,13 @@ function readSplunkHecMessage(payload) {
 }
 function mapSplunkHecError(status, code, message, phase) {
     if (phase === "validate" && (status === 401 || status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && (status === 401 || status === 403 || code === 4 || code === 21 || code === 22)) {
         return new ProviderRequestError(401, message);
     }
     if (status === 400 || status === 404) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 429) {
         return new ProviderRequestError(429, message);

package/src/providers/sportsdata/runtime.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError, readProviderJsonBody, runProviderRequest, } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, readProviderJsonBody, runProviderRequest, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const sportsdataApiBaseUrl = "https://api.sportsdata.io";
 const apiKeyHeader = "Ocp-Apim-Subscription-Key";
 export const sportsdataActionHandlers = {
@@ -81,12 +81,12 @@ function createSportsdataError(status, payload, phase) {
     if (status === 429)
         return new ProviderRequestError(429, message);
     if (phase === "validate" && 400 <= status && status < 500)
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     if (status === 401 || status === 403)
         return new ProviderRequestError(status, message);
     if (400 <= status && status < 500)
-        return new ProviderRequestError(400, message);
-    return new ProviderRequestError(502, message);
+        return providerInputError(message);
+    return providerResponseError(message);
 }
 function segment(value) {
     return encodeURIComponent(String(value));

package/src/providers/spyfu/runtime.js

@@ -1,5 +1,5 @@
 import { optionalBoolean, optionalInteger as asOptionalInteger, optionalNumber as asOptionalNumber, optionalRecord as asOptionalObject, optionalString as asOptionalString, } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 function requiredApiKey(input) {
     if (input.apiKey?.trim())
         return input.apiKey.trim();
@@ -7,7 +7,6 @@ function requiredApiKey(input) {
 }
 export const spyfuApiBaseUrl = "https://api.spyfu.com";
 export const spyfuProxyBaseUrl = `${spyfuApiBaseUrl}/apis`;
-const spyfuDefaultRequestTimeoutMs = 30_000;
 export const spyfuActionHandlers = {
     async get_monthly_usage(input, fetcher, apiKey) {
         const usageMonth = readUsageMonth(input.usageMonth);
@@ -448,7 +447,7 @@ function buildSharedKeywordQuery(input) {
     };
 }
 async function requestSpyfuJson(input) {
-    const timeoutSignal = AbortSignal.timeout(spyfuDefaultRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const method = input.method ?? "GET";
     const url = new URL(input.path, spyfuApiBaseUrl);
     url.searchParams.set("api_key", input.apiKey);
@@ -505,13 +504,13 @@ function createSpyfuError(response, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && response.status >= 400 && response.status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && (response.status === 401 || response.status === 403)) {
         return new ProviderRequestError(401, message);
     }
     if (phase === "execute" && response.status >= 400 && response.status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 500, message);
 }

package/src/providers/square/runtime.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalRecord, optionalString, requiredRecord, requiredString } from "../../core/cast.js";
 import { encodePathSegment } from "../../core/request.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 export const squareApiBaseUrl = "https://connect.squareup.com";
 export const squareApiVersion = "2026-05-20";
 export const squareActionHandlers = {
@@ -162,7 +162,7 @@ function createSquareError(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 === "execute" && (status === 401 || status === 403)) {
         return new ProviderRequestError(status, message);
@@ -191,7 +191,7 @@ function normalizeCustomerPage(payload) {
     };
 }
 function customerRequestBody(input) {
-    const customer = requiredRecord(input.customer, "customer", (message) => new ProviderRequestError(400, message));
+    const customer = requiredRecord(input.customer, "customer", providerInputError);
     return compactObject({
         ...customer,
         idempotency_key: input.idempotency_key,
@@ -201,7 +201,7 @@ function pickQuery(input, keys) {
     return Object.fromEntries(keys.flatMap((key) => (input[key] === undefined ? [] : [[key, input[key]]])));
 }
 function requiredInputString(input, fieldName) {
-    return requiredString(input[fieldName], fieldName, (message) => new ProviderRequestError(400, message));
+    return requiredString(input[fieldName], fieldName, providerInputError);
 }
 function requireResponseObject(payload, fieldName, label) {
     const record = asRecord(payload, label);