@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/cronlytic/executors.js

@@ -0,0 +1,146 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { providerInputError, providerResponseError, defineProviderExecutors, requireApiKeyCredential, defineProviderProxy, mapProviderActionHandlers, requiredInputString, requiredResponseRecord, providerUserAgent, runProviderRequest, ProviderRequestError, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { cronlyticActions } from "./actions.js";
+const apiBaseUrl = "https://api.cronlytic.com/prog";
+async function requestCronlytic({ apiKey, userId, path, method, body, fetcher, validating = false, signal: parentSignal, }) {
+    return runProviderRequest({ label: "Cronlytic", signal: parentSignal }, async (signal) => {
+        const response = await fetcher(`${apiBaseUrl}${path}`, {
+            method,
+            signal,
+            headers: {
+                "X-API-Key": apiKey,
+                "X-User-ID": userId,
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const text = await response.text();
+        let payload = undefined;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Cronlytic returned non-JSON content (HTTP ${response.status})`, undefined, "provider_error");
+        }
+        if (!response.ok) {
+            const detail = optionalRecord(payload)?.detail;
+            const message = optionalRawString(detail) ??
+                optionalRawString(optionalRecord(detail)?.error) ??
+                (Array.isArray(detail)
+                    ? detail
+                        .map((entry) => optionalRawString(optionalRecord(entry)?.msg))
+                        .filter(Boolean)
+                        .join("; ")
+                    : undefined);
+            if (response.status === 401 && detail === "Invalid API key") {
+                throw new ProviderRequestError(401, "Cronlytic rejected the API key or User ID", undefined, validating ? "invalid_input" : "authorization_failed");
+            }
+            throw new ProviderRequestError(response.status, message ? `Cronlytic: ${message}` : `Cronlytic request failed (HTTP ${response.status})`, undefined, "provider_error");
+        }
+        return payload;
+    });
+}
+const handlers = mapProviderActionHandlers("cronlytic", cronlyticActions, (action) => async (values, context) => {
+    let path = "/jobs";
+    let method = "GET";
+    let body = undefined;
+    if (action.name !== "create_job" && action.name !== "list_jobs") {
+        const id = requiredInputString(values.job_id, "job_id");
+        if (id === "." || id === "..")
+            throw providerInputError("Invalid job_id");
+        path += `/${encodeURIComponent(id)}`;
+    }
+    switch (action.name) {
+        case "create_job":
+        case "update_job":
+            method = action.name === "create_job" ? "POST" : "PUT";
+            body = {
+                name: values.name,
+                url: values.url,
+                method: values.method ?? "GET",
+                headers: values.headers ?? {},
+                body: values.body ?? "",
+                cron_expression: values.cron_expression,
+            };
+            break;
+        case "delete_job":
+            method = "DELETE";
+            break;
+        case "pause_job":
+            method = "POST";
+            path += "/pause";
+            break;
+        case "resume_job":
+            method = "POST";
+            path += "/resume";
+            break;
+        case "get_job_logs":
+            path += "/logs";
+            break;
+    }
+    const payload = await requestCronlytic({ ...context, path, method, body });
+    if (action.name === "list_jobs") {
+        if (!Array.isArray(payload))
+            throw providerResponseError("Cronlytic returned an invalid job list");
+        return { jobs: payload };
+    }
+    return requiredResponseRecord(payload, "Cronlytic");
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await requestCronlytic({
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            userId: requiredInputString(input.values.userId, "userId"),
+            path: "/jobs",
+            method: "GET",
+            fetcher,
+            validating: true,
+            signal,
+        });
+        return {
+            profile: { displayName: "Cronlytic API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl },
+        };
+    },
+};
+export const executors = defineProviderExecutors({
+    service: "cronlytic",
+    handlers,
+    skipDnsValidation: true,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, "cronlytic");
+        return {
+            apiKey: credential.apiKey,
+            userId: requiredInputString(credential.values.userId, "userId"),
+            fetcher,
+            signal: context.signal,
+        };
+    },
+});
+export const proxy = defineProviderProxy({
+    service: "cronlytic",
+    baseUrl: apiBaseUrl,
+    auth: {
+        type: "credential_headers",
+        headers: [
+            { name: "X-API-Key", source: { type: "api_key" } },
+            { name: "X-User-ID", source: { type: "credential_value", name: "userId" } },
+        ],
+    },
+    skipDnsValidation: true,
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, `Provider request failed with HTTP ${response.status}`), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({
+            accept: "application/json",
+            "content-type": "application/json",
+            "user-agent": providerUserAgent,
+        }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+});

package/src/providers/dataforseo/runtime.js

@@ -456,13 +456,13 @@ function createDataForSeoError(httpStatus, envelope, phase) {
     const statusMessage = optionalString(envelope.status_message) ?? "DataForSEO request failed";
     const envelopeStatusCode = readOptionalNumber(envelope.status_code);
     const isAuthError = httpStatus === 401 || httpStatus === 403 || envelopeStatusCode === 40100;
-    return new ProviderRequestError(phase === "validate" || isAuthError ? 400 : 502, statusMessage);
+    return new ProviderRequestError(phase === "validate" || isAuthError ? 400 : 502, `DataForSEO request failed (HTTP ${httpStatus}, status_code ${envelopeStatusCode ?? "unknown"}): ${statusMessage}`);
 }
 function createDataForSeoTaskError(task, phase) {
     const statusMessage = optionalString(task.status_message) ?? "DataForSEO task failed";
     const statusCode = readOptionalNumber(task.status_code);
     const isAuthError = statusCode === 40100;
-    return new ProviderRequestError(phase === "validate" || isAuthError ? 400 : 502, statusMessage);
+    return new ProviderRequestError(phase === "validate" || isAuthError ? 400 : 502, `DataForSEO task failed (status_code ${statusCode ?? "unknown"}): ${statusMessage}`);
 }
 function isSuccessfulStatus(statusCode) {
     const parsed = readOptionalNumber(statusCode);

package/src/providers/dropbox/executors.js

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import { compactObject, optionalBoolean, optionalNumber, optionalRecord as asOptionalObject, optionalString as asOptionalString, requiredRecord, } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { createProviderFetch, createProviderProxyUrl, defineOAuthProviderExecutors, normalizeProviderProxyEndpoint, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyResponse, requireOAuthCredential, toProviderProxyError, } from "../provider-runtime.js";
 const dropboxApiBaseUrl = "https://api.dropboxapi.com/2";
 const dropboxContentBaseUrl = "https://content.dropboxapi.com/2";
@@ -536,12 +536,12 @@ async function storeDropboxDownload(input, response, transitFiles, actionName) {
         throw new ProviderRequestError(413, `Dropbox download exceeds ${transitFiles.maxBytes} bytes`);
     }
     const mimeType = optionalString(response.headers.get("content-type")) ?? "application/octet-stream";
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: transitFiles.maxBytes,
+    const file = await storeResponseInTransit(response, transitFiles, {
+        name: transitName,
+        mimeType,
         fieldName: "Dropbox download",
         createError: (message) => new ProviderRequestError(413, message),
     });
-    const file = await transitFiles.create(new File([Uint8Array.from(bytes)], transitName, { type: mimeType }));
     return {
         fileId,
         name: remoteName,

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

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

package/src/providers/dynalist/actions.js

@@ -0,0 +1,191 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const id = s.nonEmptyString("The Dynalist ID.");
+const position = s.integer("The zero-based position; -1 appends at the end.", { minimum: -1 });
+const nodeFields = {
+    content: s.string("The node title."),
+    note: s.string("The node note."),
+    checked: s.boolean("Whether the node is checked."),
+    checkbox: s.boolean("Whether the node has a checkbox."),
+    heading: s.integer("The heading level; 0 disables headings.", { minimum: 0, maximum: 3 }),
+    color: s.integer("The color label; 0 removes the label.", { minimum: 0, maximum: 6 }),
+};
+const optionalNodeFields = Object.keys(nodeFields);
+const envelope = {
+    _code: s.string("The Dynalist result code; OK indicates success."),
+    _msg: s.string("The Dynalist result message."),
+};
+const fileType = s.stringEnum("The file type.", ["document", "folder"]);
+const fileChange = s.union([
+    s.object("Create a document or folder.", {
+        action: s.literal("create", { description: "The change operation." }),
+        type: fileType,
+        parent_id: id,
+        index: position,
+        title: s.string("The file title."),
+    }, { optional: ["title"] }),
+    s.object("Rename a document or folder.", {
+        action: s.literal("edit", { description: "The change operation." }),
+        type: fileType,
+        file_id: id,
+        title: s.string("The file title."),
+    }, { optional: [] }),
+    s.object("Move a document or folder.", {
+        action: s.literal("move", { description: "The change operation." }),
+        type: fileType,
+        file_id: id,
+        parent_id: id,
+        index: position,
+    }, { optional: [] }),
+], { description: "A file change." });
+const nodeChange = s.union([
+    s.object("Insert a node.", {
+        action: s.literal("insert", { description: "The change operation." }),
+        parent_id: id,
+        index: position,
+        ...nodeFields,
+    }, { optional: optionalNodeFields.filter((key) => key !== "content") }),
+    s.object("Edit a node.", {
+        action: s.literal("edit", { description: "The change operation." }),
+        node_id: id,
+        ...nodeFields,
+    }, { optional: optionalNodeFields }),
+    s.object("Move a node.", {
+        action: s.literal("move", { description: "The change operation." }),
+        node_id: id,
+        parent_id: id,
+        index: position,
+    }, { optional: [] }),
+    s.object("Delete a node.", {
+        action: s.literal("delete", { description: "The change operation." }),
+        node_id: id,
+    }, { optional: [] }),
+], { description: "A node change." });
+const preferenceKey = s.stringEnum("The preference key.", ["inbox_location", "inbox_move_position"]);
+const results = s.array("Whether each requested change succeeded, in request order.", s.boolean("Whether this change succeeded."));
+export const dynalistActions = [
+    defineProviderAction("dynalist", {
+        name: "list_files",
+        description: "List all Dynalist documents and folders.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("The request parameters.", {}, { optional: [] }),
+        outputSchema: s.looseObject("The Dynalist response.", {
+            ...envelope,
+            root_file_id: id,
+            files: s.array("The documents and folders.", s.looseObject("A document or folder.", {
+                id,
+                title: s.string("The file title."),
+                type: fileType,
+                permission: s.integer("The permission level: 0 none, 1 read, 2 edit, 3 manage, 4 owner."),
+                collapsed: s.boolean("Whether the folder is collapsed."),
+                children: s.array("The child IDs.", id),
+            })),
+        }),
+    }),
+    defineProviderAction("dynalist", {
+        name: "edit_files",
+        description: "Create, rename, or move Dynalist documents and folders in a batch. Inspect results for partial failures.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("The request parameters.", {
+            changes: s.array("The changes in execution order.", fileChange, { minItems: 1 }),
+        }, { optional: [] }),
+        outputSchema: s.looseObject("The Dynalist response.", {
+            ...envelope,
+            results,
+            created: s.array("The successfully created file IDs in request order.", id),
+        }),
+    }),
+    defineProviderAction("dynalist", {
+        name: "read_document",
+        description: "Read a Dynalist document and its nodes.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("The request parameters.", { file_id: id }, { optional: [] }),
+        outputSchema: s.looseObject("The Dynalist response.", {
+            ...envelope,
+            file_id: id,
+            title: s.string("The file title."),
+            version: s.integer("The document version."),
+            nodes: s.array("The document nodes.", s.looseObject("A document node.", {
+                id,
+                ...nodeFields,
+                children: s.array("The child IDs.", id),
+                created: s.integer("The creation time in Unix milliseconds."),
+                modified: s.integer("The modification time in Unix milliseconds."),
+                collapsed: s.boolean("Whether the node is collapsed."),
+            })),
+        }),
+    }),
+    defineProviderAction("dynalist", {
+        name: "check_for_updates",
+        description: "Get Dynalist document versions. Inaccessible or missing documents are omitted.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("The request parameters.", {
+            file_ids: s.array("The document IDs to check.", id),
+        }, { optional: [] }),
+        outputSchema: s.looseObject("The Dynalist response.", {
+            ...envelope,
+            versions: s.record("Document IDs mapped to current versions.", s.integer("The document version.")),
+        }),
+    }),
+    defineProviderAction("dynalist", {
+        name: "edit_document",
+        description: "Insert, edit, move, or delete Dynalist nodes in a batch. Content edits replace the supplied fields.",
+        operationType: "destructive",
+        requiredScopes: [],
+        inputSchema: s.object("The request parameters.", {
+            file_id: id,
+            changes: s.array("The changes in execution order.", nodeChange, { minItems: 1 }),
+        }, { optional: [] }),
+        outputSchema: s.looseObject("The Dynalist response.", {
+            ...envelope,
+            results,
+            new_node_ids: s.array("The newly inserted node IDs in request order.", id),
+        }),
+    }),
+    defineProviderAction("dynalist", {
+        name: "add_to_inbox",
+        description: "Add a node to the configured Dynalist inbox. Configure an inbox before calling this action.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.object("The request parameters.", { index: position, ...nodeFields }, { optional: ["index", ...optionalNodeFields] }),
+        outputSchema: s.looseObject("The Dynalist response.", {
+            ...envelope,
+            file_id: id,
+            node_id: id,
+            index: position,
+        }),
+    }),
+    defineProviderAction("dynalist", {
+        name: "get_preference",
+        description: "Read a Dynalist inbox preference.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("The request parameters.", { key: preferenceKey }, { optional: [] }),
+        outputSchema: s.looseObject("The Dynalist response.", {
+            ...envelope,
+            key: preferenceKey,
+            value: s.string("The preference value."),
+        }),
+    }),
+    defineProviderAction("dynalist", {
+        name: "set_preference",
+        description: "Set the Dynalist inbox location or insertion position.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.union([
+            s.object("Set the inbox location.", {
+                key: s.literal("inbox_location", { description: "The preference key." }),
+                value: s.string("The inbox file ID, optionally followed by /node ID."),
+            }, { optional: [] }),
+            s.object("Set the inbox insertion position.", {
+                key: s.literal("inbox_move_position", { description: "The preference key." }),
+                value: s.stringEnum("The insertion position.", ["top", "bottom"]),
+            }, { optional: [] }),
+        ], { description: "The request parameters." }),
+        outputSchema: s.looseObject("The Dynalist response.", envelope),
+    }),
+];

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

@@ -0,0 +1,58 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { dynalistActions } from "./actions.js";
+const baseUrl = "https://dynalist.io/api/v1";
+const endpoints = {
+    list_files: "/file/list",
+    edit_files: "/file/edit",
+    read_document: "/doc/read",
+    check_for_updates: "/doc/check_for_updates",
+    edit_document: "/doc/edit",
+    add_to_inbox: "/inbox/add",
+    get_preference: "/pref/get",
+    set_preference: "/pref/set",
+};
+export const executors = defineApiKeyProviderExecutors("dynalist", mapProviderActionHandlers("dynalist", dynalistActions, (_action, name) => (input, context) => requestDynalist(endpoints[name], input, context.apiKey, context.fetcher, false, context.signal)), { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await requestDynalist("/pref/get", { key: "inbox_move_position" }, input.apiKey, fetcher, true, signal);
+        return { profile: { displayName: "Dynalist Account" }, grantedScopes: [], metadata: {} };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "dynalist",
+    baseUrl,
+    auth: { type: "api_key_json_body", name: "token" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});
+async function requestDynalist(endpoint, body, apiKey, fetcher, validating = false, parentSignal) {
+    return runProviderRequest({ label: "Dynalist", signal: parentSignal }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${endpoint}`, {
+            method: "POST",
+            headers: { accept: "application/json", "content-type": "application/json" },
+            body: JSON.stringify({ ...body, token: apiKey }),
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = optionalRecord(JSON.parse(text));
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Dynalist returned a non-JSON response (HTTP ${response.status})`, undefined, "provider_error");
+        }
+        const code = optionalString(payload?._code);
+        const message = optionalString(payload?._msg);
+        if (code === "InvalidToken") {
+            throw new ProviderRequestError(validating ? 400 : 401, message || "Dynalist API secret token is invalid");
+        }
+        if (!response.ok || code !== "OK") {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Dynalist ${code ?? response.status}: ${message || "request failed"}`, undefined, "provider_error");
+        }
+        return requiredResponseRecord(payload, "Dynalist");
+    });
+}

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

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

package/src/providers/easy_peasy_ai/actions.js

@@ -0,0 +1,107 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const presetProperties = {
+    slug: s.string("Unique preset identifier."),
+    title: s.string("Human-readable preset name."),
+    description: s.string("Short description of what the preset does."),
+    category: s.anyOf("Category or categories the preset belongs to.", [
+        s.string("A preset category."),
+        s.array("Preset categories.", s.string("A preset category.")),
+    ]),
+    isFree: s.boolean("Whether this preset is available on the free plan."),
+};
+const preset = s.looseRequiredObject("A text generation preset.", presetProperties, {
+    optional: ["description", "category", "isFree"],
+});
+export const easyPeasyAiActions = [
+    defineProviderAction("easy_peasy_ai", {
+        name: "list_presets",
+        operationType: "read",
+        description: "List Easy-Peasy.AI text generation presets, optionally filtered by category.",
+        requiredScopes: [],
+        inputSchema: s.object("Filters for discovering text generation presets.", {
+            category: s.stringEnum("Filter presets by category.", [
+                "Social Media",
+                "Content",
+                "Business",
+                "HR",
+                "Marketing",
+                "Resume",
+                "Education",
+                "Project Management",
+                "Tools",
+                "Other",
+            ]),
+        }, { optional: ["category"] }),
+        outputSchema: s.looseRequiredObject("Available text generation presets.", {
+            presets: s.array("List of available presets.", preset),
+            total: s.integer("Total number of presets returned."),
+            categories: s.array("All available preset categories.", s.string("A preset category.")),
+        }),
+    }),
+    defineProviderAction("easy_peasy_ai", {
+        name: "get_preset",
+        operationType: "read",
+        description: "Get an Easy-Peasy.AI preset's input fields and current constraints before generating text.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("The preset to inspect.", {
+            slug: s.string("The preset slug, such as custom-generator or paragraph-writer.", {
+                minLength: 1,
+            }),
+        }),
+        outputSchema: s.looseRequiredObject("The preset configuration and input requirements.", {
+            ...presetProperties,
+            fields: s.array("Input fields to pass to generate_text, including template-specific constraints.", s.looseRequiredObject("A preset input field and its constraints.", {
+                name: s.string("The request body field name."),
+                label: s.string("Human-readable field label."),
+                type: s.string("Input control type."),
+                required: s.boolean("Whether the preset requires this field."),
+                placeholder: s.string("An example value or input hint."),
+                maxLength: s.integer("Maximum text length for this field."),
+                radioOptions: s.array("Choices for a radio input.", s.looseRequiredObject("A radio choice.", {
+                    value: s.string("The value to send."),
+                    default: s.boolean("Whether this choice is the default."),
+                }, { optional: ["default"] })),
+            }, { optional: ["label", "type", "required", "placeholder", "maxLength", "radioOptions"] })),
+        }, { optional: ["description", "category", "isFree"] }),
+    }),
+    defineProviderAction("easy_peasy_ai", {
+        name: "generate_text",
+        operationType: "write",
+        description: "Generate text with an Easy-Peasy.AI preset. Use get_preset first for template-specific fields and constraints; generation consumes word credits.",
+        requiredScopes: [],
+        inputSchema: s.object("Text generation parameters; field meanings and length limits depend on the preset.", {
+            preset: s.string("The template slug to use for generation.", { minLength: 1 }),
+            keywords: s.string("The main input text or topic; may be empty for templates that use other fields."),
+            tone: s.string("The desired tone, such as professional, friendly, or funny."),
+            length: s.stringEnum("The desired output length.", ["Short", "Medium", "Long"]),
+            outputs: s.integer("Number of outputs to generate; defaults to 1."),
+            language: s.string("Output language; defaults to English."),
+            shouldUseGPT4: s.boolean("Whether to use the advanced AI model; defaults to false."),
+            extra1: s.string("Additional context, such as background information, key skills, or a blog introduction."),
+            extra2: s.string("Additional context, such as a blog title or reply sentiment."),
+            extra3: s.string("Additional context, such as a job title."),
+            extra4: s.string("Additional context, such as recommendation details."),
+            suffix: s.string("End section text for the Fill the Gaps template."),
+        }, {
+            optional: [
+                "tone",
+                "length",
+                "outputs",
+                "language",
+                "shouldUseGPT4",
+                "extra1",
+                "extra2",
+                "extra3",
+                "extra4",
+                "suffix",
+            ],
+        }),
+        outputSchema: s.requiredObject("Generated text outputs.", {
+            outputs: s.array("The generated outputs returned by Easy-Peasy.AI.", s.looseRequiredObject("A generated text output.", {
+                id: s.integer("The generated output ID."),
+                name: s.string("The generated text."),
+            })),
+        }),
+    }),
+];

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

@@ -0,0 +1,90 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerResponseError, requiredInputString, requiredResponseRecord, runProviderRequest, readProviderTextBody, } from "../provider-runtime.js";
+import { easyPeasyAiActions } from "./actions.js";
+const baseUrl = "https://easy-peasy.ai/api";
+async function request(endpoint, apiKey, fetcher, body, validating = false, parentSignal) {
+    return runProviderRequest({ signal: parentSignal, label: "Easy-Peasy.AI" }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${endpoint}`, {
+            method: body === undefined ? "GET" : "POST",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal,
+        });
+        const text = await readProviderTextBody(response, "easy_peasy_ai response", undefined, signal);
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, "Easy-Peasy.AI returned invalid JSON", undefined, "provider_error");
+        }
+        if (!response.ok) {
+            const error = optionalRecord(payload)?.error;
+            const message = optionalRawString(error) ??
+                optionalRawString(optionalRecord(error)?.message) ??
+                `Easy-Peasy.AI request failed with status ${response.status}`;
+            if (response.status === 401 && message === "Invalid API key") {
+                throw new ProviderRequestError(validating ? 400 : 401, message, undefined, validating ? "invalid_input" : "authorization_failed");
+            }
+            throw new ProviderRequestError(response.status, message, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return payload;
+    });
+}
+const handlers = mapProviderActionHandlers("easy_peasy_ai", easyPeasyAiActions, (action) => async (values, context) => {
+    const apiKey = context.apiKey;
+    const fetcher = context.fetcher;
+    if (action.name === "generate_text") {
+        const payload = await request("/generate", apiKey, fetcher, {
+            ...values,
+            outputs: values.outputs ?? 1,
+            language: values.language ?? "English",
+            shouldUseGPT4: values.shouldUseGPT4 ?? false,
+        }, undefined, context.signal);
+        if (!Array.isArray(payload))
+            throw providerResponseError("Easy-Peasy.AI generated outputs must be an array");
+        return { outputs: payload };
+    }
+    let endpoint = "/presets";
+    if (action.name === "get_preset") {
+        const slug = requiredInputString(values.slug, "slug");
+        // Reject dot segments before URL normalization can change the endpoint.
+        if (slug === "." || slug === "..") {
+            throw new ProviderRequestError(400, "slug must identify a preset", undefined, "invalid_input");
+        }
+        endpoint += `/${encodeURIComponent(slug)}`;
+    }
+    else if (values.category !== undefined) {
+        endpoint += `?${new URLSearchParams({ category: String(values.category) })}`;
+    }
+    return requiredResponseRecord(await request(endpoint, apiKey, fetcher, undefined, undefined, context.signal), "Easy-Peasy.AI preset response");
+});
+export const executors = defineApiKeyProviderExecutors("easy_peasy_ai", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        const payload = requiredResponseRecord(await request("/presets", requiredInputString(input.apiKey, "API Key"), fetcher, undefined, true), "Easy-Peasy.AI presets");
+        if (!Array.isArray(payload.presets))
+            throw providerResponseError("Easy-Peasy.AI presets must be an array");
+        return {
+            profile: { displayName: "Easy-Peasy.AI API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "easy_peasy_ai",
+    baseUrl,
+    auth: { type: "api_key_header", name: "x-api-key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});

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