@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/retell_ai/executors.js

@@ -1,16 +1,17 @@
-import { compactObject, nullableInteger, nullableString, optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerUserAgent, requiredInputString, } from "../provider-runtime.js";
+import { compactObject, nullableInteger, nullableString, objectArray, optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredBoolean, requiredNumber, requiredString, } from "../../core/cast.js";
+import { queryParams } from "../../core/request.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerResponseError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, setSearchParams, } from "../provider-runtime.js";
 const service = "retell_ai";
 const retellAiApiBaseUrl = "https://api.retellai.com";
 const validationPath = "/list-voices";
-export const retellAiActionHandlers = {
+const retellAiActionHandlers = {
     async list_voices(_input, context) {
         const payload = await requestRetellAiJson({
             path: validationPath,
             context,
             phase: "execute",
         });
-        const voices = readArrayPayload(payload, "Retell AI voices response");
+        const voices = objectArray(payload, "Retell AI voices response", providerResponseError);
         return {
             voices: voices.map(normalizeVoice),
             raw: voices,
@@ -26,29 +27,26 @@ export const retellAiActionHandlers = {
     },
     async list_voice_agents(input, context) {
         const payload = await requestRetellAiJson({
-            path: "/list-agents",
+            path: "/v2/list-agents",
+            method: "POST",
             context,
-            query: compactObject({
+            query: {
                 limit: optionalInteger(input.limit),
                 pagination_key: optionalString(input.paginationKey),
-                pagination_key_version: optionalInteger(input.paginationKeyVersion),
-                is_latest: optionalBoolean(input.isLatest),
-            }),
+                sort_order: optionalString(input.sortOrder),
+            },
+            body: { filter_criteria: { channel: { type: "string", op: "eq", value: "voice" } } },
             phase: "execute",
         });
-        const agents = readArrayPayload(payload, "Retell AI voice agents response");
-        return {
-            agents: agents.map(normalizeAgent),
-            raw: agents,
-        };
+        return normalizePaginatedAgents(payload);
     },
     async get_voice_agent(input, context) {
         const payload = await requestRetellAiJson({
             path: `/get-agent/${encodeURIComponent(requiredInputString(input.agentId, "agentId"))}`,
             context,
-            query: compactObject({
+            query: {
                 version: optionalString(input.version) ?? optionalInteger(input.version),
-            }),
+            },
             phase: "execute",
         });
         return { agent: normalizeAgent(payload) };
@@ -57,11 +55,11 @@ export const retellAiActionHandlers = {
         const payload = await requestRetellAiJson({
             path: "/v2/list-phone-numbers",
             context,
-            query: compactObject({
+            query: {
                 limit: optionalInteger(input.limit),
                 sort_order: optionalString(input.sortOrder),
                 pagination_key: optionalString(input.paginationKey),
-            }),
+            },
             phase: "execute",
         });
         return normalizePaginatedPhoneNumbers(payload);
@@ -133,9 +131,7 @@ export const credentialValidators = {
 };
 async function requestRetellAiJson(input) {
     const url = new URL(input.path, retellAiApiBaseUrl);
-    for (const [key, value] of Object.entries(input.query ?? {})) {
-        appendQueryValue(url, key, value);
-    }
+    setSearchParams(url, queryParams(input.query ?? {}));
     const method = input.method ?? "GET";
     const headers = {
         accept: "application/json",
@@ -151,22 +147,14 @@ async function requestRetellAiJson(input) {
         headers["content-type"] = "application/json";
         init.body = JSON.stringify(input.body);
     }
-    let response;
-    let payload;
-    try {
-        response = await input.context.fetcher(url.toString(), init);
-        payload = await readRetellAiPayload(response);
-    }
-    catch (error) {
-        if (error instanceof ProviderRequestError) {
-            throw error;
+    return runProviderRequest({ signal: input.context.signal, label: "Retell AI" }, async (signal) => {
+        const response = await input.context.fetcher(url.toString(), { ...init, signal });
+        const payload = await readRetellAiPayload(response);
+        if (!response.ok) {
+            throw createRetellAiError(response, payload, input.phase);
         }
-        throw new ProviderRequestError(502, error instanceof Error ? `Retell AI request failed: ${error.message}` : "Retell AI request failed");
-    }
-    if (!response.ok) {
-        throw createRetellAiError(response, payload, input.phase);
-    }
-    return payload;
+        return payload;
+    });
 }
 async function readRetellAiPayload(response) {
     const text = await response.text();
@@ -188,37 +176,19 @@ function createRetellAiError(response, payload, phase) {
     if (phase === "validate" && response.status >= 400 && response.status < 500) {
         return new ProviderRequestError(400, message, payload);
     }
-    return new ProviderRequestError(response.status || 502, message, payload);
+    return new ProviderRequestError(response.status || 502, message, payload, "provider_error");
 }
 function extractRetellAiErrorMessage(payload) {
     const record = optionalRecord(payload);
     return record ? (optionalString(record.message) ?? optionalString(record.error)) : undefined;
 }
-function appendQueryValue(url, key, value) {
-    if (value !== undefined && value !== null && value !== "") {
-        url.searchParams.set(key, String(value));
-    }
-}
-function readArrayPayload(payload, label) {
-    if (!Array.isArray(payload)) {
-        throw new ProviderRequestError(502, `${label} was not an array`);
-    }
-    return payload.map((item) => ensureRecord(item, label));
-}
-function ensureRecord(value, label) {
-    const record = optionalRecord(value);
-    if (!record) {
-        throw new ProviderRequestError(502, `${label} included a non-object item`);
-    }
-    return record;
-}
 function normalizeVoice(value) {
-    const record = ensureRecord(value, "Retell AI voice response");
+    const record = requiredResponseRecord(value, "Retell AI voice response");
     return {
-        voiceId: requireProviderString(record.voice_id, "voice_id"),
-        voiceName: requireProviderString(record.voice_name, "voice_name"),
-        provider: requireProviderString(record.provider, "provider"),
-        gender: requireProviderString(record.gender, "gender"),
+        voiceId: requiredString(record.voice_id, "voice_id", providerResponseError),
+        voiceName: requiredString(record.voice_name, "voice_name", providerResponseError),
+        provider: requiredString(record.provider, "provider", providerResponseError),
+        gender: requiredString(record.gender, "gender", providerResponseError),
         accent: nullableString(record.accent) ?? null,
         age: nullableString(record.age) ?? null,
         previewAudioUrl: nullableString(record.preview_audio_url) ?? null,
@@ -226,9 +196,9 @@ function normalizeVoice(value) {
     };
 }
 function normalizeAgent(value) {
-    const record = ensureRecord(value, "Retell AI voice agent response");
+    const record = requiredResponseRecord(value, "Retell AI voice agent response");
     return {
-        agentId: requireProviderString(record.agent_id, "agent_id"),
+        agentId: requiredString(record.agent_id, "agent_id", providerResponseError),
         version: nullableInteger(record.version) ?? null,
         agentName: nullableString(record.agent_name) ?? null,
         voiceId: nullableString(record.voice_id) ?? null,
@@ -238,9 +208,9 @@ function normalizeAgent(value) {
     };
 }
 function normalizePhoneNumber(value) {
-    const record = ensureRecord(value, "Retell AI phone number response");
+    const record = requiredResponseRecord(value, "Retell AI phone number response");
     return {
-        phoneNumber: requireProviderString(record.phone_number, "phone_number"),
+        phoneNumber: requiredString(record.phone_number, "phone_number", providerResponseError),
         phoneNumberType: nullableString(record.phone_number_type) ?? null,
         phoneNumberPretty: nullableString(record.phone_number_pretty) ?? null,
         nickname: nullableString(record.nickname) ?? null,
@@ -250,9 +220,9 @@ function normalizePhoneNumber(value) {
     };
 }
 function normalizeCall(value) {
-    const record = ensureRecord(value, "Retell AI call response");
+    const record = requiredResponseRecord(value, "Retell AI call response");
     return {
-        callId: requireProviderString(record.call_id, "call_id"),
+        callId: requiredString(record.call_id, "call_id", providerResponseError),
         callType: nullableString(record.call_type) ?? null,
         agentId: nullableString(record.agent_id) ?? null,
         agentName: nullableString(record.agent_name) ?? null,
@@ -266,22 +236,38 @@ function normalizeCall(value) {
         raw: record,
     };
 }
+function normalizePaginatedAgents(payload) {
+    const record = requiredResponseRecord(payload, "Retell AI voice agents response");
+    return {
+        paginationKey: nullableString(record.pagination_key) ?? null,
+        hasMore: requiredBoolean(record.has_more, "has_more", providerResponseError),
+        agents: objectArray(record.items, "Retell AI voice agents response.items", providerResponseError).map((agent) => ({
+            agentId: requiredString(agent.agent_id, "agent_id", providerResponseError),
+            agentName: nullableString(agent.agent_name) ?? null,
+            channel: requiredString(agent.channel, "channel", providerResponseError),
+            userModifiedTimestamp: requiredNumber(agent.user_modified_timestamp, "user_modified_timestamp", providerResponseError),
+            tags: requiredResponseRecord(agent.tags, "tags"),
+            raw: agent,
+        })),
+        raw: record,
+    };
+}
 function normalizePaginatedPhoneNumbers(payload) {
-    const record = ensureRecord(payload, "Retell AI phone numbers response");
+    const record = requiredResponseRecord(payload, "Retell AI phone numbers response");
     return {
         paginationKey: nullableString(record.pagination_key) ?? null,
-        hasMore: requireProviderBoolean(record.has_more, "has_more"),
-        phoneNumbers: readPaginatedItems(record.items, "Retell AI phone numbers response.items").map(normalizePhoneNumber),
+        hasMore: requiredBoolean(record.has_more, "has_more", providerResponseError),
+        phoneNumbers: objectArray(record.items, "Retell AI phone numbers response.items", providerResponseError).map(normalizePhoneNumber),
         raw: record,
     };
 }
 function normalizePaginatedCalls(payload) {
-    const record = ensureRecord(payload, "Retell AI calls response");
+    const record = requiredResponseRecord(payload, "Retell AI calls response");
     return {
         paginationKey: nullableString(record.pagination_key) ?? null,
-        hasMore: requireProviderBoolean(record.has_more, "has_more"),
+        hasMore: requiredBoolean(record.has_more, "has_more", providerResponseError),
         total: nullableInteger(record.total) ?? null,
-        calls: readPaginatedItems(record.items, "Retell AI calls response.items").map(normalizeCall),
+        calls: objectArray(record.items, "Retell AI calls response.items", providerResponseError).map(normalizeCall),
         raw: record,
     };
 }
@@ -301,28 +287,9 @@ function buildAgentFilter(value) {
 function buildEnumFilter(value) {
     return Array.isArray(value) && value.length > 0
         ? {
-            operator: "in",
+            type: "enum",
+            op: "in",
             value: value.map(String),
         }
         : undefined;
 }
-function requireProviderString(value, fieldName) {
-    const parsed = optionalString(value);
-    if (!parsed) {
-        throw new ProviderRequestError(502, `Retell AI response did not include ${fieldName}`);
-    }
-    return parsed;
-}
-function requireProviderBoolean(value, fieldName) {
-    const parsed = optionalBoolean(value);
-    if (parsed === undefined) {
-        throw new ProviderRequestError(502, `Retell AI response did not include boolean ${fieldName}`);
-    }
-    return parsed;
-}
-function readPaginatedItems(value, fieldName) {
-    if (!Array.isArray(value)) {
-        throw new ProviderRequestError(502, `${fieldName} was not an array`);
-    }
-    return value;
-}

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

@@ -0,0 +1,25 @@
+import { optionalString, optionalRawString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { roxyapiActionHandlers, roxyapiBaseUrl, readRoxyapiError, requestRoxyapiJson, requireRoxyapiServerKey, } from "./runtime.js";
+const service = "roxyapi";
+export const executors = defineApiKeyProviderExecutors(service, roxyapiActionHandlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: roxyapiBaseUrl,
+    auth: { type: "api_key_header", name: "X-API-Key" },
+    readError: readRoxyapiError,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const usage = await requestRoxyapiJson(new URL(`${roxyapiBaseUrl}/usage`), requireRoxyapiServerKey(input.apiKey), fetcher, "validate", undefined, signal);
+        return {
+            profile: { displayName: optionalString(usage.email) ?? "RoxyAPI API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: roxyapiBaseUrl, validationEndpoint: "/usage", plan: optionalRawString(usage.plan) },
+        };
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { ProviderActionHandlers, ApiKeyProviderContext, ProviderRuntimeHandler } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const roxyapiBaseUrl = "https://roxyapi.com/api/v2";
+type RequestPhase = "validate" | "execute";
+export declare function requireRoxyapiServerKey(apiKey: string): string;
+export declare function requestRoxyapiJson(url: URL, apiKey: string, fetcher: typeof fetch, phase: RequestPhase, body?: Record<string, unknown>, callerSignal?: AbortSignal): Promise<Record<string, unknown>>;
+/** Interpret failed action, validation and proxy responses with the same provider error signals. */
+export declare function readRoxyapiError(response: Response, phase?: RequestPhase): Promise<ProviderRequestError>;
+export declare const roxyapiActionHandlers: ProviderActionHandlers<"roxyapi", ProviderRuntimeHandler<ApiKeyProviderContext>>;
+export {};

package/src/providers/roxyapi/runtime.js

@@ -0,0 +1,279 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { readProviderTextBody, mapProviderActionSources, providerInputError, ProviderRequestError, providerUserAgent, parseProviderJsonBodyText, readProviderErrorTextBody, requiredResponseRecord, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+const roxyapiRoutes = {
+    get_forecast_timeline: {
+        method: "POST",
+        path: "/forecast/timeline",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_forecast_digest: {
+        method: "POST",
+        path: "/forecast/digest",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_bazi_luck_pillars: {
+        method: "POST",
+        path: "/chinese-astrology/bazi/luck-pillars",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_bazi_day_master_strength: {
+        method: "POST",
+        path: "/chinese-astrology/bazi/day-master",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_bazi_annual_forecast: {
+        method: "POST",
+        path: "/chinese-astrology/bazi/annual-forecast",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    convert_lunar_date: {
+        method: "POST",
+        path: "/chinese-astrology/calendar/lunar-date",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_almanac_day: {
+        method: "GET",
+        path: "/chinese-astrology/calendar/day/{date}",
+        pathKeys: ["date"],
+        queryKeys: ["lang"],
+    },
+    find_auspicious_days: {
+        method: "POST",
+        path: "/chinese-astrology/calendar/auspicious-days",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_usage: { method: "GET", path: "/usage", pathKeys: [], queryKeys: [] },
+    search_cities: {
+        method: "GET",
+        path: "/location/search",
+        pathKeys: [],
+        queryKeys: ["q", "limit", "offset"],
+    },
+    get_natal_chart: {
+        method: "POST",
+        path: "/astrology/natal-chart",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_synastry: { method: "POST", path: "/astrology/synastry", pathKeys: [], queryKeys: ["lang"] },
+    get_daily_horoscope: {
+        method: "GET",
+        path: "/astrology/horoscope/{sign}/daily",
+        pathKeys: ["sign"],
+        queryKeys: ["lang", "date", "timezone"],
+    },
+    get_weekly_horoscope: {
+        method: "GET",
+        path: "/astrology/horoscope/{sign}/weekly",
+        pathKeys: ["sign"],
+        queryKeys: ["lang", "date", "timezone"],
+    },
+    get_monthly_horoscope: {
+        method: "GET",
+        path: "/astrology/horoscope/{sign}/monthly",
+        pathKeys: ["sign"],
+        queryKeys: ["lang", "date", "timezone"],
+    },
+    get_yearly_horoscope: {
+        method: "GET",
+        path: "/astrology/horoscope/{sign}/yearly",
+        pathKeys: ["sign"],
+        queryKeys: ["lang", "year", "timezone"],
+    },
+    get_bazi_chart: {
+        method: "POST",
+        path: "/chinese-astrology/bazi/chart",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_bazi_compatibility: {
+        method: "POST",
+        path: "/chinese-astrology/bazi/compatibility",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_bodygraph: {
+        method: "POST",
+        path: "/human-design/bodygraph",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_human_design_connection: {
+        method: "POST",
+        path: "/human-design/connection",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_numerology_chart: {
+        method: "POST",
+        path: "/numerology/chart",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    get_numerology_compatibility: {
+        method: "POST",
+        path: "/numerology/compatibility",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    list_tarot_cards: {
+        method: "GET",
+        path: "/tarot/cards",
+        pathKeys: [],
+        queryKeys: ["lang", "limit", "offset", "arcana", "suit", "number"],
+    },
+    get_tarot_card: {
+        method: "GET",
+        path: "/tarot/cards/{id}",
+        pathKeys: ["id"],
+        queryKeys: ["lang"],
+    },
+    draw_tarot_cards: { method: "POST", path: "/tarot/draw", pathKeys: [], queryKeys: ["lang"] },
+    get_daily_tarot: { method: "POST", path: "/tarot/daily", pathKeys: [], queryKeys: ["lang"] },
+    cast_yes_no_tarot: { method: "POST", path: "/tarot/yes-no", pathKeys: [], queryKeys: ["lang"] },
+    cast_three_card_tarot: {
+        method: "POST",
+        path: "/tarot/spreads/three-card",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    cast_celtic_cross_tarot: {
+        method: "POST",
+        path: "/tarot/spreads/celtic-cross",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    cast_love_tarot: {
+        method: "POST",
+        path: "/tarot/spreads/love",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    cast_career_tarot: {
+        method: "POST",
+        path: "/tarot/spreads/career",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    cast_custom_tarot: {
+        method: "POST",
+        path: "/tarot/spreads/custom",
+        pathKeys: [],
+        queryKeys: ["lang"],
+    },
+    cast_iching: { method: "GET", path: "/iching/cast", pathKeys: [], queryKeys: ["lang", "seed"] },
+};
+export const roxyapiBaseUrl = "https://roxyapi.com/api/v2";
+export function requireRoxyapiServerKey(apiKey) {
+    const key = requiredInputString(apiKey, "apiKey");
+    if (key.startsWith("pk_")) {
+        throw providerInputError("RoxyAPI requires a server-side secret key (sk_), not a publishable browser key (pk_). Get a secret key at https://roxyapi.com/account.");
+    }
+    return key;
+}
+async function executeRoxyapiAction(actionName, input, apiKey, fetcher, callerSignal) {
+    input = normalizeRoxyapiInput(actionName, input);
+    const route = roxyapiRoutes[actionName];
+    let path = route.path;
+    for (const key of route.pathKeys) {
+        path = path.replace(`{${key}}`, encodeURIComponent(String(input[key])));
+    }
+    const url = new URL(`${roxyapiBaseUrl}${path}`);
+    for (const key of route.queryKeys) {
+        if (input[key] !== undefined) {
+            url.searchParams.set(key, String(input[key]));
+        }
+    }
+    const body = Object.fromEntries(Object.entries(input).filter(([key]) => !route.pathKeys.includes(key) && !route.queryKeys.includes(key)));
+    return requestRoxyapiJson(url, apiKey, fetcher, "execute", route.method === "POST" ? body : undefined, callerSignal);
+}
+export async function requestRoxyapiJson(url, apiKey, fetcher, phase, body, callerSignal) {
+    return runProviderRequest({ label: "RoxyAPI", signal: callerSignal }, async (signal) => {
+        const response = await fetcher(url, {
+            method: body === undefined ? "GET" : "POST",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+                "X-API-Key": apiKey,
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok) {
+            throw await readRoxyapiError(response, phase);
+        }
+        const text = await readProviderTextBody(response, "RoxyAPI response");
+        const payload = parseProviderJsonBodyText(text, {
+            emptyBody: null,
+            invalidJsonMessage: "RoxyAPI returned invalid JSON",
+        });
+        return requiredResponseRecord(payload, "RoxyAPI response");
+    });
+}
+/** Interpret failed action, validation and proxy responses with the same provider error signals. */
+export async function readRoxyapiError(response, phase = "execute") {
+    const text = await readProviderErrorTextBody(response, "RoxyAPI error response");
+    let payload;
+    try {
+        payload = parseProviderJsonBodyText(text, { emptyBody: null, invalidJsonMessage: "RoxyAPI returned invalid JSON" });
+    }
+    catch {
+        // Non-JSON denials have no documented credential signal and keep the upstream status.
+    }
+    return createRoxyapiError(response.status, payload, phase);
+}
+function createRoxyapiError(status, payload, phase) {
+    const record = optionalRecord(payload);
+    const code = optionalRawString(record?.code);
+    const upstreamMessage = optionalRawString(record?.error);
+    const message = `${code ? `${code}: ` : ""}${upstreamMessage ?? `RoxyAPI request failed with status ${status}`}`;
+    const data = {
+        upstreamCode: code,
+        docUrl: optionalRawString(record?.doc_url),
+        issues: Array.isArray(record?.issues) ? record.issues : undefined,
+    };
+    // Only documented key failures ask callers to reconnect; plan and origin failures keep their status.
+    if (status === 401 && (code === "invalid_api_key" || code === "api_key_revoked")) {
+        return new ProviderRequestError(phase === "validate" ? 400 : 401, message, data, phase === "validate" ? "invalid_input" : "authorization_failed");
+    }
+    if (status === 429) {
+        return new ProviderRequestError(429, message, data, "rate_limited");
+    }
+    if (status === 400 && ["validation_error", "bad_request", "date_out_of_range"].includes(code ?? "")) {
+        return new ProviderRequestError(400, message, data, "invalid_input");
+    }
+    return new ProviderRequestError(status, message, data, "provider_error");
+}
+export const roxyapiActionHandlers = mapProviderActionSources("roxyapi", roxyapiRoutes, (name) => (input, context) => executeRoxyapiAction(name, input, requireRoxyapiServerKey(context.apiKey), context.fetcher, context.signal));
+function normalizeRoxyapiInput(actionName, input) {
+    const normalized = { ...input };
+    const sign = optionalRawString(input.sign);
+    if (sign !== undefined)
+        normalized.sign = sign.trim().toLowerCase();
+    const activity = optionalRawString(input.activity);
+    if (activity !== undefined)
+        normalized.activity = activity.trim().toLowerCase().split("_").join("-");
+    const start = optionalRawString(input.startDate);
+    const end = optionalRawString(input.endDate);
+    if (["get_forecast_timeline", "find_auspicious_days"].includes(actionName) &&
+        start !== undefined &&
+        end !== undefined &&
+        end < start)
+        throw providerInputError("endDate must be on or after startDate");
+    if (actionName === "get_almanac_day" && (String(input.date) < "1900-01-01" || String(input.date) > "2100-12-31"))
+        throw providerInputError("almanac date must be within years 1900 through 2100");
+    if (["get_bazi_luck_pillars", "get_bazi_day_master_strength", "get_bazi_annual_forecast"].includes(actionName) &&
+        input.hourClock !== undefined &&
+        input.hourClock !== "clock" &&
+        input.longitude === undefined)
+        throw providerInputError("longitude is required when hourClock is local-mean or solar");
+    return normalized;
+}

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

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

package/src/providers/scanmalware/executors.js

@@ -0,0 +1,17 @@
+import { defineProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { scanmalwareActionHandlers, scanmalwareApiBaseUrl } from "./runtime.js";
+const service = "scanmalware";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: scanmalwareActionHandlers,
+    skipDnsValidation: true,
+    createContext(context, fetcher) {
+        return { fetcher, signal: context.signal };
+    },
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: scanmalwareApiBaseUrl,
+    auth: { type: "none" },
+    skipDnsValidation: true,
+});

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

@@ -0,0 +1,9 @@
+import type { ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const scanmalwareApiBaseUrl = "https://scanmalware.com";
+export interface ScanmalwareRuntimeContext {
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type ScanmalwareActionHandler = (input: Record<string, unknown>, context: ScanmalwareRuntimeContext) => Promise<unknown>;
+export declare const scanmalwareActionHandlers: ProviderActionHandlers<"scanmalware", ScanmalwareActionHandler>;
+export {};