@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/drawio_mcp/runtime.js

@@ -0,0 +1,175 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { looseArray, optionalInteger, optionalNumber, optionalRawString, optionalRecord, optionalString, } from "../../core/cast.js";
+import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
+import { callMcpTool, listMcpTools } from "../mcp-tools.js";
+import { parseProviderJsonBodyText, providerInputError, providerResponseError, requiredInputString, } from "../provider-runtime.js";
+const hostedEndpoint = "https://mcp.draw.io/mcp";
+const defaultShapeLimit = 10;
+// The two create_diagram tool errors that judge the submitted source; anything else is a server failure.
+const sourceVerdictPrefixes = ["Could not extract draw.io XML", "Provide exactly one of"];
+const errorsHeading = "ERRORS (will cause rendering issues):\n- ";
+const warningsHeading = "WARNINGS (may cause issues):\n- ";
+export const drawioMcpActionHandlers = {
+    async create_diagram(input, options) {
+        const result = await callMcpTool({
+            ...options,
+            toolName: "create_diagram",
+            arguments: { mermaid: optionalString(input.mermaid), xml: optionalString(input.xml) },
+            transformToolResult: rejectDiagramSource,
+        });
+        const texts = readTextContent(result);
+        const editorUrl = readEditorUrl(texts);
+        if (editorUrl === undefined) {
+            throw providerResponseError("draw.io MCP create_diagram response did not include an editor link; a self-hosted server must be jgraph/drawio-mcp mcp-app-server 1.0.4 or later");
+        }
+        return { editorUrl, ...readFindings(texts) };
+    },
+    async search_shapes(input, options) {
+        const result = await callMcpTool({
+            ...options,
+            toolName: "search_shapes",
+            arguments: {
+                query: requiredInputString(input.query, "query"),
+                limit: optionalInteger(input.limit) ?? defaultShapeLimit,
+            },
+        });
+        return { shapes: readShapes(result) };
+    },
+};
+/** Resolve the MCP server a connection points at; a blank endpoint selects the hosted draw.io server. */
+export function createDrawioMcpContext(values, fetcher, signal) {
+    return {
+        endpoint: normalizeDrawioMcpEndpoint(values.mcpEndpoint),
+        service: "draw.io",
+        fetcher,
+        signal,
+        terminateSession: true,
+        maxResponseBytes: 4 * 1024 * 1024,
+        // tools/list is about 64 KB because create_diagram embeds draw.io's drawing reference in its description.
+        toolListMaxBytes: 1024 * 1024,
+        toolListMaxPages: 5,
+        toolListMaxTools: 100,
+    };
+}
+/** Confirm the endpoint serves the draw.io tools and derive a stable identity from the endpoint. */
+export async function validateDrawioMcpCredential(values, fetcher, signal) {
+    const options = createDrawioMcpContext(values, fetcher, signal);
+    const discovered = new Set((await listMcpTools(options)).map((tool) => tool.name));
+    const missing = Object.keys(drawioMcpActionHandlers).filter((toolName) => !discovered.has(toolName));
+    if (missing.length > 0) {
+        throw providerInputError(`mcpEndpoint does not serve the draw.io MCP tools: missing ${missing.join(", ")}`);
+    }
+    return {
+        profile: {
+            accountId: `drawio_mcp:mcp:${sha256Hex(options.endpoint).slice(0, 16)}`,
+            displayName: `draw.io MCP · ${new URL(options.endpoint).host}`,
+        },
+        grantedScopes: [],
+        metadata: { mcpEndpoint: options.endpoint },
+    };
+}
+function normalizeDrawioMcpEndpoint(value) {
+    const allowPrivateNetwork = isPrivateNetworkAccessAllowed();
+    const url = assertPublicHttpUrl(optionalString(value) ?? hostedEndpoint, {
+        fieldName: "mcpEndpoint",
+        createError: providerInputError,
+        allowPrivateNetwork,
+    });
+    if (url.username || url.password) {
+        throw providerInputError("mcpEndpoint must not include a username or password");
+    }
+    if (url.protocol === "http:" && !allowPrivateNetwork) {
+        throw providerInputError("mcpEndpoint must use https unless private-network access is enabled");
+    }
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+}
+// Also drops structured content: the editor link and findings only ever arrive as text blocks,
+// which the shared result normalizer would otherwise discard in favour of structuredContent.
+function rejectDiagramSource(result) {
+    const message = "content" in result && result.isError ? readTextContent(result).join("\n") : "";
+    if (sourceVerdictPrefixes.some((prefix) => message.startsWith(prefix))) {
+        throw providerInputError(`draw.io rejected the diagram source: ${message.slice(0, 300)}`);
+    }
+    return { ...result, structuredContent: undefined };
+}
+// draw.io puts the editor link on a line of its own after the source echo, which is single-line JSON, and after
+// the XML findings, which quote attribute values from the source verbatim, line breaks included. Skipping the
+// findings and taking the last such line keeps a link written inside the submitted source from being returned instead.
+function readEditorUrl(texts) {
+    return texts
+        .filter((text) => !isFindingsText(text))
+        .flatMap((text) => text.split("\n"))
+        .findLast((line) => line.startsWith("https://") && line.includes("#create="));
+}
+// draw.io reports XML problems in one text block of "ERRORS (...):\n- item" and "WARNINGS (...):\n- item" sections.
+function isFindingsText(text) {
+    return text.startsWith("ERRORS ") || text.startsWith("WARNINGS ");
+}
+function readTextContent(result) {
+    return looseArray(optionalRecord(result)?.content).flatMap((item) => {
+        const content = optionalRecord(item);
+        const text = content?.type === "text" ? optionalRawString(content.text) : undefined;
+        return text === undefined ? [] : [text];
+    });
+}
+// Findings items quote attribute values verbatim, so blank lines and line starts can come from the source. Only
+// draw.io's exact layout splits the block: each heading is followed by the items joined with "\n- ", and a blank
+// line separates the errors section from the warnings section. The layout leaves no way to tell a quoted value from
+// that structure: a value that itself contains "\n- " still reads as two items, and one that contains the whole
+// "\n\nWARNINGS (may cause issues):\n- " separator can move items between errors and warnings. The editor link is
+// unaffected, since readEditorUrl skips the findings block as a whole.
+function readFindings(texts) {
+    const text = texts.find(isFindingsText) ?? "";
+    if (text.startsWith(warningsHeading)) {
+        return { errors: [], warnings: splitFindings(text.slice(warningsHeading.length)) };
+    }
+    if (!text.startsWith(errorsHeading)) {
+        return { errors: [], warnings: [] };
+    }
+    const body = text.slice(errorsHeading.length);
+    const separator = body.lastIndexOf(`\n\n${warningsHeading}`);
+    if (separator < 0) {
+        return { errors: splitFindings(body), warnings: [] };
+    }
+    return {
+        errors: splitFindings(body.slice(0, separator)),
+        warnings: splitFindings(body.slice(separator + 2 + warningsHeading.length)),
+    };
+}
+// draw.io never reports an empty finding, so an empty piece can only come from a quoted value that contains the
+// separator, such as one ending in "\n- ", and is dropped.
+function splitFindings(section) {
+    return section.split("\n- ").filter((item) => item !== "");
+}
+// Newer draw.io servers return structured shapes; the hosted server returns a JSON array as text.
+function readShapes(result) {
+    const structured = optionalRecord(result)?.shapes;
+    const payload = structured === undefined ? parseShapeText(readTextContent(result)[0]) : structured;
+    if (!Array.isArray(payload)) {
+        throw providerResponseError("draw.io MCP search_shapes returned an unexpected payload");
+    }
+    return payload.map(readShape);
+}
+function parseShapeText(text) {
+    if (text === undefined) {
+        throw providerResponseError("draw.io MCP search_shapes response did not include any text");
+    }
+    if (text.startsWith("No shapes found"))
+        return [];
+    return parseProviderJsonBodyText(text, {
+        emptyBody: [],
+        invalidJsonMessage: `draw.io MCP search_shapes returned an unexpected payload: ${text.slice(0, 200)}`,
+    });
+}
+function readShape(value) {
+    const shape = optionalRecord(value);
+    const style = optionalRawString(shape?.style);
+    const width = optionalNumber(shape?.w);
+    const height = optionalNumber(shape?.h);
+    if (!style || width === undefined || height === undefined) {
+        throw providerResponseError("draw.io MCP search_shapes returned a shape without a style or size");
+    }
+    return { title: optionalRawString(shape?.title) ?? "", style, width, height };
+}

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

@@ -0,0 +1,97 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { encodePathSegment } from "../../core/request.js";
+import { basicAuthorizationHeader, defineApiKeyProviderExecutors, defineProviderProxy, providerResponseError, ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const baseUrl = "https://api.enormail.eu/api/1.0";
+async function request(endpoint, query, context) {
+    const url = new URL(`${baseUrl}/${endpoint}.json`);
+    for (const [key, value] of Object.entries(query)) {
+        if (value != null)
+            url.searchParams.set(key, String(value));
+    }
+    return runProviderRequest({ label: "Enormail", signal: context.signal }, async (signal) => {
+        const response = await context.fetcher(url, {
+            signal,
+            headers: {
+                authorization: basicAuthorizationHeader(`${context.apiKey}:`),
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+            },
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Enormail returned invalid JSON (HTTP ${response.status})`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        if (!response.ok) {
+            const error = optionalRecord(payload);
+            const message = optionalString(error?.message) ?? optionalString(error?.Message) ?? optionalString(error?.error);
+            throw new ProviderRequestError(response.status, `Enormail HTTP ${response.status}${message ? `: ${message}` : ""}`, { providerCode: error?.code }, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return payload;
+    });
+}
+function resourceId(value, fieldName) {
+    const id = requiredInputString(value, fieldName);
+    if (id === "." || id === "..")
+        throw new ProviderRequestError(400, "Invalid Enormail resource ID");
+    return encodePathSegment(id);
+}
+export const executors = defineApiKeyProviderExecutors("enormail", {
+    async get_account(_input, context) {
+        return requiredResponseRecord(await request("account", {}, context), "Enormail account");
+    },
+    async list_senders(_input, context) {
+        const senders = await request("account/senders", {}, context);
+        if (!Array.isArray(senders))
+            throw providerResponseError("Enormail returned an invalid collection");
+        return { senders };
+    },
+    async list_lists(input, context) {
+        const lists = await request("lists", { page: input.page }, context);
+        if (!Array.isArray(lists))
+            throw providerResponseError("Enormail returned an invalid collection");
+        return { lists };
+    },
+    async get_list(input, context) {
+        return requiredResponseRecord(await request(`lists/${resourceId(input.listid, "listid")}`, {}, context), "Enormail response");
+    },
+    async list_contacts(input, context) {
+        return requiredResponseRecord(await request(`contacts/${resourceId(input.listid, "listid")}/${input.state}`, { page: input.page }, context), "Enormail response");
+    },
+    async get_contact(input, context) {
+        return requiredResponseRecord(await request(`contacts/${resourceId(input.listid, "listid")}`, { email: input.email }, context), "Enormail response");
+    },
+    async list_mailings(input, context) {
+        return requiredResponseRecord(await request(`mailings/${input.state}`, { page: input.page }, context), "Enormail response");
+    },
+    async get_mailing_stats(input, context) {
+        return requiredResponseRecord(await request(`mailings/${resourceId(input.mailingid, "mailingid")}/stats`, {}, context), "Enormail response");
+    },
+}, { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const account = requiredResponseRecord(await request("account", {}, { apiKey: input.apiKey, fetcher, signal }), "Enormail account");
+        const name = [optionalString(account.firstname), optionalString(account.lastname)].filter(Boolean).join(" ").trim();
+        return {
+            profile: {
+                accountId: optionalString(account.id),
+                displayName: name || optionalString(account.email) || "Enormail Account",
+            },
+            grantedScopes: [],
+            metadata: { accountId: optionalString(account.id), apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "enormail",
+    baseUrl,
+    auth: { type: "api_key_basic", suffix: ":" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});

package/src/providers/fastmoss_mcp/executors.js

@@ -25,7 +25,7 @@ export const proxy = defineProviderProxy({
     baseUrl: origin,
     auth: { type: "api_key_query", name: "api_key" },
     skipDnsValidation: true,
-    redirect: "error",
+    redirect: "manual",
     allowedEndpoint(value) {
         const url = new URL(value, origin);
         return (url.origin === origin &&
@@ -57,7 +57,7 @@ function connectionInput(key, fetcher, signal) {
         service: "FastMoss",
         fetcher,
         signal,
-        redirect: "error",
+        redirect: "manual",
         terminateSession: true,
         maxResponseBytes: 16 * 1024 * 1024,
     };

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor, TransitFileWriter } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlerSubset } from "../provider-runtime.ts";
 interface FeishuAppBotCredential {
     appId: string;
@@ -16,4 +18,5 @@ export declare const feishuAppBotActionHandlers: ProviderActionHandlerSubset<"fe
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/feishu_app_bot/executors.js

@@ -27,6 +27,7 @@ import { createFeishuWhiteboardActionHandlers } from "../feishu/shared/whiteboar
 import { createFeishuWikiActionHandlers } from "../feishu/shared/wiki-runtime.js";
 import { createProviderProxyUrl, defineProviderExecutors, getProviderActionHandler, mapProviderActionHandlers, normalizeProviderProxyHeaders, providerFetch, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireCustomCredential, requiredInputString, toProviderProxyError, } from "../provider-runtime.js";
 import { feishuAppBotActions, feishuAppBotProviderScopes } from "./actions.js";
+import { feishuEvents } from "./trigger-on-event.js";
 const service = "feishu_app_bot";
 const feishuOpenBaseUrl = "https://open.feishu.cn/open-apis";
 const feishuRequestTimeoutMs = 30_000;
@@ -1047,3 +1048,4 @@ function createFeishuRequestSignal(parent) {
 function isAbortError(error) {
     return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
 }
+export const triggers = [...feishuEvents];

package/src/providers/feishu_app_bot/trigger-config.d.ts

@@ -0,0 +1 @@
+export declare function feishuResourceKind(events: readonly string[]): "document" | "calendar" | "approval" | undefined;

package/src/providers/feishu_app_bot/trigger-config.js

@@ -0,0 +1,10 @@
+export function feishuResourceKind(events) {
+    if (events.length == 0)
+        return;
+    if (events.every((event) => event.startsWith("drive.file.")))
+        return "document";
+    if (events.every((event) => event == "calendar.calendar.event.changed_v4"))
+        return "calendar";
+    if (events.every((event) => ["approval_instance", "approval_task", "approval_cc", "approval"].includes(event)))
+        return "approval";
+}

package/src/providers/feishu_app_bot/trigger-on-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const feishuEvents: readonly IntegrationDefinition[];

package/src/providers/feishu_app_bot/trigger-on-event.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const additionalSnapshot0: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/feishu_app_bot/trigger-on-event.definition.js

@@ -0,0 +1,63 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const additionalSnapshot0 = {
+    key: "feishu_app_bot.on_event",
+    provider: "feishu_app_bot",
+    name: "on_event",
+    displayName: "Application Event",
+    description: "Receives selected Feishu application events through a shared event source.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "sourceId",
+            jsonSchema: { ...s.string({ pattern: "^source_[0-9a-f]{32}$" }), title: "Event source" },
+            nullable: false,
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                ...s.array(s.string({ pattern: "^[a-z][a-z0-9_.]{0,127}$" }), {
+                    minItems: 1,
+                    maxItems: 200,
+                    uniqueItems: true,
+                }),
+                title: "Event types",
+            },
+            nullable: false,
+        },
+        {
+            handle: "chatIds",
+            jsonSchema: {
+                ...s.array(s.string({ minLength: 1, maxLength: 256 }), { maxItems: 100, uniqueItems: true }),
+                title: "Chat IDs",
+            },
+            nullable: true,
+            description: "Leave empty to receive events from all chats available to the source.",
+        },
+        {
+            handle: "resource",
+            jsonSchema: {
+                ...s.object({
+                    kind: s.stringEnum(["document", "calendar", "approval"]),
+                    id: s.string({ minLength: 1, maxLength: 256 }),
+                    documentType: s.stringEnum(["doc", "docx", "sheet", "bitable", "file", "folder"]),
+                }, { additionalProperties: false, required: ["kind", "id"] }),
+                title: "Resource subscription",
+            },
+            nullable: true,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "appId", jsonSchema: s.string(), nullable: false },
+        { handle: "tenantKey", jsonSchema: s.string(), nullable: false },
+        { handle: "occurredAt", jsonSchema: s.string(), nullable: true },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/feishu_app_bot/trigger-on-event.js

@@ -0,0 +1,29 @@
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { additionalSnapshot0 } from "./trigger-on-event.definition.js";
+import { feishuSubscriptions, feishuResponse } from "./trigger-subscriptions.js";
+export const feishuEvents = [
+    {
+        eventSource: "feishu",
+        resources: { subscriptions: (config) => feishuSubscriptions(config, "feishu_app_bot"), response: feishuResponse },
+        snapshot: additionalSnapshot0,
+        receive(context) {
+            if (context.eventSourceId !== context.config.sourceId)
+                return { outcome: "respond", status: 404, body: "", contentType: "text/plain" };
+            const payload = context.payload;
+            if (!isJsonObject(payload) ||
+                typeof payload.deliveryId !== "string" ||
+                payload.deliveryId.length === 0 ||
+                typeof payload.event !== "string" ||
+                typeof payload.appId !== "string" ||
+                typeof payload.tenantKey !== "string" ||
+                (payload.occurredAt != null && typeof payload.occurredAt !== "string") ||
+                !isJsonObject(payload.body))
+                throw new PermanentIntegrationError("Invalid Feishu shared event payload.");
+            return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+        },
+        async reconcile() {
+            throw new PermanentIntegrationError("This deployment does not support shared Feishu event sources.");
+        },
+    },
+];

package/src/providers/feishu_app_bot/trigger-subscriptions.d.ts

@@ -0,0 +1,5 @@
+import type { ResourceSubscription } from "../../triggers/common/integration.ts";
+import type { ConnectorProxyResult } from "../../triggers/common/proxy.ts";
+import type { JsonValue } from "../../triggers/common/types.ts";
+export declare function feishuSubscriptions(config: Readonly<Record<string, JsonValue>>, provider: string): readonly ResourceSubscription[];
+export declare function feishuResponse(result: ConnectorProxyResult): Readonly<Record<string, JsonValue>>;

package/src/providers/feishu_app_bot/trigger-subscriptions.js

@@ -0,0 +1,70 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { feishuResourceKind } from "./trigger-config.js";
+export function feishuSubscriptions(config, provider) {
+    if (config.resource == null)
+        return [];
+    if (!isJsonObject(config.resource))
+        throw new PermanentIntegrationError("Invalid Feishu resource.");
+    const { kind, id, documentType } = config.resource;
+    if (typeof id != "string" || id.length == 0)
+        throw new PermanentIntegrationError("A Feishu resource ID is required.");
+    if (kind != feishuResourceKind(config.eventTypes))
+        throw new PermanentIntegrationError("The selected events do not support this resource subscription.");
+    const resource = encodeURIComponent(id);
+    if (kind == "document") {
+        if (typeof documentType != "string" ||
+            !["doc", "docx", "sheet", "bitable", "file", "folder", "slides"].includes(documentType)) {
+            throw new PermanentIntegrationError("A supported document type is required.");
+        }
+        return config.eventTypes.map((eventType) => {
+            const query = { file_type: documentType, event_type: eventType };
+            const prefix = `/drive/v1/files/${resource}`;
+            return {
+                key: JSON.stringify(["document", documentType, id, eventType]),
+                subscribe: { endpoint: `${prefix}/subscribe`, method: "POST", query },
+                unsubscribe: { endpoint: `${prefix}/delete_subscribe`, method: "DELETE", query },
+                inspect: { endpoint: `${prefix}/get_subscribe`, method: "GET", query },
+            };
+        });
+    }
+    if (kind == "calendar") {
+        const prefix = `/calendar/v4/calendars/${resource}/events`;
+        return [
+            {
+                key: JSON.stringify(["calendar", id]),
+                subscribe: { endpoint: `${prefix}/subscription`, method: "POST" },
+                unsubscribe: { endpoint: `${prefix}/unsubscription`, method: "POST" },
+            },
+        ];
+    }
+    if (kind == "approval") {
+        if (provider != "feishu_app_bot")
+            throw new PermanentIntegrationError("Approval definition subscriptions require an application Connection.");
+        const prefix = `/approval/v4/approvals/${resource}`;
+        return [
+            {
+                key: JSON.stringify(["approval", id]),
+                subscribe: { endpoint: `${prefix}/subscribe`, method: "POST" },
+                unsubscribe: { endpoint: `${prefix}/unsubscribe`, method: "POST" },
+            },
+        ];
+    }
+    throw new PermanentIntegrationError("Unsupported Feishu resource subscription.");
+}
+export function feishuResponse(result) {
+    if (!isJsonObject(result.data))
+        throw new TransientIntegrationError("Feishu returned an invalid response.");
+    const code = result.data.code;
+    if (result.status >= 200 && result.status < 300 && code === 0)
+        return isJsonObject(result.data.data) ? result.data.data : {};
+    const details = `HTTP ${result.status}${typeof code == "number" && Number.isSafeInteger(code) ? `, Feishu code ${code}` : ""}`;
+    if (result.status == 401 ||
+        result.status == 403 ||
+        [99991661, 99991663, 99991668, 99991671, 99991677].includes(Number(code))) {
+        throw new IntegrationConnectionError(`Feishu rejected the Connection (${details}).`);
+    }
+    if (result.status == 429 || result.status >= 500 || code === 99991400)
+        throw new TransientIntegrationError(`Feishu is temporarily unavailable (${details}).`);
+    throw new PermanentIntegrationError(`Feishu rejected the request (${details}). Check the application's API permissions and request parameters.`);
+}

package/src/providers/finchina/executors.js

@@ -98,7 +98,7 @@ function mcpInput(apiKey, fetcher, signal) {
         service: "FinChina",
         headers: { "x-api-key": apiKey },
         fetcher,
-        redirect: "error",
+        redirect: "manual",
         terminateSession: true,
     };
 }

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

@@ -0,0 +1,19 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { framejetActionHandlers, framejetApiBaseUrl, framejetCaptureTimeoutMs, readFramejetError, validateFramejetApiKey, } from "./runtime.js";
+const service = "framejet";
+export const executors = defineApiKeyProviderExecutors(service, framejetActionHandlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: framejetApiBaseUrl,
+    auth: { type: "api_key_header", name: "X-Api-Key" },
+    readError: readFramejetError,
+    skipDnsValidation: true,
+    timeoutMs: framejetCaptureTimeoutMs,
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateFramejetApiKey(input.apiKey, fetcher, signal);
+    },
+};

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

@@ -0,0 +1,16 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const framejetApiBaseUrl = "https://framejet.dev";
+export declare const framejetCaptureTimeoutMs = 90000;
+type FramejetActionHandler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const framejetActionHandlers: ProviderActionHandlers<"framejet", FramejetActionHandler>;
+/**
+ * Check a key against GET /v1/me, which does not spend a screenshot.
+ */
+export declare function validateFramejetApiKey(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+/**
+ * Map a failed Framejet response for both actions and the proxy, so a spent quota reads the same on either path.
+ */
+export declare function readFramejetError(response: Response): Promise<ProviderRequestError>;
+export {};