@oomol-lab/open-connector 1.8.0 → 1.9.0

package/src/providers/agenty/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString, recordOrEmpty, requiredRecord } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { providerFetch, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
 export const agentyApiBaseUrl = "https://api.agenty.com/v2";
 export const agentyBrowserBaseUrl = "https://browser.agenty.com/api";
@@ -523,12 +523,13 @@ async function uploadAgentyTransitFile(context, response, name) {
         throw new ProviderRequestError(500, "agenty file output requires local transit files");
     }
     const mimeType = response.headers.get("content-type") ?? "application/octet-stream";
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
+    const upload = await storeResponseInTransit(response, context.transitFiles, {
+        name,
+        mimeType,
         fieldName: "Agenty file output",
         createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
     });
-    const upload = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
     return {
         name,
         mimetype: mimeType,

package/src/providers/aisa/executors.js

@@ -59,6 +59,16 @@ const aisaActionRoutes = {
     query_dataforseo_claude: dataForSeoLlmRoute("/apis/v1/dataforseo/ai_optimization/claude/llm_responses/live"),
     query_dataforseo_gemini: dataForSeoLlmRoute("/apis/v1/dataforseo/ai_optimization/gemini/llm_responses/live"),
     query_dataforseo_perplexity: dataForSeoLlmRoute("/apis/v1/dataforseo/ai_optimization/perplexity/llm_responses/live"),
+    get_dataforseo_keyword_trends: dataForSeoRoute("/apis/v1/dataforseo/keywords_data/dataforseo_trends/explore/live", {
+        keywords: "keywords",
+        locationName: "locationName",
+        locationCode: "locationCode",
+        type: "type",
+        dateFrom: "dateFrom",
+        dateTo: "dateTo",
+        timeRange: "timeRange",
+        tag: "tag",
+    }),
     get_dataforseo_ai_keyword_volume: dataForSeoRoute("/apis/v1/dataforseo/ai_optimization/ai_keyword_data/keywords_search_volume/live", {
         keywords: "keywords",
         locationName: "locationName",

package/src/providers/aliyun_oss/executors.js

@@ -1,7 +1,7 @@
 import AliOss from "ali-oss";
 import { compactObject, optionalInteger, optionalRecord, optionalString, requiredRawString } from "../../core/cast.js";
 import { assertGuardedEgressUrl } from "../../core/guarded-fetch.js";
-import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed, readBoundedResponseBytes } from "../../core/request.js";
+import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed, storeResponseInTransit } from "../../core/request.js";
 import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, providerFetch, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, toProviderProxyError, } from "../provider-runtime.js";
 const service = "aliyun_oss";
 const sourceFetchTimeoutMs = 15_000;
@@ -356,12 +356,13 @@ async function aliyunDownloadObject(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: "Alibaba Cloud OSS 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/amazing_marvin/actions.d.ts

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

package/src/providers/amazing_marvin/actions.js

@@ -0,0 +1,145 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const date = s.string("Calendar date in YYYY-MM-DD format.", { format: "date" });
+const timeZoneOffset = s.integer("UTC offset in minutes, positive east of UTC; used for local dates.");
+const creationProperties = {
+    title: s.nonEmptyString("Item title; Marvin processes supported task input shortcuts."),
+    done: s.boolean("Whether the new item is already complete."),
+    day: s.nullable(date),
+    parentId: s.nonEmptyString("Parent category or project ID; unassigned is the inbox."),
+    labelIds: s.array("Label IDs to attach.", s.nonEmptyString("A label ID.")),
+    firstScheduled: date,
+    rank: s.number("Sort rank within the parent."),
+    dailySection: s.string("Daily section name, such as Morning."),
+    bonusSection: s.stringEnum("Essential or bonus section.", ["Essential", "Bonus"]),
+    customSection: s.string("Custom section ID from the user's settings."),
+    timeBlockSection: s.string("Time block ID."),
+    note: s.string("Item notes."),
+    dueDate: date,
+    timeEstimate: s.number("Estimated duration in milliseconds."),
+    isReward: s.boolean("Whether the item is a reward."),
+    isFrogged: s.integer("Frog difficulty level."),
+    plannedWeek: date,
+    plannedMonth: s.string("Planned month in YYYY-MM format."),
+    rewardPoints: s.number("Reward points for completing the item."),
+    backburner: s.boolean("Whether to manually place the item on the backburner."),
+    reviewDate: date,
+    timeZoneOffset,
+};
+const resultSchema = s.object("Write operation response.", {
+    result: s.unknown("Upstream JSON or text confirmation, or null for an empty response; an item ID is not guaranteed."),
+}, {
+    optional: [],
+});
+const itemsSchema = s.object("Matching Marvin items.", {
+    items: s.array("Items returned by Marvin; these endpoints do not paginate.", s.looseObject("A Marvin item with its upstream fields.")),
+}, {
+    optional: [],
+});
+export const amazingMarvinActions = [
+    defineProviderAction("amazing_marvin", {
+        name: "create_task",
+        description: "Create a Marvin task with scheduling, labels, notes, and optional title shortcuts.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Task creation input.", {
+            ...creationProperties,
+            isStarred: s.integer("Task priority star level."),
+            autoComplete: s.boolean("Process title shortcuts; defaults to Marvin's enabled behavior. Set false to keep the title literal."),
+        }, {
+            required: ["title"],
+        }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("amazing_marvin", {
+        name: "create_project",
+        description: "Create a Marvin project with scheduling, labels, notes, and priority.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Project creation input; set day to null for an unscheduled project.", {
+            ...creationProperties,
+            priority: s.stringEnum("Project priority.", ["high", "mid", "low"]),
+            rewardId: s.string("ID of the attached reward."),
+            itemSnoozeTime: s.number("Snooze until this Unix timestamp in milliseconds."),
+            permaSnoozeTime: s.string("Daily snooze time in HH:mm format."),
+        }, {
+            required: ["title"],
+        }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("amazing_marvin", {
+        name: "complete_task",
+        description: "Mark a Marvin task complete. This experimental API does not reproduce all client recurrence and reward behavior.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("Task completion input.", {
+            itemId: s.nonEmptyString("ID of the task to complete."),
+            timeZoneOffset,
+        }, {
+            optional: ["timeZoneOffset"],
+        }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("amazing_marvin", {
+        name: "list_today_items",
+        description: "List tasks and projects scheduled on a day, including enabled rollover and auto-scheduled due items. Omitted date uses the server's UTC date.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Scheduled items query.", { date }, {
+            optional: ["date"],
+        }),
+        outputSchema: itemsSchema,
+    }),
+    defineProviderAction("amazing_marvin", {
+        name: "list_done_items",
+        description: "List tasks and projects completed on a day. Omitted date uses the server's UTC date.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Completed items query.", { date }, {
+            optional: ["date"],
+        }),
+        outputSchema: itemsSchema,
+    }),
+    defineProviderAction("amazing_marvin", {
+        name: "list_due_items",
+        description: "List open tasks and projects due on or before a date. Omitted by uses the server's UTC date.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Due items query.", { by: date }, {
+            optional: ["by"],
+        }),
+        outputSchema: itemsSchema,
+    }),
+    defineProviderAction("amazing_marvin", {
+        name: "list_children",
+        description: "List open direct child tasks and projects of a category or project; descendants are not expanded.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Direct children query.", {
+            parentId: s.nonEmptyString("Parent category or project ID; use unassigned for the inbox."),
+        }, {
+            optional: [],
+        }),
+        outputSchema: itemsSchema,
+    }),
+    defineProviderAction("amazing_marvin", {
+        name: "list_categories",
+        description: "List all Marvin categories for organizing tasks and projects.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Category list input.", {}, {
+            optional: [],
+        }),
+        outputSchema: itemsSchema,
+    }),
+    defineProviderAction("amazing_marvin", {
+        name: "list_labels",
+        description: "List all Marvin labels in their configured sort order.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Label list input.", {}, {
+            optional: [],
+        }),
+        outputSchema: itemsSchema,
+    }),
+];

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

@@ -0,0 +1,98 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { readProviderTextBody, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { amazingMarvinActions } from "./actions.js";
+const baseUrl = "https://serv.amazingmarvin.com/api";
+const endpoints = {
+    create_task: "/addTask",
+    create_project: "/addProject",
+    complete_task: "/markDone",
+    list_today_items: "/todayItems",
+    list_done_items: "/doneItems",
+    list_due_items: "/dueItems",
+    list_children: "/children",
+    list_categories: "/categories",
+    list_labels: "/labels",
+};
+async function request(endpoint, method, input, apiKey, fetcher, parentSignal) {
+    return runProviderRequest({ signal: parentSignal, label: "Amazing Marvin" }, async (signal) => {
+        const url = new URL(`${baseUrl}${endpoint}`);
+        const headers = new Headers({
+            "X-API-Token": apiKey,
+            accept: "application/json",
+            "user-agent": providerUserAgent,
+        });
+        const { autoComplete, ...body } = input;
+        if (autoComplete !== undefined)
+            headers.set("X-Auto-Complete", String(autoComplete));
+        if (method === "GET") {
+            for (const [key, value] of Object.entries(body)) {
+                if (value !== undefined)
+                    url.searchParams.set(key, String(value));
+            }
+        }
+        else {
+            headers.set("content-type", "application/json");
+        }
+        const response = await fetcher(url.toString(), {
+            method,
+            headers,
+            signal,
+            body: method === "POST" ? JSON.stringify(body) : undefined,
+        });
+        const text = await readProviderTextBody(response, "amazing_marvin response", undefined, signal);
+        let payload = null;
+        if (text.trim()) {
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                if (response.ok && (method === "GET" || response.headers.get("content-type")?.includes("json"))) {
+                    throw new ProviderRequestError(502, "Amazing Marvin returned invalid JSON", undefined, "provider_error");
+                }
+                payload = text;
+            }
+        }
+        if (!response.ok) {
+            const record = optionalRecord(payload);
+            const message = optionalRawString(record?.message) ?? optionalRawString(record?.error) ?? optionalRawString(payload);
+            throw new ProviderRequestError(response.status, message ? `Amazing Marvin: ${message}` : `Amazing Marvin request failed (${response.status})`, undefined, "provider_error");
+        }
+        return payload;
+    });
+}
+export const executors = defineApiKeyProviderExecutors("amazing_marvin", mapProviderActionHandlers("amazing_marvin", amazingMarvinActions, (action) => async (input, context) => {
+    const method = action.operationType === "read" ? "GET" : "POST";
+    const payload = await request(endpoints[action.name], method, input, context.apiKey, context.fetcher, context.signal);
+    if (method === "GET") {
+        if (!Array.isArray(payload)) {
+            throw new ProviderRequestError(502, "Amazing Marvin returned an invalid item list", undefined, "provider_error");
+        }
+        return { items: payload };
+    }
+    return { result: payload };
+}), { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        const payload = requiredResponseRecord(await request("/me", "GET", {}, requiredInputString(input.apiKey, "API Key"), fetcher), "Amazing Marvin account");
+        return {
+            profile: { displayName: optionalRawString(payload.email) ?? "Amazing Marvin Account" },
+            grantedScopes: [],
+            metadata: { validationEndpoint: "/api/me" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "amazing_marvin",
+    baseUrl,
+    auth: { type: "api_key_header", name: "X-API-Token" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [key, value] of Object.entries({
+            accept: "application/json",
+            "content-type": "application/json",
+            "user-agent": providerUserAgent,
+        }))
+            if (!headers.has(key))
+                headers.set(key, value);
+    },
+});

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/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[];