@oomol-lab/open-connector 1.8.0 → 1.9.0

package/src/providers/sendblue/actions.js

@@ -0,0 +1,163 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const phone = (description) => s.string(description, { pattern: "^\\+[1-9][0-9]{1,14}$" });
+const number = phone("Contact phone number in E.164 format.");
+const tags = s.array("Complete set of contact tags; replaces existing tags on update.", s.string("A tag label."));
+const variables = s.record("Custom variables keyed by human-readable label; new labels are created and updates merge existing values.", s.string("A custom variable value."));
+const fields = {
+    first_name: s.string("Contact first name."),
+    last_name: s.string("Contact last name."),
+    sendblue_number: phone("Associated Sendblue phone number in E.164 format."),
+    assigned_to_email: s.string("Email of the user assigned to the contact."),
+    tags,
+    custom_variables: variables,
+};
+const contact = s.looseObject("Contact returned by Sendblue; upstream snake_case or camelCase fields are preserved.", {
+    phone: s.string("Contact phone number."),
+    contact_id: s.string("Immutable contact identifier when returned."),
+});
+const status = s.string("Upstream operation status.");
+const contactOutput = s.looseObject("Contact operation response.", { status, contact });
+const statusOutput = s.looseObject("Operation response.", { status });
+export const sendblueActions = [
+    defineProviderAction("sendblue", {
+        name: "list_contacts",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List Sendblue contacts with offset pagination, phone or identity filters, and sorting.",
+        inputSchema: s.object("Contact list input.", {
+            limit: s.integer("Maximum contacts per page; defaults to 100, capped at 1000.", {
+                minimum: 1,
+                maximum: 1000,
+                default: 100,
+            }),
+            offset: s.integer("Contacts to skip; capped at 10000.", {
+                minimum: 0,
+                maximum: 10000,
+                default: 0,
+            }),
+            order_by: s.stringEnum("Contact sort field.", ["created_at", "firstName", "lastName", "phone"]),
+            order_direction: s.stringEnum("Sort direction.", ["asc", "desc"]),
+            phone_number: number,
+            cid: s.nonEmptyString("Filter by contact ID."),
+            created_at_gte: s.string("Include contacts created at or after this ISO 8601 timestamp.", {
+                format: "date-time",
+            }),
+        }, {
+            optional: ["limit", "offset", "order_by", "order_direction", "phone_number", "cid", "created_at_gte"],
+        }),
+        outputSchema: s.requiredObject("Contact list response; advance offset by the returned count to request another page.", {
+            contacts: s.array("Contacts in this page.", contact),
+        }),
+    }),
+    defineProviderAction("sendblue", {
+        name: "count_contacts",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Count Sendblue contacts, optionally filtered by phone number.",
+        inputSchema: s.object("Contact count input.", { phone_number: number }, { optional: ["phone_number"] }),
+        outputSchema: s.looseObject("Contact count response.", {
+            count: s.integer("Number of matching contacts."),
+        }),
+    }),
+    defineProviderAction("sendblue", {
+        name: "get_contact",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve a Sendblue contact by phone number.",
+        inputSchema: s.requiredObject("Contact lookup input.", { number }),
+        outputSchema: contactOutput,
+    }),
+    defineProviderAction("sendblue", {
+        name: "create_contact",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Create a Sendblue contact, optionally updating an existing contact with the same number.",
+        inputSchema: s.object("Contact creation input.", {
+            number,
+            ...fields,
+            update_if_exists: s.boolean("Update the contact when it already exists; defaults to false."),
+        }, { optional: [...Object.keys(fields), "update_if_exists"] }),
+        outputSchema: contactOutput,
+    }),
+    defineProviderAction("sendblue", {
+        name: "update_contact",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Update a Sendblue contact. Tags replace the full set; custom variables merge with existing values.",
+        inputSchema: s.object("Contact update input.", {
+            number,
+            ...fields,
+            phone_number: phone("New phone number in E.164 format; number selects the existing contact."),
+            company_name: s.string("Contact company name."),
+            opt_out: s.boolean("Whether the contact is opted out of SMS."),
+        }, { optional: [...Object.keys(fields), "phone_number", "company_name", "opt_out"] }),
+        outputSchema: contactOutput,
+    }),
+    defineProviderAction("sendblue", {
+        name: "delete_contact",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Delete a Sendblue contact by phone number.",
+        inputSchema: s.requiredObject("Contact deletion input.", { number }),
+        outputSchema: statusOutput,
+    }),
+    defineProviderAction("sendblue", {
+        name: "bulk_create_contacts",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Create multiple Sendblue contacts and return successful contacts and any per-contact failures.",
+        inputSchema: s.requiredObject("Bulk contact creation input.", {
+            contacts: s.array("Contacts to create.", s.object("One contact to create.", {
+                phone: number,
+                firstName: fields.first_name,
+                lastName: fields.last_name,
+                company: s.string("Contact company name."),
+                tags,
+                customVariables: variables,
+            }, { optional: ["firstName", "lastName", "company", "tags", "customVariables"] }), { minItems: 1 }),
+        }),
+        outputSchema: s.looseObject("Bulk contact creation response; inspect failures even when the request succeeds.", {
+            status,
+            contacts: s.array("Successfully created contacts.", contact),
+            numberOfContactsCreated: s.integer("Number of contacts created."),
+            failures: s.array("Per-contact creation failures when present.", s.looseObject("One contact creation failure.", {
+                contact: s.looseObject("Submitted contact that failed."),
+                error: s.string("Reason the contact failed."),
+            })),
+        }),
+    }),
+    defineProviderAction("sendblue", {
+        name: "bulk_delete_contacts",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Delete multiple Sendblue contacts by phone number and return deletion counts.",
+        inputSchema: s.requiredObject("Bulk contact deletion input.", {
+            contact_ids: s.array("Phone numbers of contacts to delete, not internal IDs.", number, {
+                minItems: 1,
+            }),
+        }),
+        outputSchema: s.looseObject("Bulk contact deletion response.", {
+            status,
+            amount: s.integer("Upstream amount count."),
+            total: s.integer("Total contacts processed."),
+            successes: s.integer("Successful deletions."),
+            failures: s.integer("Failed deletions."),
+        }),
+    }),
+    defineProviderAction("sendblue", {
+        name: "set_contact_opt_out",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Set a Sendblue contact's messaging opt-out preference, or opt the contact back in.",
+        inputSchema: s.object("Contact messaging preference input.", {
+            number,
+            opted_out: s.withDefault(s.boolean("True blocks outbound messages; false opts back in. Defaults to true."), true),
+        }, { optional: ["opted_out"] }),
+        outputSchema: s.looseObject("Contact messaging preference response.", {
+            status,
+            number: s.string("Normalized contact phone number."),
+            opted_out: s.boolean("Current opt-out preference."),
+        }),
+    }),
+];

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

@@ -0,0 +1,156 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { providerResponseError, defineProviderExecutors, requireApiKeyCredential, defineProviderProxy, mapProviderActionHandlers, requiredInputString, requiredResponseRecord, providerUserAgent, runProviderRequest, isAbortLikeError, ProviderRequestError, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { sendblueActions } from "./actions.js";
+const baseUrl = "https://api.sendblue.com";
+const contactsPath = "/api/v2/contacts";
+async function request({ endpoint, method, parameters, apiKey, apiSecret, fetcher, signal: parentSignal, }) {
+    const url = new URL(endpoint, baseUrl);
+    if (method === "GET") {
+        for (const [key, value] of Object.entries(parameters)) {
+            if (value != null)
+                url.searchParams.set(key, String(value));
+        }
+    }
+    try {
+        return await runProviderRequest({ label: "Sendblue", signal: parentSignal }, async (signal) => {
+            const response = await fetcher(url, {
+                method,
+                signal,
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/json",
+                    "user-agent": providerUserAgent,
+                    "sb-api-key-id": apiKey,
+                    "sb-api-secret-key": apiSecret,
+                },
+                body: method === "GET" || Object.keys(parameters).length === 0 ? undefined : JSON.stringify(parameters),
+            });
+            let payload = undefined;
+            try {
+                payload = await response.json();
+            }
+            catch (error) {
+                if (isAbortLikeError(error))
+                    throw error;
+                if (response.ok)
+                    throw providerResponseError("Sendblue returned malformed JSON");
+            }
+            const record = optionalRecord(payload);
+            if (!response.ok || record?.status === "ERROR") {
+                throw new ProviderRequestError(response.ok ? 502 : response.status, optionalRawString(record?.message) ?? optionalRawString(record?.error) ?? `Sendblue HTTP ${response.status}`, withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+            }
+            return payload;
+        });
+    }
+    catch (error) {
+        // Redact credentials from upstream and network errors.
+        if (error instanceof Error)
+            error.message = error.message.replaceAll(apiKey, "[REDACTED]").replaceAll(apiSecret, "[REDACTED]");
+        throw error;
+    }
+}
+const handlers = mapProviderActionHandlers("sendblue", sendblueActions, (action) => async (values, context) => {
+    let endpoint = contactsPath;
+    let method = "GET";
+    let parameters = values;
+    if (action.name === "list_contacts")
+        parameters = { ...values, limit: values.limit ?? 100, offset: values.offset ?? 0 };
+    if (action.name === "set_contact_opt_out")
+        parameters = { ...values, opted_out: values.opted_out ?? true };
+    switch (action.name) {
+        case "count_contacts":
+            endpoint += "/count";
+            break;
+        case "get_contact":
+        case "delete_contact":
+        case "update_contact": {
+            const { number, ...body } = values;
+            endpoint += `/${encodeURIComponent(String(number))}`;
+            method = action.name === "update_contact" ? "PUT" : action.name === "delete_contact" ? "DELETE" : "GET";
+            parameters = body;
+            break;
+        }
+        case "create_contact":
+            method = "POST";
+            break;
+        case "bulk_create_contacts":
+            method = "POST";
+            endpoint += "/bulk";
+            break;
+        case "bulk_delete_contacts":
+            method = "DELETE";
+            break;
+        case "set_contact_opt_out":
+            method = "POST";
+            endpoint += "/opt-out";
+            break;
+    }
+    const payload = await request({ ...context, endpoint, method, parameters });
+    if (action.name === "list_contacts")
+        return { contacts: requireContacts(payload) };
+    return requiredResponseRecord(payload, "Sendblue response");
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = requiredResponseRecord(await request({
+            endpoint: `${contactsPath}/count`,
+            method: "GET",
+            parameters: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            apiSecret: requiredInputString(input.values.apiSecret, "apiSecret"),
+            fetcher,
+            signal,
+        }), "Sendblue contact count");
+        if (typeof payload.count !== "number" || !Number.isFinite(payload.count)) {
+            throw providerResponseError("Sendblue contact count is missing");
+        }
+        return {
+            profile: { displayName: "Sendblue API Key" },
+            grantedScopes: [],
+            metadata: { validationEndpoint: `${contactsPath}/count` },
+        };
+    },
+};
+function requireContacts(payload) {
+    if (!Array.isArray(payload))
+        throw providerResponseError("Sendblue contacts is not an array");
+    return payload;
+}
+export const executors = defineProviderExecutors({
+    service: "sendblue",
+    handlers,
+    skipDnsValidation: true,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, "sendblue");
+        return {
+            apiKey: credential.apiKey,
+            apiSecret: requiredInputString(credential.values.apiSecret, "apiSecret"),
+            fetcher,
+            signal: context.signal,
+        };
+    },
+});
+export const proxy = defineProviderProxy({
+    service: "sendblue",
+    baseUrl,
+    auth: {
+        type: "credential_headers",
+        headers: [
+            { name: "sb-api-key-id", source: { type: "api_key" } },
+            { name: "sb-api-secret-key", source: { type: "credential_value", name: "apiSecret" } },
+        ],
+    },
+    skipDnsValidation: true,
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, `Provider request failed with HTTP ${response.status}`), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({
+            accept: "application/json",
+            "content-type": "application/json",
+            "user-agent": providerUserAgent,
+        }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+});

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

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

package/src/providers/serwersms_pl/actions.js

@@ -0,0 +1,166 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const service = "serwersms_pl";
+function stringOrArray(description, maxItems) {
+    return s.anyOf(description, [
+        s.nonEmptyString("A single value."),
+        s.array("Multiple values.", s.nonEmptyString("One value."), { minItems: 1, maxItems }),
+    ]);
+}
+const messageItems = s.array("Message records, including per-recipient status and errors.", s.looseObject("A message record returned by SerwerSMS.pl."));
+const successOutput = s.looseObject("The operation result.", {
+    success: s.boolean("Whether the operation succeeded."),
+});
+export const serwersmsPlActions = [
+    defineProviderAction(service, {
+        name: "send_sms",
+        description: "Send or schedule SMS messages with the same content. Omit sender for ECO+ or use an approved sender for FULL SMS. A queued result does not mean delivery.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: {
+            ...s.object("SMS content, recipients, and delivery options.", {
+                text: s.nonEmptyString("The message content; for vcard, supply newline-separated vCard text."),
+                phone: stringOrArray("Recipient phone numbers, preferably in international +country format. Use batches of 50–200 numbers.", 100000),
+                group_id: stringOrArray("Recipient group IDs in the Customer Panel."),
+                contact_id: stringOrArray("Recipient contact IDs in the Customer Panel."),
+                sender: s.string("An approved sender name or number for FULL SMS; empty or omitted selects ECO+. Use 2waySMS for a reply-capable random number."),
+                flash: s.boolean("Send as a flash SMS if enabled on the account."),
+                test: s.boolean("Simulate submission without sending messages."),
+                wap_push: s.string("The WAP Push URL."),
+                utf: s.boolean("Enable Unicode for FULL SMS; requires sender and reduces a single part to 70 characters."),
+                details: s.boolean({
+                    description: "Include individual message IDs and statuses; defaults to true.",
+                    default: true,
+                }),
+                vcard: s.boolean("Interpret the message text as a vCard."),
+                speed: s.boolean("Use the highest-quality independent channel, which may incur an extra charge."),
+                date: s.nonEmptyString("Scheduled dispatch time in provider format, for example 2026-12-01 12:25:55."),
+                unique_id: s.anyOf("Caller-assigned message IDs; provide one per recipient, with unique values.", [
+                    s.string("One caller-assigned ID.", {
+                        minLength: 3,
+                        maxLength: 50,
+                        pattern: "^[a-zA-Z0-9]+$",
+                    }),
+                    s.array("Caller-assigned IDs in recipient order.", s.string("One caller-assigned ID.", {
+                        minLength: 3,
+                        maxLength: 50,
+                        pattern: "^[a-zA-Z0-9]+$",
+                    }), { minItems: 1, uniqueItems: true }),
+                ]),
+                dlr_url: s.nonEmptyString("Delivery callback URL template, passed to SerwerSMS.pl. Supply the unencoded URL; form encoding is handled automatically. Supported placeholders include #SMSID#, #STAN#, #DATA#, and #PRZYCZYNA#."),
+            }, {
+                required: ["text"],
+            }),
+            anyOf: [{ required: ["phone"] }, { required: ["group_id"] }, { required: ["contact_id"] }],
+        },
+        outputSchema: s.object("SMS submission result, including any partial failures.", {
+            success: s.boolean("Whether the submission was processed."),
+            queued: s.integer("Number of queued messages."),
+            unsent: s.integer("Number of messages not sent."),
+            items: messageItems,
+        }, {
+            optional: ["items"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_delivery_reports",
+        description: "Query SMS delivery reports by message IDs or filters. Reports are available for about 14 days and updated for up to 72 hours; prefer batches of 50–200 IDs.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Delivery report filters.", {
+            id: stringOrArray("Provider message IDs; at most 500 per request.", 500),
+            unique_id: stringOrArray("Caller-assigned message IDs.", 500),
+            phone: stringOrArray("Recipient phone numbers in international format."),
+            date_from: s.nonEmptyString("Start of the queuing-time interval, for example 2026-12-01 00:00:00."),
+            date_to: s.nonEmptyString("End of the queuing-time interval, for example 2026-12-01 23:59:59."),
+            status: s.stringEnum("Filter by dispatch status.", [
+                "delivered",
+                "undelivered",
+                "pending",
+                "sent",
+                "unsent",
+                "in_progress",
+                "saved",
+            ]),
+            show_contact: s.boolean("Include contact details when the recipient exists in the contact database."),
+        }, {
+            required: [],
+        }),
+        outputSchema: s.looseObject("Delivery report result; archived messages may produce an empty list.", {
+            items: messageItems,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "cancel_scheduled_sms",
+        description: "Cancel scheduled SMS messages by provider or caller-assigned IDs before dispatch.",
+        operationType: "destructive",
+        requiredScopes: [],
+        inputSchema: {
+            ...s.object("Scheduled messages to cancel.", {
+                id: stringOrArray("Provider message IDs."),
+                unique_id: stringOrArray("Caller-assigned message IDs."),
+            }, {
+                required: [],
+            }),
+            anyOf: [{ required: ["id"] }, { required: ["unique_id"] }],
+        },
+        outputSchema: s.looseObject("Cancellation result.", {
+            success: s.boolean("Whether the operation was processed."),
+            correct: s.integer("Number of successfully cancelled messages."),
+            failed: s.integer("Number of messages that could not be cancelled."),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_account_limits",
+        description: "Get available message quotas and optionally the account type.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Account quota options.", {
+            show_type: s.boolean({
+                description: "Include the account type; defaults to true.",
+                default: true,
+            }),
+        }, {
+            required: [],
+        }),
+        outputSchema: s.object("Account quotas.", {
+            account: s.looseObject("Account information, including prepaid or postpaid type."),
+            items: s.array("Available quotas by message or lookup type.", s.looseObject("A quota record; value may be a numeric string, no_limit, or not_available.")),
+        }, {
+            optional: ["account"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "list_senders",
+        description: "List sender names and their authorization status, optionally including predefined senders.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Sender list options.", {
+            predefined: s.boolean("Include predefined sender names ready to use."),
+            type: s.stringEnum("Filter by sender type.", ["ndi", "mms"]),
+            sort: s.stringEnum("Sort by sender name.", ["name"]),
+            order: s.stringEnum("Sort direction.", ["asc", "desc"]),
+        }, {
+            required: [],
+        }),
+        outputSchema: s.looseObject("Sender list result.", {
+            items: s.array("Sender names and approval states.", s.looseObject("A sender record with name, agreement, status, and optional note or networks.")),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "add_sender",
+        description: "Submit a sender name for authorization. Wait until list_senders reports authorized before using it to send SMS.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Sender name to submit.", {
+            name: s.nonEmptyString("The alphanumeric sender name, at most 11 characters.", {
+                maxLength: 11,
+            }),
+        }, {
+            optional: [],
+        }),
+        outputSchema: successOutput,
+    }),
+];

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

@@ -0,0 +1,85 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { readProviderTextBody, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { serwersmsPlActions } from "./actions.js";
+const apiBaseUrl = "https://api2.serwersms.pl/";
+const endpoints = {
+    send_sms: "messages/send_sms",
+    get_delivery_reports: "messages/reports",
+    cancel_scheduled_sms: "messages/delete",
+    get_account_limits: "account/limits",
+    list_senders: "senders/index",
+    add_sender: "senders/add",
+};
+function request(endpoint, input, apiKey, fetcher, parentSignal) {
+    return runProviderRequest({ signal: parentSignal, label: "SerwerSMS.pl" }, async (signal) => {
+        const body = new URLSearchParams();
+        for (const [key, value] of Object.entries(input)) {
+            if (value == null)
+                continue;
+            if (Array.isArray(value)) {
+                value.forEach((item, index) => body.append(`${key}[${index}]`, String(item)));
+            }
+            else {
+                body.set(key, String(value));
+            }
+        }
+        const response = await fetcher(new URL(`${endpoint}.json`, apiBaseUrl), {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${apiKey}`,
+                accept: "application/json",
+                "content-type": "application/x-www-form-urlencoded",
+                "user-agent": providerUserAgent,
+            },
+            body,
+            signal,
+        });
+        const text = await readProviderTextBody(response, "serwersms_pl response", undefined, signal);
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, "SerwerSMS.pl returned invalid JSON", undefined, "provider_error");
+        }
+        const record = requiredResponseRecord(payload, "SerwerSMS.pl");
+        const error = optionalRecord(record.error);
+        if (!response.ok || record.error != null || record.success === false) {
+            const message = optionalRawString(error?.message) ?? optionalRawString(record.message) ?? "Request failed";
+            const code = error?.code;
+            const type = optionalRawString(error?.type);
+            const detail = [code, type, message].filter((part) => part != null).join(": ");
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `SerwerSMS.pl: ${detail}`, undefined, "provider_error");
+        }
+        return record;
+    });
+}
+export const executors = defineApiKeyProviderExecutors("serwersms_pl", mapProviderActionHandlers("serwersms_pl", serwersmsPlActions, (_action, actionName) => async (input, context) => {
+    const values = input;
+    if (actionName === "send_sms" && values.details === undefined)
+        values.details = true;
+    if (actionName === "get_account_limits" && values.show_type === undefined)
+        values.show_type = true;
+    return request(endpoints[actionName], values, context.apiKey, context.fetcher, context.signal);
+}), { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        await request("account/limits", { show_type: true }, requiredInputString(input.apiKey, "API Key"), fetcher);
+        return {
+            profile: { displayName: "SerwerSMS.pl API Token" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "serwersms_pl",
+    baseUrl: apiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [key, value] of Object.entries({ accept: "application/json" }))
+            if (!headers.has(key))
+                headers.set(key, value);
+    },
+});

package/src/providers/shopify/bulk.d.ts

@@ -0,0 +1,2 @@
+import type { ShopifyActionHandler } from "./context.ts";
+export declare const bulkHandlers: Record<string, ShopifyActionHandler>;