@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/twittrapi/runtime.js

@@ -0,0 +1,203 @@
+import { optionalInteger, optionalRecord, optionalScalarString, optionalString, optionalStringArray, rawStringOrNull, } from "../../core/cast.js";
+import { encodePathSegment } from "../../core/request.js";
+import { parseProviderJsonBodyText, providerInputError, providerResponseError, providerUserAgent, ProviderRequestError, readProviderTextBody, requiredResponseRecord, runProviderRequest, setSearchParams, } from "../provider-runtime.js";
+export const twittrapiApiBaseUrl = "https://api.twittrapi.com";
+// The balance endpoint is free and identifies the key's account.
+const twittrapiValidationPath = "/balance";
+export const twittrapiActionHandlers = {
+    async search_tweets(input, context) {
+        const payload = await getTwittrapiJson({
+            path: "/search",
+            query: {
+                searchItem: optionalString(input.query),
+                category: optionalString(input.category),
+                ...pageQuery(input),
+            },
+        }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async search_users(input, context) {
+        const payload = await getTwittrapiJson({
+            path: "/search",
+            query: { searchItem: optionalString(input.query), category: "People", ...pageQuery(input) },
+        }, context);
+        return pageOutput(payload, "users");
+    },
+    async get_tweet(input, context) {
+        const payload = await getTwittrapiJson({ path: `/simpletweet/${encodePathSegment(input.tweetId)}` }, context);
+        const tweet = readData(payload);
+        return { tweet: tweet === null ? null : requiredResponseRecord(tweet, "TwittrAPI tweet") };
+    },
+    async get_tweet_conversation(input, context) {
+        const payload = await getTwittrapiJson({
+            path: `/tweet/${encodePathSegment(input.tweetId)}`,
+            query: { rankingMode: optionalString(input.rankingMode), cursor: optionalString(input.cursor) },
+        }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async get_tweet_quotes(input, context) {
+        const payload = await getTwittrapiJson({ path: `/tweet/${encodePathSegment(input.tweetId)}/quotes`, query: pageQuery(input) }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async get_tweet_retweeters(input, context) {
+        const payload = await getTwittrapiJson({ path: `/tweet/${encodePathSegment(input.tweetId)}/retweets`, query: pageQuery(input) }, context);
+        return pageOutput(payload, "users");
+    },
+    async get_user(input, context) {
+        const userId = optionalString(input.userId);
+        const username = optionalString(input.username);
+        if (!userId && !username) {
+            throw providerInputError("userId or username is required.");
+        }
+        const path = userId
+            ? `/user/${encodePathSegment(userId)}`
+            : `/user/by/username/${encodePathSegment(stripHandlePrefix(username))}`;
+        const payload = await getTwittrapiJson({ path }, context);
+        const user = readData(payload);
+        return { user: user === null ? null : requiredResponseRecord(user, "TwittrAPI user") };
+    },
+    async get_users_by_ids(input, context) {
+        const payload = await getTwittrapiJson({ path: "/user/users/by/ids", query: { ids: optionalStringArray(input.userIds)?.join(",") } }, context);
+        return { users: readTwittrapiPage(payload).items };
+    },
+    async get_user_tweets(input, context) {
+        return pageOutput(await getUserCollection(input, "tweets", context), "tweets");
+    },
+    async get_user_tweets_and_replies(input, context) {
+        return pageOutput(await getUserCollection(input, "tweetsAndReplies", context), "tweets");
+    },
+    async get_user_followers(input, context) {
+        return pageOutput(await getUserCollection(input, "followers", context), "users");
+    },
+    async get_user_following(input, context) {
+        return pageOutput(await getUserCollection(input, "followings", context), "users");
+    },
+    async get_list_tweets(input, context) {
+        const payload = await getTwittrapiJson({ path: "/lists/tweets", query: { listId: optionalString(input.listId), ...pageQuery(input) } }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async get_community_tweets(input, context) {
+        const payload = await getTwittrapiJson({ path: `/communities/${encodePathSegment(input.communityId)}/tweets`, query: pageQuery(input) }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async get_trends(input, context) {
+        const woeid = optionalString(input.woeid) ?? "1";
+        const payload = await getTwittrapiJson({ path: `/trends/${encodePathSegment(woeid)}` }, context);
+        return { trends: readTwittrapiPage(payload).items };
+    },
+};
+/**
+ * Validate a TwittrAPI key against the free balance endpoint and report the
+ * account it belongs to.
+ */
+export async function validateTwittrapiCredential(apiKey, fetcher, signal) {
+    const payload = await getTwittrapiJson({ path: twittrapiValidationPath, simple: false }, { apiKey, fetcher, signal }, "validate");
+    const accountId = optionalScalarString(optionalRecord(payload)?.user_id);
+    return {
+        profile: {
+            accountId: accountId ?? "api_key",
+            displayName: "TwittrAPI API Key",
+        },
+        grantedScopes: [],
+        metadata: {
+            apiBaseUrl: twittrapiApiBaseUrl,
+            validationEndpoint: twittrapiValidationPath,
+        },
+    };
+}
+// Profile collections take a numeric user ID in the path. With only a handle,
+// the API expects -1 there and the handle in the username query parameter.
+async function getUserCollection(input, collection, context) {
+    const userId = optionalString(input.userId);
+    const username = optionalString(input.username);
+    if (!userId && !username) {
+        throw providerInputError("userId or username is required.");
+    }
+    return getTwittrapiJson({
+        path: `/user/${encodePathSegment(userId ?? "-1")}/${collection}`,
+        query: { username: userId ? undefined : stripHandlePrefix(username), ...pageQuery(input) },
+    }, context);
+}
+async function getTwittrapiJson(request, context, phase = "execute") {
+    const url = new URL(request.path, twittrapiApiBaseUrl);
+    setSearchParams(url, { ...request.query, format: request.simple === false ? undefined : "simple" });
+    return runProviderRequest({ signal: context.signal, label: "TwittrAPI" }, async (signal) => {
+        const response = await context.fetcher(url, {
+            method: "GET",
+            headers: {
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+                "x-api-key": context.apiKey,
+            },
+            signal,
+        });
+        const text = await readProviderTextBody(response, "TwittrAPI response", undefined, signal);
+        if (!response.ok) {
+            throw createTwittrapiError(response.status, parseErrorBody(text), phase);
+        }
+        return parseProviderJsonBodyText(text, {
+            emptyBody: null,
+            invalidJsonMessage: "TwittrAPI returned a response that is not valid JSON",
+        });
+    });
+}
+function parseErrorBody(text) {
+    return parseProviderJsonBodyText(text, {
+        emptyBody: null,
+        invalidJsonMessage: "TwittrAPI returned an error that is not valid JSON",
+        invalidJsonFallback: (raw) => raw.trim().slice(0, 500),
+    });
+}
+function createTwittrapiError(status, payload, phase) {
+    const message = optionalString(optionalRecord(payload)?.error) ??
+        (typeof payload === "string" ? optionalString(payload) : undefined) ??
+        `TwittrAPI request failed with status ${status}`;
+    // An invalid, unknown, or deactivated key should surface as a field error on
+    // the connect form rather than as a reconnect prompt.
+    if (phase === "validate" && (status === 401 || status === 404)) {
+        return new ProviderRequestError(400, message, payload);
+    }
+    if (status === 402) {
+        return new ProviderRequestError(402, message, payload, "insufficient_credit");
+    }
+    return new ProviderRequestError(status || 500, message, payload, status === 429 ? "rate_limited" : "provider_error");
+}
+function readData(payload) {
+    const record = requiredResponseRecord(payload, "TwittrAPI response");
+    if (!("data" in record)) {
+        throw providerResponseError("TwittrAPI response is missing data.");
+    }
+    return record.data;
+}
+function readTwittrapiPage(payload) {
+    const record = requiredResponseRecord(payload, "TwittrAPI response");
+    if (!Array.isArray(record.data)) {
+        throw providerResponseError("TwittrAPI response data must be an array.");
+    }
+    const nextCursor = rawStringOrNull(record.nextCursor);
+    return {
+        nextCursor,
+        previousCursor: rawStringOrNull(record.previousCursor),
+        hasNextPage: typeof record.hasNextPage === "boolean" ? record.hasNextPage : nextCursor !== null,
+        items: record.data.map((item) => requiredResponseRecord(item, "TwittrAPI response item")),
+    };
+}
+function pageOutput(payload, itemField) {
+    const page = readTwittrapiPage(payload);
+    return {
+        [itemField]: page.items,
+        nextCursor: page.nextCursor,
+        previousCursor: page.previousCursor,
+        hasNextPage: page.hasNextPage,
+    };
+}
+function pageQuery(input) {
+    const count = optionalInteger(input.count);
+    return {
+        count: count === undefined ? undefined : String(count),
+        cursor: optionalString(input.cursor),
+    };
+}
+function stripHandlePrefix(username) {
+    return username.startsWith("@") ? username.slice(1) : username;
+}

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

@@ -0,0 +1,40 @@
+import { defineProviderExecutors, defineProviderProxy, requireApiKeyCredential } from "../provider-runtime.js";
+import { readUrlhausError } from "./runtime.js";
+import { urlhausActionHandlers, urlhausApiBaseUrl, urlhausValidationPath, validateUrlhausAuthKey } from "./runtime.js";
+const service = "urlhaus";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: urlhausActionHandlers,
+    skipDnsValidation: true,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, service);
+        return {
+            apiKey: credential.apiKey,
+            fetcher,
+            signal: context.signal,
+        };
+    },
+});
+export const proxy = defineProviderProxy({
+    readError: readUrlhausError,
+    service,
+    baseUrl: urlhausApiBaseUrl,
+    auth: { type: "api_key_header", name: "Auth-Key" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await validateUrlhausAuthKey(input.apiKey, fetcher, signal);
+        return {
+            profile: {
+                accountId: "urlhaus-auth-key",
+                displayName: "URLhaus Auth-Key",
+            },
+            grantedScopes: [],
+            metadata: {
+                apiBaseUrl: urlhausApiBaseUrl,
+                validationEndpoint: urlhausValidationPath,
+            },
+        };
+    },
+};

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

@@ -0,0 +1,15 @@
+import type { ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const urlhausApiBaseUrl = "https://urlhaus-api.abuse.ch";
+export declare const urlhausValidationPath = "/v1/urls/recent/limit/1/";
+export interface UrlhausRuntimeContext {
+    apiKey: string;
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type UrlhausActionHandler = (input: Record<string, unknown>, context: UrlhausRuntimeContext) => Promise<unknown>;
+export declare const urlhausActionHandlers: ProviderActionHandlers<"urlhaus", UrlhausActionHandler>;
+/** Lightweight credential check: lists one recent URL; HTTP failures retain their provider error semantics. */
+export declare function validateUrlhausAuthKey(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<void>;
+export declare function readUrlhausError(response: Response): Promise<ProviderRequestError>;
+export {};

package/src/providers/urlhaus/runtime.js

@@ -0,0 +1,142 @@
+import { optionalInteger, optionalObjectArray, optionalRecord, optionalString, optionalStringArray, } from "../../core/cast.js";
+import { parseProviderJsonBodyText, providerInputError, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredInputString, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const urlhausApiBaseUrl = "https://urlhaus-api.abuse.ch";
+export const urlhausValidationPath = "/v1/urls/recent/limit/1/";
+export const urlhausActionHandlers = {
+    async lookup_url(input, context) {
+        const url = lookupUrlParam(input.url);
+        const payload = await requestUrlhaus({ context, url });
+        const record = optionalRecord(payload);
+        const queryStatus = optionalString(record?.query_status) ?? "";
+        if (queryStatus === "no_results") {
+            return { found: false, query_status: queryStatus, entry: undefined };
+        }
+        if (queryStatus === "invalid_url") {
+            throw providerInputError("URLhaus rejected the url as invalid.");
+        }
+        if (queryStatus !== "ok" || !record) {
+            throw new ProviderRequestError(502, `URLhaus returned an unexpected query_status: ${queryStatus || "missing"}`);
+        }
+        return { found: true, query_status: queryStatus, entry: normalizeUrlEntry(record) };
+    },
+};
+/**
+ * The queried value travels to URLhaus as POST data and is never fetched, so
+ * only the scheme and general shape are validated here; URLhaus itself
+ * reports `invalid_url` for anything it cannot parse.
+ */
+function lookupUrlParam(value) {
+    const url = requiredInputString(value, "url").trim();
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw providerInputError("url must be a valid absolute URL, for example https://example.com/payload.exe.");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw providerInputError("url must use the http or https scheme.");
+    }
+    return url;
+}
+async function requestUrlhaus(request) {
+    const endpoint = new URL("/v1/url/", urlhausApiBaseUrl);
+    return runProviderRequest({ label: "URLhaus", signal: request.context.signal }, async (signal) => {
+        const response = await request.context.fetcher(endpoint, {
+            method: "POST",
+            headers: {
+                "Auth-Key": request.context.apiKey,
+                accept: "application/json",
+                // URLhaus expects form-encoded POST data (see urlhaus-api.abuse.ch docs),
+                // not JSON: a JSON body yields HTTP 200 with an empty response.
+                "content-type": "application/x-www-form-urlencoded",
+                "user-agent": providerUserAgent,
+            },
+            body: new URLSearchParams({ url: request.url }).toString(),
+            signal,
+        });
+        if (!response.ok) {
+            throw await readUrlhausError(response);
+        }
+        return parseProviderJsonBodyText(await readProviderTextBody(response, "URLhaus response"), {
+            emptyBody: null,
+            invalidJsonMessage: "URLhaus returned malformed JSON",
+        });
+    });
+}
+/** Lightweight credential check: lists one recent URL; HTTP failures retain their provider error semantics. */
+export async function validateUrlhausAuthKey(apiKey, fetcher, signal) {
+    await runProviderRequest({ label: "URLhaus", signal }, async (requestSignal) => {
+        const response = await fetcher(new URL(urlhausValidationPath, urlhausApiBaseUrl), {
+            headers: {
+                "Auth-Key": apiKey,
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+            },
+            signal: requestSignal,
+        });
+        if (!response.ok) {
+            throw await readUrlhausError(response);
+        }
+        const payload = optionalRecord(parseProviderJsonBodyText(await readProviderTextBody(response, "URLhaus validation response"), {
+            emptyBody: null,
+            invalidJsonMessage: "URLhaus returned malformed JSON",
+        }));
+        if (optionalString(payload?.query_status) !== "ok") {
+            throw new ProviderRequestError(502, "URLhaus validation returned an unexpected response");
+        }
+    });
+}
+function normalizeUrlEntry(record) {
+    const blacklists = optionalRecord(record.blacklists) ?? {};
+    const idValue = record.id;
+    return {
+        ...record,
+        id: typeof idValue === "string" ? idValue : typeof idValue === "number" ? String(idValue) : "",
+        urlhaus_reference: optionalString(record.urlhaus_reference) ?? "",
+        url: optionalString(record.url) ?? "",
+        url_status: optionalString(record.url_status) ?? "",
+        host: optionalString(record.host) ?? "",
+        date_added: optionalString(record.date_added) ?? "",
+        last_online: optionalString(record.last_online) ?? null,
+        threat: optionalString(record.threat) ?? "",
+        blacklists: {
+            ...blacklists,
+            surbl: optionalString(blacklists.surbl) ?? "",
+            spamhaus_dbl: optionalString(blacklists.spamhaus_dbl) ?? "",
+        },
+        reporter: optionalString(record.reporter) ?? "",
+        larted: optionalString(record.larted) ?? "",
+        takedown_time_seconds: optionalInteger(record.takedown_time_seconds) ?? null,
+        tags: optionalStringArray(record.tags) ?? [],
+        payloads: (optionalObjectArray(record.payloads) ?? []).map(normalizePayload),
+    };
+}
+function normalizePayload(item) {
+    return {
+        ...item,
+        firstseen: optionalString(item.firstseen) ?? "",
+        filename: optionalString(item.filename) ?? null,
+        file_type: optionalString(item.file_type) ?? "",
+        response_size: stringifySize(item.response_size),
+        response_md5: optionalString(item.response_md5) ?? "",
+        response_sha256: optionalString(item.response_sha256) ?? "",
+        urlhaus_download: optionalString(item.urlhaus_download) ?? "",
+        signature: optionalString(item.signature) ?? null,
+    };
+}
+/** URLhaus reports the payload size inconsistently as a string or a number. */
+function stringifySize(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return String(Math.trunc(value));
+    }
+    return optionalString(value) ?? "";
+}
+// HTTP status alone cannot distinguish an invalid key from access or subscription restrictions.
+export async function readUrlhausError(response) {
+    const text = (await readProviderErrorTextBody(response, "URLhaus error response")).trim();
+    const message = text.slice(0, 200) || `URLhaus request failed with HTTP ${response.status}`;
+    const status = response.status;
+    const code = status === 429 ? "rate_limited" : "provider_error";
+    return new ProviderRequestError(status, message, withRetryAfterSeconds(response, {}), code);
+}

package/src/providers/wangdian/runtime.js

@@ -1,7 +1,7 @@
 import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, mapProviderActionSources, ProviderRequestError, providerUserAgent, toProviderExecutionError, } from "../provider-runtime.js";
+import { createProviderTimeout, mapProviderActionSources, ProviderRequestError, providerUserAgent, toProviderExecutionError, providerInputError, } from "../provider-runtime.js";
 export const wangdianApiBaseUrl = "https://api.wangdian.cn/openapi2";
 const maximumWindowMs = 30 * 24 * 60 * 60 * 1_000;
 const maximumOrderWindowMs = 60 * 60 * 1_000;
@@ -93,7 +93,7 @@ export function readWangdianProxyParameters(body) {
         return Object.fromEntries(new URLSearchParams(body));
     const value = optionalRecord(body);
     if (!value) {
-        throw new ProviderRequestError(400, "Wangdian proxy body must be an object or form-encoded string");
+        throw providerInputError("Wangdian proxy body must be an object or form-encoded string");
     }
     return value;
 }
@@ -103,7 +103,7 @@ export function toWangdianExecutionError(error) {
 async function executeWangdianAction(actionName, input, context) {
     const config = actionConfigByName[actionName];
     if (!config)
-        throw new ProviderRequestError(400, `Unsupported Wangdian action: ${actionName}`);
+        throw providerInputError(`Unsupported Wangdian action: ${actionName}`);
     validateActionInput(actionName, input);
     const payload = await requestWangdian({
         endpoint: config.endpoint,
@@ -114,7 +114,7 @@ async function executeWangdianAction(actionName, input, context) {
     const responseRecords = payload[config.responseField];
     const records = responseRecords === undefined && config.optionalResponseList ? [] : responseRecords;
     if (!Array.isArray(records)) {
-        throw wangdianError("provider_error", `Wangdian returned an invalid ${config.responseField} response`, 502);
+        throw new ProviderRequestError(502, `Wangdian returned an invalid ${config.responseField} response`, undefined, "provider_error");
     }
     return {
         [config.outputField]: records,
@@ -175,7 +175,7 @@ function validateOptionalDateTimes(input) {
     }
 }
 function invalidInput(message) {
-    throw wangdianError("invalid_input", message, 400);
+    throw new ProviderRequestError(400, message, undefined, "invalid_input");
 }
 function hasValue(value, fields) {
     return fields.some((field) => Boolean(optionalString(value[field])));
@@ -197,7 +197,7 @@ function parseChinaDateTime(value) {
 function requireCredentialValue(value, label) {
     const normalized = optionalString(value);
     if (!normalized)
-        throw new ProviderRequestError(400, `${label} is required`);
+        throw providerInputError(`${label} is required`);
     return normalized;
 }
 function buildActionParameters(actionName, input) {
@@ -291,7 +291,7 @@ function buildActionParameters(actionName, input) {
                 ...page,
             });
         default:
-            throw new ProviderRequestError(400, `Unsupported Wangdian action: ${actionName}`);
+            throw providerInputError(`Unsupported Wangdian action: ${actionName}`);
     }
 }
 function booleanFlag(value) {
@@ -338,7 +338,7 @@ async function requestWangdian(input) {
         const root = optionalRecord(payload);
         const code = parseOptionalInteger(root?.code);
         if (!root || code === undefined) {
-            throw wangdianError("provider_error", "Wangdian returned an invalid response", 502);
+            throw new ProviderRequestError(502, "Wangdian returned an invalid response", undefined, "provider_error");
         }
         if (code !== 0)
             throw createWangdianError(200, root, input.phase);
@@ -348,9 +348,9 @@ async function requestWangdian(input) {
         if (error instanceof ProviderRequestError)
             throw error;
         if (timeout.didTimeout() || (error instanceof Error && error.name === "AbortError")) {
-            throw wangdianError("provider_error", "Wangdian request timed out", 504);
+            throw new ProviderRequestError(504, "Wangdian request timed out", undefined, "provider_error");
         }
-        throw wangdianError("provider_error", error instanceof Error ? `Wangdian request failed: ${error.message}` : "Wangdian request failed", 502);
+        throw new ProviderRequestError(502, error instanceof Error ? `Wangdian request failed: ${error.message}` : "Wangdian request failed", undefined, "provider_error");
     }
     finally {
         timeout.cleanup();
@@ -364,7 +364,7 @@ async function readWangdianPayload(response) {
         return JSON.parse(text);
     }
     catch {
-        throw wangdianError("provider_error", "Wangdian returned invalid JSON", 502);
+        throw new ProviderRequestError(502, "Wangdian returned invalid JSON", undefined, "provider_error");
     }
 }
 function createWangdianError(status, payload, phase) {
@@ -373,9 +373,9 @@ function createWangdianError(status, payload, phase) {
     const message = optionalString(root?.message) ?? `Wangdian request failed with status ${status}`;
     const lowerMessage = message.toLowerCase();
     if (status === 429)
-        return wangdianError("rate_limited", message, 429, payload);
+        return new ProviderRequestError(429, message, payload, "rate_limited");
     if (message.includes("权限不足") || message.includes("无仓库访问权限")) {
-        return wangdianError("authorization_failed", message, 403, payload);
+        return new ProviderRequestError(403, message, payload, "authorization_failed");
     }
     if (status === 401 ||
         status === 403 ||
@@ -390,15 +390,12 @@ function createWangdianError(status, payload, phase) {
         lowerMessage.includes("sign error") ||
         lowerMessage.includes("invalid sign") ||
         lowerMessage.includes("sign is")) {
-        return wangdianError(phase === "validate" ? "invalid_input" : "authorization_failed", message, phase === "validate" ? 400 : 401, payload);
+        return new ProviderRequestError(phase === "validate" ? 400 : 401, message, payload, phase === "validate" ? "invalid_input" : "authorization_failed");
     }
     if (status === 400 || status === 422 || code === 1 || code === 100 || code === 2104) {
-        return wangdianError("invalid_input", message, 400, payload);
+        return new ProviderRequestError(400, message, payload, "invalid_input");
     }
-    return wangdianError("provider_error", message, 502, payload);
-}
-function wangdianError(code, message, status, details) {
-    return new ProviderRequestError(status, message, details, code);
+    return new ProviderRequestError(502, message, payload, "provider_error");
 }
 function parseOptionalInteger(value) {
     if (value === undefined || value === null || value === "")

package/src/providers/weread/actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const wereadActions: ActionDefinition[];