@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/clay/batch-runtime.js

@@ -0,0 +1,79 @@
+import { optionalRawString } from "../../core/cast.js";
+import { createProviderFetch, providerInputError, ProviderRequestError, providerResponseError, runProviderRequest, } from "../provider-runtime.js";
+import { encodeSegment, requestClay } from "./request.js";
+const maximumBatchBytes = 2 * 1024 * 1024 * 1024;
+export async function runClayBatch(context, input) {
+    const store = context.transitFiles;
+    if (!store?.createFromStream || !store.response)
+        throw providerInputError("Clay batch upload requires streaming transit storage");
+    const fetcher = createProviderFetch({ fetch: context.fetcher });
+    const routinePath = `/routines/${encodeSegment(input.routine_id)}/run-batch`;
+    const stored = await runProviderRequest({ label: "Clay batch download", signal: context.signal, timeoutMs: 300_000 }, async (signal) => {
+        const response = await fetcher(String(input.fileUrl), { signal });
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new ProviderRequestError(response.status, `Clay batch file download failed (HTTP ${response.status})`, undefined, "provider_error");
+        }
+        if (!response.body)
+            throw providerInputError("Clay batch file is empty");
+        const limit = Math.min(maximumBatchBytes, store.maxBytes);
+        if (Number(response.headers.get("content-length")) > limit) {
+            await response.body.cancel();
+            throw new ProviderRequestError(413, "Clay batch file exceeds the configured transfer limit");
+        }
+        let size = 0;
+        const body = response.body.pipeThrough(new TransformStream({
+            transform(chunk, controller) {
+                size += chunk.byteLength;
+                if (size > limit)
+                    throw new ProviderRequestError(413, "Clay batch file exceeds the configured transfer limit");
+                controller.enqueue(chunk);
+            },
+            flush() {
+                if (size === 0)
+                    throw providerInputError("Clay batch file is empty");
+            },
+        }));
+        return store.createFromStream({ body, name: "input.jsonl", mimeType: "application/x-ndjson", signal });
+    });
+    const { fileId } = stored;
+    try {
+        const upload = await requestClay(context, `${routinePath}/upload-url`, undefined, "POST");
+        const uploadUrl = optionalRawString(upload.upload_url);
+        const upstreamFileId = optionalRawString(upload.file_id);
+        if (!uploadUrl || !upstreamFileId)
+            throw providerResponseError("Clay batch upload response is missing upload_url or file_id");
+        if (new URL(uploadUrl).protocol !== "https:")
+            throw providerResponseError("Clay upload_url must use HTTPS");
+        await runProviderRequest({ label: "Clay batch upload", signal: context.signal, timeoutMs: 300_000 }, async (signal) => {
+            const staged = await store.response(fileId);
+            if (!staged.body)
+                throw providerResponseError("Clay staged file has no body");
+            const options = {
+                method: "PUT",
+                body: staged.body,
+                duplex: "half",
+                signal,
+                redirect: "manual",
+                headers: { "content-type": "application/x-ndjson", "content-length": String(stored.sizeBytes) },
+            };
+            try {
+                const response = await fetcher(uploadUrl, options);
+                await response.body?.cancel();
+                if (!response.ok)
+                    throw new ProviderRequestError(response.status, `Clay batch file upload failed (HTTP ${response.status})`, undefined, "provider_error");
+            }
+            finally {
+                if (!staged.body.locked)
+                    await staged.body.cancel().catch(() => { });
+            }
+        });
+        return await requestClay(context, `${routinePath}/start`, {
+            file_id: upstreamFileId,
+            webhook_id: input.webhook_id,
+        });
+    }
+    finally {
+        await store.delete(fileId);
+    }
+}

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

@@ -0,0 +1,78 @@
+import { optionalRawString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, requiredInputString, requiredResponseRecord, providerUserAgent, } from "../provider-runtime.js";
+import { clayActions } from "./actions.js";
+import { runClayBatch } from "./batch-runtime.js";
+import { baseUrl, encodeSegment, requestClay } from "./request.js";
+const readPaths = {
+    get_me: "/me",
+    get_credit_balance: "/credits/balance",
+    get_search_query_reference: "/search/query-mode/reference",
+    get_workflow_run_query_reference: "/workflows/runs/query/reference",
+};
+const handlers = mapProviderActionHandlers("clay", clayActions, (action) => async (values, context) => {
+    const body = values;
+    switch (action.name) {
+        case "get_me":
+        case "get_credit_balance":
+        case "get_search_query_reference":
+        case "get_workflow_run_query_reference":
+            return requestClay(context, readPaths[action.name]);
+        case "create_search":
+            return requestClay(context, "/search/query-mode", body);
+        case "get_search_results": {
+            const { search_id, ...page } = body;
+            return requestClay(context, `/search/query-mode/${encodeSegment(search_id)}/run`, page);
+        }
+        case "run_routine": {
+            const { routine_id, ...run } = body;
+            return requestClay(context, `/routines/${encodeSegment(routine_id)}/run`, run);
+        }
+        case "get_routine_results": {
+            const { routine_run_id, cursor, limit } = body;
+            const query = new URLSearchParams();
+            if (cursor !== undefined)
+                query.set("cursor", String(cursor));
+            if (limit !== undefined)
+                query.set("limit", String(limit));
+            return requestClay(context, `/routines/run/${encodeSegment(routine_run_id)}/results?${query}`);
+        }
+        case "run_routine_batch":
+            return runClayBatch(context, body);
+        case "get_routine_batch_results":
+            return requestClay(context, `/routines/run-batch/${encodeSegment(body.routine_run_id)}/results`);
+        case "query_tables":
+            return requestClay(context, "/tables/query", body);
+        case "query_workflow_runs":
+            return requestClay(context, "/workflows/runs/query", body);
+    }
+});
+export const executors = defineApiKeyProviderExecutors("clay", handlers, {
+    skipDnsValidation: false,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = await requestClay({ apiKey: requiredInputString(input.apiKey, "API Key"), fetcher, signal }, "/me");
+        const workspace = requiredResponseRecord(payload.workspace, "Clay workspace");
+        const user = requiredResponseRecord(payload.user, "Clay user");
+        return {
+            profile: { displayName: optionalRawString(workspace.name) ?? optionalRawString(user.name) ?? "Clay API Key" },
+            grantedScopes: [],
+            metadata: { workspaceId: optionalRawString(workspace.id), apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "clay",
+    baseUrl,
+    auth: { type: "api_key_header", name: "clay-api-key" },
+    skipDnsValidation: true,
+    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/clay/request.d.ts

@@ -0,0 +1,4 @@
+import type { ApiKeyProviderContext } from "../provider-runtime.ts";
+export declare const baseUrl = "https://api.clay.com/public/v0";
+export declare function encodeSegment(value: unknown): string;
+export declare function requestClay(context: ApiKeyProviderContext, path: string, body?: Record<string, unknown>, method?: string): Promise<Record<string, unknown>>;

package/src/providers/clay/request.js

@@ -0,0 +1,34 @@
+import { optionalRawString, optionalRecord } from "../../core/cast.js";
+import { providerInputError, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const baseUrl = "https://api.clay.com/public/v0";
+export function encodeSegment(value) {
+    const segment = String(value);
+    if (segment === "." || segment === "..")
+        throw providerInputError("Invalid Clay resource ID");
+    return encodeURIComponent(segment);
+}
+export function requestClay(context, path, body, method = body === undefined ? "GET" : "POST") {
+    return runProviderRequest({ label: "Clay", signal: context.signal }, async (signal) => {
+        const response = await context.fetcher(`${baseUrl}${path}`, {
+            method,
+            headers: {
+                "clay-api-key": context.apiKey,
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "Clay returned invalid JSON",
+            invalidJsonFallback: response.ok ? undefined : () => null,
+        });
+        if (!response.ok) {
+            const message = optionalRawString(optionalRecord(payload)?.message);
+            throw new ProviderRequestError(response.status, message ? `Clay: ${message}` : `Clay request failed (HTTP ${response.status})`, undefined, "provider_error");
+        }
+        return requiredResponseRecord(payload, "Clay");
+    });
+}

package/src/providers/clay/table-schema.d.ts

@@ -0,0 +1,2 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const tableQueryInput: JsonSchema;

package/src/providers/clay/table-schema.js

@@ -0,0 +1,102 @@
+import { s } from "../../core/json-schema.js";
+const field = s.nonEmptyString("Field name or ID according to field_mode.");
+const nestedPath = s.array("Nested property path, up to 5 segments.", s.nonEmptyString("Path segment."), {
+    minItems: 1,
+    maxItems: 5,
+});
+const filterRef = { $ref: "#/$defs/filter", description: "Recursive filter expression." };
+const filter = s.anyOf([
+    s.object("Field predicate.", {
+        field,
+        op: s.stringEnum("Comparison operator.", [
+            "=",
+            "!=",
+            ">",
+            ">=",
+            "<",
+            "<=",
+            "contains",
+            "not_contains",
+            "starts_with",
+            "ends_with",
+            "in",
+            "not_in",
+            "is_empty",
+            "is_not_empty",
+        ]),
+        path: nestedPath,
+        value: s.anyOf([
+            s.string("Text value."),
+            s.number("Numeric value."),
+            s.boolean("Boolean value."),
+            s.array("Values for membership tests.", s.anyOf([s.string("Text value."), s.number("Numeric value.")], {
+                description: "Text or number.",
+            })),
+        ], { description: "Comparison value; omit for empty checks." }),
+    }, {
+        optional: ["path", "value"],
+    }),
+    s.requiredObject("All child conditions must match.", {
+        and: s.array("Conjoined conditions.", filterRef, { minItems: 1, maxItems: 10 }),
+    }),
+    s.requiredObject("Any child condition may match.", {
+        or: s.array("Alternative conditions.", filterRef, { minItems: 1, maxItems: 10 }),
+    }),
+    s.requiredObject("Negated condition.", { not: filterRef }),
+], { description: "Predicate or Boolean filter expression." });
+export const tableQueryInput = {
+    ...s.object("Structured table query parameters.", {
+        query: s.object("Structured query over known tables.", {
+            tables: s.array("Tables to query, up to 5.", s.object("Table reference.", {
+                id: s.nonEmptyString("Table ID from the Clay table URL after /tables/."),
+                alias: s.string("Optional table alias."),
+            }, {
+                optional: ["alias"],
+            }), { minItems: 1, maxItems: 5 }),
+            field_mode: s.stringEnum("Whether fields use names or IDs.", ["names", "ids"]),
+            select: s.array("Selected fields or aggregates, up to 20.", s.anyOf([
+                s.object("Aggregate selection.", {
+                    fn: s.stringEnum("Aggregate function.", ["count", "sum", "avg", "max", "min"]),
+                    field,
+                    as: s.nonEmptyString("Output alias for the aggregate."),
+                    path: nestedPath,
+                }, {
+                    optional: ["path"],
+                }),
+                s.object("Field selection.", {
+                    field,
+                    path: nestedPath,
+                    as: s.string("Output column alias."),
+                    table: s.string("Table reference for the field."),
+                }, {
+                    optional: ["path", "as", "table"],
+                }),
+            ], { description: "Field selection or aggregate." }), { maxItems: 20 }),
+            filter: filterRef,
+            group_by: s.array("Grouping fields, up to 5.", field, { maxItems: 5 }),
+            join: s.array("Table joins, up to 4.", s.object("Table join.", {
+                table: s.nonEmptyString("Table reference to join."),
+                type: s.stringEnum("Join type; defaults to inner.", ["inner", "left"]),
+                on: s.requiredObject("Join condition.", {
+                    left: s.nonEmptyString("Left join field."),
+                    right: s.nonEmptyString("Right join field."),
+                }),
+            }, {
+                optional: ["type"],
+            }), { maxItems: 4 }),
+            order_by: s.array("Custom ordering disables cursor pagination; up to 3 fields.", s.object("Sort term.", {
+                field,
+                direction: s.stringEnum("Sort direction; defaults to asc.", ["asc", "desc"]),
+            }, {
+                optional: ["direction"],
+            }), { maxItems: 3 }),
+        }, {
+            optional: ["field_mode", "select", "filter", "group_by", "join", "order_by"],
+        }),
+        cursor: s.string("Opaque cursor; concurrent updates can repeat rows, so deduplicate by ID."),
+        limit: s.integer("Page size, 1–100; defaults to 50.", { minimum: 1, maximum: 100 }),
+    }, {
+        optional: ["cursor", "limit"],
+    }),
+    $defs: { filter },
+};

package/src/providers/cloudflare_r2/runtime.js

@@ -1,5 +1,5 @@
 import { base64Bytes, compactObject, integer, optionalInteger, optionalRecord, optionalString, requiredRawString, requiredString, } from "../../core/cast.js";
-import { assertPublicHttpUrl, queryParams, readBoundedResponseBytes } from "../../core/request.js";
+import { assertPublicHttpUrl, queryParams, readBoundedResponseBytes, storeResponseInTransit, } from "../../core/request.js";
 import { readCloudflareCurrentUser } from "../cloudflare_dns/runtime-user.js";
 import { combineProviderActionHandlers, providerFetch, providerInputError, ProviderRequestError, providerUserAgent, runProviderRequest, } from "../provider-runtime.js";
 import { cloudflareR2AccountActionHandlers } from "./runtime-account.js";
@@ -158,12 +158,13 @@ async function downloadObject(input, context) {
     }
     const name = optionalString(input.fileName) ?? defaultObjectFileName(objectKey);
     const mimeType = optionalString(response.headers.get("content-type")) ?? "application/octet-stream";
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
+    const file = await storeResponseInTransit(response, context.transitFiles, {
+        name,
+        mimeType,
         fieldName: "Cloudflare R2 download",
         createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
     });
-    const file = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
     return {
         fileId: objectKey,
         name,

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

@@ -0,0 +1,118 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerInputError, providerResponseError, requiredInputString, requiredResponseRecord, runProviderRequest, providerUserAgent, readProviderTextBody, } from "../provider-runtime.js";
+const baseUrl = "https://api.commoninja.com/platform/api/v1";
+const defaultHeaders = { accept: "application/json", "user-agent": providerUserAgent };
+function encodePathSegment(input) {
+    const value = requiredInputString(input, "id");
+    if (value === "." || value === "..") {
+        throw providerInputError("id cannot be a dot path segment");
+    }
+    return encodeURIComponent(value);
+}
+async function request(context, endpoint, options = {}) {
+    const { apiKey, fetcher } = context;
+    const { method = "GET", query = {}, body } = options;
+    return runProviderRequest({ label: "Common Ninja", signal: context.signal }, async (signal) => {
+        const url = new URL(`${baseUrl}${endpoint}`);
+        for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+        const headers = new Headers(defaultHeaders);
+        headers.set("CN-API-Token", apiKey);
+        if (body !== undefined)
+            headers.set("content-type", "application/json");
+        const response = await fetcher(url, {
+            method,
+            headers,
+            signal,
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const text = await readProviderTextBody(response, "commonninja response", undefined, signal);
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        if (!response.ok) {
+            const message = optionalRawString(optionalRecord(payload)?.message) ??
+                `Common Ninja request failed with status ${response.status}`;
+            throw new ProviderRequestError(response.status, message.split(apiKey).join("[REDACTED]"), undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        if (response.status === 204 && method === "DELETE")
+            return {};
+        return requiredResponseRecord(payload, "Common Ninja response");
+    });
+}
+export const executors = defineApiKeyProviderExecutors("commonninja", {
+    get_user(_input, context) {
+        return request(context, "/user");
+    },
+    list_widgets(input, context) {
+        return request(context, "/widgets", { query: input });
+    },
+    list_widget_types(input, context) {
+        return request(context, "/widget-types", { query: input });
+    },
+    list_projects(input, context) {
+        return request(context, "/projects", { query: input });
+    },
+    create_widget(input, context) {
+        return request(context, "/widgets", { method: "POST", body: input });
+    },
+    get_widget(input, context) {
+        return request(context, `/widgets/${encodePathSegment(input.id)}`);
+    },
+    get_widget_embed_code(input, context) {
+        return request(context, `/widgets/${encodePathSegment(input.id)}/embed-code`);
+    },
+    get_widget_editor_url(input, context) {
+        return request(context, `/widgets/${encodePathSegment(input.id)}/editor`);
+    },
+    get_widget_type(input, context) {
+        return request(context, `/widget-types/${encodePathSegment(input.id)}`);
+    },
+    get_widget_type_schema(input, context) {
+        return request(context, `/widget-types/${encodePathSegment(input.id)}/schema`);
+    },
+    get_project(input, context) {
+        return request(context, `/projects/${encodePathSegment(input.id)}`);
+    },
+    delete_widget(input, context) {
+        return request(context, `/widgets/${encodePathSegment(input.id)}`, {
+            method: "DELETE",
+            query: { permanent: input.permanent },
+        });
+    },
+    update_widget(input, context) {
+        const { id, ...body } = input;
+        return request(context, `/widgets/${encodePathSegment(id)}`, { method: "PUT", body });
+    },
+}, { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const user = await request({ apiKey: requiredInputString(input.apiKey, "API Key"), fetcher, signal }, "/user");
+        const accountId = optionalRawString(user.id);
+        if (!accountId) {
+            throw providerResponseError("Common Ninja profile is missing an account ID");
+        }
+        return {
+            profile: { displayName: optionalRawString(user.name) || optionalRawString(user.email) || "Common Ninja Account" },
+            grantedScopes: [],
+            metadata: { accountId, apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "commonninja",
+    baseUrl,
+    auth: { type: "api_key_header", name: "CN-API-Token" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries(defaultHeaders))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+});

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

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

package/src/providers/cronlytic/actions.js

@@ -0,0 +1,116 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const jobFields = {
+    name: s.string("Job name containing only letters, digits, hyphens, and underscores.", {
+        minLength: 1,
+        maxLength: 50,
+        pattern: "^[a-zA-Z0-9_-]+$",
+    }),
+    url: s.string("HTTP or HTTPS URL called by Cronlytic.", { format: "uri", pattern: "^https?://" }),
+    method: s.stringEnum("HTTP method used by the scheduled request.", [
+        "GET",
+        "POST",
+        "PUT",
+        "DELETE",
+        "PATCH",
+        "HEAD",
+        "OPTIONS",
+    ]),
+    headers: s.record("Headers sent to the scheduled destination.", s.string("Header value.")),
+    body: s.string("Request body sent verbatim to the destination; may be empty."),
+    cron_expression: s.nonEmptyString("Standard five-field cron expression: minute hour day month weekday."),
+};
+const jobId = { job_id: s.nonEmptyString("Cronlytic job ID.") };
+const jobInput = s.requiredObject("Identify a Cronlytic job.", jobId);
+const jobOutput = s.looseObject("Cronlytic job, including any additional upstream fields.", {
+    job_id: s.string("Cronlytic job ID."),
+    user_id: s.string("Owner user ID."),
+    name: s.string("Job name."),
+    url: s.string("Scheduled destination URL."),
+    method: s.string("Scheduled HTTP method."),
+    headers: s.record("Scheduled request headers.", s.string("Header value.")),
+    body: s.string("Scheduled request body."),
+    cron_expression: s.string("Five-field cron expression."),
+    status: s.string("Current job status, including pending, paused, success, failed, or quota_reached."),
+    last_run_at: s.nullable(s.string("Last execution timestamp, or null if never executed.")),
+    next_run_at: s.nullable(s.string("Next scheduled execution timestamp, or null.")),
+});
+export const cronlyticActions = [
+    defineProviderAction("cronlytic", {
+        name: "create_job",
+        operationType: "write",
+        description: "Create a recurring HTTP job in Cronlytic.",
+        requiredScopes: [],
+        inputSchema: s.object("Create a recurring HTTP job; omitted method, headers, and body default to GET, {}, and an empty string.", jobFields, { optional: ["method", "headers", "body"] }),
+        outputSchema: jobOutput,
+    }),
+    defineProviderAction("cronlytic", {
+        name: "list_jobs",
+        operationType: "read",
+        description: "List all Cronlytic jobs for the connected user.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("List jobs without pagination parameters.", {}),
+        outputSchema: s.requiredObject("All jobs belonging to the connected user.", {
+            jobs: s.array("Cronlytic jobs.", jobOutput),
+        }),
+    }),
+    defineProviderAction("cronlytic", {
+        name: "get_job",
+        operationType: "read",
+        description: "Get a Cronlytic job and its current schedule.",
+        requiredScopes: [],
+        inputSchema: jobInput,
+        outputSchema: jobOutput,
+    }),
+    defineProviderAction("cronlytic", {
+        name: "update_job",
+        operationType: "write",
+        description: "Update a Cronlytic job using its complete configuration; provide all six job fields.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Complete replacement job configuration.", { ...jobId, ...jobFields }),
+        outputSchema: jobOutput,
+    }),
+    defineProviderAction("cronlytic", {
+        name: "delete_job",
+        operationType: "destructive",
+        description: "Permanently delete a Cronlytic job and all its execution logs.",
+        requiredScopes: [],
+        inputSchema: jobInput,
+        outputSchema: s.looseObject("Job deletion result.", {
+            deleted: s.boolean("Whether the job was deleted."),
+        }),
+    }),
+    defineProviderAction("cronlytic", {
+        name: "pause_job",
+        operationType: "destructive",
+        description: "Pause a Cronlytic job to stop scheduled executions while retaining its configuration.",
+        requiredScopes: [],
+        inputSchema: jobInput,
+        outputSchema: jobOutput,
+    }),
+    defineProviderAction("cronlytic", {
+        name: "resume_job",
+        operationType: "write",
+        description: "Resume a paused Cronlytic job according to its cron expression.",
+        requiredScopes: [],
+        inputSchema: jobInput,
+        outputSchema: jobOutput,
+    }),
+    defineProviderAction("cronlytic", {
+        name: "get_job_logs",
+        operationType: "read",
+        description: "Get the latest 50 execution logs for a Cronlytic job, newest first.",
+        requiredScopes: [],
+        inputSchema: jobInput,
+        outputSchema: s.looseObject("Recent job execution logs.", {
+            job_id: s.string("Cronlytic job ID."),
+            logs: s.array("Up to 50 execution logs, newest first.", s.looseObject("One job execution.", {
+                timestamp: s.string("Execution timestamp."),
+                status: s.string("Execution status."),
+                response_code: s.nullable(s.integer("Destination HTTP response status, or null when unavailable.")),
+                response_time: s.number("Request duration in seconds."),
+                error_message: s.string("Execution error message, or an empty string."),
+            })),
+        }),
+    }),
+];

package/src/providers/cronlytic/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;