@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/bainiu/actions.js

@@ -0,0 +1,108 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const keyFields = {
+    key: s.string("Company identifier, name, unified social credit code, registration number or organization code.", {
+        minLength: 1,
+    }),
+    key_type: s.stringEnum("Identifier type: 0 entity ID (default), 1 company name, 2 unified social credit code, 3 registration number, 4 organization code.", ["0", "1", "2", "3", "4"]),
+};
+const pagination = {
+    page_index: s.integer("Page number, starting at 1. Omit for the provider default.", {
+        minimum: 1,
+    }),
+    page_size: s.integer("Number of records per page. Omit for the provider default.", {
+        minimum: 1,
+    }),
+};
+const record = s.looseObject("One upstream company record, including provider-specific fields.");
+const page = s.looseObject("A page of upstream records.", {
+    datalist: s.array("Records on this page.", record),
+    total: s.integer("Total matching records."),
+});
+function companyResponse(result) {
+    return s.object("Bainiu response envelope; upstream fields are preserved.", {
+        code: s.string("Upstream response code; 200 indicates success."),
+        message: s.string("Upstream response message."),
+        result,
+        ordernum: s.string("Upstream request or order identifier."),
+        is_verify: s.string("Billing indicator: 0 not charged, 1 charged."),
+    }, { required: ["code", "message", "result"], additionalProperties: true });
+}
+export const bainiuActions = [
+    defineProviderAction("bainiu", {
+        name: "resolve_companies",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Resolve company identifiers in a batch. Separate multiple lookup keys with commas; queries may consume provider credits.",
+        inputSchema: s.object("Company identifier lookup parameters.", keyFields, {
+            optional: ["key_type"],
+        }),
+        outputSchema: companyResponse(s.record("Mapping from each lookup key to its entity ID.", s.string("Company entity ID."))),
+    }),
+    defineProviderAction("bainiu", {
+        name: "search_companies",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search companies using Bainiu's DSL with filters, sorting, highlighting and pagination. Queries may consume provider credits.",
+        inputSchema: s.requiredObject("Company search parameters.", {
+            data: s.object("Search request encoded as JSON by Connector. Supports the full upstream query DSL and additional provider options.", {
+                dsl_query: s.looseObject('Bainiu filter tree, using must/should and field operators any/all/not/range/exist. Example: {"must":[{"main__ENTNAME":{"all":["小米"]}}]}.'),
+                sort: s.looseObject("Upstream sort configuration, including algorithm or geographical sorting."),
+                highlight: s.looseObject("Upstream highlight configuration."),
+                ...pagination,
+            }, { required: ["dsl_query"], additionalProperties: true }),
+        }),
+        outputSchema: companyResponse(page),
+    }),
+    defineProviderAction("bainiu", {
+        name: "get_company",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read company registration and business information. Queries may consume provider credits.",
+        inputSchema: s.object("Company detail lookup parameters.", keyFields, { required: ["key"] }),
+        outputSchema: companyResponse(s.looseObject("Requested company detail nodes.", {
+            versions: s.array("Returned detail node codes.", s.string("Detail node code.")),
+            basic: record,
+        })),
+    }),
+    defineProviderAction("bainiu", {
+        name: "list_company_branches",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List company branches with pagination. Queries may consume provider credits.",
+        inputSchema: s.object("Company detail lookup parameters.", { ...keyFields, ...pagination }, { required: ["key"] }),
+        outputSchema: companyResponse(s.looseObject("Requested company detail nodes.", {
+            versions: s.array("Returned detail node codes.", s.string("Detail node code.")),
+            filiation: page,
+        })),
+    }),
+    defineProviderAction("bainiu", {
+        name: "list_company_shareholders",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List company shareholders and managers with pagination. Queries may consume provider credits.",
+        inputSchema: s.object("Company detail lookup parameters.", { ...keyFields, ...pagination }, { required: ["key"] }),
+        outputSchema: companyResponse(s.looseObject("Requested company detail nodes.", {
+            versions: s.array("Returned detail node codes.", s.string("Detail node code.")),
+            shareholder: page,
+            person: page,
+        })),
+    }),
+    defineProviderAction("bainiu", {
+        name: "list_company_changes",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List company registration changes with optional type and date filters. Queries may consume provider credits.",
+        inputSchema: s.object("Company detail lookup parameters.", {
+            ...keyFields,
+            ...pagination,
+            alttype: s.string("Upstream change type code, for example 01 name, 03 representative, 10 business scope or 20 registered capital."),
+            altdate_start: s.date("Inclusive change date lower bound (YYYY-MM-DD)."),
+            altdate_end: s.date("Exclusive change date upper bound (YYYY-MM-DD)."),
+        }, { required: ["key"] }),
+        outputSchema: companyResponse(s.looseObject("Requested company detail nodes.", {
+            versions: s.array("Returned detail node codes.", s.string("Detail node code.")),
+            alter: page,
+        })),
+    }),
+];

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

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineProviderExecutors, requireApiKeyCredential, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { bainiuActions } from "./actions.js";
+const baseUrl = "https://openapi.bainiudata.com";
+const versions = {
+    get_company: "A1",
+    list_company_changes: "A2",
+    list_company_branches: "A3",
+    list_company_shareholders: "B1",
+};
+function signedHeaders(clientId, clientKey) {
+    const timestamp = String(Math.floor(Date.now() / 1000));
+    return {
+        accept: "application/json",
+        CLIENTID: clientId,
+        TIMESPAN: timestamp,
+        Authorization: createHash("md5").update(`${clientId}-${timestamp}-${clientKey}`).digest("hex").toUpperCase(),
+    };
+}
+const handlers = mapProviderActionHandlers("bainiu", bainiuActions, (action) => async (dataInput, context) => {
+    const clientKey = context.apiKey;
+    const clientId = requiredInputString(context.values?.clientId, "clientId");
+    const data = dataInput;
+    if (action.name === "search_companies") {
+        const query = optionalRecord(data.data);
+        data.data = {
+            ...query,
+            page_index: query.page_index == null ? undefined : String(query.page_index),
+            page_size: query.page_size == null ? undefined : String(query.page_size),
+        };
+    }
+    const form = new FormData();
+    for (const [key, value] of Object.entries(data)) {
+        if (value != null)
+            form.set(key, key === "data" ? JSON.stringify(value) : String(value));
+    }
+    const version = versions[action.name];
+    if (version)
+        form.set("version", version);
+    const route = action.name === "search_companies"
+        ? "mohu"
+        : action.name === "resolve_companies"
+            ? "get_entid"
+            : "company_detail";
+    return runProviderRequest({ signal: context.signal, label: "Bainiu" }, async (signal) => {
+        const response = await context.fetcher(`${baseUrl}/openapi/common/${route}/`, {
+            method: "POST",
+            headers: signedHeaders(clientId, clientKey),
+            body: form,
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const body = optionalRecord(payload);
+        const code = optionalRawString(body?.code);
+        if (!response.ok || code !== "200") {
+            const message = optionalRawString(body?.message) ?? `HTTP ${response.status}`;
+            const detail = `${code ? `${code}: ` : ""}${message}`
+                .split(clientKey)
+                .join("[REDACTED]")
+                .split(clientId)
+                .join("[REDACTED]");
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Bainiu request failed: ${detail}`, undefined, "provider_error");
+        }
+        return requiredResponseRecord(payload, "Bainiu response");
+    });
+});
+export const executors = defineProviderExecutors({
+    service: "bainiu",
+    handlers,
+    skipDnsValidation: true,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, "bainiu");
+        return { apiKey: credential.apiKey, values: credential.values, fetcher, signal: context.signal };
+    },
+});
+export const credentialValidators = {
+    async apiKey(input) {
+        requiredInputString(input.apiKey, "API Key");
+        requiredInputString(input.values.clientId, "clientId");
+        return {
+            profile: { displayName: "Bainiu API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationMode: "format_only" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "bainiu",
+    baseUrl,
+    auth: { type: "none" },
+    skipDnsValidation: true,
+    sensitiveHeaders: ["CLIENTID", "TIMESPAN"],
+    allowedEndpoint(endpoint) {
+        const path = new URL(endpoint, baseUrl).pathname;
+        return path === "/openapi" || path.startsWith("/openapi/");
+    },
+    async customizeRequest({ context, headers }) {
+        const credential = await requireApiKeyCredential(context, "bainiu");
+        for (const [name, value] of Object.entries(signedHeaders(requiredInputString(credential.values.clientId, "clientId"), credential.apiKey)))
+            headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Bainiu request failed"), withRetryAfterSeconds(response), "provider_error");
+    },
+});

package/src/providers/baixiao/executors.js

@@ -73,7 +73,7 @@ async function callTool(context, name, args) {
     const result = await withClient(context, (client) => client.callTool({ name, arguments: args }, { timeout: timeoutMs }));
     const error = findError(result);
     if (error)
-        throw new ProviderRequestError(error.code === "unauthorized" ? 401 : 502, error.message ?? `Baixiao MCP returned ${error.code}`, error.raw, error.code);
+        throw new ProviderRequestError(error.code === "unauthorized" ? 401 : 502, error.message ?? `Baixiao MCP returned ${error.code}`, error.raw);
     return result;
 }
 function withClient(context, run) {

package/src/providers/bing_webmaster/executors.js

@@ -94,7 +94,7 @@ async function request(endpoint, method, input, context) {
     const envelope = optionalRecord(payload);
     if (!response.ok || envelope?.ErrorCode !== undefined) {
         const code = envelope?.ErrorCode;
-        throw new ProviderRequestError(response.status || 502, `Bing Webmaster${code === undefined ? "" : ` (${String(code)})`}: ${optionalString(envelope?.Message) ?? `request failed (HTTP ${response.status})`}`, payload, code === undefined ? undefined : String(code));
+        throw new ProviderRequestError(response.status || 502, `Bing Webmaster${code === undefined ? "" : ` (${String(code)})`}: ${optionalString(envelope?.Message) ?? `request failed (HTTP ${response.status})`}`, payload);
     }
     if (payload === undefined)
         return null;

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/calendly/executors.js

@@ -1,5 +1,6 @@
 import { defineBearerProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { calendlyActionHandlers, calendlyApiOrigin, validateCalendlyCredential } from "./runtime.js";
+import { calendlyBookingEvent } from "./trigger-on-booking-event.js";
 const service = "calendly";
 export const executors = defineBearerProviderExecutors(service, calendlyActionHandlers);
 export const proxy = defineProviderProxy({
@@ -15,3 +16,4 @@ export const credentialValidators = {
         return validateCalendlyCredential(input.accessToken, fetcher, signal);
     },
 };
+export const triggers = [calendlyBookingEvent];

package/src/providers/calendly/trigger-on-booking-event.d.ts

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

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

@@ -0,0 +1,5 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const events: readonly ["invitee.created", "invitee.canceled"];
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/calendly/trigger-on-booking-event.definition.js

@@ -0,0 +1,42 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const events = ["invitee.created", "invitee.canceled"];
+export const snapshot = {
+    key: "calendly.on_booking_event",
+    provider: "calendly",
+    name: "on_booking_event",
+    displayName: "Booking Created or Canceled",
+    description: "Receives bookings and cancellations, preserving reschedule links. Requires a Personal Access Token connection.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "scope",
+            jsonSchema: { type: "string", enum: ["user", "organization"], title: "Scope" },
+            nullable: false,
+            value: "user",
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", enum: events },
+                minItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: events,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "inviteeUri", jsonSchema: s.string(), nullable: false },
+        { handle: "createdAt", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/calendly/trigger-on-booking-event.js

@@ -0,0 +1,144 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { bytes, verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-booking-event.definition.js";
+function webhookId(uri) {
+    if (typeof uri != "string" || !uri.startsWith("https://api.calendly.com/webhook_subscriptions/"))
+        throw new TransientIntegrationError("Calendly returned an invalid subscription URI.");
+    const id = uri.slice("https://api.calendly.com/webhook_subscriptions/".length);
+    if (!id || id.includes("/") || id.includes("?") || id.includes("#"))
+        throw new TransientIntegrationError("Calendly returned an invalid subscription identity.");
+    return id;
+}
+export const calendlyBookingEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        // OAuth subscriptions use the application signing key; signing_key cannot override it.
+        if (context.connector.authType != "api_key")
+            throw new PermanentIntegrationError("Calendly Triggers require a Personal Access Token connection. OAuth application signing keys are not configured by this deployment.");
+        const current = await webhookRequest(context, { endpoint: "/users/me", method: "GET" });
+        if (!isJsonObject(current.data) ||
+            !isJsonObject(current.data.resource) ||
+            typeof current.data.resource.uri != "string" ||
+            typeof current.data.resource.current_organization != "string")
+            throw new TransientIntegrationError("Calendly returned an invalid current user.");
+        const organization = current.data.resource.current_organization;
+        const user = current.data.resource.uri;
+        const scope = String(context.config.scope);
+        const query = { organization, scope, count: 100 };
+        if (scope == "user")
+            query.user = user;
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const found = [];
+                const seen = new Set();
+                for (let page = 0; page < 100; page++) {
+                    const result = await webhookRequest(context, {
+                        endpoint: "/webhook_subscriptions",
+                        method: "GET",
+                        query,
+                    });
+                    if (!isJsonObject(result.data) ||
+                        !Array.isArray(result.data.collection) ||
+                        !isJsonObject(result.data.pagination))
+                        throw new TransientIntegrationError("Calendly returned an invalid webhook page.");
+                    for (const item of result.data.collection) {
+                        if (!isJsonObject(item) || typeof item.callback_url != "string")
+                            throw new TransientIntegrationError("Calendly returned an invalid webhook.");
+                        if (item.callback_url != context.endpointUrl)
+                            continue;
+                        if (item.organization != organization || item.scope != scope || (scope == "user" && item.user != user))
+                            throw new PermanentIntegrationError("Calendly webhook scope differs from this subscription.");
+                        if (context.active && item.state != "active")
+                            throw new PermanentIntegrationError("Calendly disabled this webhook. Restore it or remove the owned webhook before retrying.");
+                        if (context.active &&
+                            (!Array.isArray(item.events) ||
+                                item.events.length != context.config.eventTypes.length ||
+                                !context.config.eventTypes.every((event) => item.events.includes(event))))
+                            throw new PermanentIntegrationError("Calendly webhook events differ from this subscription. Remove the owned webhook before retrying.");
+                        found.push({ id: webhookId(item.uri), secret: context.callbackSecret });
+                    }
+                    const next = result.data.pagination.next_page_token;
+                    if (next == null)
+                        return found;
+                    if (typeof next != "string" || !next || seen.has(next))
+                        throw new TransientIntegrationError("Calendly webhook pagination did not advance.");
+                    seen.add(next);
+                    query.page_token = next;
+                }
+                throw new PermanentIntegrationError("The Calendly webhook list exceeds 10000 entries.");
+            },
+            async create() {
+                const body = {
+                    url: context.endpointUrl,
+                    events: context.config.eventTypes,
+                    organization,
+                    scope,
+                    signing_key: context.callbackSecret,
+                };
+                if (scope == "user")
+                    body.user = user;
+                const result = await webhookRequest(context, {
+                    endpoint: "/webhook_subscriptions",
+                    method: "POST",
+                    body,
+                });
+                if (!isJsonObject(result.data) || !isJsonObject(result.data.resource))
+                    throw new TransientIntegrationError("Calendly webhook creation returned no resource.");
+                return { id: webhookId(result.data.resource.uri), secret: context.callbackSecret };
+            },
+            async remove(id) {
+                await webhookRequest(context, {
+                    endpoint: `/webhook_subscriptions/${encodeURIComponent(id)}`,
+                    method: "DELETE",
+                });
+            },
+        });
+    },
+    async receive(context) {
+        const parts = context
+            .header("calendly-webhook-signature")
+            ?.split(",")
+            .map((part) => part.trim()) ?? [];
+        const timestamps = parts.filter((part) => part.startsWith("t="));
+        const timestamp = timestamps[0]?.slice(2);
+        let valid = false;
+        if (timestamps.length == 1 &&
+            timestamp &&
+            Number.isInteger(Number(timestamp)) &&
+            Math.abs(context.now.getTime() / 1000 - Number(timestamp)) <= 180) {
+            for (const part of parts) {
+                if (part.startsWith("v1=") &&
+                    (await verifyHexHmac(context.callbackSecret, [bytes(`${timestamp}.`), context.rawBody], part.slice(3)))) {
+                    valid = true;
+                    break;
+                }
+            }
+        }
+        if (!valid)
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) ||
+            typeof body.event != "string" ||
+            !context.config.eventTypes.includes(body.event))
+            return { outcome: "ignored", reason: "Calendly event does not match." };
+        if (!isJsonObject(body.payload) ||
+            typeof body.payload.uri != "string" ||
+            !body.payload.uri ||
+            typeof body.created_at != "string" ||
+            !body.created_at)
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: JSON.stringify([body.event, body.payload.uri, body.created_at]),
+            outputs: {
+                event: body.event,
+                inviteeUri: body.payload.uri,
+                createdAt: body.created_at,
+                body: body.payload,
+            },
+        };
+    },
+};

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

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

package/src/providers/chaport/actions.js

@@ -0,0 +1,70 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const visitorId = s.nonEmptyString("Visitor ID.");
+const chatId = s.integer("Chat ID.");
+const eventId = s.nonEmptyString("Chat event ID.");
+const chatOptions = {
+    transcript: s.optional(s.boolean("Return message events as a transcript.")),
+    eventTypes: s.optional(s.array("Filter returned events by type. Ignored when transcript is true.", s.nonEmptyString("Chat event type."))),
+};
+const links = s.optional(s.looseObject("Related API links, including pagination or older chats."));
+const recordOutput = s.object("Chaport response.", {
+    result: s.looseObject("The requested record, including provider-defined fields."),
+    links,
+}, { required: [], additionalProperties: true });
+const listOutput = s.object("Chaport response.", {
+    result: s.array("The requested records.", s.looseObject("A record including provider-defined fields.")),
+    links,
+}, { required: [], additionalProperties: true });
+export const chaportActions = [
+    defineProviderAction("chaport", {
+        name: "list_visitors",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List visitors ordered by their most recent chat, one page at a time.",
+        inputSchema: s.requiredObject("Visitor list input.", {
+            page: s.optional(s.integer("Page number, starting at 1.", { minimum: 1 })),
+        }),
+        outputSchema: listOutput,
+    }),
+    defineProviderAction("chaport", {
+        name: "get_visitor",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve a visitor by ID.",
+        inputSchema: s.requiredObject("Visitor lookup input.", { visitorId }),
+        outputSchema: recordOutput,
+    }),
+    defineProviderAction("chaport", {
+        name: "get_latest_chat",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve a visitor's current or most recent chat and links to older chats.",
+        inputSchema: s.requiredObject("Latest chat input.", { visitorId, ...chatOptions }),
+        outputSchema: recordOutput,
+    }),
+    defineProviderAction("chaport", {
+        name: "get_chat",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve a specific chat for a visitor.",
+        inputSchema: s.requiredObject("Chat lookup input.", { visitorId, chatId, ...chatOptions }),
+        outputSchema: recordOutput,
+    }),
+    defineProviderAction("chaport", {
+        name: "list_chat_events",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve all events for a visitor's chat.",
+        inputSchema: s.requiredObject("Chat events input.", { visitorId, chatId }),
+        outputSchema: listOutput,
+    }),
+    defineProviderAction("chaport", {
+        name: "get_chat_event",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve a specific event in a visitor's chat.",
+        inputSchema: s.requiredObject("Chat event lookup input.", { visitorId, chatId, eventId }),
+        outputSchema: recordOutput,
+    }),
+];

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