@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/threatfox/runtime.js

@@ -0,0 +1,128 @@
+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 threatfoxApiBaseUrl = "https://threatfox-api.abuse.ch";
+export const threatfoxApiPath = "/api/v1/";
+const threatfoxValidationQuery = { query: "get_iocs", days: 1 };
+export const threatfoxActionHandlers = {
+    async lookup_ioc(input, context) {
+        const ioc = lookupIocParam(input.ioc);
+        const isHash = (ioc.length === 32 || ioc.length === 64) &&
+            [...ioc.toLowerCase()].every((character) => "0123456789abcdef".includes(character));
+        const payload = await requestThreatfox(context, isHash ? { query: "search_hash", hash: ioc } : { query: "search_ioc", search_term: ioc, exact_match: true });
+        const record = optionalRecord(payload);
+        const queryStatus = optionalString(record?.query_status) ?? "";
+        // ThreatFox reports "no_result" (singular) when the IOC is unknown.
+        if (queryStatus === "no_result" || queryStatus === "no_results") {
+            return { found: false, query_status: queryStatus, entries: undefined };
+        }
+        if (queryStatus !== "ok" || !record) {
+            throw new ProviderRequestError(502, `ThreatFox returned an unexpected query_status: ${queryStatus || "missing"}`);
+        }
+        // An "ok" without an entry array is a malformed upstream response: never
+        // report a positive IOC match with zero evidence.
+        if (!Array.isArray(record.data)) {
+            throw new ProviderRequestError(502, "ThreatFox returned ok without an entry array");
+        }
+        return {
+            found: true,
+            query_status: queryStatus,
+            entries: optionalObjectArray(record.data).map(normalizeIocEntry),
+        };
+    },
+};
+/**
+ * The queried IOC travels to ThreatFox as POST data and is never fetched, so
+ * only the general shape is validated here; ThreatFox itself reports
+ * `illegal_search_term` for anything it cannot parse.
+ */
+function lookupIocParam(value) {
+    const ioc = requiredInputString(value, "ioc").trim();
+    if (!ioc) {
+        throw providerInputError("ioc must be a non-empty indicator of compromise.");
+    }
+    if (/\s/.test(ioc)) {
+        throw providerInputError("ioc must not contain whitespace.");
+    }
+    if (ioc.length > 2048) {
+        throw providerInputError("ioc must not exceed 2048 characters.");
+    }
+    return ioc;
+}
+async function requestThreatfox(context, query) {
+    const endpoint = new URL(threatfoxApiPath, threatfoxApiBaseUrl);
+    return runProviderRequest({ label: "ThreatFox", signal: context.signal }, async (signal) => {
+        const response = await context.fetcher(endpoint, {
+            method: "POST",
+            headers: {
+                "Auth-Key": context.apiKey,
+                accept: "application/json",
+                // ThreatFox expects a JSON body (see threatfox.abuse.ch/api docs); a
+                // form-encoded body is rejected with query_status "no_json".
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: JSON.stringify(query),
+            signal,
+        });
+        if (!response.ok) {
+            throw await readThreatfoxError(response);
+        }
+        return parseProviderJsonBodyText(await readProviderTextBody(response, "ThreatFox response"), {
+            emptyBody: null,
+            invalidJsonMessage: "ThreatFox returned malformed JSON",
+        });
+    });
+}
+/** Lightweight credential check: lists one day of recent IOCs; HTTP failures retain their provider error semantics. */
+export async function validateThreatfoxAuthKey(apiKey, fetcher, signal) {
+    const context = { apiKey, fetcher, signal };
+    const payload = optionalRecord(await requestThreatfox(context, threatfoxValidationQuery));
+    if (optionalString(payload?.query_status) !== "ok") {
+        throw new ProviderRequestError(502, "ThreatFox validation returned an unexpected response");
+    }
+}
+function normalizeIocEntry(record) {
+    return {
+        ...record,
+        id: stringifyId(record.id),
+        ioc: optionalString(record.ioc) ?? "",
+        threat_type: optionalString(record.threat_type) ?? "",
+        threat_type_desc: optionalString(record.threat_type_desc) ?? "",
+        ioc_type: optionalString(record.ioc_type) ?? "",
+        ioc_type_desc: optionalString(record.ioc_type_desc) ?? "",
+        malware: optionalString(record.malware) ?? "",
+        malware_printable: optionalString(record.malware_printable) ?? "",
+        confidence_level: optionalInteger(record.confidence_level) ?? 0,
+        first_seen: optionalString(record.first_seen) ?? "",
+        last_seen: optionalString(record.last_seen) ?? null,
+        reporter: optionalString(record.reporter) ?? "",
+        reference: optionalString(record.reference) ?? null,
+        tags: optionalStringArray(record.tags) ?? [],
+        malware_samples: (optionalObjectArray(record.malware_samples) ?? []).map(normalizeMalwareSample),
+    };
+}
+function normalizeMalwareSample(item) {
+    return {
+        ...item,
+        time_stamp: optionalString(item.time_stamp) ?? "",
+        md5_hash: optionalString(item.md5_hash) ?? "",
+        sha256_hash: optionalString(item.sha256_hash) ?? "",
+        malware_bazaar: optionalString(item.malware_bazaar) ?? "",
+    };
+}
+/** ThreatFox entry IDs arrive as strings but may be numbers in edge cases. */
+function stringifyId(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(Math.trunc(value));
+    return "";
+}
+// HTTP status alone cannot distinguish an invalid key from access or subscription restrictions.
+export async function readThreatfoxError(response) {
+    const text = (await readProviderErrorTextBody(response, "ThreatFox error response")).trim();
+    const message = text.slice(0, 200) || `ThreatFox 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/ticket_tailor/runtime.js

@@ -143,7 +143,7 @@ function createError(response, payload) {
         optionalString(record.error) ??
         `Ticket Tailor request failed with HTTP ${response.status}`;
     const code = optionalString(record.error_code);
-    return new ProviderRequestError(response.status || 502, code ? `[${code}] ${upstreamMessage}` : upstreamMessage, payload, code);
+    return new ProviderRequestError(response.status || 502, code ? `[${code}] ${upstreamMessage}` : upstreamMessage, payload);
 }
 function requireArray(value, label) {
     if (Array.isArray(value))

package/src/providers/ticketmaster/runtime.js

@@ -357,15 +357,12 @@ async function createTicketmasterError(response, fallbackMessage) {
 function mapTicketmasterErrorFromPayload(status, payload, fallbackMessage) {
     const message = extractTicketmasterErrorMessage(payload) ?? fallbackMessage;
     if (status === 429) {
-        return ticketmasterError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message);
     }
     if ([400, 401, 403, 404].includes(status)) {
-        return ticketmasterError("invalid_input", message, status === 404 ? 400 : status);
+        return new ProviderRequestError(status === 404 ? 400 : status, message);
     }
-    return ticketmasterError("provider_error", message, status >= 500 ? 500 : status);
-}
-function ticketmasterError(_code, message, status = 500) {
-    return new ProviderRequestError(status, message);
+    return new ProviderRequestError(status >= 500 ? 500 : status, message);
 }
 async function readJsonBody(response) {
     const text = await response.text();

package/src/providers/timelinesai/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { createProviderTimeout, providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const timelinesAiApiBaseUrl = "https://app.timelines.ai/integrations/api";
 export const timelinesAiActionHandlers = {
     async get_workspace(_input, context) {
@@ -142,7 +142,7 @@ async function request(input) {
         }
         const envelope = requireProviderObject(payload, "response envelope");
         if (envelope.status !== "ok" || !("data" in envelope)) {
-            throw providerError("provider_error", readErrorMessage(payload), 502);
+            throw providerResponseError(readErrorMessage(payload));
         }
         return envelope.data;
     }
@@ -151,17 +151,14 @@ async function request(input) {
             throw error;
         }
         if (timeout.didTimeout()) {
-            throw providerError("provider_error", "TimelinesAI request timed out", 504);
+            throw new ProviderRequestError(504, "TimelinesAI request timed out");
         }
-        throw providerError("provider_error", error instanceof Error ? `TimelinesAI request failed: ${error.message}` : "TimelinesAI request failed", 502);
+        throw providerResponseError(error instanceof Error ? `TimelinesAI request failed: ${error.message}` : "TimelinesAI request failed");
     }
     finally {
         timeout.cleanup();
     }
 }
-function providerError(_code, message, status) {
-    return new ProviderRequestError(status, message);
-}
 async function readPayload(response) {
     const text = await response.text();
     if (!text) {
@@ -174,24 +171,24 @@ async function readPayload(response) {
         if (!response.ok) {
             return { message: text };
         }
-        throw providerError("provider_error", "TimelinesAI returned invalid JSON", 502);
+        throw providerResponseError("TimelinesAI returned invalid JSON");
     }
 }
 function createRequestError(response, payload, phase) {
     const message = readErrorMessage(payload);
     if (response.status === 429) {
-        return providerError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && (response.status === 401 || response.status === 403)) {
-        return providerError("invalid_input", message, 400);
+        return providerInputError(message);
     }
     if (response.status === 401) {
-        return providerError("credential_expired", message, 401);
+        return new ProviderRequestError(401, message);
     }
     if (response.status === 400 || response.status === 404) {
-        return providerError("invalid_input", message, 400);
+        return providerInputError(message);
     }
-    return providerError("provider_error", message, response.status >= 500 ? 502 : response.status);
+    return new ProviderRequestError(response.status >= 500 ? 502 : response.status, message);
 }
 function readErrorMessage(payload) {
     const record = optionalRecord(payload);
@@ -203,19 +200,19 @@ function commaSeparated(value) {
 function requireProviderObject(value, name) {
     const record = optionalRecord(value);
     if (!record) {
-        throw providerError("provider_error", `TimelinesAI returned invalid ${name}`, 502);
+        throw providerResponseError(`TimelinesAI returned invalid ${name}`);
     }
     return record;
 }
 function requireProviderArray(value, name) {
     if (!Array.isArray(value)) {
-        throw providerError("provider_error", `TimelinesAI returned invalid ${name}`, 502);
+        throw providerResponseError(`TimelinesAI returned invalid ${name}`);
     }
     return value;
 }
 function requireProviderString(value, name) {
     if (typeof value !== "string" || !value) {
-        throw providerError("provider_error", `TimelinesAI returned invalid ${name}`, 502);
+        throw providerResponseError(`TimelinesAI returned invalid ${name}`);
     }
     return value;
 }

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

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

package/src/providers/tradebee/actions.js

@@ -0,0 +1,176 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const language = s.nonWhitespaceString("An enabled site language code returned by list_languages.");
+const id = {
+    type: ["integer", "string"],
+    description: "The resource ID, returned as an integer or string by Tradebee.",
+};
+const paginationInput = s.object("Pagination; omitted values default to page 1 and 5 items.", {
+    current_page: s.integer("Page number, starting at 1.", { minimum: 1 }),
+    page_size: s.integer("Items per page, from 1 to 10.", { minimum: 1, maximum: 10 }),
+}, { optional: ["current_page", "page_size"] });
+const paginationOutput = s.looseObject("Pagination returned by Tradebee; use next_page while has_next_page is true.", {
+    current_page: s.integer("The current page number."),
+    page_size: s.integer("The returned page size."),
+    total_page: s.integer("The total number of pages."),
+    total_count: s.integer("The total number of matching records."),
+    has_next_page: s.boolean("Whether another page is available."),
+    next_page: s.nullable(s.integer("The next page number, or null on the last page.")),
+});
+const commonFields = {
+    language: s.string("The site language code."),
+    tags: s.array("Resource keywords.", s.string("A keyword.")),
+    seo: s.looseObject("Search engine metadata.", {
+        title: s.string("The SEO title."),
+        description: s.string("The SEO description."),
+        keywords: s.string("Comma-separated SEO keywords."),
+    }),
+    create_time: s.string("The creation time as returned by Tradebee."),
+    update_time: s.string("The last update time as returned by Tradebee."),
+};
+const productFields = {
+    products_id: id,
+    ...commonFields,
+    group: s.looseObject("The product group.", {
+        productsgroup_id: id,
+        group_name: s.string("The group name."),
+    }),
+    product_name: s.string("The product name."),
+    model: s.string("The product model."),
+    images: s.array("Product image URLs.", s.string("An image URL.")),
+    attributes: s.array("Product attributes.", s.looseObject("A product attribute.", {
+        name: s.string("The attribute name."),
+        value: s.string("The attribute value."),
+    })),
+    brief_description: s.string("A short product description."),
+    description: s.string("The product HTML description."),
+    view_count: s.integer("The product view count."),
+    inquiry_count: s.integer("The product inquiry count."),
+    products_url: s.string("The product page URL."),
+};
+const productGroupFields = {
+    productsgroup_id: id,
+    ...commonFields,
+    group_name: s.string("The group name."),
+    productsgroup_url: s.string("The product group page URL."),
+    section: s.looseObject("HTML sections of the product group page.", {
+        top: s.string("The header HTML fragment."),
+        bottom: s.string("The footer HTML fragment."),
+    }),
+    is_leaf: s.boolean("Whether the group has no child groups."),
+    children: s.array("Recursive child groups, preserving provider-defined fields.", s.looseObject("A child product group.", {})),
+};
+const blogFields = {
+    blog_id: id,
+    ...commonFields,
+    group: s.looseObject("The blog group.", {
+        bloggroup_id: id,
+        group_name: s.string("The group name."),
+    }),
+    publisher: s.string("The publisher name."),
+    publication_date: s.string("The publication date as returned by Tradebee."),
+    title: s.string("The blog title."),
+    images: s.array("Blog cover image URLs.", s.string("An image URL.")),
+    summary: s.string("The blog summary."),
+    description: s.string("The blog HTML body."),
+    blog_url: s.string("The blog page URL."),
+};
+const blogGroupFields = {
+    bloggroup_id: id,
+    ...commonFields,
+    group_name: s.string("The group name."),
+    brief_description: s.string("A short blog group description."),
+    bloggroup_url: s.string("The blog group page URL."),
+};
+function fieldsInput(fields) {
+    return s.array("Return only these fields; omit to use the provider defaults.", s.stringEnum("A documented response field.", Object.keys(fields)));
+}
+export const tradebeeActions = [
+    defineProviderAction("tradebee", {
+        name: "list_languages",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List the enabled Tradebee site languages before querying products or blogs.",
+        inputSchema: s.requiredObject("No input parameters are required.", {}),
+        outputSchema: s.looseRequiredObject("Enabled site languages.", {
+            list: s.array("The enabled languages.", s.looseObject("An enabled language.", {
+                name: s.string("The language display name."),
+                language: s.string("The site language code."),
+            })),
+        }),
+    }),
+    defineProviderAction("tradebee", {
+        name: "list_products",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read Tradebee products in an enabled language, optionally by product or group. Filters are mutually exclusive. Follow pagination.next_page to continue.",
+        inputSchema: {
+            ...s.object("Product query.", {
+                language,
+                products_id: s.integer("Filter by product ID; cannot be combined with productsgroup_id."),
+                productsgroup_id: s.integer("Filter by product group ID; cannot be combined with products_id."),
+                fields: fieldsInput(productFields),
+                pagination: paginationInput,
+            }, { optional: ["products_id", "productsgroup_id", "fields", "pagination"] }),
+            not: { required: ["products_id", "productsgroup_id"] },
+        },
+        outputSchema: s.looseRequiredObject("A page of products with selected fields.", {
+            list: s.array("Products on this page.", s.looseObject("A product with the selected fields.", productFields)),
+            pagination: paginationOutput,
+        }),
+    }),
+    defineProviderAction("tradebee", {
+        name: "list_product_groups",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read Tradebee product groups and their children. Omit both filters for top-level groups, or select one group or parent. This endpoint is not paginated.",
+        inputSchema: {
+            ...s.object("Product group query.", {
+                language,
+                productsgroup_id: s.integer("Read one product group; cannot be combined with parent_productsgroup_id."),
+                parent_productsgroup_id: s.integer("Read children of this group; 0 selects top-level groups. Cannot be combined with productsgroup_id."),
+                fields: fieldsInput(productGroupFields),
+            }, { optional: ["productsgroup_id", "parent_productsgroup_id", "fields"] }),
+            not: { required: ["productsgroup_id", "parent_productsgroup_id"] },
+        },
+        outputSchema: s.looseRequiredObject("Product group hierarchy with selected fields.", {
+            list: s.array("Product groups.", s.looseObject("A product group with the selected fields.", productGroupFields)),
+        }),
+    }),
+    defineProviderAction("tradebee", {
+        name: "list_blogs",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read Tradebee blogs in an enabled language, optionally by blog or group. Filters are mutually exclusive. Follow pagination.next_page to continue.",
+        inputSchema: {
+            ...s.object("Blog query.", {
+                language,
+                blog_id: s.integer("Filter by blog ID; cannot be combined with bloggroup_id."),
+                bloggroup_id: s.integer("Filter by blog group ID; cannot be combined with blog_id."),
+                fields: fieldsInput(blogFields),
+                pagination: paginationInput,
+            }, { optional: ["blog_id", "bloggroup_id", "fields", "pagination"] }),
+            not: { required: ["blog_id", "bloggroup_id"] },
+        },
+        outputSchema: s.looseRequiredObject("A page of blogs with selected fields.", {
+            list: s.array("Blogs on this page.", s.looseObject("A blog with the selected fields.", blogFields)),
+            pagination: paginationOutput,
+        }),
+    }),
+    defineProviderAction("tradebee", {
+        name: "list_blog_groups",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read Tradebee blog groups in an enabled language, optionally selecting one group. Follow pagination.next_page to continue.",
+        inputSchema: s.object("Blog group query.", {
+            language,
+            bloggroup_id: s.integer("Read one blog group; omit to list all blog groups."),
+            fields: fieldsInput(blogGroupFields),
+            pagination: paginationInput,
+        }, { optional: ["bloggroup_id", "fields", "pagination"] }),
+        outputSchema: s.looseRequiredObject("A page of blog groups with selected fields.", {
+            list: s.array("Blog groups on this page.", s.looseObject("A blog group with the selected fields.", blogGroupFields)),
+            pagination: paginationOutput,
+        }),
+    }),
+];

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

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

package/src/providers/tradebee/executors.js

@@ -0,0 +1,83 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { tradebeeActions } from "./actions.js";
+const baseUrl = "https://platform.tradew.com/openapis";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const routes = {
+    list_languages: "/languages",
+    list_products: "/products/read",
+    list_product_groups: "/productsgroup/read",
+    list_blogs: "/blog/read",
+    list_blog_groups: "/bloggroup/read",
+};
+async function request({ route, body, apiKey, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "Tradebee" }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${route}`, {
+            method: "POST",
+            signal,
+            headers: { ...defaultHeaders, authorization: `Bearer ${apiKey}` },
+            body: JSON.stringify(body),
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const envelope = optionalRecord(payload);
+        if (!response.ok || envelope?.status !== true) {
+            const detail = optionalRawString(envelope?.msg) || `HTTP ${response.status}; invalid or unsuccessful response`;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Tradebee request failed: ${detail.split(apiKey).join("[REDACTED]")}`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return requiredResponseRecord(envelope.data, "Tradebee response data");
+    });
+}
+const handlers = mapProviderActionHandlers("tradebee", tradebeeActions, (action) => async (dataInput, context) => {
+    const route = routes[action.name];
+    const body = dataInput;
+    if (["list_products", "list_blogs", "list_blog_groups"].includes(action.name)) {
+        const pagination = optionalRecord(body.pagination);
+        body.pagination = {
+            current_page: pagination?.current_page ?? 1,
+            page_size: pagination?.page_size ?? 5,
+        };
+    }
+    return request({
+        route: route,
+        body: body,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("tradebee", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request({
+            route: "/languages",
+            body: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return { profile: { displayName: "Tradebee API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "tradebee",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json", "content-type": "application/json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

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

@@ -0,0 +1,17 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { twittrapiActionHandlers, twittrapiApiBaseUrl, validateTwittrapiCredential } from "./runtime.js";
+const service = "twittrapi";
+export const executors = defineApiKeyProviderExecutors(service, twittrapiActionHandlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: twittrapiApiBaseUrl,
+    auth: { type: "api_key_header", name: "x-api-key" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateTwittrapiCredential(input.apiKey, fetcher, signal);
+    },
+};

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

@@ -0,0 +1,12 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ProviderActionHandlers } from "../provider-runtime.ts";
+import type { ApiKeyProviderContext, ProviderFetch, ProviderRuntimeHandler } from "../provider-runtime.ts";
+export declare const twittrapiApiBaseUrl = "https://api.twittrapi.com";
+type TwittrapiActionHandler = ProviderRuntimeHandler<ApiKeyProviderContext>;
+export declare const twittrapiActionHandlers: ProviderActionHandlers<"twittrapi", TwittrapiActionHandler>;
+/**
+ * Validate a TwittrAPI key against the free balance endpoint and report the
+ * account it belongs to.
+ */
+export declare function validateTwittrapiCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export {};