@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/kolsprite_mcp/actions.js

@@ -0,0 +1,519 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+export const kolspriteMcpActions = [
+    defineProviderAction("kolsprite_mcp", {
+        name: "creator_search",
+        operationType: "read",
+        description: "Search TikTok creators by keyword, audience, engagement, and sales. Query creator_category_list or product_category_list before selecting a category.",
+        requiredScopes: [],
+        inputSchema: s.object("KOLSprite tool arguments.", {
+            keyword: s.string("Search keyword."),
+            search_type: s.withEnum(s.string("Search mode: N for nickname (creators) or ID (products and shops), K for keyword."), ["N", "K"]),
+            region: s.string("TikTok region code; defaults to US, or to market for ASIN analysis."),
+            category_list: s.array("One creator category value returned by creator_category_list.", s.string("One upstream identifier."), { maxItems: 1 }),
+            product_category_list: s.array("One product category ID returned by product_category_list.", s.string("One upstream identifier."), { maxItems: 1 }),
+            fans_cnt_from: s.integer("Lower bound for follower count."),
+            fans_cnt_to: s.integer("Upper bound for follower count."),
+            fans_gr_from: s.number("Lower bound for follower growth rate."),
+            fans_gr_to: s.number("Upper bound for follower growth rate."),
+            interact_from: s.number("Lower bound for engagement rate."),
+            interact_to: s.number("Upper bound for engagement rate."),
+            avg_like_from: s.number("Lower bound for average likes."),
+            avg_like_to: s.number("Upper bound for average likes."),
+            play_cnt_from: s.integer("Lower bound for video views (average views for creator searches)."),
+            play_cnt_to: s.integer("Upper bound for video views (average views for creator searches)."),
+            video_cnt_from: s.integer("Lower bound for video count."),
+            video_cnt_to: s.integer("Upper bound for video count."),
+            product_cnt_from: s.integer("Lower bound for product count."),
+            product_cnt_to: s.integer("Upper bound for product count."),
+            sales_volume_from: s.integer("Lower bound for sales volume."),
+            sales_volume_to: s.integer("Upper bound for sales volume."),
+            order_field: s.string("Upstream sort field."),
+            order_type: s.withEnum(s.integer("Sort direction: 0 descending, 1 ascending."), [0, 1]),
+            page_num: s.integer("Page number, starting at 1. Page number multiplied by page size must not exceed 1000.", {
+                minimum: 1,
+                default: 1,
+            }),
+            page_size: s.integer("Results per page, from 1 to 100; defaults to 20.", {
+                minimum: 1,
+                maximum: 100,
+                default: 20,
+            }),
+        }, {
+            optional: [
+                "keyword",
+                "search_type",
+                "region",
+                "category_list",
+                "product_category_list",
+                "fans_cnt_from",
+                "fans_cnt_to",
+                "fans_gr_from",
+                "fans_gr_to",
+                "interact_from",
+                "interact_to",
+                "avg_like_from",
+                "avg_like_to",
+                "play_cnt_from",
+                "play_cnt_to",
+                "video_cnt_from",
+                "video_cnt_to",
+                "product_cnt_from",
+                "product_cnt_to",
+                "sales_volume_from",
+                "sales_volume_to",
+                "order_field",
+                "order_type",
+                "page_num",
+                "page_size",
+            ],
+        }),
+        outputSchema: s.object("KOLSprite response with additional upstream fields preserved.", {
+            code: s.string("Upstream business status code."),
+            message: s.string("Upstream message."),
+            success: s.boolean("Upstream success flag."),
+            data: s.object("Paginated search results.", {
+                total: s.integer("Total matching records."),
+                pageNum: s.integer("Current page number."),
+                pageSize: s.integer("Results per page."),
+                list: s.array("Matching records.", s.looseObject("An upstream record with its available metrics and links.")),
+            }, {
+                required: ["list"],
+                additionalProperties: true,
+            }),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("kolsprite_mcp", {
+        name: "product_search",
+        operationType: "read",
+        description: "Search TikTok Shop products by keyword, price, sales, ratings, and category. Query product_category_list for category IDs.",
+        requiredScopes: [],
+        inputSchema: s.object("KOLSprite tool arguments.", {
+            keyword: s.string("Search keyword."),
+            search_type: s.withEnum(s.string("Search mode: N for nickname (creators) or ID (products and shops), K for keyword."), ["N", "K"]),
+            region: s.string("TikTok region code; defaults to US, or to market for ASIN analysis."),
+            cat_ids: s.array("One product category ID returned by product_category_list.", s.string("One upstream identifier."), { maxItems: 1 }),
+            exclude_keyword: s.string("Keywords to exclude."),
+            ft: s.withEnum(s.string("Fulfillment type: fbt for managed fulfillment, pop for merchant operations."), [
+                "fbt",
+                "pop",
+            ]),
+            lt: s.withEnum(s.string("Logistics type: local or crossborder."), ["local", "crossborder"]),
+            shop_id: s.string("TikTok Shop ID."),
+            price_from: s.number("Lower bound for price."),
+            price_to: s.number("Upper bound for price."),
+            rating_from: s.number("Lower bound for rating."),
+            rating_to: s.number("Upper bound for rating."),
+            reviews_from: s.integer("Lower bound for review count."),
+            reviews_to: s.integer("Upper bound for review count."),
+            sales_volume_from: s.integer("Lower bound for sales volume."),
+            sales_volume_to: s.integer("Upper bound for sales volume."),
+            sales_volume_lst7d_from: s.integer("Lower bound for sales volume in the last 7 days."),
+            sales_volume_lst7d_to: s.integer("Upper bound for sales volume in the last 7 days."),
+            sales_volume_lst30d_from: s.integer("Lower bound for sales volume in the last 30 days."),
+            sales_volume_lst30d_to: s.integer("Upper bound for sales volume in the last 30 days."),
+            sales_lst30d_from: s.number("Lower bound for sales revenue in the last 30 days."),
+            sales_lst30d_to: s.number("Upper bound for sales revenue in the last 30 days."),
+            sales_volume_gr7d_from: s.number("Lower bound for sales volume growth rate over 7 days."),
+            sales_volume_gr7d_to: s.number("Upper bound for sales volume growth rate over 7 days."),
+            sales_volume_gr30d_from: s.number("Lower bound for sales volume growth rate over 30 days."),
+            sales_volume_gr30d_to: s.number("Upper bound for sales volume growth rate over 30 days."),
+            influencer_from: s.integer("Lower bound for promoting creator count."),
+            influencer_to: s.integer("Upper bound for promoting creator count."),
+            videos_from: s.integer("Lower bound for video count."),
+            videos_to: s.integer("Upper bound for video count."),
+            listing_date_from: s.string("Lower bound for listing date (yyyy-mm-dd).", {
+                format: "date",
+            }),
+            listing_date_to: s.string("Upper bound for listing date (yyyy-mm-dd).", { format: "date" }),
+            order_field: s.string("Upstream sort field."),
+            order_type: s.withEnum(s.integer("Sort direction: 0 descending, 1 ascending."), [0, 1]),
+            page_num: s.integer("Page number, starting at 1. Page number multiplied by page size must not exceed 1000.", {
+                minimum: 1,
+                default: 1,
+            }),
+            page_size: s.integer("Results per page, from 1 to 100; defaults to 20.", {
+                minimum: 1,
+                maximum: 100,
+                default: 20,
+            }),
+        }, {
+            optional: [
+                "keyword",
+                "search_type",
+                "region",
+                "cat_ids",
+                "exclude_keyword",
+                "ft",
+                "lt",
+                "shop_id",
+                "price_from",
+                "price_to",
+                "rating_from",
+                "rating_to",
+                "reviews_from",
+                "reviews_to",
+                "sales_volume_from",
+                "sales_volume_to",
+                "sales_volume_lst7d_from",
+                "sales_volume_lst7d_to",
+                "sales_volume_lst30d_from",
+                "sales_volume_lst30d_to",
+                "sales_lst30d_from",
+                "sales_lst30d_to",
+                "sales_volume_gr7d_from",
+                "sales_volume_gr7d_to",
+                "sales_volume_gr30d_from",
+                "sales_volume_gr30d_to",
+                "influencer_from",
+                "influencer_to",
+                "videos_from",
+                "videos_to",
+                "listing_date_from",
+                "listing_date_to",
+                "order_field",
+                "order_type",
+                "page_num",
+                "page_size",
+            ],
+        }),
+        outputSchema: s.object("KOLSprite response with additional upstream fields preserved.", {
+            code: s.string("Upstream business status code."),
+            message: s.string("Upstream message."),
+            success: s.boolean("Upstream success flag."),
+            data: s.object("Paginated search results.", {
+                total: s.integer("Total matching records."),
+                pageNum: s.integer("Current page number."),
+                pageSize: s.integer("Results per page."),
+                list: s.array("Matching records.", s.looseObject("An upstream record with its available metrics and links.")),
+            }, {
+                required: ["list"],
+                additionalProperties: true,
+            }),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("kolsprite_mcp", {
+        name: "product_related_creator",
+        operationType: "read",
+        description: "List creators promoting a TikTok Shop product, with optional contact availability and sorting filters.",
+        requiredScopes: [],
+        inputSchema: s.object("KOLSprite tool arguments.", {
+            product_id: s.nonEmptyString("TikTok Shop product ID."),
+            region: s.string("TikTok region code; defaults to US, or to market for ASIN analysis."),
+            contact_exist: s.withEnum(s.integer("Filter contact availability: 1 with contact details, 0 without."), [0, 1]),
+            order_field: s.string("Upstream sort field."),
+            order_type: s.withEnum(s.integer("Sort direction: 0 descending, 1 ascending."), [0, 1]),
+            page_num: s.integer("Page number, starting at 1. Page number multiplied by page size must not exceed 1000.", {
+                minimum: 1,
+                default: 1,
+            }),
+            page_size: s.integer("Results per page, from 1 to 100; defaults to 20.", {
+                minimum: 1,
+                maximum: 100,
+                default: 20,
+            }),
+        }, {
+            optional: ["region", "contact_exist", "order_field", "order_type", "page_num", "page_size"],
+        }),
+        outputSchema: s.object("KOLSprite response with additional upstream fields preserved.", {
+            code: s.string("Upstream business status code."),
+            message: s.string("Upstream message."),
+            success: s.boolean("Upstream success flag."),
+            data: s.object("Paginated search results.", {
+                total: s.integer("Total matching records."),
+                pageNum: s.integer("Current page number."),
+                pageSize: s.integer("Results per page."),
+                list: s.array("Matching records.", s.looseObject("An upstream record with its available metrics and links.")),
+            }, {
+                required: ["list"],
+                additionalProperties: true,
+            }),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("kolsprite_mcp", {
+        name: "shop_search",
+        operationType: "read",
+        description: "Search TikTok Shop stores by keyword, category, ratings, sales, and operating model.",
+        requiredScopes: [],
+        inputSchema: s.object("KOLSprite tool arguments.", {
+            keyword: s.string("Search keyword."),
+            search_type: s.withEnum(s.string("Search mode: N for nickname (creators) or ID (products and shops), K for keyword."), ["N", "K"]),
+            region: s.string("TikTok region code; defaults to US, or to market for ASIN analysis."),
+            category: s.array("One shop category ID returned by product_category_list.", s.string("One upstream identifier."), { maxItems: 1 }),
+            shop_type: s.string("Upstream seller type."),
+            service_type: s.string("Upstream operating model."),
+            price_from: s.number("Lower bound for price."),
+            price_to: s.number("Upper bound for price."),
+            rating_from: s.number("Lower bound for rating."),
+            rating_to: s.number("Upper bound for rating."),
+            products_from: s.integer("Lower bound for listed product count."),
+            products_to: s.integer("Upper bound for listed product count."),
+            sales_volume_from: s.integer("Lower bound for sales volume."),
+            sales_volume_to: s.integer("Upper bound for sales volume."),
+            sales_volume_lst30d_from: s.integer("Lower bound for sales volume in the last 30 days."),
+            sales_volume_lst30d_to: s.integer("Upper bound for sales volume in the last 30 days."),
+            sales_volume_gr30d_from: s.number("Lower bound for sales volume growth rate over 30 days."),
+            sales_volume_gr30d_to: s.number("Upper bound for sales volume growth rate over 30 days."),
+            influencer_from: s.integer("Lower bound for promoting creator count."),
+            influencer_to: s.integer("Upper bound for promoting creator count."),
+            videos_from: s.integer("Lower bound for video count."),
+            videos_to: s.integer("Upper bound for video count."),
+            order_field: s.string("Upstream sort field."),
+            order_type: s.withEnum(s.integer("Sort direction: 0 descending, 1 ascending."), [0, 1]),
+            page_num: s.integer("Page number, starting at 1. Page number multiplied by page size must not exceed 1000.", {
+                minimum: 1,
+                default: 1,
+            }),
+            page_size: s.integer("Results per page, from 1 to 100; defaults to 20.", {
+                minimum: 1,
+                maximum: 100,
+                default: 20,
+            }),
+        }, {
+            optional: [
+                "keyword",
+                "search_type",
+                "region",
+                "category",
+                "shop_type",
+                "service_type",
+                "price_from",
+                "price_to",
+                "rating_from",
+                "rating_to",
+                "products_from",
+                "products_to",
+                "sales_volume_from",
+                "sales_volume_to",
+                "sales_volume_lst30d_from",
+                "sales_volume_lst30d_to",
+                "sales_volume_gr30d_from",
+                "sales_volume_gr30d_to",
+                "influencer_from",
+                "influencer_to",
+                "videos_from",
+                "videos_to",
+                "order_field",
+                "order_type",
+                "page_num",
+                "page_size",
+            ],
+        }),
+        outputSchema: s.object("KOLSprite response with additional upstream fields preserved.", {
+            code: s.string("Upstream business status code."),
+            message: s.string("Upstream message."),
+            success: s.boolean("Upstream success flag."),
+            data: s.object("Paginated search results.", {
+                total: s.integer("Total matching records."),
+                pageNum: s.integer("Current page number."),
+                pageSize: s.integer("Results per page."),
+                list: s.array("Matching records.", s.looseObject("An upstream record with its available metrics and links.")),
+            }, {
+                required: ["list"],
+                additionalProperties: true,
+            }),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("kolsprite_mcp", {
+        name: "video_search",
+        operationType: "read",
+        description: "Search TikTok videos by keyword, IDs, engagement, sales, dates, and linked products or shops.",
+        requiredScopes: [],
+        inputSchema: s.object("KOLSprite tool arguments.", {
+            keyword: s.string("Search keyword."),
+            region: s.string("TikTok region code; defaults to US, or to market for ASIN analysis."),
+            video_ids: s.array("Up to 50 TikTok video IDs.", s.string("One upstream identifier."), {
+                maxItems: 50,
+            }),
+            video_type: s.string("Upstream video type."),
+            product: s.boolean("Whether the video promotes a product."),
+            product_id: s.string("TikTok Shop product ID."),
+            shop_id: s.string("TikTok Shop ID."),
+            product_category_list: s.array("One product category ID returned by product_category_list.", s.string("One upstream identifier."), { maxItems: 1 }),
+            play_cnt_from: s.integer("Lower bound for video views (average views for creator searches)."),
+            play_cnt_to: s.integer("Upper bound for video views (average views for creator searches)."),
+            like_cnt_from: s.integer("Lower bound for like count."),
+            like_cnt_to: s.integer("Upper bound for like count."),
+            interact_from: s.number("Lower bound for engagement rate."),
+            interact_to: s.number("Upper bound for engagement rate."),
+            price_from: s.number("Lower bound for price."),
+            price_to: s.number("Upper bound for price."),
+            sales_volume_from: s.integer("Lower bound for sales volume."),
+            sales_volume_to: s.integer("Upper bound for sales volume."),
+            sales_volume_lst30d_from: s.integer("Lower bound for sales volume in the last 30 days."),
+            sales_volume_lst30d_to: s.integer("Upper bound for sales volume in the last 30 days."),
+            sales_lst30d_from: s.number("Lower bound for sales revenue in the last 30 days."),
+            sales_lst30d_to: s.number("Upper bound for sales revenue in the last 30 days."),
+            seconds_from: s.integer("Lower bound for video duration in seconds."),
+            seconds_to: s.integer("Upper bound for video duration in seconds."),
+            pub_date_from: s.string("Lower bound for publication date (yyyy-mm-dd).", {
+                format: "date",
+            }),
+            pub_date_to: s.string("Upper bound for publication date (yyyy-mm-dd).", { format: "date" }),
+            order_field: s.string("Upstream sort field."),
+            order_type: s.withEnum(s.integer("Sort direction: 0 descending, 1 ascending."), [0, 1]),
+            page_num: s.integer("Page number, starting at 1. Page number multiplied by page size must not exceed 1000.", {
+                minimum: 1,
+                default: 1,
+            }),
+            page_size: s.integer("Results per page, from 1 to 100; defaults to 20.", {
+                minimum: 1,
+                maximum: 100,
+                default: 20,
+            }),
+        }, {
+            optional: [
+                "keyword",
+                "region",
+                "video_ids",
+                "video_type",
+                "product",
+                "product_id",
+                "shop_id",
+                "product_category_list",
+                "play_cnt_from",
+                "play_cnt_to",
+                "like_cnt_from",
+                "like_cnt_to",
+                "interact_from",
+                "interact_to",
+                "price_from",
+                "price_to",
+                "sales_volume_from",
+                "sales_volume_to",
+                "sales_volume_lst30d_from",
+                "sales_volume_lst30d_to",
+                "sales_lst30d_from",
+                "sales_lst30d_to",
+                "seconds_from",
+                "seconds_to",
+                "pub_date_from",
+                "pub_date_to",
+                "order_field",
+                "order_type",
+                "page_num",
+                "page_size",
+            ],
+        }),
+        outputSchema: s.object("KOLSprite response with additional upstream fields preserved.", {
+            code: s.string("Upstream business status code."),
+            message: s.string("Upstream message."),
+            success: s.boolean("Upstream success flag."),
+            data: s.object("Paginated search results.", {
+                total: s.integer("Total matching records."),
+                pageNum: s.integer("Current page number."),
+                pageSize: s.integer("Results per page."),
+                list: s.array("Matching records.", s.looseObject("An upstream record with its available metrics and links.")),
+            }, {
+                required: ["list"],
+                additionalProperties: true,
+            }),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("kolsprite_mcp", {
+        name: "creator_category_list",
+        operationType: "read",
+        description: "List creator categories and their values for creator_search.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("KOLSprite tool arguments.", {}),
+        outputSchema: s.object("KOLSprite response with additional upstream fields preserved.", {
+            code: s.string("Upstream business status code."),
+            message: s.string("Upstream message."),
+            success: s.boolean("Upstream success flag."),
+            data: s.array("Category records.", s.looseObject("An upstream category record.")),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("kolsprite_mcp", {
+        name: "product_category_list",
+        operationType: "read",
+        description: "List the product category tree used by product, shop, video, and creator searches.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("KOLSprite tool arguments.", {}),
+        outputSchema: s.object("KOLSprite response with additional upstream fields preserved.", {
+            code: s.string("Upstream business status code."),
+            message: s.string("Upstream message."),
+            success: s.boolean("Upstream success flag."),
+            data: s.array("Category records.", s.looseObject("An upstream category record.")),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("kolsprite_mcp", {
+        name: "caption_extract_url",
+        operationType: "read",
+        description: "Extract captions from a video URL through KOLSprite. Set is_southeast_asia for Southeast Asian videos.",
+        requiredScopes: [],
+        inputSchema: s.object("KOLSprite tool arguments.", {
+            url: s.nonEmptyString("Video URL for KOLSprite to fetch."),
+            is_southeast_asia: s.boolean({
+                description: "Whether the video is from Southeast Asia; defaults to false.",
+                default: false,
+            }),
+        }, { optional: ["is_southeast_asia"] }),
+        outputSchema: s.object("KOLSprite response with additional upstream fields preserved.", {
+            code: s.string("Upstream business status code."),
+            message: s.string("Upstream message."),
+            success: s.boolean("Upstream success flag."),
+            data: s.string("Caption text."),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+    defineProviderAction("kolsprite_mcp", {
+        name: "asin_analysis_video",
+        operationType: "read",
+        description: "Find TikTok video signals related to an Amazon ASIN and marketplace. Results do not establish Amazon sales attribution.",
+        requiredScopes: [],
+        inputSchema: s.object("KOLSprite tool arguments.", {
+            market: s.nonEmptyString("Amazon marketplace code, such as US or GB."),
+            asin: s.nonEmptyString("Amazon product ASIN."),
+            region: s.string("TikTok region code; defaults to US, or to market for ASIN analysis."),
+            page_num: s.integer("Page number, starting at 1. Page number multiplied by page size must not exceed 1000.", {
+                minimum: 1,
+                default: 1,
+            }),
+            page_size: s.integer("Results per page, from 1 to 100; defaults to 20.", {
+                minimum: 1,
+                maximum: 100,
+                default: 20,
+            }),
+        }, { optional: ["region", "page_num", "page_size"] }),
+        outputSchema: s.object("KOLSprite response with additional upstream fields preserved.", {
+            code: s.string("Upstream business status code."),
+            message: s.string("Upstream message."),
+            success: s.boolean("Upstream success flag."),
+            data: s.object("Paginated search results.", {
+                total: s.integer("Total matching records."),
+                pageNum: s.integer("Current page number."),
+                pageSize: s.integer("Results per page."),
+                list: s.array("Matching records.", s.looseObject("An upstream record with its available metrics and links.")),
+            }, {
+                required: ["list"],
+                additionalProperties: true,
+            }),
+        }, {
+            required: ["data"],
+            additionalProperties: true,
+        }),
+    }),
+];

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

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

package/src/providers/kolsprite_mcp/executors.js

@@ -0,0 +1,89 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { callMcpTool, listMcpTools } from "../mcp-tools.js";
+import { requiredResponseRecord, requiredInputString, providerInputError, providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { kolspriteMcpActions } from "./actions.js";
+const origin = "https://mcp.kolsprite.com";
+const endpoint = `${origin}/mcp`;
+function connectionInput(key, fetcher, signal) {
+    return {
+        endpoint,
+        signal,
+        service: "KOLSprite",
+        headers: { "secret-key": key },
+        fetcher,
+        redirect: "manual",
+        maxResponseBytes: 16 * 1024 * 1024,
+    };
+}
+function parseResponse(result) {
+    let body = requiredResponseRecord(result, "KOLSprite MCP");
+    if (Array.isArray(body.content)) {
+        const content = body.content;
+        const block = content.length === 1 ? optionalRecord(content[0]) : undefined;
+        const text = block?.type === "text" ? optionalString(block.text) : undefined;
+        if (text === undefined) {
+            throw providerResponseError("KOLSprite MCP returned an unsupported content response");
+        }
+        let decoded;
+        try {
+            decoded = JSON.parse(text);
+        }
+        catch {
+            throw providerResponseError("KOLSprite MCP returned invalid JSON");
+        }
+        body = requiredResponseRecord(decoded, "KOLSprite MCP");
+    }
+    const code = optionalString(body.code);
+    if (body.success === false || (code !== undefined && code !== "OK")) {
+        const message = optionalString(body.message) ?? "Tool request failed";
+        throw providerResponseError(`KOLSprite ${code ?? "error"}: ${message}`);
+    }
+    if (!("data" in body)) {
+        throw providerResponseError("KOLSprite MCP response is missing data");
+    }
+    return body;
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const args = values;
+    if (typeof args.page_num === "number" &&
+        typeof args.page_size === "number" &&
+        args.page_num * args.page_size > 1000) {
+        throw providerInputError("page_num multiplied by page_size must not exceed 1000");
+    }
+    const key = requiredInputString(apiKey, "MCP Key");
+    const result = await callMcpTool({
+        ...connectionInput(key, fetcher, context.signal),
+        toolName: actionName,
+        arguments: args,
+    });
+    return parseResponse(result);
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const key = requiredInputString(input.apiKey, "MCP Key");
+        const tools = await listMcpTools(connectionInput(key, fetcher, signal));
+        const hash = sha256Hex(key);
+        return {
+            profile: { accountId: `kolsprite-mcp:${hash}`, displayName: `KOLSprite MCP · ${hash.slice(-6)}` },
+            grantedScopes: [],
+            metadata: { mcpEndpoint: endpoint, discoveredToolCount: tools.length },
+        };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("kolsprite_mcp", Object.fromEntries(kolspriteMcpActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "kolsprite_mcp",
+    baseUrl: origin,
+    auth: { type: "api_key_header", name: "secret-key" },
+    redirect: "manual",
+    allowedEndpoint(value) {
+        return new URL(value, origin).href === endpoint;
+    },
+    customizeRequest({ url, headers }) {
+        if (url.href !== endpoint)
+            throw providerInputError("KOLSprite MCP proxy only supports /mcp without a query string");
+        headers.set("accept", "application/json, text/event-stream");
+    },
+});

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

@@ -44,4 +44,18 @@ export interface LinearMcpComment {
     updatedAt?: string;
     url?: string;
 }
+/**
+ * Typed fields lifted from one Linear MCP record that names a thing: a team, a
+ * project, a workflow state or a label. The list tools answer records of
+ * different shapes; only the id is required and the rest is best effort.
+ */
+export interface LinearMcpNamedRecord {
+    id: string;
+    name?: string;
+    key?: string;
+    type?: string;
+    color?: string;
+    url?: string;
+    state?: string;
+}
 export declare const linearMcpActions: ActionDefinition[];