@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/crtsh/runtime.js

@@ -0,0 +1,84 @@
+import { looseArray, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { parseProviderJsonBodyText, providerInputError, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredInputString, runProviderRequest, setSearchParams, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const crtshApiBaseUrl = "https://crt.sh";
+const defaultLimit = 100;
+export const crtshActionHandlers = {
+    async search_certificates(input, context) {
+        const domain = domainQueryParam(input.domain);
+        const limit = optionalInteger(input.limit) ?? defaultLimit;
+        const payload = await requestCrtsh({ context, domain });
+        const records = looseArray(payload);
+        const certificates = [];
+        for (const item of records) {
+            const record = optionalRecord(item);
+            if (!record)
+                continue;
+            certificates.push(normalizeCertificate(record));
+            if (certificates.length >= limit)
+                break;
+        }
+        return {
+            certificates,
+            returned: certificates.length,
+            total_matches: records.length,
+        };
+    },
+};
+/**
+ * crt.sh treats `q` as a SQL LIKE pattern where % is the wildcard. Keep the
+ * charset tight so a model-supplied URL or junk never reaches the query string.
+ */
+function domainQueryParam(value) {
+    const domain = requiredInputString(value, "domain").trim();
+    if (!/^[A-Za-z0-9%][A-Za-z0-9.\-_%]*$/.test(domain)) {
+        throw providerInputError("domain must be a domain such as example.com, optionally with % wildcards like %.example.com.");
+    }
+    return domain;
+}
+async function requestCrtsh(request) {
+    const url = new URL(crtshApiBaseUrl);
+    // Explicit ILIKE: crt.sh defaults hyphenated queries to "Single" matching,
+    // which disables % wildcards (see certwatch_db web_apis.fnc).
+    setSearchParams(url, { q: request.domain, output: "json", match: "ILIKE" });
+    return runProviderRequest({ label: "crt.sh", signal: request.context.signal }, async (signal) => {
+        const response = await request.context.fetcher(url, {
+            headers: {
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        if (!response.ok) {
+            throw await readCrtshError(response);
+        }
+        return parseProviderJsonBodyText(await readProviderTextBody(response, "crt.sh response"), {
+            emptyBody: [],
+            invalidJsonMessage: "crt.sh returned malformed JSON",
+        });
+    });
+}
+function normalizeCertificate(record) {
+    return {
+        ...record,
+        id: optionalInteger(record.id) ?? 0,
+        issuer_ca_id: optionalInteger(record.issuer_ca_id) ?? 0,
+        issuer_name: optionalString(record.issuer_name) ?? "",
+        common_name: optionalString(record.common_name) ?? "",
+        name_value: optionalString(record.name_value) ?? "",
+        not_before: optionalString(record.not_before) ?? "",
+        not_after: optionalString(record.not_after) ?? "",
+        serial_number: optionalString(record.serial_number) ?? "",
+    };
+}
+/**
+ * Map a crt.sh error onto the runtime's status conventions. crt.sh serves HTML
+ * error pages when overloaded, so surface a short excerpt instead of the page.
+ * The search endpoint needs no credentials, so an authorization failure is not
+ * something reconnecting can fix.
+ */
+export async function readCrtshError(response) {
+    const text = (await readProviderErrorTextBody(response, "crt.sh error response")).trim();
+    const message = text.slice(0, 200) || `crt.sh request failed with HTTP ${response.status}`;
+    const status = response.status;
+    return new ProviderRequestError(status, message, withRetryAfterSeconds(response, {}), status === 429 ? "rate_limited" : "provider_error");
+}

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

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

package/src/providers/eastmoney_miaoxiang/actions.js

@@ -0,0 +1,95 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const service = "eastmoney_miaoxiang";
+function responseSchema(data) {
+    return {
+        ...s.looseObject("The original Miaoxiang response, including provider-defined fields.", {
+            status: s.integer("The global API status; zero indicates success."),
+            message: s.string("The provider's response message."),
+            data: s.nullable(data),
+        }),
+        required: ["status"],
+    };
+}
+export const eastmoneyMiaoxiangActions = [
+    defineProviderAction(service, {
+        name: "query_financial_data",
+        description: "Query Eastmoney Miaoxiang market, financial, company and relationship data using natural language. Specify securities, indicators and a bounded date range to keep results manageable.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Financial data query parameters.", {
+            toolQuery: s.nonEmptyString("A natural-language question specifying securities, indicators and dates.", {}),
+        }),
+        outputSchema: responseSchema(s.looseObject("Financial data and query metadata.", {
+            questionId: s.string("The unique identifier for this query."),
+            dataTableDTOList: s.array("Standardized indicator tables.", s.looseObject("One security indicator table.", {
+                code: s.string("The security code including its market suffix."),
+                entityName: s.string("The security name."),
+                title: s.string("The indicator table title."),
+                table: s.looseObject("Indicator values keyed by indicator code, with time or dimension values under headName."),
+                nameMap: s.looseObject("Mappings from indicator codes to display names."),
+                indicatorOrder: s.array("The display order of indicator columns.", s.string("An indicator code.")),
+            })),
+            rawDataTableDTOList: s.array("Original unprocessed indicator tables.", s.looseObject("An original indicator table.")),
+            condition: s.looseObject("The interpreted query conditions."),
+            entityTagDTOList: s.array("Distinct security entities involved in the query.", s.looseObject("A security entity and its attributes.")),
+        })),
+    }),
+    defineProviderAction(service, {
+        name: "search_news",
+        description: "Search Eastmoney Miaoxiang financial news, announcements, research reports and policies using a natural-language question.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Financial news search parameters.", {
+            query: s.nonEmptyString("The financial topic, security, event or date range to search.", {}),
+        }),
+        outputSchema: responseSchema(s.looseObject("The search response, preserving source metadata and provider-defined content.", {
+            data: s.looseObject("Search results and interpreted query metadata.", {
+                llmSearchResponse: s.looseObject("The financial search result payload.", {
+                    data: s.array("Relevant financial information items.", s.looseObject("One news, announcement or research result.", {
+                        title: s.string("The information title."),
+                        content: s.string("The information content."),
+                        date: s.string("The source publication date."),
+                        insName: s.string("The publishing institution."),
+                        informationType: s.string("The provider's information category."),
+                    })),
+                }),
+            }),
+        })),
+    }),
+    defineProviderAction(service, {
+        name: "screen_stocks",
+        description: "Screen securities by natural-language market or financial conditions, or find sector and index constituents. Preserve the same keyword while paging; result formats depend on the interpreted query.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Stock screening parameters.", {
+            keyword: s.nonEmptyString("Natural-language screening conditions or a constituent query.", {}),
+            pageNo: s.integer("The page number, starting at one. Defaults to 1.", {
+                minimum: 1,
+                default: 1,
+            }),
+            pageSize: s.integer("The requested number of results per page. Defaults to 20.", {
+                minimum: 1,
+                default: 20,
+            }),
+        }, { optional: ["pageNo", "pageSize"] }),
+        outputSchema: responseSchema(s.looseObject("Screening business status and results.", {
+            code: s.string("The screening business status; 100 indicates successful parsing."),
+            msg: s.string("The screening business message."),
+            data: s.looseObject("Screening results, conditions and provider-specific result variants.", {
+                resultType: s.integer("The result format; 2000 denotes standard stock screening."),
+                result: s.looseObject("A standard screening result table.", {
+                    total: s.integer("The total number of matches."),
+                    totalRecordCount: s.integer("The provider's total record count."),
+                    columns: s.array("Column definitions mapping display names to row keys.", s.looseObject("A column definition and its metadata.")),
+                    dataList: s.array("Rows matching the screening conditions.", s.looseObject("A security row keyed by the returned column definitions.")),
+                }),
+                allResults: s.looseObject("An alternative full-results wrapper returned by the provider."),
+                partialResults: s.string("A partial-result Markdown table when returned by the provider."),
+                parserText: s.string("The interpreted screening conditions."),
+                responseConditionList: s.array("Per-condition match statistics.", s.looseObject("One interpreted condition and its match count.")),
+                totalCondition: s.looseObject("Combined screening conditions and match count."),
+            }),
+        })),
+    }),
+];

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

@@ -0,0 +1,81 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { eastmoneyMiaoxiangActions } from "./actions.js";
+const baseUrl = "https://mkapi2.dfcfs.com/finskillshub";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const routes = {
+    query_financial_data: "/api/claw/query",
+    search_news: "/api/claw/news-search",
+    screen_stocks: "/api/claw/stock-screen",
+};
+const handlers = mapProviderActionHandlers("eastmoney_miaoxiang", eastmoneyMiaoxiangActions, (action) => async (dataInput, context) => {
+    const route = routes[action.name];
+    const body = { ...dataInput };
+    for (const key of ["query", "keyword", "toolQuery"])
+        if (typeof body[key] === "string")
+            body[key] = requiredInputString(body[key], key);
+    if (action.name === "screen_stocks") {
+        body.pageNo ??= 1;
+        body.pageSize ??= 20;
+    }
+    const apiKey = requiredInputString(context.apiKey, "API Key");
+    return runProviderRequest({ signal: context.signal, label: "Eastmoney Miaoxiang" }, async (signal) => {
+        const response = await context.fetcher(`${baseUrl}${route}`, {
+            method: "POST",
+            headers: { ...defaultHeaders, apikey: apiKey },
+            body: JSON.stringify(body),
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const envelope = optionalRecord(payload);
+        if (!response.ok || !envelope || envelope.status !== 0 || envelope.success === false) {
+            const detail = optionalRawString(envelope?.message) || "Invalid or unsuccessful response";
+            const code = envelope?.status == null ? "unknown" : String(envelope.status);
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Eastmoney Miaoxiang request failed (HTTP ${response.status}, status ${code}): ${detail}`
+                .split(apiKey)
+                .join("[REDACTED]"), undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        if (action.name === "screen_stocks") {
+            const data = optionalRecord(envelope.data);
+            if (data?.code != null && String(data.code) !== "100") {
+                const detail = optionalRawString(data.msg) || "Screening query could not be parsed";
+                throw new ProviderRequestError(502, `Eastmoney Miaoxiang screening failed (${String(data.code)}): ${detail}`.split(apiKey).join("[REDACTED]"), undefined, "provider_error");
+            }
+        }
+        return envelope;
+    });
+});
+export const executors = defineApiKeyProviderExecutors("eastmoney_miaoxiang", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input) {
+        requiredInputString(input.apiKey, "API Key");
+        return {
+            profile: { displayName: "Eastmoney Miaoxiang Skills API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationMode: "local_non_empty_key" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "eastmoney_miaoxiang",
+    baseUrl,
+    auth: { type: "api_key_header", name: "apikey" },
+    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/fastmoss_mcp/actions-content.d.ts

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

package/src/providers/fastmoss_mcp/actions-content.js

@@ -0,0 +1,140 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { bounds, dateFields, fields, pagination, resultSchema, videoPeriodFilter } from "./schemas.js";
+export const contentActions = [
+    defineProviderAction("fastmoss_mcp", {
+        name: "ad_data_overview",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a video's advertising spend, ROAS and engagement over a date range.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: videoPeriodFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "ad_search",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search advertisements by category, spend, ROAS and activity dates.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                ad_type: s.integer("Ad type: 1 TikTok Shop commerce ad, 2 non-commerce/planting ad."),
+                category_l1_id: s.integer("Level 1 category ID."),
+                category_l2_id: s.integer("Level 2 category ID."),
+                category_l3_id: s.integer("Level 3 category ID."),
+                estimated_ad_spend_range: s.object("Estimated advertising spend range.", bounds, { required: [] }),
+                keywords: fields.keywords,
+                last_seen_ad_date_range: s.object("Last observed advertising date range.", dateFields, { required: [] }),
+                observed_active_days_range: s.object("Observed active-day count range.", bounds, { required: [] }),
+                play_count_range: fields.play_count_range,
+                region: fields.region,
+                roas_range: s.object("Return on advertising spend range.", bounds, { required: [] }),
+                video_create_date_range: s.object("Video creation date range.", dateFields, { required: [] }),
+            }, { required: [] }),
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "live_detail_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze a live session's audience and commerce performance.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", { room_id: fields.room_id }, { required: ["room_id"] }),
+            lang: fields.lang,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "live_products_list",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List products promoted in a live session.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                room_id: fields.room_id,
+                category_id: fields.category_id,
+                seller_id: fields.seller_id,
+            }, { required: ["room_id"] }),
+            lang: fields.lang,
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "live_search",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search live sessions by start time, audience and commerce performance.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                creator_category: s.integer("Creator category ID."),
+                follower_range: s.object("Follower count range.", bounds, { required: [] }),
+                live_type: s.integer("Live type: 1 shop live, 2 creator live."),
+                product_category: s.integer("Product category ID."),
+                region: fields.region,
+                room_id: fields.room_id,
+                sold_range: s.object("Units sold range.", bounds, { required: [] }),
+                start_time: s.integer("Live-session start time."),
+                viewer_range: s.object("Viewer count range.", bounds, { required: [] }),
+            }, { required: ["start_time"] }),
+            keywords: fields.keywords,
+            lang: fields.lang,
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "video_data_trends",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a video's performance trends over a date range.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: videoPeriodFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "video_detail_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze a video's engagement and commerce performance.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", { video_id: fields.video_id }, { required: ["video_id"] }),
+            lang: fields.lang,
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "video_script_info",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read the script or transcript of a video.",
+        inputSchema: s.object("FastMoss request parameters.", { video_id: fields.video_id }, { required: ["video_id"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "video_search",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search videos by creation time, creator, engagement and commerce activity.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                create_time_range: fields.create_time_range,
+                creator_category_id: fields.creator_category_id,
+                creator_uid: s.integer("Creator UID."),
+                creator_unique_id: s.string("Creator handle."),
+                digg_count_range: s.object("Like count range.", bounds, { required: [] }),
+                follower_count_range: fields.follower_count_range,
+                interact_rate_range: s.object("Engagement rate range.", bounds, { required: [] }),
+                is_ecommerce: s.boolean("Whether the video promotes products."),
+                play_count_range: fields.play_count_range,
+                product_category_id: fields.product_category_id,
+                region: fields.region,
+            }, { required: ["create_time_range"] }),
+            keywords: fields.keywords,
+            lang: fields.lang,
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+];

package/src/providers/fastmoss_mcp/actions-creator.d.ts

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

package/src/providers/fastmoss_mcp/actions-creator.js

@@ -0,0 +1,154 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { bounds, creatorFilter, dateFields, fields, pagination, periodFields, rankingFields, resultSchema, } from "./schemas.js";
+export const creatorActions = [
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_cargo_summary",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a creator's commerce performance summary.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: creatorFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_data_trends",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a creator's metric trends over a date range.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                uid: fields.uid,
+                ...dateFields,
+                date_type: s.integer("Date period selector."),
+                field_type: s.string("Metric: follower_change/play/like/comment/collect_count/share/units_sold/gmv; video_*=video commerce, live_*=live commerce, showcase_*=showcase commerce."),
+            }, { required: ["field_type", "uid"] }),
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_fans_distribution",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a creator's audience demographics and distribution.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: creatorFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_product_list",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List products promoted by a creator and their sales performance.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                uid: fields.uid,
+                time_range_days: s.string("Days: 7/14/28/90; recent=28; -1=cumulative."),
+            }, { required: ["uid"] }),
+            ...pagination,
+            orderby: s.array("Sort options. Only the first sort rule takes effect. Fields: units_sold, gmv, commission_rate_percent.", s.unknown("An item accepted by the live FastMoss tool schema.")),
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_profile_overview",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a creator's profile and account overview.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: s.object("Filter parameters.", { uid: fields.uid, lang: fields.lang }, { required: ["uid"] }) }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_rank_top_ecommerce",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Rank commerce creators for a completed period.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                ...rankingFields,
+                region: fields.region,
+                creator_category_id: fields.creator_category_id,
+                product_category_id: fields.product_category_id,
+                account_type: s.integer("Account type filter."),
+                ecommerce_type: s.integer("Commerce type filter."),
+            }, { required: ["date_type", "date_value"] }),
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_rank_top_growth",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Rank creators by growth for a completed period.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                ...rankingFields,
+                region: fields.region,
+                category_id: fields.category_id,
+                verify_type: s.integer("Verification type: 1 regular creators, 2 Blue V creators."),
+            }, { required: ["date_type", "date_value"] }),
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_rank_top_potential",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Rank promising creators by category and audience for a completed period.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                ...rankingFields,
+                category_path: fields.category_path,
+                creator_category_id: fields.creator_category_id,
+                region: fields.region,
+                ecommerce_type: s.integer("Commerce type filter."),
+                follower_age_type: s.looseObject("Audience age filter accepted by FastMoss."),
+                follower_count_range: fields.follower_count_range,
+                follower_gender_type: s.integer("Audience gender filter."),
+            }, { required: ["date_type", "date_value"] }),
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_search",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search creators by identity, category, audience and commerce activity.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                category_id: fields.category_id,
+                creator_type: s.integer("Creator type: 1 personal, 2 shop."),
+                follower_age_type: s.integer("Follower age: 1=18-24, 2=25-34, 3=35+."),
+                follower_gender_type: s.integer("Audience gender filter."),
+                follower_range: s.object("Follower count range.", bounds, { required: [] }),
+                is_ecommerce_creator: s.boolean("Whether the creator participates in commerce."),
+                is_mcn_creator: s.boolean("Whether the creator belongs to an MCN agency."),
+                region: fields.region,
+                uid: fields.uid,
+                unique_id: s.string("Creator handle."),
+                verify_type: s.integer("Verification type: 1 regular creators, 2 Blue V creators."),
+            }, { required: [] }),
+            keywords: fields.keywords,
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "creator_video_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze a creator's videos over a date range.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                uid: fields.uid,
+                ...periodFields,
+                orderby: pagination.orderby,
+                page: s.integer("Page number. Default 1, max 10."),
+                pagesize: s.integer("Page size. Default 10, max 10."),
+                type: s.string("Video analysis type."),
+            }, { required: ["uid"] }),
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+];

package/src/providers/fastmoss_mcp/actions-product.d.ts

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