@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/scanmalware/runtime.js

@@ -0,0 +1,120 @@
+import { booleanString, objectArray, optionalInteger, optionalRecord, optionalString, optionalStringArray, requiredRawString, requiredStringArray, } from "../../core/cast.js";
+import { encodePathSegment, isIpAddress, queryParams } from "../../core/request.js";
+import { parseProviderJsonBodyText, providerInputError, providerResponseError, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const scanmalwareApiBaseUrl = "https://scanmalware.com";
+const hostnamePattern = /^(?=.{1,253}$)(?:[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9])?\.)+[a-z0-9-]{2,63}$/i;
+export const scanmalwareActionHandlers = {
+    async submit_scan(input, context) {
+        return requiredResponseRecord(await requestScanmalware({
+            context,
+            path: "/api/v1/scan",
+            method: "POST",
+            body: {
+                url: requiredInputString(input.url, "url"),
+                scan_type: requiredInputString(input.visibility, "visibility"),
+            },
+        }), "ScanMalware scan submission");
+    },
+    async get_scan_summary(input, context) {
+        const scanId = encodePathSegment(requiredInputString(input.scanId, "scanId"));
+        return requiredResponseRecord(await requestScanmalware({ context, path: `/api/v1/scan/${scanId}/summary` }), "ScanMalware scan summary");
+    },
+    async search_scans(input, context) {
+        return requiredResponseRecord(await requestScanmalware({
+            context,
+            path: "/api/v1/search/smql",
+            query: {
+                q: requiredInputString(input.query, "query"),
+                page: optionalInteger(input.page),
+                limit: optionalInteger(input.limit),
+                sort: optionalString(input.sort),
+            },
+        }), "ScanMalware search response");
+    },
+    async get_domain_scans(input, context) {
+        const payload = await requestScanmalware({
+            context,
+            path: `/api/v1/domains/${domainPathSegment(input.domain)}/scans`,
+            query: { limit: optionalInteger(input.limit), status: optionalString(input.status) },
+        });
+        // matched_on is checked for shape only: a match kind added upstream must read as "not submitted
+        // for this domain", which is what lacking url already means, rather than failing every lookup.
+        return {
+            scans: objectArray(payload, "ScanMalware domain scans", providerResponseError).map((scan) => ({
+                ...scan,
+                scan_id: requiredRawString(scan.scan_id, "ScanMalware domain scan scan_id", providerResponseError),
+                url: requiredRawString(scan.url, "ScanMalware domain scan url", providerResponseError),
+                matched_on: requiredStringArray(scan.matched_on, "ScanMalware domain scan matched_on", providerResponseError),
+            })),
+        };
+    },
+    async get_domain_dns(input, context) {
+        return requiredResponseRecord(await requestScanmalware({
+            context,
+            path: `/api/v1/ct/dns/${domainPathSegment(input.domain)}`,
+            query: {
+                include_subdomains: booleanString(input.includeSubdomains),
+                subdomain_limit: optionalInteger(input.subdomainLimit),
+            },
+        }), "ScanMalware DNS response");
+    },
+};
+/**
+ * Accept a hostname or an IP address only, so a model-supplied value such as ../admin
+ * never reaches the request path.
+ */
+function domainPathSegment(value) {
+    const domain = requiredInputString(value, "domain");
+    if (!isIpAddress(domain) && !hostnamePattern.test(domain)) {
+        throw providerInputError("domain must be a hostname such as example.com or an IP address.");
+    }
+    return encodePathSegment(domain);
+}
+async function requestScanmalware(request) {
+    const url = new URL(`${scanmalwareApiBaseUrl}${request.path}`);
+    for (const [key, value] of Object.entries(queryParams(request.query ?? {}))) {
+        url.searchParams.set(key, value);
+    }
+    return runProviderRequest({ label: "ScanMalware", signal: request.context.signal }, async (signal) => {
+        const response = await request.context.fetcher(url, {
+            method: request.method ?? "GET",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: request.body === undefined ? undefined : JSON.stringify(request.body),
+            signal,
+        });
+        if (!response.ok) {
+            throw await readScanmalwareError(response);
+        }
+        return parseProviderJsonBodyText(await readProviderTextBody(response, "ScanMalware response"), {
+            emptyBody: null,
+            invalidJsonMessage: "ScanMalware returned malformed JSON",
+        });
+    });
+}
+/**
+ * Map a ScanMalware error onto the runtime's status conventions. The API reports errors as
+ * `{error: "..."}`, as `{error: {message}}` for query syntax errors, or as `{message, details[]}`
+ * for parameter validation, where the details name the offending parameter.
+ */
+async function readScanmalwareError(response) {
+    const payload = parseProviderJsonBodyText(await readProviderErrorTextBody(response, "ScanMalware error response"), {
+        emptyBody: {},
+        invalidJsonMessage: "ScanMalware returned malformed JSON",
+        invalidJsonFallback: () => ({}),
+    });
+    const body = optionalRecord(payload);
+    const details = optionalStringArray(body?.details);
+    const message = (details && details.length > 0 ? details.join("; ") : undefined) ??
+        optionalString(optionalRecord(body?.error)?.message) ??
+        optionalString(body?.error) ??
+        optionalString(body?.message) ??
+        `ScanMalware request failed with HTTP ${response.status}`;
+    // The API needs no credentials, so an authorization failure is not something reconnecting can fix,
+    // and a 408 is the API's own query timeout rather than a problem with the input.
+    const status = response.status === 401 || response.status === 403 ? 502 : response.status === 408 ? 504 : response.status;
+    return new ProviderRequestError(status, message, withRetryAfterSeconds(response, payload));
+}

package/src/providers/screenshotone/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
 export const screenshotoneApiBaseUrl = "https://api.screenshotone.com";
 const screenshotoneUsagePath = "/usage";
@@ -144,14 +144,15 @@ async function postScreenshotoneJson(path, input, context) {
 }
 async function uploadScreenshotoneResponse(response, context, kind) {
     const transitFiles = requireTransitFiles(context, kind === "animation" ? "take_animated_screenshot" : "take_screenshot");
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: transitFiles.maxBytes,
+    const mimeType = response.headers.get("content-type") ?? "application/octet-stream";
+    const name = buildScreenshotoneTransitFileName(kind, mimeType);
+    const upload = await storeResponseInTransit(response, transitFiles, {
+        name,
+        mimeType,
         fieldName: `ScreenshotOne ${kind} output`,
         createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
     });
-    const mimeType = response.headers.get("content-type") ?? "application/octet-stream";
-    const name = buildScreenshotoneTransitFileName(kind, mimeType);
-    const upload = await transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
     return {
         file: {
             name,

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

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

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;