@oomol-lab/open-connector 1.9.1 → 1.9.3

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

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

package/src/providers/ploid/executors.js

@@ -0,0 +1,119 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { requiredResponseRecord, runProviderRequest, ProviderRequestError, providerInputError, providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { ploidActions } from "./actions.js";
+import { ploidEndpointByName } from "./actions.js";
+const baseUrl = "https://api.ploid.com";
+async function request(apiKey, name, input, fetcher, parentSignal) {
+    const endpoint = ploidEndpointByName.get(name);
+    let path = endpoint.path;
+    for (const key of endpoint.pathKeys) {
+        const value = String(input[key]);
+        if (value === "." || value === "..")
+            throw providerInputError(`${key} must not be a dot path segment`);
+        path = path.replace(`{${key}}`, encodeURIComponent(value));
+    }
+    const url = new URL(path, baseUrl);
+    for (const key of endpoint.queryKeys) {
+        if (input[key] !== undefined)
+            url.searchParams.set(key, String(input[key]));
+    }
+    if (name === "export_set")
+        url.searchParams.set("format", "json");
+    const body = optionalRecord(input.body);
+    const data = name === "start_dataset" ? { ...body, mode: "async" } : body;
+    const timeoutMs = name === "sync_people_search"
+        ? 150000
+        : name === "create_harness_chat_completion"
+            ? 100000
+            : name === "enrich_person"
+                ? 90000
+                : name === "create_dataset"
+                    ? 70000
+                    : undefined;
+    return runProviderRequest({ label: "Ploid", timeoutMs, signal: parentSignal }, async (signal) => {
+        const headers = new Headers({ authorization: `Bearer ${apiKey}`, accept: "application/json" });
+        if (data !== undefined)
+            headers.set("content-type", "application/json");
+        const idempotencyKey = optionalString(input.idempotencyKey);
+        if (idempotencyKey !== undefined)
+            headers.set("Idempotency-Key", idempotencyKey);
+        const response = await fetcher(url, {
+            method: endpoint.method,
+            headers,
+            body: data === undefined ? undefined : JSON.stringify(data),
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        if (text.trim()) {
+            try {
+                payload = JSON.parse(text);
+            }
+            catch { }
+        }
+        if (!response.ok) {
+            const error = optionalRecord(optionalRecord(payload)?.error);
+            const code = optionalString(error?.code);
+            const message = optionalString(error?.message);
+            const requestId = optionalString(error?.request_id);
+            const detail = [code, message, requestId ? `request_id=${requestId}` : undefined].filter(Boolean).join(": ");
+            throw new ProviderRequestError(response.status, `Ploid request failed (${response.status})${detail ? `: ${detail}` : ""}`, undefined, code && ["invalid_api_key", "expired_api_key", "revoked_api_key"].includes(code)
+                ? "authorization_failed"
+                : code === "insufficient_scope"
+                    ? "authorization_failed"
+                    : "provider_error");
+        }
+        if (name === "enrich_person" &&
+            body?.response_format === "markdown" &&
+            response.headers.get("content-type")?.includes("text/markdown"))
+            return { markdown: text };
+        if (name === "delete_monitor" && !text.trim())
+            return { success: true };
+        if (name === "export_set" && Array.isArray(payload))
+            return { items: payload };
+        const result = requiredResponseRecord(payload, "Ploid response");
+        if (name === "get_person" || name === "get_person_run") {
+            if (!("data" in result))
+                throw providerResponseError("Ploid person response is missing data");
+            const person = optionalRecord(result.data);
+            const runId = optionalString(person?.run_id);
+            const pendingStatus = optionalString(person?.status);
+            if (runId && !pendingStatus)
+                throw providerResponseError("Ploid person run is missing status");
+            return {
+                ...result,
+                status: runId ? pendingStatus : "completed",
+                run_id: runId ?? (name === "get_person_run" ? String(input.id) : undefined),
+            };
+        }
+        return result;
+    });
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    return request(apiKey, actionName, values, fetcher, context.signal);
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const result = await request(input.apiKey, "get_account_profile", {}, fetcher, signal);
+        const profile = requiredResponseRecord(result.data, "Ploid account profile");
+        const name = [optionalString(profile.first_name), optionalString(profile.last_name)]
+            .filter(Boolean)
+            .join(" ")
+            .trim();
+        return {
+            profile: { displayName: name || optionalString(profile.email) || "Ploid API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("ploid", Object.fromEntries(ploidActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "ploid",
+    baseUrl: baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/posthog/runtime.js

@@ -1,6 +1,6 @@
 import { compactObject, looseArray, optionalBoolean, optionalRawString, optionalString } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError } from "../provider-runtime.js";
 const posthogUserAgent = providerUserAgent;
 const posthogValidationPath = "/api/users/@me/";
 export const posthogActionHandlers = {
@@ -1313,7 +1313,7 @@ function mapPosthogError(input) {
         return new ProviderRequestError(429, message);
     }
     if (input.status === 404 && input.notFoundAsInvalidInput) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if ([400, 409, 422].includes(input.status))
         return new ProviderRequestError(400, message, undefined, "invalid_input");
@@ -1326,7 +1326,7 @@ function normalizePosthogBaseUrl(value) {
     }
     const parsed = assertPublicHttpUrl(baseUrl, {
         fieldName: "Base URL",
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
     });
     if (parsed.protocol !== "https:") {
         throw new ProviderRequestError(400, "Base URL must use https");

package/src/providers/predis_ai/executors.js

@@ -1,5 +1,5 @@
 import { optionalInteger, optionalRawString, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, readProviderTextBody, } from "../provider-runtime.js";
+import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, readProviderTextBody, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const service = "predis_ai";
 const apiBaseUrl = "https://brain.predis.ai/predis_api/v1";
 const createContentPath = "/create_content/";
@@ -218,9 +218,9 @@ function createPredisAiError(status, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function readErrorMessage(payload) {
     const record = optionalRecord(payload);

package/src/providers/printavo/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalNumber, optionalRawString, optionalRecord, optionalString, } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, } from "../provider-runtime.js";
 export const printavoApiBaseUrl = "https://www.printavo.com/api/v2";
 const identifyQuery = `
 query PrintavoIdentify {
@@ -369,7 +369,7 @@ async function readPrintavoPayload(response) {
 function createPrintavoError(status, payload, phase) {
     const message = extractPrintavoErrorMessage(payload) ?? `Printavo request failed with status ${status}`;
     if (phase === "validate" && status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status || 500, message);
 }

package/src/providers/prospeo/runtime.js

@@ -1,7 +1,6 @@
 import { compactObject, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, isAbortLikeError, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, isAbortLikeError, ProviderRequestError, providerUserAgent, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const prospeoApiBaseUrl = "https://api.prospeo.io";
-const defaultRequestTimeoutMs = 30_000;
 export const prospeoActionHandlers = {
     async get_account_information(_input, context) {
         const payload = await requestProspeoJson({
@@ -104,7 +103,7 @@ export async function validateProspeoCredential(input, fetcher) {
 export const executors = defineApiKeyProviderExecutors("prospeo", prospeoActionHandlers);
 async function requestProspeoJson(input, context) {
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), defaultRequestTimeoutMs);
+    const timeout = setTimeout(() => controller.abort(), defaultProviderRequestTimeoutMs);
     try {
         const response = await context.fetcher(buildProspeoUrl(input.path), {
             method: input.method,

package/src/providers/provider-runtime.d.ts

@@ -1,5 +1,6 @@
 import type { ProviderErrorCode } from "../core/provider-error-codes.ts";
 import type { ProviderDispatchContext, ProviderHttpDispatchOptions } from "../core/provider-http-dispatch.ts";
+import type { ProviderNetworkPolicy } from "../core/provider-network-policy.ts";
 import type { ActionExecutor, ExecutionContext, ExecutionResult, ProviderExecutors, ProviderProxyExecutor, ProxyExecutionResult, ProxyResponse, ResolvedCredential, TransitFileWriter } from "../core/types.ts";
 import type { ProviderActionNames } from "./action-contracts.generated.ts";
 /**
@@ -7,9 +8,11 @@ import type { ProviderActionNames } from "./action-contracts.generated.ts";
  */
 export type ProviderFetch = typeof fetch;
 export interface ProviderFetchOptions {
+    /** Bind runtime policy; private targets still require the transport's allowPrivateNetwork opt-in. */
+    network?: ProviderNetworkPolicy;
     /** Base transport; defaults to the global fetch. A guarded fetch is unwrapped so guards never stack. */
     fetch?: ProviderFetch;
-    /** Allow private-network targets for this provider's egress (see `assertPublicHttpUrl`); default public-only. */
+    /** Opt into runtime private-network permission with isPrivateNetworkAccessAllowed; omitted keeps targets public-only. */
     allowPrivateNetwork?: () => boolean;
     /**
      * Skip the DNS resolved-address check (URL and redirect guards still apply).
@@ -310,6 +313,8 @@ export interface ProviderProxyDefinition {
     maxResponseBytes?: number;
 }
 export declare const defaultProviderJsonMaxResponseBytes: number;
+/** Shared request budget for native AbortSignal and SDK timeout APIs. */
+export declare const defaultProviderRequestTimeoutMs = 30000;
 export declare function createProviderProxyUrl(baseUrl: string, endpointInput: unknown, queryInput?: unknown, allowedOrigins?: readonly string[]): URL;
 export declare function normalizeProviderProxyEndpoint(endpointInput: unknown, allowedOrigins?: readonly string[]): string;
 export declare function normalizeProviderProxyQuery(queryInput: unknown): Record<string, string>;
@@ -419,6 +424,19 @@ export declare function readProviderJsonBody(response: Response, options: ReadPr
  * Parse an already-read provider response body as JSON.
  */
 export declare function parseProviderJsonBodyText(text: string, options: ReadProviderJsonBodyOptions): unknown;
+interface UploadSourceInput {
+    url: string;
+    fetcher: typeof fetch;
+    fieldName: string;
+    maximumBytes?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+/** Download an upload source through public-only egress with a bounded body. */
+export declare function downloadUploadSource(input: UploadSourceInput): Promise<{
+    bytes: Uint8Array;
+    contentType?: string;
+}>;
 /**
  * Store a provider-hosted file in the local transit file service when enabled.
  */
@@ -431,6 +449,13 @@ export declare function uploadProviderUrlToTransitFile(input: {
  * Read a user-uploaded transit file reference from action input.
  */
 export declare function readTransitFileInput(input: unknown, context: Pick<ApiKeyProviderContext, "transitFiles">): Promise<ProviderInputFile>;
+/**
+ * The action error code a provider request failure reports: the provider's own
+ * code when it chose one, else one inferred from the upstream status. A
+ * provider that needs to react to the classification, such as retrying a rate
+ * limit, reads it here instead of re-deriving it from the status.
+ */
+export declare function providerRequestErrorCode(error: ProviderRequestError): ProviderErrorCode;
 /**
  * Map provider runtime failures to the standard action execution result.
  */

package/src/providers/provider-runtime.js

@@ -11,6 +11,7 @@ import { readBoundedResponseBytes } from "../core/request.js";
  */
 export function createProviderFetch(options = {}) {
     return createGuardedFetch({
+        network: options.network,
         dispatchAttempt: async (attempt, signal, transport, revalidate) => {
             try {
                 return await dispatchProviderHttpAttempt(attempt, signal, transport, revalidate);
@@ -155,7 +156,8 @@ const blockedProxyRequestHeaders = new Set([
 const defaultProviderProxyMaxResponseBytes = 20 * 1024 * 1024;
 export const defaultProviderJsonMaxResponseBytes = 20 * 1024 * 1024;
 const defaultProviderErrorMaxResponseBytes = 64 * 1024;
-const defaultProviderRequestTimeoutMs = 30_000;
+/** Shared request budget for native AbortSignal and SDK timeout APIs. */
+export const defaultProviderRequestTimeoutMs = 30_000;
 export function createProviderProxyUrl(baseUrl, endpointInput, queryInput, allowedOrigins) {
     const endpoint = normalizeProviderProxyEndpoint(endpointInput, allowedOrigins);
     const base = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
@@ -262,7 +264,7 @@ export async function readProviderProxyResponse(response, options = {}) {
         createError: (message) => new ProviderRequestError(413, message),
     });
     const contentType = response.headers.get("content-type") ?? "";
-    const normalizedContentType = contentType.toLowerCase();
+    const normalizedContentType = contentType.split(";", 1)[0].trim().toLowerCase();
     if (bytes.byteLength === 0) {
         return {
             status: response.status,
@@ -270,7 +272,19 @@ export async function readProviderProxyResponse(response, options = {}) {
             data: null,
         };
     }
-    if (normalizedContentType.includes("json")) {
+    if (!normalizedContentType) {
+        try {
+            return {
+                status: response.status,
+                headers,
+                data: new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+            };
+        }
+        catch {
+            // Preserve invalid UTF-8 bytes through the base64 fallback.
+        }
+    }
+    if (normalizedContentType === "application/json" || normalizedContentType.endsWith("+json")) {
         return {
             status: response.status,
             headers,
@@ -303,9 +317,13 @@ export async function readProviderProxyErrorMessage(response, fallbackMessage) {
     return (await readProviderErrorTextBody(response, "proxy error response")) || fallbackMessage;
 }
 function isTextProxyContentType(contentType) {
-    const normalized = contentType.toLowerCase();
+    const normalized = contentType.split(";", 1)[0].trim().toLowerCase();
     return (normalized.startsWith("text/") ||
-        normalized.includes("xml") ||
+        normalized === "application/x-ndjson" ||
+        normalized === "application/xml" ||
+        normalized === "application/xml-external-parsed-entity" ||
+        normalized === "application/xml-dtd" ||
+        normalized.endsWith("+xml") ||
         normalized.includes("javascript") ||
         normalized.includes("x-www-form-urlencoded"));
 }
@@ -814,6 +832,23 @@ export function parseProviderJsonBodyText(text, options) {
         throw new ProviderRequestError(options.invalidJsonStatus ?? 502, options.invalidJsonMessage, error);
     }
 }
+/** Download an upload source through public-only egress with a bounded body. */
+export async function downloadUploadSource(input) {
+    return runProviderRequest({ label: input.fieldName, timeoutMs: input.timeoutMs ?? 15_000, signal: input.signal }, async (signal) => {
+        const response = await createProviderFetch({ fetch: input.fetcher })(input.url, { signal });
+        if (!response.ok) {
+            void response.body?.cancel().catch(() => undefined);
+            throw providerInputError(`${input.fieldName} download failed with HTTP ${response.status}`);
+        }
+        const bytes = await readBoundedResponseBytes(response, {
+            maxBytes: input.maximumBytes ?? 20 * 1024 * 1024,
+            fieldName: input.fieldName,
+            createError: providerInputError,
+            signal,
+        });
+        return { bytes, contentType: response.headers.get("content-type") ?? undefined };
+    });
+}
 /**
  * Store a provider-hosted file in the local transit file service when enabled.
  */
@@ -899,6 +934,27 @@ export async function readTransitFileInput(input, context) {
         sizeBytes: stored.sizeBytes,
     };
 }
+/**
+ * The action error code a provider request failure reports: the provider's own
+ * code when it chose one, else one inferred from the upstream status. A
+ * provider that needs to react to the classification, such as retrying a rate
+ * limit, reads it here instead of re-deriving it from the status.
+ */
+export function providerRequestErrorCode(error) {
+    // `provider_error` is the generic fallback; a 429 is unambiguous, so refine it.
+    // A specific provider code (including one chosen for a 429) still wins.
+    return error.code === "provider_error" && error.status === 429
+        ? "rate_limited"
+        : (error.code ??
+            (error.status === 401 || error.status === 403
+                ? "authorization_failed"
+                : error.status === 429
+                    ? "rate_limited"
+                    : // A 3xx is an upstream redirect that `redirect: "manual"` surfaced unfollowed, not bad input.
+                        error.status < 500 && (error.status < 300 || error.status >= 400)
+                            ? "invalid_input"
+                            : "provider_error"));
+}
 /**
  * Map provider runtime failures to the standard action execution result.
  */
@@ -907,15 +963,7 @@ export function toProviderExecutionError(error, fallbackMessage) {
         return {
             ok: false,
             error: {
-                code: error.code ??
-                    (error.status === 401 || error.status === 403
-                        ? "authorization_failed"
-                        : error.status === 429
-                            ? "rate_limited"
-                            : // A 3xx is an upstream redirect that `redirect: "manual"` surfaced unfollowed, not bad input.
-                                error.status < 500 && (error.status < 300 || error.status >= 400)
-                                    ? "invalid_input"
-                                    : "provider_error"),
+                code: providerRequestErrorCode(error),
                 message: error.message,
                 details: {
                     status: error.status,

package/src/providers/push_by_techulus/executors.js

@@ -1,8 +1,7 @@
 import { compactObject, optionalBoolean, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "push_by_techulus";
 const pushByTechulusApiBaseUrl = "https://push.techulus.com/api/v1";
-const pushByTechulusDefaultRequestTimeoutMs = 30_000;
 export const pushByTechulusActionHandlers = {
     send_notification(input, context) {
         return sendPushByTechulusNotification("notify", input, context);
@@ -72,7 +71,7 @@ function buildPushByTechulusNotificationPayload(input) {
     });
 }
 async function requestPushByTechulusJson(input) {
-    const timeout = createProviderTimeout(input.context.signal, pushByTechulusDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.context.signal);
     let response;
     try {
         response = await input.context.fetcher(new URL(input.path, `${pushByTechulusApiBaseUrl}/`), {
@@ -89,7 +88,7 @@ async function requestPushByTechulusJson(input) {
     }
     catch (error) {
         if (timeout.didTimeout()) {
-            throw new ProviderRequestError(504, `push_by_techulus request timed out after ${pushByTechulusDefaultRequestTimeoutMs}ms`);
+            throw new ProviderRequestError(504, `push_by_techulus request timed out after ${defaultProviderRequestTimeoutMs}ms`);
         }
         if (isAbortLikeError(error)) {
             throw new ProviderRequestError(502, "push_by_techulus request aborted");

package/src/providers/pushover/runtime.js

@@ -1,13 +1,12 @@
 import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
 import { compactObject, optionalString, requiredString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, mapProviderActionSources, ProviderRequestError, providerUserAgent, readTransitFileInput, providerInputError, providerResponseError, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, mapProviderActionSources, ProviderRequestError, providerUserAgent, readTransitFileInput, providerInputError, providerResponseError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const pushoverApiBaseUrl = "https://api.pushover.net";
 export const pushoverVersionedApiBaseUrl = `${pushoverApiBaseUrl}/1`;
 const pushoverIconBaseUrl = `${pushoverApiBaseUrl}/icons`;
 const pushoverRealtimeUrl = "wss://client.pushover.net/push";
 const pushoverUserAgent = providerUserAgent;
-const pushoverDefaultTimeoutMs = 30_000;
 const pushoverDefaultRealtimeTimeoutSeconds = 60;
 const pushoverMaxRealtimeTimeoutSeconds = 300;
 const pushoverMaxAttachmentBytes = 5 * 1024 * 1024;
@@ -288,7 +287,7 @@ async function validateAndStoreTeamToken(input, fetcher) {
 async function getPushoverAppIconImage(input, fetcher) {
     const parsed = input.input;
     const iconUrl = `${pushoverIconBaseUrl}/${encodeURIComponent(parsed.icon)}.png`;
-    const timeout = createTimeoutSignal({ timeoutMs: pushoverDefaultTimeoutMs });
+    const timeout = createTimeoutSignal({ timeoutMs: defaultProviderRequestTimeoutMs });
     try {
         const response = await fetcher(iconUrl, {
             method: "GET",
@@ -792,7 +791,7 @@ async function requestPushoverJson(input) {
         }
         url.searchParams.set(key, value);
     }
-    const timeout = createTimeoutSignal({ timeoutMs: input.timeoutMs ?? pushoverDefaultTimeoutMs });
+    const timeout = createTimeoutSignal({ timeoutMs: input.timeoutMs ?? defaultProviderRequestTimeoutMs });
     try {
         const response = await input.fetcher(url.toString(), {
             method: input.method ?? "GET",
@@ -823,7 +822,7 @@ async function requestPushoverJson(input) {
             throw error;
         }
         if (timeout.didTimeout) {
-            throw new ProviderRequestError(504, `pushover request timed out after ${(input.timeoutMs ?? pushoverDefaultTimeoutMs) / 1000} seconds`);
+            throw new ProviderRequestError(504, `pushover request timed out after ${(input.timeoutMs ?? defaultProviderRequestTimeoutMs) / 1000} seconds`);
         }
         throw providerResponseError(error instanceof Error ? error.message : "pushover request failed");
     }

package/src/providers/pushsafer/runtime.js

@@ -1,7 +1,6 @@
 import { optionalInteger, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { defineProviderExecutors, providerInputError, ProviderRequestError, providerUserAgent, requireApiKeyCredential, } from "../provider-runtime.js";
+import { defineProviderExecutors, providerInputError, ProviderRequestError, providerUserAgent, requireApiKeyCredential, providerResponseError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const pushsaferApiBaseUrl = "https://www.pushsafer.com";
-const pushsaferDefaultRequestTimeoutMs = 30_000;
 export async function validatePushsaferCredential(input, fetcher, signal) {
     const apiKey = requiredString(input.apiKey, "apiKey", providerInputError);
     const username = requireNonEmptyString(input.username, "username");
@@ -139,7 +138,7 @@ async function requestPushsaferJson(input) {
                 "user-agent": providerUserAgent,
             },
             body: params,
-            signal: input.signal ?? AbortSignal.timeout(pushsaferDefaultRequestTimeoutMs),
+            signal: input.signal ?? AbortSignal.timeout(defaultProviderRequestTimeoutMs),
         });
         const payload = await readPayload(response);
         if (response.status !== 200) {
@@ -173,7 +172,7 @@ function requireSuccessPayload(payload) {
     }
     if (record.status !== 1) {
         const message = extractErrorMessage(record) ?? "Pushsafer rejected the request";
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return record;
 }
@@ -185,7 +184,7 @@ function createPushsaferError(status, payload, phase) {
     if (status === 250 || status === 255 || status === 401 || status === 403) {
         return new ProviderRequestError(phase === "validate" ? 400 : 401, message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function extractErrorMessage(payload) {
     const record = optionalRecord(payload);

package/src/providers/pylon/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, providerUserAgent, ProviderRequestError, providerInputError, } from "../provider-runtime.js";
 export const pylonApiBaseUrl = "https://api.usepylon.com";
 const listIssuesMaxRangeMs = 30 * 24 * 60 * 60 * 1000;
 export const pylonActionHandlers = {
@@ -334,7 +334,7 @@ async function readPylonPayload(response) {
 function createPylonError(status, payload, phase) {
     const message = readPylonErrorMessage(payload) ?? `Pylon request failed with status ${status}`;
     if (phase === "validate" && (status === 401 || status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 401 || status === 403) {
         return new ProviderRequestError(401, message);

package/src/providers/qase/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger as asOptionalInteger, optionalRecord as asOptionalObject, optionalString as asOptionalString, } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const qaseApiBaseUrl = "https://api.qase.io/v1";
 export const qaseActionHandlers = {
     list_projects: handler("list_projects"),
@@ -188,9 +188,9 @@ function createQaseError(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 readPage(payload, entity) {
     const result = readResultObject(payload, entity);

package/src/providers/qdrant/runtime.js

@@ -193,7 +193,7 @@ function createQdrantError(status, payload, phase) {
         optionalString(record?.message) ??
         `Qdrant request failed with status ${status}`;
     if ((status === 401 || status === 403) && phase === "validate") {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status >= 500 ? 502 : status || 502, message);
 }

package/src/providers/qichacha/runtime.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { createProviderTimeout, providerUserAgent, ProviderRequestError, providerResponseError, } from "../provider-runtime.js";
 export const qichachaApiBaseUrl = "https://api.qichacha.com";
 const actionPathByName = {
     list_company_shareholders: "/ECIPartner/GetList",
@@ -112,7 +112,7 @@ function createQichachaError(httpStatus, payload) {
     if (httpStatus == 429 || ["频率", "限流", "too many"].some((value) => normalized.includes(value))) {
         return new ProviderRequestError(429, message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function readResultRecords(payload) {
     if (Array.isArray(payload.Result))

package/src/providers/qingflow/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, providerInputError, } from "../provider-runtime.js";
 export const qingflowApiBaseUrl = "https://api.qingflow.com";
 const qingflowValidationPath = "/app";
 export const qingflowActionHandlers = {
@@ -500,7 +500,7 @@ function mapQingflowApiError(errorCode, envelope, phase) {
     if (qingflowPermissionErrorCodes.has(errorCode)) {
         return new ProviderRequestError(403, message);
     }
-    return new ProviderRequestError(400, message);
+    return providerInputError(message);
 }
 const qingflowPermissionErrorCodes = new Set([40002, 40064, 40065, 40066, 40069, 40095]);
 const qingflowAuditResultByDecision = {

package/src/providers/quickchart/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject } from "../../core/cast.js";
-import { defineProviderExecutors, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { defineProviderExecutors, providerUserAgent, ProviderRequestError, providerInputError, } from "../provider-runtime.js";
 export const quickchartBaseUrl = "https://quickchart.io";
 export const quickchartActionHandlers = {
     async build_chart_url(input) {
@@ -118,7 +118,7 @@ function createQuickchartError(response, payload) {
         return new ProviderRequestError(429, message);
     }
     if ([400, 404, 422].includes(response.status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status >= 500 ? 502 : response.status || 502, message);
 }

package/src/providers/quintadb/runtime.js

@@ -211,12 +211,12 @@ function createQuintaDbError(status, payload, phase) {
     }
     if (status === 401 || status === 403) {
         if (phase === "validate") {
-            return new ProviderRequestError(400, message);
+            return providerInputError(message);
         }
         return new ProviderRequestError(status, message);
     }
     if (status === 400 || status === 404 || status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status || 500, message);
 }

package/src/providers/quo/runtime.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { compactObject, requiredString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, providerUserAgent, ProviderRequestError, providerInputError, } from "../provider-runtime.js";
 export const quoApiBaseUrl = "https://api.openphone.com";
 export const quoActionHandlers = {
     list_phone_numbers(input, context) {
@@ -166,7 +166,7 @@ function normalizeQuoPayload(payload) {
 function createQuoError(status, payload) {
     const message = extractErrorMessage(payload) ?? `Quo request failed with ${status || 500}`;
     if (status === 400 || status === 401 || status === 404) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 402 || status === 403) {
         return new ProviderRequestError(status, message);