@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/agentearth/executors.js

@@ -0,0 +1,109 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { agentearthActions } from "./actions.js";
+const baseUrl = "https://agentearth.ai/agent-api/v1/tool";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const endpoints = {
+    get_account: "account",
+    recommend_tools: "recommend",
+    list_tools: "list",
+    get_tool_detail: "detail",
+    execute_tool: "execute",
+};
+function executionQuery(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new ProviderRequestError(400, "tool_url must be an AgentEarth execution URL", undefined, "invalid_input");
+    }
+    if (url.origin !== "https://agentearth.ai" ||
+        url.pathname !== "/agent-api/v1/tool/execute" ||
+        url.username ||
+        url.password ||
+        url.hash) {
+        throw new ProviderRequestError(400, "tool_url must use the official AgentEarth HTTPS execution endpoint without credentials or fragments", undefined, "invalid_input");
+    }
+    return url.search;
+}
+async function request({ action, input, apiKey, fetcher, parentSignal }) {
+    const execute = action === "execute_tool";
+    const post = execute || action === "recommend_tools";
+    const query = execute ? executionQuery(input.tool_url) : "";
+    const url = new URL(`${baseUrl}/${endpoints[action]}${query}`);
+    if (!post) {
+        for (const [name, value] of Object.entries(input)) {
+            url.searchParams.set(name, String(value));
+        }
+    }
+    return runProviderRequest({ signal: parentSignal, label: "AgentEarth", timeoutMs: execute ? 300_000 : undefined }, async (signal) => {
+        const response = await fetcher(url.toString(), {
+            method: post ? "POST" : "GET",
+            headers: { ...defaultHeaders, "X-Api-Key": apiKey },
+            body: post ? JSON.stringify(execute ? { params: input.params ?? {} } : input) : undefined,
+            redirect: "manual",
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const envelope = optionalRecord(payload);
+        if (!response.ok || envelope?.error_no !== 0) {
+            const message = optionalRawString(envelope?.error_msg) || `HTTP ${response.status}; invalid or unsuccessful response`;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `AgentEarth request failed: ${message.split(apiKey).join("[REDACTED]")}`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return envelope;
+    });
+}
+const handlers = mapProviderActionHandlers("agentearth", agentearthActions, (action) => async (dataInput, context) => {
+    return request({
+        action: action.name,
+        input: dataInput,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("agentearth", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const account = await request({
+            action: "get_account",
+            input: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return {
+            profile: {
+                displayName: optionalRawString(account.user_name)?.trim() ||
+                    optionalRawString(account.key_name)?.trim() ||
+                    "AgentEarth API Key",
+            },
+            grantedScopes: [],
+            metadata: {},
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "agentearth",
+    baseUrl,
+    auth: { type: "api_key_header", name: "X-Api-Key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json", "content-type": "application/json" }))
+            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");
+    },
+});

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

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

package/src/providers/appgrowing_mcp/actions.js

@@ -0,0 +1,175 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const service = "appgrowing_mcp";
+const resultSchema = s.requiredObject("The AppGrowing Global MCP tool result.", {
+    result: s.unknown("Structured MCP content when available; otherwise the complete MCP content envelope. Data availability and Credits depend on the connected AppGrowing Global account."),
+});
+const category = s.array("Store categories for the selected product type; obtain IDs from filterOptions.", s.nullableInteger("Store category ID."));
+const appStyle = s.array("App styles for the selected product type; obtain IDs from filterOptions.", s.nullableInteger("App style ID."));
+const area = s.array("Countries to include; obtain codes from filterOptions.", s.nullableString("Country code."));
+const page = s.integer("Page number, starting at 1. Each page contains up to 100 results.", { minimum: 1 });
+const creativeSearchInput = s.object("Advertising creative filters. Omit filters that do not apply to the selected product type.", {
+    purpose: s.withEnum(s.integer("Promoted product: 1 game, 2 app, 3 website."), [1, 2, 3]),
+    startDate: s.date("First date to include."),
+    endDate: s.date("Last date to include."),
+    isAllDate: s.integer("Use 1 to search all dates, or 0 to use the date range."),
+    category,
+    resourceElement: s.array("Visual element tags for games or apps.", s.nullableInteger("Visual element tag ID from filterOptions.")),
+    appStyle,
+    media: s.array("Advertising channels for the selected product type.", s.nullableInteger("Media channel ID from filterOptions.")),
+    area,
+    format: s.array("Advertising formats for the selected product type.", s.nullableInteger("Ad format ID from filterOptions.")),
+    platform: s.array("Promotion platforms for games or apps.", s.nullableInteger("Promotion platform ID from filterOptions.")),
+    language: s.array("Creative languages.", s.nullableString("Language value from filterOptions.")),
+    videoTime: s.integer("Video duration filter ID from filterOptions, not seconds."),
+    minDuration: s.string("Minimum advertising days as a numeric string.", { pattern: "^[0-9]*$" }),
+    maxDuration: s.string("Maximum advertising days as a numeric string.", { pattern: "^[0-9]*$" }),
+    accurateSearch: s.integer("Use 1 for an exact ordered keyword match, or 0 for broad matching."),
+    isNew: s.integer("Use 1 for new creatives only, or 0 to include existing creatives."),
+    isNewAd: s.integer("Use 1 for new advertisements only, or 0 to include existing advertisements."),
+    resolution: s.integer("Use 1 for high-definition creatives, or 0 to include other resolutions."),
+    keyword: s.string("Search keyword."),
+    order: s.stringEnum("Sort order.", [
+        "_score_desc",
+        "max_dt_desc",
+        "max_dt",
+        "min_dt_desc",
+        "min_dt",
+        "cnt_ad_id_desc",
+        "cnt_dt_desc",
+        "cnt_dt",
+        "impression_inc_2y_desc",
+        "similar_cnt_desc",
+    ]),
+    page,
+    isCreative: s.integer("Use 1 for innovative game or app creatives, or 0 for other creatives."),
+    gender: s.array("Audience genders for games or apps.", s.nullableInteger("Gender: 1 male, 2 female, 3 unknown.")),
+    ageRange: s.array("Audience age groups for games or apps.", s.nullableString("Age group: 13-17, 18-24, 25-34, 35-44, 45-54, 55-64 or 65+.")),
+    isW2a: s.integer("Use 1 for web-to-app promotion; omit to leave it unfiltered."),
+    excludeW2a: s.integer("For games or apps, use 0 with isW2a=1 or 1 with isW2a=0; otherwise omit."),
+    campaignTypeCombine: s.integer("Use 1 when filtering game or app promotion types; otherwise omit."),
+    campaignType: s.array("Game or app promotion types.", s.nullableInteger("Promotion type: 101/201/298/295 app downloads, 299 web-to-APK, 297 PWA/H5; omit for web-to-app.")),
+    platformCampaignType: s.array("Platform-specific promotion types.", s.nullableInteger("App platform: 201 Google Play, 295 Galaxy, 298 RuStore, 299 APK, 101 App Store.")),
+    appCashWay: s.array("Game or app monetization methods.", s.nullable(s.stringEnum("Monetization method: ads, purchases, mixed, or subscriptions.", [
+        "iaa",
+        "iap",
+        "iaa_iap",
+        "subscribable",
+    ]))),
+    materialRatio: s.array("Creative aspect ratios.", s.nullableString("Aspect ratio from filterOptions.")),
+    blockIds: s.array("Creative IDs to exclude.", s.nullableString("Creative ID.")),
+    blockAppIds: s.array("Promoted product IDs to exclude.", s.nullableString("Product ID.")),
+    isPre: s.integer("Use 1 for games with preregistration campaigns, or 0 for other games."),
+    asr: s.integer("Use 1 for narrated creatives, or 0 for creatives without narration."),
+    asrLanguage: s.string("Narration language from filterOptions."),
+    searchDsl: s.array("Field-level search conditions. The upstream equal operator may not narrow results; prefer contain when appropriate.", s.nullable(s.object("A field-level search condition.", {
+        key: s.stringEnum("Field to search.", [
+            "campaign_name",
+            "appid",
+            "slogan",
+            "asr",
+            "brands_name",
+            "developer_name",
+            "website",
+        ]),
+        type: s.stringEnum("Matching operator.", ["contain", "exclude", "equal", "notEqual"]),
+        value: s.string("Value to match."),
+    }, { required: ["key", "type", "value"] }))),
+    isViolation: s.integer("Use 1 for policy-violating game or app advertisements, or 0 for other advertisements."),
+    hasCooperate: s.integer("Use 1 for ads featuring a collaborating creator, or 0 for other ads."),
+    marketingWord: s.string("Game or app selling-point word returned by creativeSellingPointTrends."),
+    singleArea: s.integer("Use 1 for ads running in a single region, or 0 for other ads."),
+    postpage: s.integer("Use 1 to filter original advertising posts, or 0 for other creatives."),
+    hasPpid: s.integer("Custom product page filter for games or apps."),
+    excludeLowQuality: s.integer("Use 1 to exclude low-quality creatives, or 0 to include them. The provider excludes them by default."),
+}, { required: ["purpose", "order"] });
+const sellingPointInput = s.object("Selling-point trend filters for games and apps.", {
+    purpose: s.withEnum(s.integer("Promoted product: 1 game, 2 app."), [1, 2]),
+    category,
+    appStyle,
+    area,
+    wordAttr: s.array("Selling-point categories.", s.nullableString("Selling-point category from filterOptions.")),
+    keyword: s.string("Search keyword."),
+    order: s.stringEnum("Sort order.", [
+        "adverts_desc",
+        "material_cnt_desc",
+        "shot_cnt_desc",
+        "product_cnt_desc",
+        "ratio_desc",
+    ]),
+    page,
+}, { required: ["purpose"] });
+export const appgrowingMcpActions = [
+    defineProviderAction(service, {
+        name: "filterOptions",
+        operationType: "read",
+        description: "List the advertising filters available to your AppGrowing account. Business queries consume account credits.",
+        requiredScopes: [],
+        inputSchema: s.object("No input is required.", {}),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "creativeResourceUrl",
+        operationType: "read",
+        description: "Refresh expired creative download links using the resource filenames, including their extensions.",
+        requiredScopes: [],
+        inputSchema: s.object("Resources whose download links should be refreshed.", {
+            key: s.array("Resource filenames from expired URLs, not resource IDs.", s.nullableString("Resource filename including its extension."), { minItems: 1 }),
+        }, { required: ["key"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "searchAdCreatives",
+        operationType: "read",
+        description: "Find global advertising creatives by product, audience and campaign filters. Use filterOptions for valid IDs and page to continue through results.",
+        requiredScopes: [],
+        inputSchema: creativeSearchInput,
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "creativeSellingPointTrends",
+        operationType: "read",
+        description: "Compare selling-point trends for games and apps by category, style and country.",
+        requiredScopes: [],
+        inputSchema: sellingPointInput,
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "creativeAIAnalysisData",
+        operationType: "read",
+        description: "Read narration, selling points and AI analysis for up to 100 creative resources. Pair each resource ID with one of its ad format IDs.",
+        requiredScopes: [],
+        inputSchema: s.object("Creative resources to analyze.", {
+            ids: s.array("Resource IDs from material.creative.resource[].id, in their original form.", s.string("Creative resource ID."), { minItems: 1, maxItems: 100 }),
+            format: s.array("One material.format[].id for each resource, in the same order as ids.", s.integer("Ad format ID."), { minItems: 1, maxItems: 100 }),
+        }, { required: ["ids", "format"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "list_tools",
+        operationType: "read",
+        description: "Discover current AppGrowing Global MCP tools, live argument schemas and behavior annotations for advertising creative, app, publisher and developer research.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("No input is required.", {}),
+        outputSchema: s.requiredObject("The live AppGrowing Global MCP tool catalog.", {
+            tools: s.array("Tools available to the connected AppGrowing Global account.", s.object("One AppGrowing Global MCP tool.", {
+                name: s.nonEmptyString("The exact tool name."),
+                description: s.string("The current official tool description."),
+                annotations: s.looseObject("Official MCP behavior annotations."),
+                inputSchema: s.looseObject("The current JSON Schema for tool arguments."),
+            }, { optional: ["description", "annotations"] })),
+        }),
+        followUpActions: ["appgrowing_mcp.call_tool"],
+    }),
+    defineProviderAction(service, {
+        name: "call_tool",
+        operationType: "destructive",
+        description: "Call any current AppGrowing Global MCP tool after inspecting list_tools. Arguments must match the live schema. Calls may consume AppGrowing credits; inspect behavior annotations before invoking newly added tools.",
+        requiredScopes: [],
+        inputSchema: s.object("Call a live AppGrowing Global MCP tool.", {
+            toolName: s.nonEmptyString("The exact tool name returned by list_tools."),
+            arguments: s.looseObject("Arguments matching the selected tool's live input schema."),
+        }, { optional: ["arguments"] }),
+        outputSchema: resultSchema,
+    }),
+];

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

@@ -0,0 +1,66 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { recordOrEmpty } from "../../core/cast.js";
+import { callMcpTool, listMcpTools } from "../mcp-tools.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, requiredInputString, ProviderRequestError, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { appgrowingMcpActions } from "./actions.js";
+const origin = "https://api-appgrowing-global.youcloud.com";
+const endpoint = `${origin}/mcp`;
+const defaultHeaders = {
+    accept: "application/json, text/event-stream",
+    "content-type": "application/json",
+    "accept-language": "en",
+};
+const handlers = mapProviderActionHandlers("appgrowing_mcp", appgrowingMcpActions, (action) => async (input, context) => {
+    if (action.name === "creativeAIAnalysisData" &&
+        input.ids.length !== input.format.length)
+        throw new ProviderRequestError(400, "ids and format must have the same length");
+    const connection = {
+        service: "AppGrowing",
+        endpoint,
+        headers: { ...defaultHeaders, authorization: `Bearer ${requiredInputString(context.apiKey, "API Key")}` },
+        fetcher: context.fetcher,
+        signal: context.signal,
+        // Cloudflare Workers rejects `redirect: "error"`; a 3xx under "manual" still fails the MCP request.
+        redirect: "manual",
+        maxResponseBytes: 16 * 1024 * 1024,
+        terminateSession: true,
+    };
+    if (action.name === "list_tools")
+        return { tools: await listMcpTools(connection, { includeAnnotations: true }) };
+    return {
+        result: await callMcpTool({
+            ...connection,
+            toolName: action.name === "call_tool" ? requiredInputString(input.toolName, "toolName") : action.name,
+            arguments: action.name === "call_tool" ? recordOrEmpty(input.arguments) : input,
+        }),
+    };
+});
+export const executors = defineApiKeyProviderExecutors("appgrowing_mcp", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input) {
+        const hash = sha256Hex(requiredInputString(input.apiKey, "API Key"));
+        return {
+            profile: { accountId: `appgrowing-mcp:${hash}`, displayName: `AppGrowing Global · ${hash.slice(-6)}` },
+            metadata: { mcpEndpoint: endpoint, validationMode: "local_non_empty_key" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "appgrowing_mcp",
+    baseUrl: origin,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    redirect: "manual",
+    customizeRequest({ url, headers }) {
+        if (url.href !== endpoint)
+            throw new ProviderRequestError(400, "AppGrowing proxy only supports the official /mcp endpoint without query parameters");
+        for (const [name, value] of Object.entries(defaultHeaders))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "MCP proxy request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

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

@@ -0,0 +1,8 @@
+import { defineApiKeyProviderExecutors } from "../provider-runtime.js";
+import { arcmiraActionHandlers, validateArcmiraCredential } from "./runtime.js";
+export const executors = defineApiKeyProviderExecutors("arcmira", arcmiraActionHandlers);
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateArcmiraCredential({ apiKey: input.apiKey, fetcher, signal });
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers } from "../provider-runtime.ts";
+type Handler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const arcmiraActionHandlers: ProviderActionHandlers<"arcmira", Handler>;
+export declare function validateArcmiraCredential(context: ApiKeyProviderContext): Promise<CredentialValidationResult>;
+export {};

package/src/providers/arcmira/runtime.js

@@ -0,0 +1,41 @@
+import { optionalRecord, optionalString, requiredString, requiredStringArray } from "../../core/cast.js";
+import { ProviderRequestError, providerResponseError, readProviderJsonBody, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+async function requestArcmira(context, path, input = {}) {
+    const url = new URL(`https://api.arcmira.com/v1/${path}`);
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return runProviderRequest({ label: "Arcmira", signal: context.signal }, async (signal) => {
+        const response = await context.fetcher(url.toString(), {
+            headers: { Authorization: `Bearer ${context.apiKey}`, Accept: "application/json" },
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "Arcmira returned invalid JSON",
+        });
+        if (!response.ok) {
+            const error = optionalRecord(optionalRecord(payload)?.error);
+            const status = response.status;
+            throw new ProviderRequestError(status, optionalString(error?.message) ?? `Arcmira returned HTTP ${response.status}`, withRetryAfterSeconds(response, payload), status === 402 ? "insufficient_credit" : status === 429 ? "rate_limited" : "provider_error");
+        }
+        return payload;
+    });
+}
+export const arcmiraActionHandlers = {
+    get_account: (_input, context) => requestArcmira(context, "me"),
+    resolve_entity: (input, context) => requestArcmira(context, "entities/resolve", input),
+    search_transcripts: (input, context) => requestArcmira(context, "search", input),
+    get_transcript: ({ video_id, ...query }, context) => requestArcmira(context, `transcripts/${encodeURIComponent(requiredString(video_id, "video_id"))}`, query),
+};
+export async function validateArcmiraCredential(context) {
+    const payload = optionalRecord(await requestArcmira(context, "me", {}));
+    const account = optionalRecord(payload?.account);
+    const accountId = requiredString(account?.id, "Arcmira account ID", providerResponseError);
+    return {
+        profile: { accountId, displayName: optionalString(account?.name) ?? accountId },
+        grantedScopes: requiredStringArray(payload?.scopes, "Arcmira scopes", providerResponseError),
+    };
+}

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

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

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;