@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/jira/trigger-on-issue-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/jira/trigger-on-issue-event.definition.js

@@ -0,0 +1,44 @@
+export const snapshot = {
+    key: "jira.on_issue_event",
+    provider: "jira",
+    name: "on_issue_event",
+    displayName: "Issue or Comment Event",
+    description: "Receives Jira Cloud issue creation, issue updates and new comments through a shared project webhook with automatic renewal.",
+    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: ["jira:issue_created", "jira:issue_updated", "comment_created"],
+                },
+                minItems: 1,
+                maxItems: 3,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["jira:issue_created", "jira:issue_updated", "comment_created"],
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "cloudId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "issueId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/jira/trigger-on-issue-event.js

@@ -0,0 +1,116 @@
+import { jwtVerify } from "jose";
+import { IntegrationConnectionError } from "../../triggers/common/integration.js";
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { webhookRequest } from "../../triggers/managed-webhook.js";
+import { jiraProject } from "../../triggers/sources/jira.js";
+import { snapshot } from "./trigger-on-issue-event.definition.js";
+import { reconcileJiraResource, requireJiraCloud, jiraEvents } from "./trigger-resource.js";
+export const jiraIssueEvents = {
+    snapshot,
+    eventSource: "jira",
+    source: jiraProject,
+    resources: { reconcile: reconcileJiraResource },
+    async sourceIdentity(context) {
+        const cloudId = requireJiraCloud(context.connector);
+        const project = context.config.projectId ?? context.config.project;
+        if (typeof project !== "string" || !project || project.length > 256)
+            throw new PermanentIntegrationError("Choose a Jira project.");
+        const [projectResult, userResult, siteResult] = await Promise.all([
+            webhookRequest(context, { method: "GET", endpoint: `/project/${encodeURIComponent(project)}` }),
+            webhookRequest(context, { method: "GET", endpoint: "/myself" }),
+            webhookRequest(context, { method: "GET", endpoint: "/serverInfo" }),
+        ]);
+        const item = projectResult.data, user = userResult.data, site = siteResult.data;
+        if (!isJsonObject(item) ||
+            typeof item.id !== "string" ||
+            !/^\d+$/.test(item.id) ||
+            typeof item.key !== "string" ||
+            !isJsonObject(user) ||
+            typeof user.accountId !== "string" ||
+            !isJsonObject(site) ||
+            typeof site.baseUrl !== "string")
+            throw new PermanentIntegrationError("Jira did not return a verified project, user and site.");
+        const url = new URL(site.baseUrl);
+        if (url.protocol !== "https:" || url.username || url.password)
+            throw new PermanentIntegrationError("Invalid Jira Cloud site URL.");
+        return {
+            accountId: context.connector.providerAccountId,
+            cloudId,
+            userId: user.accountId,
+            projectId: item.id,
+            projectKey: item.key,
+            siteUrl: url.origin,
+        };
+    },
+    async sourceReceive(context) {
+        const cloudId = requireJiraCloud(context.connector);
+        if (context.config.cloudId !== cloudId)
+            throw new IntegrationConnectionError("The Jira connection belongs to another site.");
+        const authorization = context.headers.authorization ?? "";
+        if (!authorization.startsWith("Bearer "))
+            return { outcome: "unauthorized" };
+        try {
+            await jwtVerify(authorization.slice(7), new TextEncoder().encode(context.connector.oauthClientConfig.clientSecret), { algorithms: ["HS256"], currentDate: context.now, requiredClaims: ["exp"] });
+        }
+        catch {
+            return { outcome: "unauthorized" };
+        }
+        let payload;
+        try {
+            payload = JSON.parse(context.rawBody);
+        }
+        catch {
+            return { outcome: "unauthorized" };
+        }
+        if (!isJsonObject(payload) ||
+            typeof payload.webhookEvent !== "string" ||
+            !jiraEvents.includes(payload.webhookEvent))
+            return { outcome: "ignored" };
+        if (!Array.isArray(payload.matchedWebhookIds) || !payload.matchedWebhookIds.includes(context.config.webhookId))
+            return { outcome: "ignored" };
+        const issue = payload.issue;
+        if (!isJsonObject(issue) ||
+            typeof issue.id !== "string" ||
+            typeof issue.self !== "string" ||
+            !isJsonObject(issue.fields) ||
+            !isJsonObject(issue.fields.project) ||
+            issue.fields.project.id !== context.config.projectId)
+            return { outcome: "ignored" };
+        let issueUrl;
+        try {
+            issueUrl = new URL(issue.self);
+        }
+        catch {
+            return { outcome: "ignored" };
+        }
+        if (issueUrl.origin !== context.config.siteUrl)
+            return { outcome: "ignored" };
+        const id = context.headers["x-atlassian-webhook-identifier"];
+        if (!id || id.length > 256)
+            return { outcome: "unauthorized" };
+        if (payload.webhookEvent === "comment_created" &&
+            (!isJsonObject(payload.comment) || typeof payload.comment.id !== "string"))
+            return { outcome: "unauthorized" };
+        return {
+            outcome: "event",
+            id,
+            type: payload.webhookEvent,
+            payload: { event: payload.webhookEvent, deliveryId: id, cloudId, issueId: issue.id, body: payload },
+        };
+    },
+    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 Jira event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Jira event sources.");
+    },
+};

package/src/providers/jira/trigger-resource.d.ts

@@ -0,0 +1,4 @@
+import type { IntegrationReconcileContext, IntegrationReconcileResult } from "../../triggers/common/integration.ts";
+export declare const jiraEvents: string[];
+export declare function requireJiraCloud(connector: IntegrationReconcileContext["connector"]): string;
+export declare function reconcileJiraResource(context: IntegrationReconcileContext): Promise<IntegrationReconcileResult>;

package/src/providers/jira/trigger-resource.js

@@ -0,0 +1,141 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { webhookRequest } from "../../triggers/managed-webhook.js";
+export const jiraEvents = ["jira:issue_created", "jira:issue_updated", "comment_created"];
+const day = 86_400_000;
+export function requireJiraCloud(connector) {
+    const cloudId = /^jira:([^:]+)(?::|$)/.exec(connector.providerAccountId ?? "")?.[1];
+    if (connector.authType !== "oauth2" || !cloudId || !connector.oauthClientConfig?.clientSecret)
+        throw new IntegrationConnectionError("Jira Cloud OAuth and the matching application client secret are required. Reconnect with webhook permissions.");
+    return cloudId;
+}
+async function webhooks(context) {
+    const items = [];
+    let startAt = 0;
+    for (;;) {
+        const { data } = await webhookRequest(context, {
+            method: "GET",
+            endpoint: "/webhook",
+            query: { startAt, maxResults: 100 },
+        });
+        if (!isJsonObject(data) || !Array.isArray(data.values) || typeof data.isLast !== "boolean")
+            throw new TransientIntegrationError("Invalid Jira webhook page.");
+        for (const item of data.values) {
+            if (!isJsonObject(item) ||
+                !Number.isSafeInteger(item.id) ||
+                Number(item.id) <= 0 ||
+                typeof item.url !== "string" ||
+                typeof item.jqlFilter !== "string" ||
+                !Array.isArray(item.events) ||
+                !item.events.every((event) => typeof event === "string") ||
+                typeof item.expirationDate !== "string")
+                throw new TransientIntegrationError("Invalid Jira webhook record.");
+            const expiresAt = Date.parse(item.expirationDate);
+            if (!Number.isFinite(expiresAt))
+                throw new TransientIntegrationError("Invalid Jira webhook expiration.");
+            items.push({
+                id: Number(item.id),
+                url: item.url,
+                jqlFilter: item.jqlFilter,
+                events: item.events,
+                expiresAt,
+            });
+        }
+        if (data.isLast)
+            return items;
+        if (data.values.length === 0 || data.startAt !== startAt)
+            throw new TransientIntegrationError("Invalid Jira webhook pagination.");
+        startAt += data.values.length;
+    }
+}
+export async function reconcileJiraResource(context) {
+    requireJiraCloud(context.connector);
+    const { projectId } = context.config;
+    if (typeof projectId !== "string" || !/^\d+$/.test(projectId))
+        throw new PermanentIntegrationError("A verified Jira project ID is required.");
+    let endpoint;
+    try {
+        endpoint = new URL(context.endpointUrl);
+    }
+    catch {
+        throw new PermanentIntegrationError("A public HTTPS callback URL is required.");
+    }
+    if (endpoint.protocol !== "https:" || endpoint.username || endpoint.password || endpoint.hash)
+        throw new PermanentIntegrationError("Jira requires a public HTTPS callback without credentials or a fragment.");
+    const now = context.now.getTime();
+    const state = context.state;
+    const saved = state.subscription;
+    if (context.active &&
+        typeof saved.checkedAt === "number" &&
+        typeof saved.expiresAt === "number" &&
+        saved.checkedAt + day > now &&
+        saved.expiresAt - 7 * day > now)
+        return { outcome: "ready" };
+    const save = (value) => state.saveSubscription(value, new Date(now + day));
+    let all = await webhooks(context);
+    const own = () => {
+        const matches = all.filter((item) => item.url === endpoint.href);
+        if (matches.length > 1)
+            throw new PermanentIntegrationError("Multiple Jira webhooks use this source callback. Resolve the duplicate subscriptions before retrying.");
+        return matches[0];
+    };
+    let hook = own();
+    if (!context.active) {
+        if (hook)
+            await webhookRequest(context, { method: "DELETE", endpoint: "/webhook", body: { webhookIds: [hook.id] } });
+        else if (saved.creating === true)
+            throw new PermanentIntegrationError("Jira registration is still uncertain. Confirm the remote webhook before cleanup.", "trigger_subscription_uncertain");
+        await save({});
+        return { outcome: "ready" };
+    }
+    if (!hook) {
+        if (saved.creating === true)
+            throw new PermanentIntegrationError("Jira registration is uncertain and no matching webhook is visible. Retry after checking Jira; do not create another source.", "trigger_subscription_uncertain");
+        if (all.length >= 5)
+            throw new PermanentIntegrationError("Jira OAuth webhook quota reached: five subscriptions per application, user and site. Remove an unused subscription, then retry.", "trigger_quota_exceeded");
+        await save({ creating: true });
+        const result = await context.connector.execute({
+            method: "POST",
+            endpoint: "/webhook",
+            body: { url: endpoint.href, webhooks: [{ jqlFilter: `project = ${projectId}`, events: jiraEvents }] },
+        }, context.signal);
+        context.signal?.throwIfAborted();
+        if (result.status < 200 || result.status >= 300) {
+            if (result.status >= 400 && result.status < 500)
+                await save({});
+            const message = `Jira webhook registration failed (HTTP ${result.status}). Check OAuth scopes, callback domain and webhook quota.`;
+            if (result.status === 429 || result.status >= 500)
+                throw new TransientIntegrationError(message);
+            throw new PermanentIntegrationError(message);
+        }
+        const results = isJsonObject(result.data) ? result.data.webhookRegistrationResult : undefined;
+        if (!Array.isArray(results) || results.length !== 1 || !isJsonObject(results[0]))
+            throw new TransientIntegrationError("Jira registration returned no confirmed webhook ID.");
+        const created = results[0];
+        if (Array.isArray(created.errors) && created.errors.length) {
+            await save({});
+            throw new PermanentIntegrationError(`Jira rejected the webhook: ${created.errors.filter((value) => typeof value === "string").join("; ")}`);
+        }
+        if (!Number.isSafeInteger(created.createdWebhookId) || Number(created.createdWebhookId) <= 0)
+            throw new TransientIntegrationError("Jira registration returned no confirmed webhook ID.");
+        await save({ creating: true, webhookId: Number(created.createdWebhookId) });
+        all = await webhooks(context);
+        hook = own();
+        if (!hook || hook.id !== created.createdWebhookId)
+            throw new TransientIntegrationError("The newly registered Jira webhook is not yet visible.");
+    }
+    if (hook.jqlFilter !== `project = ${projectId}` ||
+        hook.events.length !== jiraEvents.length ||
+        !jiraEvents.every((event) => hook.events.includes(event)))
+        throw new PermanentIntegrationError("The Jira webhook no longer matches this source's project and events. Remove the source subscription before recreating it.");
+    if (hook.expiresAt - 7 * day <= now) {
+        await webhookRequest(context, { method: "PUT", endpoint: "/webhook/refresh", body: { webhookIds: [hook.id] } });
+        const previousId = hook.id;
+        all = await webhooks(context);
+        hook = own();
+        if (!hook || hook.id !== previousId || hook.expiresAt - 7 * day <= now)
+            throw new TransientIntegrationError("Jira did not confirm the renewed webhook expiration.");
+    }
+    await save({ webhookId: hook.id, expiresAt: hook.expiresAt, checkedAt: now });
+    return { outcome: "ready" };
+}

package/src/providers/kaleido/runtime.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { isAbortLikeError, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 import { kaleidoDefaultBaseUrl } from "./constants.js";
 const membershipsValidationPath = "/memberships";
 export const kaleidoActionHandlers = {
@@ -156,7 +156,7 @@ async function normalizeKaleidoError(response) {
         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 || 500, message);
 }

package/src/providers/kandji/runtime.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent, runProviderRequest } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, runProviderRequest, providerInputError, } from "../provider-runtime.js";
 export const kandjiActionHandlers = {
     async list_blueprints(input, context) {
         const payload = await requestKandjiJson({
@@ -186,7 +186,7 @@ function createKandjiError(status, payload, phase, notFoundAsInvalidInput) {
         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) {
         return new ProviderRequestError(401, message);

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

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;
+export declare const credentialValidators: CredentialValidators;

package/src/providers/keenable/executors.js

@@ -0,0 +1,20 @@
+import { defineProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { createKeenableContext, keenableActionHandlers, keenableApiBaseUrl, keenableAppTitle, validateKeenableCredential, } from "./runtime.js";
+const service = "keenable";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: keenableActionHandlers,
+    createContext: createKeenableContext,
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: keenableApiBaseUrl,
+    auth: { type: "optional_api_key_header", name: "X-API-Key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("x-keenable-title"))
+            headers.set("x-keenable-title", keenableAppTitle);
+    },
+});
+export const credentialValidators = { apiKey: validateKeenableCredential };

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

@@ -0,0 +1,26 @@
+import type { CredentialValidationResult, ExecutionContext } from "../../core/types.ts";
+import type { ProviderFetch } from "../provider-runtime.ts";
+export declare const keenableApiBaseUrl = "https://api.keenable.ai";
+/** Keenable requires keyless callers to name their app in the X-Keenable-Title header. */
+export declare const keenableAppTitle = "OpenConnector";
+interface KeenableContext {
+    apiKey?: string;
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type KeenableActionHandler = (input: Record<string, unknown>, context: KeenableContext) => Promise<unknown>;
+export declare const keenableActionHandlers: Record<string, KeenableActionHandler>;
+/**
+ * Build the action context. A no_auth connection has no key and uses the keyless endpoints.
+ */
+export declare function createKeenableContext(context: ExecutionContext, fetcher: ProviderFetch): Promise<KeenableContext>;
+/**
+ * Validate a key through a one-result search on the keyed endpoint.
+ */
+export declare function validateKeenableCredential(input: {
+    apiKey: string;
+}, options: {
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}): Promise<CredentialValidationResult>;
+export {};

package/src/providers/keenable/runtime.js

@@ -0,0 +1,89 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { parseProviderJsonBodyText, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredResponseRecord, runProviderRequest, setSearchParams, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const keenableApiBaseUrl = "https://api.keenable.ai";
+/** Keenable requires keyless callers to name their app in the X-Keenable-Title header. */
+export const keenableAppTitle = "OpenConnector";
+export const keenableActionHandlers = {
+    search(input, context) {
+        return requestKeenable({
+            context,
+            method: "POST",
+            path: context.apiKey ? "/v1/search" : "/v1/search/public",
+            body: input,
+        });
+    },
+    fetch(input, context) {
+        const query = Object.fromEntries(Object.entries(input)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => [key, String(value)]));
+        return requestKeenable({ context, method: "GET", path: context.apiKey ? "/v1/fetch" : "/v1/fetch/public", query });
+    },
+};
+/**
+ * Build the action context. A no_auth connection has no key and uses the keyless endpoints.
+ */
+export async function createKeenableContext(context, fetcher) {
+    const credential = await context.getCredential("keenable");
+    return {
+        apiKey: credential?.authType === "api_key" ? credential.apiKey : undefined,
+        fetcher,
+        signal: context.signal,
+    };
+}
+/**
+ * Validate a key through a one-result search on the keyed endpoint.
+ */
+export async function validateKeenableCredential(input, options) {
+    await requestKeenable({
+        context: { apiKey: input.apiKey, fetcher: options.fetcher, signal: options.signal },
+        method: "POST",
+        path: "/v1/search",
+        body: { query: "Keenable", max_results: 1 },
+    });
+    return {
+        profile: { displayName: "Keenable API Key" },
+        grantedScopes: [],
+        metadata: { apiBaseUrl: keenableApiBaseUrl, validationEndpoint: "/v1/search" },
+    };
+}
+async function requestKeenable(request) {
+    const { context } = request;
+    const url = new URL(request.path, keenableApiBaseUrl);
+    setSearchParams(url, request.query ?? {});
+    const headers = new Headers({
+        accept: "application/json",
+        "user-agent": providerUserAgent,
+        "x-keenable-title": keenableAppTitle,
+    });
+    if (context.apiKey)
+        headers.set("x-api-key", context.apiKey);
+    if (request.body)
+        headers.set("content-type", "application/json");
+    return runProviderRequest({ signal: context.signal, label: "Keenable" }, async (signal) => {
+        const response = await context.fetcher(url, {
+            method: request.method,
+            headers,
+            body: request.body ? JSON.stringify(request.body) : undefined,
+            signal,
+        });
+        if (!response.ok) {
+            throw await readKeenableError(response);
+        }
+        const payload = parseProviderJsonBodyText(await readProviderTextBody(response, "Keenable response"), {
+            emptyBody: {},
+            invalidJsonMessage: "Keenable returned malformed JSON",
+        });
+        return requiredResponseRecord(payload, "Keenable response");
+    });
+}
+async function readKeenableError(response) {
+    const status = response.status;
+    const body = optionalRecord(parseProviderJsonBodyText(await readProviderErrorTextBody(response, "Keenable error response"), {
+        emptyBody: {},
+        invalidJsonMessage: "Keenable returned malformed JSON",
+        invalidJsonFallback: () => ({}),
+    }));
+    const message = optionalString(body?.message) ?? optionalString(body?.error) ?? `Keenable request failed with HTTP ${status}`;
+    const details = withRetryAfterSeconds(response, body ?? {});
+    return new ProviderRequestError(status, message, details, status === 429 ? "rate_limited" : "provider_error");
+}

package/src/providers/keygen/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { defineProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, requireApiKeyCredential, } from "../provider-runtime.js";
+import { defineProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, requireApiKeyCredential, providerInputError, } from "../provider-runtime.js";
 const keygenApiBaseUrl = "https://api.keygen.sh/v1/accounts";
 const keygenValidationPath = "/me";
 const service = "keygen";
@@ -529,16 +529,16 @@ function createKeygenError(response, payload, phase, usedAuth) {
         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" && usedAuth && (response.status === 401 || response.status === 403)) {
         return new ProviderRequestError(401, message);
     }
     if (phase === "execute" && !usedAuth && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if ([400, 404, 422].includes(response.status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 500, message);
 }

package/src/providers/keyword/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError, runProviderRequest } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, runProviderRequest, providerInputError, } from "../provider-runtime.js";
 export const keywordApiBaseUrl = "https://app.keyword.com";
 const keywordApiPathPrefix = "/api/v2";
 export const keywordActionHandlers = {
@@ -105,7 +105,7 @@ function createKeywordError(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);
     }
     return new ProviderRequestError(response.status || 502, message);
 }

package/src/providers/kie_ai/executors.js

@@ -103,7 +103,7 @@ function mapKieAiError(code, message, status) {
         case 403:
             return new ProviderRequestError(401, message);
         case 422:
-            return new ProviderRequestError(400, message);
+            return providerInputError(message);
         case 429:
             return new ProviderRequestError(429, message);
         default:

package/src/providers/kintone/runtime.js

@@ -184,7 +184,7 @@ function createKintoneError(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) {
         return new ProviderRequestError(401, message);

package/src/providers/kit/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, looseArray, optionalBoolean, optionalNumber, optionalRecord, optionalString, } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError, runProviderRequest } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, runProviderRequest, providerInputError, } from "../provider-runtime.js";
 const kitApiBaseUrl = "https://api.kit.com/v4";
 export const kitActionHandlers = {
     async get_current_account(_input, context) {
@@ -229,7 +229,7 @@ function createKitError(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) {
         return new ProviderRequestError(401, message);

package/src/providers/klangio/runtime.js

@@ -1,6 +1,6 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes, storeResponseInTransit } from "../../core/request.js";
-import { providerFetch, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerFetch, providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 export const klangioApiBaseUrl = "https://api.klang.io";
 const klangioValidationJobId = "00000000-0000-0000-0000-000000000000";
 const maxKlangioUploadSourceBytes = 100 * 1024 * 1024;
@@ -208,7 +208,7 @@ async function resolveKlangioUploadSource(value, context) {
     if (fileUrl) {
         const url = assertPublicHttpUrl(fileUrl, {
             fieldName: "file.url",
-            createError: (message) => new ProviderRequestError(400, message),
+            createError: providerInputError,
         });
         const response = await providerFetch(url, {
             method: "GET",
@@ -255,7 +255,7 @@ async function readKlangioUploadSourceBytes(response) {
     return readBoundedResponseBytes(response, {
         maxBytes: maxKlangioUploadSourceBytes,
         fieldName: "klangio upload source",
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
     });
 }
 function assertUploadSourceSize(byteLength) {
@@ -321,7 +321,7 @@ function createKlangioError(response, payload) {
         return new ProviderRequestError(429, message);
     }
     if (response.status >= 400 && response.status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 500, message);
 }

package/src/providers/klaviyo/executors.js

@@ -272,7 +272,7 @@ function mapKlaviyoHttpError(status, payload, rawBody, phase) {
         return new ProviderRequestError(phase === "validate" ? 400 : 401, message);
     }
     if (status === 400 || status === 404 || status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 429) {
         return new ProviderRequestError(429, message);

package/src/providers/klazify/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, runProviderRequest, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, runProviderRequest, providerInputError, } from "../provider-runtime.js";
 const service = "klazify";
 const klazifyApiBaseUrl = "https://www.klazify.com/api";
 export const klazifyActionHandlers = {
@@ -260,11 +260,11 @@ function createKlazifyError(status, payload, phase) {
             return new ProviderRequestError(401, message);
         }
         if (normalizedMessage.includes("/unreachable") || normalizedMessage.includes("/no indexable content")) {
-            return new ProviderRequestError(400, message);
+            return providerInputError(message);
         }
     }
     if (phase === "validate" && status < 400) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status || 500, message);
 }