@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/clickup/trigger-on-task-event.js

@@ -0,0 +1,94 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-task-event.definition.js";
+function webhook(value) {
+    if (!isJsonObject(value) ||
+        typeof value.id != "string" ||
+        !value.id ||
+        typeof value.secret != "string" ||
+        !value.secret)
+        throw new TransientIntegrationError("ClickUp returned an invalid webhook identity or secret.");
+    return { id: value.id, secret: value.secret };
+}
+export const clickupTaskEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const endpoint = `/team/${encodeURIComponent(String(context.config.workspaceId))}/webhook`;
+        const location = context.config.listId == null ? {} : { list_id: Number(context.config.listId) };
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const result = await webhookRequest(context, { endpoint, method: "GET" });
+                if (!isJsonObject(result.data) || !Array.isArray(result.data.webhooks))
+                    throw new TransientIntegrationError("ClickUp returned an invalid webhook list.");
+                return result.data.webhooks
+                    .filter((item) => {
+                    if (!isJsonObject(item) || typeof item.endpoint != "string")
+                        throw new TransientIntegrationError("ClickUp returned an invalid webhook.");
+                    if (item.endpoint !== context.endpointUrl)
+                        return false;
+                    if (context.active && String(item.list_id ?? "") !== String(context.config.listId ?? ""))
+                        throw new PermanentIntegrationError("The ClickUp webhook no longer matches the configured List. Remove the subscription before recreating it.");
+                    return true;
+                })
+                    .map(webhook);
+            },
+            async create() {
+                const result = await webhookRequest(context, {
+                    endpoint,
+                    method: "POST",
+                    body: { endpoint: context.endpointUrl, events: context.config.eventTypes, ...location },
+                });
+                if (!isJsonObject(result.data) || !isJsonObject(result.data.webhook))
+                    throw new TransientIntegrationError("ClickUp webhook creation returned no webhook.");
+                return webhook(result.data.webhook);
+            },
+            async align(id) {
+                await webhookRequest(context, {
+                    endpoint: `/webhook/${encodeURIComponent(id)}`,
+                    method: "PUT",
+                    body: {
+                        endpoint: context.endpointUrl,
+                        events: context.config.eventTypes,
+                        status: "active",
+                    },
+                });
+            },
+            async remove(id) {
+                await webhookRequest(context, {
+                    endpoint: `/webhook/${encodeURIComponent(id)}`,
+                    method: "DELETE",
+                });
+            },
+        });
+    },
+    async receive(context) {
+        const secret = context.state?.subscription.secret;
+        if (typeof secret != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        if (!(await verifyHexHmac(secret, [context.rawBody], context.header("x-signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) ||
+            body.webhook_id != context.state?.subscription.hookId ||
+            typeof body.event != "string" ||
+            !context.config.eventTypes.includes(body.event))
+            return { outcome: "ignored", reason: "ClickUp subscription or event does not match." };
+        if (typeof body.task_id != "string" ||
+            !body.task_id ||
+            (body.history_items != null &&
+                (!Array.isArray(body.history_items) ||
+                    body.history_items.some((item) => !isJsonObject(item) || typeof item.id != "string" || !item.id))))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const historyIds = body.history_items?.map((item) => item.id).sort() ?? [];
+        if (historyIds.length == 0 && body.event != "taskCreated")
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: JSON.stringify([body.webhook_id, body.event, historyIds.length ? historyIds : body.task_id]),
+            outputs: { event: body.event, taskId: body.task_id, body },
+        };
+    },
+};

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

@@ -0,0 +1,12 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export interface CloroEndpoint {
+    action: ActionDefinition;
+    path: string;
+    method: "GET" | "POST" | "DELETE";
+    timeoutMs?: number;
+    arrayField?: string;
+}
+declare const endpoints: CloroEndpoint[];
+export declare const cloroActions: ActionDefinition[];
+export declare const cloroEndpointByName: Map<string, (typeof endpoints)[number]>;
+export {};

package/src/providers/cloro/actions.js

@@ -0,0 +1,155 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { aiModeMonitorRequest, chatGPTMonitorRequest, copilotMonitorRequest, geminiMonitorRequest, googleGotoRequest, googleMonitorRequest, googleNewsMonitorRequest, googleProductRequest, perplexityMonitorRequest, } from "./inputs.js";
+const actionLifecycles = {
+    create_task: { startActionId: "cloro.create_task", statusActionId: "cloro.get_task" },
+};
+const empty = s.requiredObject("No parameters.", {});
+const success = s.boolean("Whether the request succeeded.");
+const rawResult = s.looseObject("Engine-specific structured result, including answer text, sources, search results and requested extra formats.", {});
+const monitorOutput = s.looseRequiredObject("Monitoring response.", {
+    success,
+    result: s.anyOf("Structured result, or one result per ChatGPT conversation turn.", [
+        rawResult,
+        s.array("Conversation results in prompt order.", rawResult),
+    ]),
+});
+const task = s.looseRequiredObject("Task identity and state.", {
+    id: s.string("Task ID.", { format: "uuid" }),
+    taskType: s.string("Task engine."),
+    status: s.string("Task state: QUEUED, PROCESSING, COMPLETED or FAILED."),
+    priority: s.integer("Task priority."),
+    createdAt: s.string("Task creation timestamp."),
+});
+const credits = s.looseObject("Task credit usage reported by Cloro.", {});
+const submitOutput = s.looseRequiredObject("Submitted task and credit information.", {
+    success,
+    task,
+    credits,
+});
+const resultOutput = s.object("Task state and final response. Finished tasks are retained for about 24 hours after creation.", {
+    task,
+    credits,
+    response: s.looseObject("Completed engine response or failed task error, including its code, message and details.", {}),
+    webhook: s.looseObject("Webhook delivery status, if configured.", {}),
+}, {
+    optional: ["response", "webhook"],
+    additionalProperties: true,
+});
+const engines = [
+    { name: "chatgpt", taskType: "CHATGPT", schema: chatGPTMonitorRequest, label: "ChatGPT" },
+    { name: "gemini", taskType: "GEMINI", schema: geminiMonitorRequest, label: "Gemini" },
+    { name: "google", taskType: "GOOGLE", schema: googleMonitorRequest, label: "Google Search" },
+    {
+        name: "google/news",
+        taskType: "GOOGLE_NEWS",
+        schema: googleNewsMonitorRequest,
+        label: "Google News",
+    },
+    { name: "copilot", taskType: "COPILOT", schema: copilotMonitorRequest, label: "Copilot" },
+    {
+        name: "perplexity",
+        taskType: "PERPLEXITY",
+        schema: perplexityMonitorRequest,
+        label: "Perplexity",
+    },
+    { name: "aimode", taskType: "AIMODE", schema: aiModeMonitorRequest, label: "Google AI Mode" },
+    {
+        name: "google/product",
+        taskType: "GOOGLE_PRODUCT",
+        schema: googleProductRequest,
+        label: "Google product details",
+    },
+];
+const taskInput = s.anyOf("Task parameters matched to the selected engine.", engines.map((engine) => s.object(`Async ${engine.label} task.`, {
+    taskType: { type: "string", const: engine.taskType, description: "Task engine." },
+    payload: engine.schema,
+    priority: s.integer("Priority from 1 to 10; higher runs first. Defaults to 1. Use high priority for product tokens that expire after five minutes.", { minimum: 1, maximum: 10 }),
+    idempotencyKey: s.string("Account-wide unique key to prevent duplicate task submission. Reuse returns a conflict rather than creating another task."),
+    webhook: s.requiredObject("Optional completion webhook delivered by Cloro.", {
+        url: s.string("Webhook destination URL.", { format: "uri" }),
+    }),
+}, { optional: ["priority", "idempotencyKey", "webhook"] })));
+function endpoint(name, description, path, method, inputSchema, outputSchema, operationType = "read", timeoutMs, arrayField) {
+    return {
+        path,
+        method,
+        timeoutMs,
+        arrayField,
+        action: defineProviderAction("cloro", {
+            name,
+            description,
+            operationType,
+            requiredScopes: [],
+            inputSchema,
+            outputSchema,
+            asyncLifecycle: actionLifecycles[name],
+        }),
+    };
+}
+const endpoints = [
+    ...engines.map((engine) => endpoint(`monitor_${engine.name.replaceAll("/", "_")}`, `Retrieve ${engine.label} results synchronously. For long-running or bulk work, use create_task or create_batch_tasks. Sync calls include a credit surcharge; Google product tokens expire after five minutes.`, `/v1/monitor/${engine.name}`, "POST", engine.schema, monitorOutput, "read", 310000)),
+    endpoint("resolve_google_link", "Resolve a Google redirect link through Cloro without consuming credits.", "/v1/monitor/google/goto", "POST", googleGotoRequest, s.looseRequiredObject("Resolved Google link.", { url: s.string("Resolved destination URL.") })),
+    endpoint("create_task", "Submit a native asynchronous monitoring task. Use get_task for the result; priority, idempotency and webhooks are supported.", "/v1/async/task", "POST", taskInput, submitOutput, "write"),
+    endpoint("create_batch_tasks", "Submit up to 500 monitoring tasks. Each task is validated independently upstream; inspect results for partial failures.", "/v1/async/task/batch", "POST", s.requiredObject("Batch task submission.", {
+        tasks: s.array("Tasks in submission order.", taskInput, { minItems: 1, maxItems: 500 }),
+    }), s.looseRequiredObject("Batch submission results.", {
+        success,
+        summary: s.looseRequiredObject("Batch totals.", {
+            total: s.integer("Total tasks."),
+            succeeded: s.integer("Accepted tasks."),
+            failed: s.integer("Rejected tasks."),
+        }),
+        results: s.array("Per-task success or failure in original index order.", s.looseObject("Task submission result with index, success and task or error.", {})),
+    }), "write"),
+    endpoint("get_task", "Read task status and final engine response. Failed task details remain available in response.", "/v1/async/task/{taskId}", "GET", s.requiredObject("Task lookup.", { taskId: s.string("Task ID.", { format: "uuid" }) }), resultOutput, "read"),
+    endpoint("get_queue_status", "Read queued and processing task counts and concurrency usage.", "/v1/async/status", "GET", empty, s.object("Organization queue status.", {
+        queuedTasks: s.integer("Queued task count."),
+        processingTasks: s.integer("Processing task count."),
+        priorityBreakdown: s.array("Queue counts by priority.", s.looseRequiredObject("One priority level.", {
+            priority: s.integer("Task priority."),
+            count: s.integer("Queued task count."),
+        })),
+        concurrency: s.nullable(s.looseRequiredObject("Concurrency usage.", {
+            used: s.integer("Used slots."),
+            max: s.integer("Maximum slots."),
+        })),
+    }, {
+        optional: ["concurrency"],
+        additionalProperties: true,
+    })),
+    endpoint("clear_queue", "Delete all QUEUED tasks in the organization. Processing, completed and failed tasks are unaffected.", "/v1/async/queue", "DELETE", empty, s.looseRequiredObject("Queue clearing result.", {
+        success,
+        cleared: s.integer("Number of removed queued tasks."),
+    }), "destructive"),
+    endpoint("get_credits", "Read organization credit balance and billing cycle. Values can be cached for up to 60 seconds.", "/v1/credits", "GET", empty, s.looseRequiredObject("Organization credit balance.", {
+        remaining: s.integer("Remaining credits."),
+        perCycle: s.nullable(s.integer("Credits per billing cycle; null without a subscription.")),
+        cycleResetsAt: s.nullable(s.string("Cycle reset timestamp; null without a subscription.")),
+    })),
+    endpoint("list_countries", "List supported country codes, optionally filtered by engine.", "/v1/countries", "GET", s.object("Country lookup.", {
+        model: s.stringEnum("Engine filter.", [
+            "aimode",
+            "aioverview",
+            "chatgpt",
+            "copilot",
+            "gemini",
+            "google",
+            "perplexity",
+        ]),
+    }, { optional: ["model"] }), s.looseRequiredObject("Supported countries.", {
+        countries: s.array("Country codes.", s.string("ISO country code.")),
+    }), "read", undefined, "countries"),
+    endpoint("list_states", "List supported US states. Other country codes return an empty list.", "/v1/states", "GET", s.requiredObject("State lookup.", {
+        country: s.string("Uppercase ISO country code. Only US returns states.", {
+            pattern: "^[A-Z]{2}$",
+        }),
+    }), s.looseRequiredObject("Supported states.", {
+        states: s.array("States.", s.looseRequiredObject("One state.", {
+            code: s.string("USPS state code."),
+            name: s.string("State name."),
+        })),
+    }), "read", undefined, "states"),
+];
+export const cloroActions = endpoints.map(({ action }) => action);
+export const cloroEndpointByName = new Map(endpoints.map((value) => [value.action.name, value]));

package/src/providers/cloro/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const credentialValidators: CredentialValidators;
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/cloro/executors.js

@@ -0,0 +1,67 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { requiredResponseRecord, isAbortLikeError, runProviderRequest, ProviderRequestError, providerInputError, providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { cloroActions } from "./actions.js";
+import { cloroEndpointByName } from "./actions.js";
+const baseUrl = "https://api.cloro.dev";
+async function request(apiKey, endpoint, input, fetcher, validating = false, parentSignal) {
+    return runProviderRequest({ label: "Cloro", timeoutMs: endpoint.timeoutMs, signal: parentSignal }, async (signal) => {
+        const url = new URL(endpoint.path.replace("{taskId}", encodeURIComponent(String(input.taskId))), baseUrl);
+        if (endpoint.method === "GET") {
+            for (const [key, value] of Object.entries(input)) {
+                if (key !== "taskId" && value !== undefined)
+                    url.searchParams.set(key, String(value));
+            }
+        }
+        const response = await fetcher(url, {
+            method: endpoint.method,
+            headers: {
+                authorization: `Bearer ${apiKey}`,
+                accept: "application/json",
+                "content-type": "application/json",
+            },
+            body: endpoint.method === "POST" ? JSON.stringify(endpoint.path.endsWith("/batch") ? input.tasks : input) : undefined,
+            signal,
+        });
+        const body = await response.json().catch((error) => {
+            if (isAbortLikeError(error))
+                throw error;
+            return undefined;
+        });
+        if (!response.ok) {
+            const error = optionalRecord(optionalRecord(body)?.error);
+            const code = optionalString(error?.code);
+            const message = optionalString(error?.message);
+            const detail = [code, message].filter(Boolean).join(": ");
+            const invalidCredential = code === "INVALID_OR_EXPIRED_API_KEY" || code === "INVALID_API_KEY_FORMAT";
+            throw new ProviderRequestError(invalidCredential && validating ? 400 : response.status, `Cloro request failed (${response.status})${detail ? `: ${detail}` : ""}`, undefined, invalidCredential ? (validating ? "invalid_input" : "authorization_failed") : "provider_error");
+        }
+        if (endpoint.arrayField) {
+            if (!Array.isArray(body))
+                throw providerResponseError("Cloro response must be an array");
+            return { [endpoint.arrayField]: body };
+        }
+        return requiredResponseRecord(body, "Cloro response");
+    });
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const endpoint = cloroEndpointByName.get(actionName);
+    if (!endpoint)
+        throw providerInputError(`Unknown Cloro action: ${actionName}`);
+    return request(apiKey, endpoint, values, fetcher, undefined, context.signal);
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request(input.apiKey, { path: "/v1/credits", method: "GET" }, {}, fetcher, true, signal);
+        return { profile: { displayName: "Cloro API Key" }, grantedScopes: [], metadata: {} };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("cloro", Object.fromEntries(cloroActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "cloro",
+    baseUrl: baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/cloro/inputs.d.ts

@@ -0,0 +1,10 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const chatGPTMonitorRequest: JsonSchema;
+export declare const geminiMonitorRequest: JsonSchema;
+export declare const googleMonitorRequest: JsonSchema;
+export declare const googleNewsMonitorRequest: JsonSchema;
+export declare const copilotMonitorRequest: JsonSchema;
+export declare const perplexityMonitorRequest: JsonSchema;
+export declare const aiModeMonitorRequest: JsonSchema;
+export declare const googleProductRequest: JsonSchema;
+export declare const googleGotoRequest: JsonSchema;