@oomol-lab/open-connector 1.6.4 → 1.7.0

package/src/providers/bilibili/upload.js

@@ -0,0 +1,107 @@
+import { optionalNumber, requiredString } from "../../core/cast.js";
+import { providerInputError, providerResponseError, requiredResponseRecord, runProviderRequest, setSearchParams, } from "../provider-runtime.js";
+import { bilibiliApiRequest, bilibiliFormRequest, bilibiliUposBaseUrl, readBilibiliApiResponse } from "./runtime.js";
+const smallVideoUploadMaxBytes = 100 * 1024 * 1024;
+const videoUploadPartBytes = 10 * 1024 * 1024;
+const videoUploadMaxBytes = 4 * 1024 * 1024 * 1024;
+const imageUploadMaxBytes = 5 * 1024 * 1024;
+/**
+ * Upload one video through Bilibili's upload-token flow: initialize, then a
+ * single openupos upload (files up to 100MB) or equal-sized 10MB parts plus
+ * the merge call. Returns the upload token used by archive submission.
+ */
+export async function uploadBilibiliVideo(context, file) {
+    if (file.size === 0) {
+        throw providerInputError("The video file is empty.");
+    }
+    if (file.size > videoUploadMaxBytes) {
+        throw providerInputError("The video file exceeds the Bilibili 4GB upload limit.");
+    }
+    const initData = requiredResponseRecord(await bilibiliApiRequest(context, {
+        method: "POST",
+        path: "/archive/video/init",
+        body: {
+            name: normalizeUploadFileName(file.name),
+            utype: file.size <= smallVideoUploadMaxBytes ? "1" : "0",
+        },
+        label: "Bilibili video upload init",
+    }), "Bilibili video upload init");
+    const uploadToken = requiredString(initData.upload_token, "upload_token", providerResponseError);
+    if (file.size <= smallVideoUploadMaxBytes) {
+        await postBilibiliUposBytes(context, "/video/v2/upload", { upload_token: uploadToken }, file, "Bilibili video upload");
+        return uploadToken;
+    }
+    let offset = 0;
+    let partNumber = 1;
+    while (offset < file.size) {
+        const part = file.slice(offset, offset + videoUploadPartBytes);
+        await postBilibiliUposBytes(context, "/video/v2/part/upload", { upload_token: uploadToken, part_number: String(partNumber) }, part, `Bilibili video part ${partNumber} upload`);
+        offset += videoUploadPartBytes;
+        partNumber += 1;
+    }
+    await bilibiliApiRequest(context, {
+        method: "POST",
+        path: "/archive/video/complete",
+        query: { upload_token: uploadToken },
+        label: "Bilibili video upload complete",
+    });
+    return uploadToken;
+}
+/** Upload one cover image (jpeg/png, up to 5MB) and return its Bilibili-hosted URL. */
+export async function uploadBilibiliCover(context, file) {
+    if (file.size === 0) {
+        throw providerInputError("The cover image is empty.");
+    }
+    if (file.size > imageUploadMaxBytes) {
+        throw providerInputError("The cover image exceeds the Bilibili 5MB limit.");
+    }
+    const data = requiredResponseRecord(await bilibiliFormRequest(context, {
+        path: "/archive/cover/upload",
+        file,
+        label: "Bilibili cover upload",
+    }), "Bilibili cover upload");
+    return requiredString(data.url, "url", providerResponseError);
+}
+/** Upload one article image (jpg/png, up to 5MB) and return its Bilibili-hosted URL. */
+export async function uploadBilibiliArticleImage(context, file, watermark) {
+    if (file.size === 0) {
+        throw providerInputError("The article image is empty.");
+    }
+    if (file.size > imageUploadMaxBytes) {
+        throw providerInputError("The article image exceeds the Bilibili 5MB limit.");
+    }
+    const data = requiredResponseRecord(await bilibiliFormRequest(context, {
+        path: "/article/upload/image",
+        fields: { watermark: watermark === undefined ? undefined : String(watermark) },
+        file,
+        label: "Bilibili article image upload",
+    }), "Bilibili article image upload");
+    const url = requiredString(data.url, "url", providerResponseError);
+    const size = optionalNumber(data.size);
+    return size === undefined ? { url } : { url, size };
+}
+/**
+ * Post raw file bytes to the openupos upload host. These endpoints
+ * authenticate through the upload_token query parameter and must not carry
+ * multipart packaging around the bare binary body.
+ */
+async function postBilibiliUposBytes(context, path, query, body, label) {
+    const url = new URL(`${bilibiliUposBaseUrl}${path}`);
+    setSearchParams(url, query);
+    await runProviderRequest({ signal: context.signal, label }, async (signal) => {
+        const response = await context.fetcher(url.toString(), {
+            method: "POST",
+            headers: { "content-type": "application/octet-stream" },
+            body,
+            signal,
+        });
+        await readBilibiliApiResponse(response, label);
+    });
+}
+function normalizeUploadFileName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return "video.mp4";
+    }
+    return trimmed.includes(".") ? trimmed : `${trimmed}.mp4`;
+}

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

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

package/src/providers/bitwarden/executors.js

@@ -0,0 +1,146 @@
+import { compactObject, looseArray, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineProviderExecutors, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, requireCustomCredential, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "bitwarden";
+const regions = {
+    us: { api: "https://api.bitwarden.com", identity: "https://identity.bitwarden.com" },
+    eu: { api: "https://api.bitwarden.eu", identity: "https://identity.bitwarden.eu" },
+};
+const handlers = {
+    list_collections: list("/public/collections", "collections"),
+    get_collection: get("/public/collections", "collection"),
+    async list_events(input, context) {
+        const payload = requiredResponseRecord(await request("/public/events", "list events", context, compactObject({
+            start: optionalString(input.start),
+            end: optionalString(input.end),
+            actingUserId: optionalString(input.actingUserId),
+            itemId: optionalString(input.itemId),
+            secretId: optionalString(input.secretId),
+            projectId: optionalString(input.projectId),
+            continuationToken: optionalString(input.continuationToken),
+        })), "Bitwarden event list");
+        return { events: looseArray(payload.data), continuationToken: optionalString(payload.continuationToken) ?? null };
+    },
+    list_groups: list("/public/groups", "groups"),
+    get_group: get("/public/groups", "group"),
+    get_group_member_ids: ids("/public/groups", "member-ids", "memberIds"),
+    list_members: list("/public/members", "members"),
+    get_member: get("/public/members", "member"),
+    get_member_group_ids: ids("/public/members", "group-ids", "groupIds"),
+    list_policies: list("/public/policies", "policies"),
+    async get_policy(input, context) {
+        if (!Number.isInteger(input.type))
+            throw providerInputError("type is required");
+        return {
+            policy: requiredResponseRecord(await request(`/public/policies/${input.type}`, "get policy", context), "Bitwarden policy"),
+        };
+    },
+    async get_subscription(_input, context) {
+        return requiredResponseRecord(await request("/public/organization/subscription", "get subscription", context), "Bitwarden subscription");
+    },
+};
+export const executors = defineProviderExecutors({
+    service,
+    handlers,
+    async createContext(context, fetcher) {
+        const stored = await requireCustomCredential(context, service);
+        return { ...credential(stored.values), fetcher, signal: context.signal };
+    },
+});
+export const credentialValidators = {
+    async customCredential(input, { fetcher, signal }) {
+        const value = credential(input.values);
+        await token(value, fetcher, signal, true);
+        return {
+            profile: { accountId: value.clientId, displayName: `Bitwarden Organization (${value.region.toUpperCase()})` },
+            grantedScopes: ["api.organization"],
+            metadata: { region: value.region, apiBaseUrl: regions[value.region].api },
+        };
+    },
+};
+function credential(values) {
+    const region = requiredInputString(values.region, "region").toLowerCase();
+    if (region !== "us" && region !== "eu")
+        throw providerInputError("region must be us or eu");
+    return {
+        clientId: requiredInputString(values.clientId, "clientId"),
+        clientSecret: requiredInputString(values.clientSecret, "clientSecret"),
+        region,
+    };
+}
+function list(path, field) {
+    return async (input, context) => {
+        const payload = requiredResponseRecord(await request(path, `list ${field}`, context, compactObject({ continuationToken: optionalString(input.continuationToken) })), `Bitwarden ${field}`);
+        return { [field]: looseArray(payload.data), continuationToken: optionalString(payload.continuationToken) ?? null };
+    };
+}
+function get(path, field) {
+    return async (input, context) => ({
+        [field]: requiredResponseRecord(await request(`${path}/${encodeURIComponent(requiredInputString(input.id, "id"))}`, `get ${field}`, context), `Bitwarden ${field}`),
+    });
+}
+function ids(path, suffix, field) {
+    return async (input, context) => ({
+        [field]: looseArray(await request(`${path}/${encodeURIComponent(requiredInputString(input.id, "id"))}/${suffix}`, `get ${field}`, context)),
+    });
+}
+async function token(value, fetcher, parentSignal, validating) {
+    const response = await runProviderRequest({ signal: parentSignal, label: "Bitwarden token exchange" }, (signal) => fetcher(`${regions[value.region].identity}/connect/token`, {
+        method: "POST",
+        headers: {
+            accept: "application/json",
+            "content-type": "application/x-www-form-urlencoded",
+            "user-agent": providerUserAgent,
+        },
+        body: new URLSearchParams({
+            grant_type: "client_credentials",
+            scope: "api.organization",
+            client_id: value.clientId,
+            client_secret: value.clientSecret,
+        }).toString(),
+        signal,
+    }));
+    const payload = await readProviderJsonBody(response, {
+        emptyBody: null,
+        invalidJsonMessage: "Bitwarden token exchange returned invalid JSON",
+    });
+    if (!response.ok)
+        throw error(response.status, payload, validating);
+    const accessToken = optionalString(optionalRecord(payload)?.access_token)?.trim();
+    if (!accessToken)
+        throw providerResponseError("Bitwarden access token is missing");
+    return accessToken;
+}
+async function request(path, operation, context, query = {}) {
+    const accessToken = await token(context, context.fetcher, context.signal, false);
+    const url = new URL(path, `${regions[context.region].api}/`);
+    for (const [key, value] of Object.entries(query))
+        if (value != null)
+            url.searchParams.set(key, String(value));
+    const response = await runProviderRequest({ signal: context.signal, label: `Bitwarden ${operation}` }, (signal) => context.fetcher(url, {
+        headers: { accept: "application/json", authorization: `Bearer ${accessToken}`, "user-agent": providerUserAgent },
+        signal,
+    }));
+    const payload = await readProviderJsonBody(response, {
+        emptyBody: null,
+        invalidJsonMessage: `Bitwarden ${operation} returned invalid JSON`,
+    });
+    if (!response.ok)
+        throw error(response.status, payload, false);
+    if (payload == null)
+        throw providerResponseError(`Bitwarden ${operation} returned an empty response`);
+    return payload;
+}
+function error(status, payload, validating) {
+    const body = optionalRecord(payload);
+    const code = optionalString(body?.error);
+    const message = optionalString(body?.error_description) ??
+        optionalString(body?.message) ??
+        `Bitwarden request failed with ${status}`;
+    if (status === 429)
+        return new ProviderRequestError(429, message, payload);
+    if (code === "invalid_client")
+        return validating ? providerInputError(message) : new ProviderRequestError(409, message, payload);
+    if (status === 400)
+        return providerInputError(message);
+    return new ProviderRequestError(status, message, payload);
+}

package/src/providers/cloudflare_browser_rendering/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRawString, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
-import { cloudflareCurrentUserDisplayName, readCloudflareCurrentUser } from "../cloudflare-current-user.js";
+import { cloudflareCurrentUserDisplayName, readCloudflareCurrentUser } from "../cloudflare_dns/runtime-user.js";
 import { defineProviderExecutors, defineProviderProxy, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
 const service = "cloudflare_browser_rendering";
 const cloudflareBrowserRenderingApiBaseUrl = "https://api.cloudflare.com/client/v4";

package/src/providers/cloudflare_dns/executors.js

@@ -1,6 +1,6 @@
 import { compactObject } from "../../core/cast.js";
-import { cloudflareCurrentUserDisplayName } from "../cloudflare-current-user.js";
 import { defineBearerProviderExecutors } from "../provider-runtime.js";
+import { cloudflareCurrentUserDisplayName } from "./runtime-user.js";
 import { cloudflareDnsActionHandlers, requestCloudflareCurrentUser, validateCloudflareDnsToken } from "./runtime.js";
 const service = "cloudflare_dns";
 export const executors = defineBearerProviderExecutors(service, cloudflareDnsActionHandlers);

package/src/providers/{cloudflare-current-user.js → cloudflare_dns/runtime-user.js}

@@ -1,5 +1,5 @@
-import { optionalRecord, optionalString } from "../core/cast.js";
-import { ProviderRequestError } from "./provider-runtime.js";
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { ProviderRequestError } from "../provider-runtime.js";
 export function readCloudflareCurrentUser(value) {
     const user = optionalRecord(value);
     if (!user) {

package/src/providers/cloudflare_dns/runtime.d.ts

@@ -1,7 +1,7 @@
 import type { CredentialValidationResult } from "../../core/types.ts";
-import type { CloudflareCurrentUser } from "../cloudflare-current-user.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { BearerProviderContext, ProviderRuntimeHandler } from "../provider-runtime.ts";
+import type { CloudflareCurrentUser } from "./runtime-user.ts";
 interface CloudflareAccount {
     id: string;
     name?: string;

package/src/providers/cloudflare_dns/runtime.js

@@ -1,7 +1,7 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
 import { queryParams } from "../../core/request.js";
-import { readCloudflareCurrentUser } from "../cloudflare-current-user.js";
 import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { readCloudflareCurrentUser } from "./runtime-user.js";
 const cloudflareApiBaseUrl = "https://api.cloudflare.com/client/v4";
 export const cloudflareDnsActionHandlers = {
     list_accounts(input, context) {

package/src/providers/cloudflare_r2/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalString, requiredString } from "../../core/cast.js";
-import { cloudflareCurrentUserDisplayName } from "../cloudflare-current-user.js";
+import { cloudflareCurrentUserDisplayName } from "../cloudflare_dns/runtime-user.js";
 import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, toProviderProxyError, } from "../provider-runtime.js";
 import { cloudflareR2ActionHandlers, cloudflareR2ApiBaseUrl, requestCloudflareR2CurrentUser, validateCloudflareR2Credential, } from "./runtime.js";
 const service = "cloudflare_r2";

package/src/providers/cloudflare_r2/runtime.d.ts

@@ -1,5 +1,5 @@
 import type { CredentialValidationResult, TransitFileWriter } from "../../core/types.ts";
-import type { CloudflareCurrentUser } from "../cloudflare-current-user.ts";
+import type { CloudflareCurrentUser } from "../cloudflare_dns/runtime-user.ts";
 import type { ProviderActionHandlers, ProviderRuntimeHandler } from "../provider-runtime.ts";
 export interface CloudflareR2Context {
     authType: "custom_credential" | "oauth2";

package/src/providers/cloudflare_r2/runtime.js

@@ -1,6 +1,6 @@
 import { base64Bytes, compactObject, integer, optionalInteger, optionalRecord, optionalString, requiredRawString, requiredString, } from "../../core/cast.js";
 import { assertPublicHttpUrl, queryParams, readBoundedResponseBytes } from "../../core/request.js";
-import { readCloudflareCurrentUser } from "../cloudflare-current-user.js";
+import { readCloudflareCurrentUser } from "../cloudflare_dns/runtime-user.js";
 import { combineProviderActionHandlers, providerFetch, providerInputError, ProviderRequestError, providerUserAgent, runProviderRequest, } from "../provider-runtime.js";
 import { cloudflareR2AccountActionHandlers } from "./runtime-account.js";
 import { cloudflareR2BucketSettingsActionHandlers } from "./runtime-bucket-settings.js";

package/src/providers/cloudflare_worker/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalString, requiredString } from "../../core/cast.js";
-import { cloudflareCurrentUserDisplayName } from "../cloudflare-current-user.js";
+import { cloudflareCurrentUserDisplayName } from "../cloudflare_dns/runtime-user.js";
 import { defineProviderExecutors, ProviderRequestError } from "../provider-runtime.js";
 import { cloudflareWorkerActionHandlers, requestCloudflareWorkerCurrentUser, validateCloudflareWorkerCredential, } from "./runtime.js";
 const service = "cloudflare_worker";

package/src/providers/cloudflare_worker/runtime.d.ts

@@ -1,5 +1,5 @@
 import type { CredentialValidationResult } from "../../core/types.ts";
-import type { CloudflareCurrentUser } from "../cloudflare-current-user.ts";
+import type { CloudflareCurrentUser } from "../cloudflare_dns/runtime-user.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { ProviderRuntimeHandler } from "../provider-runtime.ts";
 export interface CloudflareWorkerContext {

package/src/providers/cloudflare_worker/runtime.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
 import { queryParams } from "../../core/request.js";
-import { readCloudflareCurrentUser } from "../cloudflare-current-user.js";
+import { readCloudflareCurrentUser } from "../cloudflare_dns/runtime-user.js";
 import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
 const cloudflareApiBaseUrl = "https://api.cloudflare.com/client/v4";
 const defaultModuleName = "main.js";

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

@@ -0,0 +1,89 @@
+import { looseArray, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+const service = "cronfree";
+const cronfreeApiBaseUrl = "https://login.cronfree.com/zapier";
+const handlers = {
+    async create_schedule(input, context) {
+        const result = await requestCronfree({
+            path: "/schedule",
+            body: {
+                hookUrl: requiredInputString(input.hookUrl, "hookUrl"),
+                wdays: readStringArray(input.weekdays),
+                months: readStringArray(input.months),
+                mdays: readStringArray(input.monthDays),
+                hours: readStringArray(input.hours),
+                minutes: readStringArray(input.minutes),
+                timezone: [requiredInputString(input.timezone, "timezone")],
+            },
+            context,
+            phase: "execute",
+        });
+        return { result };
+    },
+    async delete_schedule(input, context) {
+        const result = await requestCronfree({
+            path: "/unschedule",
+            body: { hookUrl: requiredInputString(input.hookUrl, "hookUrl") },
+            context,
+            phase: "execute",
+        });
+        return { result };
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: cronfreeApiBaseUrl,
+    auth: { type: "api_key_json_body", name: "license_key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+        headers.set("content-type", "application/json");
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await requestCronfree({
+            path: "/unschedule",
+            body: { hookUrl: `https://connector.oomol.com/cronfree-validation/${crypto.randomUUID()}` },
+            context: { apiKey: input.apiKey, fetcher, signal },
+            phase: "validate",
+        });
+        return {
+            profile: { accountId: "cronfree-license-key", displayName: "Cronfree License Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: cronfreeApiBaseUrl, validationEndpoint: "/unschedule" },
+        };
+    },
+};
+function readStringArray(value) {
+    return looseArray(value)
+        .map((item) => optionalString(item))
+        .filter((item) => item != null);
+}
+async function requestCronfree(input) {
+    return runProviderRequest({ signal: input.context.signal, label: "Cronfree" }, async (signal) => {
+        const response = await input.context.fetcher(`${cronfreeApiBaseUrl}${input.path}`, {
+            method: "POST",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: JSON.stringify({ ...input.body, license_key: input.context.apiKey }),
+            signal,
+        });
+        if (!response.ok) {
+            if (response.status === 401 && input.phase === "validate") {
+                throw providerInputError("Cronfree rejected the license key");
+            }
+            throw new ProviderRequestError(response.status, `Cronfree request failed with HTTP ${response.status}`);
+        }
+        return readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "Cronfree returned invalid JSON",
+        });
+    });
+}

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

@@ -0,0 +1,105 @@
+import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "cufinder";
+const baseUrl = "https://api.cufinder.io/v3";
+const handlers = {
+    find_company_domain(input, context) {
+        return execute("/companies/name-to-domain", { name: trim(input.name), country_code: upper(input.countryCode), address: trim(input.address) }, context, (data, meta) => ({ domain: requireString(data.domain, "domain"), meta }));
+    },
+    find_company_name(input, context) {
+        return execute("/companies/domain-to-name", { domain: trim(input.domain) }, context, (data, meta) => ({
+            name: requireString(data.name, "name"),
+            meta,
+        }));
+    },
+    enrich_company(input, context) {
+        return execute("/companies/enrich", { query: trim(input.query) }, context, (data, meta) => ({
+            company: requiredResponseRecord(data.company, "cufinder company"),
+            meta,
+        }));
+    },
+    enrich_person(input, context) {
+        return execute("/people/enrich-by-name", { full_name: trim(input.fullName), company: trim(input.company) }, context, (data, meta) => ({ person: requiredResponseRecord(data.person, "cufinder person"), meta }));
+    },
+    enrich_person_by_email(input, context) {
+        return execute("/people/enrich-by-email", { email: trim(input.email) }, context, (data, meta) => ({
+            person: requiredResponseRecord(data.person, "cufinder person"),
+            meta,
+        }));
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl,
+    auth: { type: "api_key_header", name: "x-api-key" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request("/normalize/url", { value: "https://cufinder.io" }, { apiKey: input.apiKey, fetcher, signal }, "validate");
+        return {
+            profile: { accountId: "cufinder-api-key", displayName: "CUFinder API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "/normalize/url" },
+        };
+    },
+};
+async function execute(path, body, context, normalize) {
+    const payload = await request(path, body, context, "execute");
+    return normalize(requiredResponseRecord(payload.data, "cufinder data"), requiredResponseRecord(payload.meta, "cufinder metadata"));
+}
+async function request(path, body, context, phase) {
+    return runProviderRequest({ signal: context.signal, label: "cufinder" }, async (signal) => {
+        const response = await context.fetcher(`${baseUrl}${path}`, {
+            method: "POST",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+                "x-api-key": context.apiKey,
+            },
+            body: JSON.stringify(compactObject(body)),
+            signal,
+        });
+        const decoded = await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "cufinder returned malformed JSON",
+            invalidJsonFallback: response.ok ? undefined : () => ({}),
+        });
+        const payload = optionalRecord(decoded) ?? {};
+        if (!response.ok)
+            throw makeError(response.status, payload, phase);
+        if (payload.success !== true)
+            throw makeError(response.status, payload, phase);
+        return payload;
+    });
+}
+function makeError(status, payload, phase) {
+    const error = optionalRecord(payload.error);
+    const code = optionalString(error?.code);
+    const message = optionalString(error?.message) ?? `cufinder request failed with status ${status}`;
+    if (code === "unauthorized")
+        return phase === "validate" ? providerInputError(message) : new ProviderRequestError(409, message, payload);
+    if (code === "rate_limited")
+        return new ProviderRequestError(429, message, payload);
+    if (["invalid_request", "validation_failed", "not_found"].includes(code ?? ""))
+        return providerInputError(message);
+    if (code === "request_timeout")
+        return new ProviderRequestError(504, message, payload);
+    return new ProviderRequestError(status >= 400 ? status : 502, message, payload);
+}
+function trim(value) {
+    return typeof value === "string" ? value.trim() : value;
+}
+function upper(value) {
+    return typeof value === "string" ? value.trim().toUpperCase() : value;
+}
+function requireString(value, field) {
+    const result = optionalString(value);
+    if (!result)
+        throw providerResponseError(`cufinder data.${field} must be a string`);
+    return result;
+}

package/src/providers/dingtalk_mcp/runtime.js

@@ -107,7 +107,7 @@ async function withDingTalkMcpClient(context, run) {
         transport: "streamable_http",
         fetcher: context.fetcher,
         headers,
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: mapDingTalkMcpError,
     }, run);

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

@@ -1,13 +1,4 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
-import type { ProviderActionHandlers } from "../provider-runtime.ts";
-interface DiscordbotContext {
-    apiKey: string;
-    fetcher: typeof fetch;
-    signal?: AbortSignal;
-}
-type DiscordbotActionHandler = (input: Record<string, unknown>, context: DiscordbotContext) => Promise<unknown>;
-export declare const discordbotActionHandlers: ProviderActionHandlers<"discordbot", DiscordbotActionHandler>;
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
-export {};