@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/api_route/executors.js

@@ -0,0 +1,77 @@
+import { looseArray, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "api_route";
+const apiBaseUrl = "https://global.api-route.com/v1";
+// Reasoning model completions may exceed the shared default request timeout.
+const inferenceTimeoutMs = 300_000;
+const handlers = {
+    create_chat_completion(input, context) {
+        if (input.stream === true) {
+            throw providerInputError("stream=true is not supported by connector actions");
+        }
+        return requestApiRoute({ path: "/chat/completions", body: input }, context);
+    },
+    list_models(_input, context) {
+        return requestApiRoute({ path: "/models" }, context);
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: apiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = await requestApiRoute({ path: "/models" }, { apiKey: input.apiKey, fetcher, signal });
+        return {
+            profile: { displayName: "API Route API Key" },
+            grantedScopes: [],
+            metadata: {
+                validationEndpoint: "/models",
+                availableModels: looseArray(payload.data)
+                    .map((model) => optionalString(optionalRecord(model)?.id))
+                    .filter((id) => id !== undefined),
+            },
+        };
+    },
+};
+function requestApiRoute(input, context) {
+    return runProviderRequest({
+        signal: context.signal,
+        label: "API Route",
+        timeoutMs: input.body === undefined ? undefined : inferenceTimeoutMs,
+    }, async (signal) => {
+        const response = await context.fetcher(`${apiBaseUrl}${input.path}`, {
+            method: input.body === undefined ? "GET" : "POST",
+            headers: {
+                authorization: `Bearer ${context.apiKey}`,
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: input.body === undefined ? undefined : JSON.stringify(input.body),
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "API Route returned invalid JSON",
+            invalidJsonFallback: response.ok ? undefined : (text) => ({ message: text }),
+        });
+        if (!response.ok) {
+            const error = optionalRecord(payload);
+            const message = optionalString(optionalRecord(error?.error)?.message) ??
+                optionalString(error?.message) ??
+                `API Route request failed with HTTP ${response.status}`;
+            const status = response.status;
+            throw new ProviderRequestError(status, message, payload, status === 429 ? "rate_limited" : "provider_error");
+        }
+        const result = requiredResponseRecord(payload, "API Route response");
+        if (input.path === "/models" && !Array.isArray(result.data)) {
+            throw providerResponseError("API Route returned a malformed model list");
+        }
+        return result;
+    });
+}

package/src/providers/aws_s3/executors.js

@@ -1,6 +1,6 @@
 import { canonicalizeSearchParams, createAwsSigV4PresignedUrl, encodeS3ObjectKey, sha256Hex, signAwsSigV4Request, } from "../../core/aws-sigv4.js";
 import { compactObject, optionalRecord, optionalString, requiredRawString } from "../../core/cast.js";
-import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
+import { assertPublicHttpUrl, storeResponseInTransit } from "../../core/request.js";
 import { createProviderProxyUrl, createProviderTimeout, defineProviderExecutors, normalizeProviderProxyHeaders, providerFetch, ProviderRequestError, providerUserAgent, readProviderProxyResponse, toProviderProxyError, } from "../provider-runtime.js";
 class AwsS3HttpError extends Error {
     status;
@@ -259,12 +259,13 @@ async function awsDownloadObject(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: "AWS S3 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 {
             objectKey,
             name,

package/src/providers/baidu_netdisk/runtime.js

@@ -1,6 +1,6 @@
 import { posix } from "node:path";
 import { compactObject, optionalInteger, optionalString, requiredRawString, requiredString } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { providerFetch, ProviderRequestError, readProviderTextBody } from "../provider-runtime.js";
 export const baiduPanBaseUrl = "https://pan.baidu.com";
 const losslessIntegerKeys = new Set(["fs_id", "fsid", "pid", "uk", "request_id", "cursor"]);
@@ -117,12 +117,13 @@ export async function downloadBaiduNetdiskFile(input, context) {
         throw new ProviderRequestError(response.status >= 500 ? 502 : response.status, message || `baidu_netdisk download failed with HTTP ${response.status}`);
     }
     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: metadata.name,
+        mimeType,
         fieldName: "Baidu Netdisk download",
         createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
     });
-    const file = await context.transitFiles.create(new File([Uint8Array.from(bytes)], metadata.name, { type: mimeType }));
     return {
         fileId: metadata.fileId,
         name: metadata.name,

package/src/providers/box/executors.js

@@ -1,5 +1,5 @@
 import { optionalBoolean, optionalNumber, optionalRecord, optionalString, requiredRecord, requiredString, } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, readProviderJsonBody, readTransitFileInput, requiredInputString, } from "../provider-runtime.js";
 const service = "box";
 const boxApiBaseUrl = "https://api.box.com/2.0";
@@ -163,12 +163,13 @@ async function downloadFile(input, context) {
         throw await boxResponseError(response, "Box file download failed");
     }
     const mimeType = 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: "Box 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 { item, file };
 }
 async function createFolder(input, context) {

package/src/providers/cal/actions.js

@@ -270,7 +270,11 @@ const createBookingInputSchema = s.object("Input payload for creating a Cal.com
     guests: s.stringArray("Additional guest email addresses."),
     meetingUrl: s.string("The meeting URL to attach to the booking."),
     location: rawObject("The location payload for the booking."),
-    metadata: rawObject("Additional metadata to attach to the booking."),
+    metadata: s.optional({
+        ...s.record("Additional booking metadata: at most 50 keys, each up to 40 characters, with string values up to 500 characters.", s.string("A metadata value, up to 500 characters.", { maxLength: 500 })),
+        maxProperties: 50,
+        propertyNames: s.string("A metadata key, up to 40 characters.", { maxLength: 40 }),
+    }),
     lengthInMinutes: s.positiveInteger("The requested booking duration in minutes."),
     routing: rawObject("Routing metadata for round-robin or collective bookings."),
     emailVerificationCode: s.string("The email verification code for protected bookings."),

package/src/providers/campaign_cleaner/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalRecord, optionalString } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerUserAgent, requiredInputString, } from "../provider-runtime.js";
 const service = "campaign_cleaner";
 const campaignCleanerApiBaseUrl = "https://api.campaigncleaner.com";
@@ -145,12 +145,13 @@ async function getCampaignPdfAnalysis(input, context) {
     }
     const mimeType = response.headers.get("content-type") ?? "application/pdf";
     const name = sanitizeFilename(readContentDispositionFilename(response.headers.get("content-disposition")) ?? `campaign-cleaner-${id}.pdf`) ?? `campaign-cleaner-${id}.pdf`;
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
+    const upload = await storeResponseInTransit(response, context.transitFiles, {
+        name,
+        mimeType,
         fieldName: name,
         createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
     });
-    const upload = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
     const content = {
         fileId: upload.fileId,
         downloadUrl: upload.downloadUrl,

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

@@ -0,0 +1,130 @@
+import { compactObject, looseArray, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, ProviderRequestError, providerUserAgent, runProviderRequest, } from "../provider-runtime.js";
+const service = "cheaperinference";
+const cheaperinferenceApiBaseUrl = "https://api.cheaperinference.com/v1";
+const anthropicApiVersion = "2023-06-01";
+const requestLabel = "Cheaper Inference";
+// Long completions routinely exceed the shared 30 second provider timeout.
+const inferenceRequestTimeoutMs = 300_000;
+const cheaperinferenceActionHandlers = {
+    create_chat_completion(input, context) {
+        assertStreamingDisabled(input);
+        return cheaperinferenceInferenceRequest({ path: "/chat/completions", body: compactObject(input) }, context);
+    },
+    create_message(input, context) {
+        assertStreamingDisabled(input);
+        return cheaperinferenceInferenceRequest({ path: "/messages", body: compactObject(input), anthropicVersion: anthropicApiVersion }, context);
+    },
+    list_models(_input, context) {
+        return listCheaperinferenceModels(context, "execute");
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, cheaperinferenceActionHandlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: cheaperinferenceApiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = optionalRecord(await listCheaperinferenceModels({ apiKey: input.apiKey, fetcher, signal }, "validate"));
+        return {
+            profile: {
+                displayName: "Cheaper Inference API Key",
+            },
+            grantedScopes: [],
+            metadata: {
+                validationEndpoint: "/models",
+                availableModels: looseArray(payload?.data)
+                    .map((model) => optionalString(optionalRecord(model)?.id))
+                    .filter((model) => model !== undefined),
+            },
+        };
+    },
+};
+function listCheaperinferenceModels(context, mode) {
+    return runProviderRequest({ signal: context.signal, label: requestLabel }, async (signal) => {
+        const response = await context.fetcher(`${cheaperinferenceApiBaseUrl}/models`, {
+            method: "GET",
+            headers: buildCheaperinferenceHeaders(context.apiKey, false),
+            signal,
+        });
+        return readCheaperinferenceResponse(response, mode);
+    });
+}
+function cheaperinferenceInferenceRequest(input, context) {
+    return runProviderRequest({ signal: context.signal, label: requestLabel, timeoutMs: inferenceRequestTimeoutMs }, async (signal) => {
+        const response = await context.fetcher(`${cheaperinferenceApiBaseUrl}${input.path}`, {
+            method: "POST",
+            headers: buildCheaperinferenceHeaders(context.apiKey, true, input.anthropicVersion),
+            body: JSON.stringify(input.body),
+            signal,
+        });
+        return readCheaperinferenceResponse(response, "execute");
+    });
+}
+function buildCheaperinferenceHeaders(apiKey, includeJsonContentType, anthropicVersion) {
+    const headers = new Headers({
+        authorization: `Bearer ${apiKey}`,
+        "user-agent": providerUserAgent,
+    });
+    if (includeJsonContentType) {
+        headers.set("content-type", "application/json");
+    }
+    if (anthropicVersion) {
+        headers.set("anthropic-version", anthropicVersion);
+    }
+    return headers;
+}
+function assertStreamingDisabled(input) {
+    if (input.stream === true) {
+        throw new ProviderRequestError(400, "stream=true is not supported by connector actions");
+    }
+}
+async function readCheaperinferenceResponse(response, mode) {
+    await assertCheaperinferenceResponse(response, mode);
+    try {
+        return await response.json();
+    }
+    catch (error) {
+        if (isAbortLikeError(error)) {
+            throw new ProviderRequestError(504, `${requestLabel} request timed out`);
+        }
+        throw new ProviderRequestError(502, `${requestLabel} returned malformed JSON`);
+    }
+}
+async function assertCheaperinferenceResponse(response, mode) {
+    if (response.ok) {
+        return;
+    }
+    const error = await readCheaperinferenceError(response);
+    if (response.status === 429) {
+        throw new ProviderRequestError(429, error.message, error);
+    }
+    if (mode === "validate" && (response.status === 401 || response.status === 403)) {
+        throw new ProviderRequestError(400, error.message, error);
+    }
+    throw new ProviderRequestError(response.status || 502, error.message, error, "provider_error");
+}
+async function readCheaperinferenceError(response) {
+    const rawText = (await response.text()) || `${requestLabel} request failed with status ${response.status}`;
+    try {
+        const payload = JSON.parse(rawText);
+        const nestedError = optionalRecord(payload.error);
+        return {
+            type: optionalString(nestedError?.type) ?? optionalString(payload.type) ?? "provider_error",
+            code: readErrorCode(nestedError?.code),
+            message: optionalString(nestedError?.message) ?? optionalString(payload.message) ?? rawText,
+        };
+    }
+    catch {
+        return {
+            type: "provider_error",
+            message: rawText,
+        };
+    }
+}
+function readErrorCode(value) {
+    return typeof value === "string" || typeof value === "number" ? value : undefined;
+}

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

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

package/src/providers/clay/actions.js

@@ -0,0 +1,222 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { clayBatchActions } from "./batch-actions.js";
+import { tableQueryInput } from "./table-schema.js";
+const empty = s.requiredObject("No parameters.", {});
+const reference = s.object("Query reference.", {
+    reference: s.string("Query grammar and field catalog in Markdown."),
+}, {
+    required: ["reference"],
+    additionalProperties: true,
+});
+const routineId = s.string("Routine ID, such as function:t_abc123.", {
+    minLength: 1,
+    maxLength: 64,
+});
+const runId = s.string("Routine run ID.", { minLength: 1, maxLength: 64 });
+const cursor = s.string("Opaque cursor returned by the previous page.");
+const pageLimit = s.integer("Maximum results per page, from 1 to 100.", {
+    minimum: 1,
+    maximum: 100,
+});
+const runOutput = s.object("Routine run progress and results. A complete run may contain failed items.", {
+    routine_run_id: runId,
+    status: s.string("Run status; in_progress or complete. Preserve unknown terminal statuses."),
+    total: s.number("Total input items in the run."),
+    finished: s.number("Finished items, including failures."),
+    data: s.array("Results on this page; absent while running.", s.object("One item result.", {
+        id: s.string("Caller-supplied item ID."),
+        status: s.string("Item status, complete or failed."),
+        result: s.looseObject("Function-defined output fields."),
+        error: s.looseObject("Item failure details.", { message: s.string("Failure message.") }),
+    }, {
+        required: ["id", "status"],
+        additionalProperties: true,
+    })),
+    cursor,
+}, {
+    required: ["routine_run_id", "status"],
+    additionalProperties: true,
+});
+export const clayActions = [
+    ...clayBatchActions,
+    defineProviderAction("clay", {
+        name: "get_me",
+        operationType: "read",
+        description: "Get the Clay user and workspace associated with the API key.",
+        inputSchema: empty,
+        outputSchema: s.object("Authenticated identity.", {
+            user: s.object("Clay user.", {
+                id: s.string("User ID."),
+                name: s.nullable(s.string("User name.")),
+                email: s.nullable(s.string("User email.")),
+                cli_onboarded: s.boolean("Whether CLI onboarding is complete."),
+            }, {
+                required: ["id", "name"],
+                additionalProperties: true,
+            }),
+            workspace: s.object("Clay workspace.", {
+                id: s.string("Workspace ID."),
+                name: s.nullable(s.string("Workspace name.")),
+            }, {
+                required: ["id"],
+                additionalProperties: true,
+            }),
+        }, {
+            required: ["user", "workspace"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("clay", {
+        name: "get_credit_balance",
+        operationType: "read",
+        description: "Get workspace credit balances without consuming credits.",
+        inputSchema: empty,
+        outputSchema: s.object("Workspace credit balances.", {
+            balance: s.number("Remaining spendable data credits, including rollover."),
+            action_execution_balance: s.number("Remaining actions; absent on some billing plans."),
+        }, {
+            required: ["balance"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("clay", {
+        name: "get_search_query_reference",
+        operationType: "read",
+        description: "Get the current Clay search query grammar and fields before creating a search.",
+        inputSchema: empty,
+        outputSchema: reference,
+    }),
+    defineProviderAction("clay", {
+        name: "create_search",
+        operationType: "write",
+        description: "Create a stateful company or people search from a Clay query. Count-mode and jobs queries are unsupported.",
+        inputSchema: s.requiredObject("Search creation parameters.", {
+            query: s.nonEmptyString("Clay advanced search query; obtain grammar with get_search_query_reference."),
+        }),
+        outputSchema: s.object("Created search iterator.", {
+            search_id: s.string("Search ID to pass to get_search_results."),
+            source_type: s.string("Detected source type, people or companies."),
+        }, {
+            required: ["search_id", "source_type"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("clay", {
+        name: "get_search_results",
+        operationType: "write",
+        description: "Fetch the next page and advance a Clay search iterator. Do not retry blindly: each call advances the iterator.",
+        inputSchema: s.object("Search page parameters.", {
+            search_id: s.nonEmptyString("Search ID returned by create_search."),
+            limit: s.integer("Page size, 1–500; default 20. Free and trial plans allow at most 50.", {
+                minimum: 1,
+                maximum: 500,
+            }),
+        }, {
+            optional: ["limit"],
+        }),
+        outputSchema: s.object("Search page.", {
+            data: s.array("Company or people records.", s.looseObject("Search record with upstream fields.")),
+            has_more: s.boolean("Whether more results can be fetched."),
+            source_type: s.string("Source type, people or companies."),
+            exhaustion_reason: s.string("Why results ended: query_limit or no_more_results."),
+            period_quota: s.looseObject("Search quota for the current period.", {
+                limit: s.number("Period quota limit."),
+                used: s.number("Results used in this period."),
+                remaining: s.number("Remaining results in this period."),
+                resets_at: s.string("Quota reset time."),
+            }),
+        }, {
+            required: ["data", "has_more", "source_type"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("clay", {
+        name: "run_routine",
+        operationType: "destructive",
+        description: "Run a configured Clay routine on 1–100 items asynchronously. The routine may perform arbitrary downstream mutations; inspect its definition before running.",
+        inputSchema: s.object("Routine execution parameters.", {
+            routine_id: routineId,
+            items: s.array("Items to process.", s.requiredObject("One input item.", {
+                id: s.string("Caller-supplied item ID for matching results.", {
+                    minLength: 1,
+                    maxLength: 64,
+                }),
+                inputs: s.looseObject("Function-defined input fields."),
+            }), { minItems: 1, maxItems: 100 }),
+            webhook_id: s.string("ID of an existing Clay webhook to notify on completion.", {
+                minLength: 1,
+                maxLength: 64,
+            }),
+        }, {
+            optional: ["webhook_id"],
+        }),
+        outputSchema: s.object("Submitted routine run.", { routine_run_id: runId, status: s.string("Initial run status, in_progress.") }, {
+            required: ["routine_run_id", "status"],
+            additionalProperties: true,
+        }),
+        asyncLifecycle: {
+            startActionId: "clay.run_routine",
+            statusActionId: "clay.get_routine_results",
+        },
+    }),
+    defineProviderAction("clay", {
+        name: "get_routine_results",
+        operationType: "read",
+        description: "Get routine progress or one page of completed results. Follow cursor until absent and check each item's status.",
+        inputSchema: s.object("Routine result parameters.", { routine_run_id: runId, cursor, limit: pageLimit }, {
+            optional: ["cursor", "limit"],
+        }),
+        outputSchema: runOutput,
+        asyncLifecycle: {
+            startActionId: "clay.run_routine",
+            statusActionId: "clay.get_routine_results",
+        },
+    }),
+    defineProviderAction("clay", {
+        name: "query_tables",
+        operationType: "read",
+        description: "Query known Clay tables on Enterprise plans. Concurrent updates can repeat rows; deduplicate by ID. Custom ordering and aggregation do not support cursor pagination.",
+        inputSchema: tableQueryInput,
+        outputSchema: s.object("Table query results.", {
+            data: s.array("Rows keyed by selected field; cells include status and value.", s.looseObject("Row of cell results.")),
+            fields: s.looseObject("Field metadata keyed by output column."),
+            cursor,
+            truncated: s.boolean("More rows matched but this query cannot issue a cursor; narrow the query or increase the limit."),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("clay", {
+        name: "get_workflow_run_query_reference",
+        operationType: "read",
+        description: "Get the workflow-run query grammar and supported fields (beta).",
+        inputSchema: empty,
+        outputSchema: reference,
+    }),
+    defineProviderAction("clay", {
+        name: "query_workflow_runs",
+        operationType: "read",
+        description: "Search or count workflow runs (beta). Results are eventually consistent; recently changed runs may be stale or absent.",
+        inputSchema: s.object("Workflow-run query parameters.", {
+            query: s.string("Clay workflow-run select or count query.", {
+                minLength: 1,
+                maxLength: 2000,
+            }),
+            cursor,
+            limit: pageLimit,
+        }, {
+            optional: ["cursor", "limit"],
+        }),
+        outputSchema: s.object("Workflow-run query result.", {
+            mode: s.string("Query mode, select or count."),
+            count: s.integer("Number of matching runs for count mode.", { minimum: 0 }),
+            data: s.array("Matching runs in newest-first order for select mode.", s.looseObject("Workflow run metadata.")),
+            cursor,
+        }, {
+            required: ["mode"],
+            additionalProperties: true,
+        }),
+    }),
+];

package/src/providers/clay/batch-actions.d.ts

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

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

@@ -0,0 +1,71 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const runId = s.string("Batch routine run ID.", { minLength: 1, maxLength: 64 });
+export const clayBatchActions = [
+    defineProviderAction("clay", {
+        name: "run_routine_batch",
+        operationType: "destructive",
+        description: "Download a JSONL file, upload it to Clay, and start an asynchronous batch routine. Each line must contain id and inputs. The routine may perform arbitrary downstream mutations. Requires streaming transit storage. Transfer limit: the lower of 2 GiB and the configured transit storage limit, five minutes each for download and upload; JSONL validation is performed by Clay.",
+        inputSchema: s.object("Batch routine submission parameters.", {
+            routine_id: s.string("Routine ID, such as function:t_abc123.", {
+                minLength: 1,
+                maxLength: 64,
+            }),
+            fileUrl: s.string("Public HTTP(S) URL of a UTF-8 JSONL file; signed URLs are supported. The connector downloads it without Clay credentials.", { format: "uri", minLength: 1 }),
+            webhook_id: s.string("ID of an existing Clay webhook to notify on completion.", {
+                minLength: 1,
+                maxLength: 64,
+            }),
+        }, {
+            optional: ["webhook_id"],
+        }),
+        outputSchema: s.object("Submitted batch routine run.", {
+            routine_run_id: runId,
+            status: s.string("Initial run status, in_progress."),
+        }, {
+            required: ["routine_run_id", "status"],
+            additionalProperties: true,
+        }),
+        asyncLifecycle: {
+            startActionId: "clay.run_routine_batch",
+            statusActionId: "clay.get_routine_batch_results",
+        },
+    }),
+    defineProviderAction("clay", {
+        name: "get_routine_batch_results",
+        operationType: "read",
+        description: "Get batch progress, a result download URL, or validation/processing failure details. Download result_url separately after completion and inspect individual item outcomes; results are not loaded into the action response.",
+        inputSchema: s.requiredObject("Batch result parameters.", { routine_run_id: runId }),
+        outputSchema: s.object("Batch progress or terminal outcome.", {
+            routine_run_id: runId,
+            status: s.string("Batch status: in_progress, complete, validation_failed, or processing_failed; unknown statuses are preserved."),
+            total: s.number("Total input items, when available."),
+            finished: s.number("Finished items, including failures, when available."),
+            result_url: s.string("Result file download URL returned on completion; may contain a signed access token.", {
+                format: "uri",
+            }),
+            error: s.object("Batch validation or processing error.", {
+                message: s.string("Failure message."),
+                total_invalid_rows: s.number("Total invalid JSONL rows for validation failures."),
+                details: s.array("Validation errors reported by Clay, up to 100 entries.", s.object("One JSONL validation error.", {
+                    field: s.string("Invalid field."),
+                    line_number: s.number("JSONL line number."),
+                    message: s.string("Validation error message."),
+                }, {
+                    required: ["field", "line_number", "message"],
+                    additionalProperties: true,
+                })),
+            }, {
+                required: ["message"],
+                additionalProperties: true,
+            }),
+        }, {
+            required: ["routine_run_id", "status"],
+            additionalProperties: true,
+        }),
+        asyncLifecycle: {
+            startActionId: "clay.run_routine_batch",
+            statusActionId: "clay.get_routine_batch_results",
+        },
+    }),
+];

package/src/providers/clay/batch-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { ApiKeyProviderContext } from "../provider-runtime.ts";
+export declare function runClayBatch(context: ApiKeyProviderContext, input: Record<string, unknown>): Promise<Record<string, unknown>>;