@oomol-lab/open-connector 1.9.0 → 1.9.1

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/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;

package/src/providers/chaport/executors.js

@@ -0,0 +1,128 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, providerUserAgent, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { chaportActions } from "./actions.js";
+const baseUrl = "https://app.chaport.com/api/v1";
+function pathId(value) {
+    if (value === "." || value === "..") {
+        throw new ProviderRequestError(400, "Chaport IDs cannot be dot segments", undefined, "invalid_input");
+    }
+    return encodeURIComponent(value);
+}
+async function request({ path, query, apiKey, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "Chaport" }, async (signal) => {
+        const url = new URL(`${baseUrl}${path}`);
+        url.search = query.toString();
+        const response = await fetcher(url, {
+            method: "GET",
+            signal,
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${apiKey}`,
+                "user-agent": providerUserAgent,
+            },
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Chaport returned a non-JSON response (HTTP ${response.status})`, undefined, "provider_error");
+        }
+        if (!response.ok) {
+            const body = optionalRecord(payload);
+            const error = optionalRecord(body?.error);
+            const message = optionalRawString(body?.message) ??
+                optionalRawString(error?.message) ??
+                optionalRawString(body?.error) ??
+                `Chaport request failed (HTTP ${response.status})`;
+            throw new ProviderRequestError(response.status, message, {
+                code: body?.code ?? error?.code,
+                links: body?.links,
+            }, "provider_error");
+        }
+        return requiredResponseRecord(payload, "Chaport response");
+    });
+}
+const handlers = mapProviderActionHandlers("chaport", chaportActions, (action) => async (dataInput, context) => {
+    const data = dataInput;
+    const query = new URLSearchParams();
+    let path = "/visitors";
+    if (action.name === "list_visitors") {
+        if (data.page != null)
+            query.set("page", String(data.page));
+    }
+    else {
+        path += `/${pathId(String(data.visitorId))}`;
+        if (action.name !== "get_visitor") {
+            path += "/chats";
+            if (action.name !== "get_latest_chat")
+                path += `/${data.chatId}`;
+            if (action.name === "list_chat_events" || action.name === "get_chat_event") {
+                path += "/events";
+                if (action.name === "get_chat_event")
+                    path += `/${pathId(String(data.eventId))}`;
+            }
+            else if (data.transcript != null) {
+                query.set("transcript", String(data.transcript));
+            }
+        }
+    }
+    const payload = await request({
+        path: path,
+        query: query,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+    if (Array.isArray(data.eventTypes) && data.transcript !== true) {
+        const result = optionalRecord(payload.result);
+        if (result && Array.isArray(result.events)) {
+            const types = data.eventTypes;
+            return {
+                ...payload,
+                result: {
+                    ...result,
+                    events: result.events.flat().filter((event) => types.includes(optionalRecord(event)?.type)),
+                },
+            };
+        }
+    }
+    return payload;
+});
+export const executors = defineApiKeyProviderExecutors("chaport", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request({
+            path: "/me.json",
+            query: new URLSearchParams(),
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return {
+            profile: { displayName: "Chaport API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "/me.json" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "chaport",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({
+            accept: "application/json",
+            "user-agent": providerUserAgent,
+        }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});