@oomol-lab/open-connector 1.9.0 → 1.9.2

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

@@ -0,0 +1,167 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { bounds, fields, pagination, periodFields, productFilter, rankingFields, resultSchema } from "./schemas.js";
+const productPeriodFilter = s.object("Filter parameters.", { product_id: fields.product_id, ...periodFields }, { required: ["product_id"] });
+export const productActions = [
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_category_info",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read the product category tree. Use search_category_by_words to resolve category names.",
+        inputSchema: s.object("FastMoss request parameters.", {}),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_creator_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze the creators selling a product, including audience and sales contributions.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: productFilter, ...pagination }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_detail_info",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a product's price, shop, ratings, logistics and media.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: productFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_investment",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze a product's advertising spend, ROAS and paid-traffic trends.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: productPeriodFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_overview",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a product's sales channels, momentum and paid-versus-organic performance.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: productPeriodFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_rank_new_listed",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Rank recently listed products by sales performance in a completed period.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                category_id: fields.category_id,
+                ...rankingFields,
+                region: fields.region,
+                is_cross_border: fields.is_cross_border,
+                is_fully_managed: fields.is_fully_managed,
+            }, { required: ["date_type", "date_value"] }),
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_rank_top_selling",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Rank bestselling products in a market or category for a completed period.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                category_id: fields.category_id,
+                ...rankingFields,
+                region: fields.region,
+            }, { required: ["date_type", "date_value"] }),
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_review_list",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read one page of product reviews and buyer feedback.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                product_id: fields.product_id,
+                time_range_days: periodFields.time_range_days,
+            }, { required: ["product_id"] }),
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_sales_trend",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read daily product GMV and units sold for a selected period.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                product_id: fields.product_id,
+                time_range_days: periodFields.time_range_days,
+            }, { required: ["product_id", "time_range_days"] }),
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_search",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Find products by keyword, category, price, sales and fulfilment filters.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            keywords: fields.keywords,
+            ...pagination,
+            filter: s.object("Filter parameters.", {
+                category_path: fields.category_path,
+                product_id: fields.product_id,
+                region: fields.region,
+                shop_type: s.integer("Shop type: 1 local, 2 cross-border; deprecated."),
+                commission_rate_range: s.object("Commission rate range.", bounds, { required: [] }),
+                creator_count_range: s.object("Promoting creator count range.", bounds, { required: [] }),
+                day28_gmv_range: s.object("GMV range over the last 28 days.", bounds, { required: [] }),
+                day28_units_sold_range: s.object("Units sold range over the last 28 days.", bounds, { required: [] }),
+                day7_gmv_range: s.object("GMV range over the last 7 days.", bounds, { required: [] }),
+                day7_units_sold_range: s.object("Units sold range over the last 7 days.", bounds, { required: [] }),
+                floor_price_range: s.object("Minimum product price range.", bounds, { required: [] }),
+                total_gmv_range: s.object("Cumulative GMV range.", bounds, { required: [] }),
+                units_sold_range: s.object("Units sold range.", bounds, { required: [] }),
+                is_cross_border: fields.is_cross_border,
+                is_fully_managed: fields.is_fully_managed,
+                is_free_shipping: s.boolean("Whether shipping is free."),
+                is_local_warehouse: s.boolean("Whether fulfilment uses a local warehouse."),
+                is_new_listed: s.boolean("Whether the product was recently listed."),
+                is_sshop: s.boolean("Whether it is fully managed."),
+                is_top_selling: s.boolean("Whether the product is a bestseller."),
+            }, { required: [] }),
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_sku",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read product SKU sales and inventory shares.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                product_id: fields.product_id,
+                time_range_days: periodFields.time_range_days,
+            }, { required: ["product_id"] }),
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "product_video_list",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List videos promoting a product, optionally filtered by publish time and ad traffic.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                product_id: fields.product_id,
+                time_range_days: periodFields.time_range_days,
+                create_time_range: fields.create_time_range,
+                is_ad: fields.is_ad,
+            }, { required: ["product_id"] }),
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+];

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

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

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

@@ -0,0 +1,174 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { agencyFilter, fields, pagination, periodFields, rankingFields, resultSchema } from "./schemas.js";
+const querySchema = s.anyOf("Search query or queries.", [
+    s.string("Search query."),
+    s.array("Search queries.", s.string("One search query.")),
+]);
+export const researchActions = [
+    defineProviderAction("fastmoss_mcp", {
+        name: "agency_creator_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze creators associated with an MCN agency.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: agencyFilter, ...pagination }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "agency_product_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze an MCN agency's product performance.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: agencyFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "agency_product_list",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List an MCN agency's products by category and price.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                agency_id: fields.agency_id,
+                time_range_days: periodFields.time_range_days,
+                product_category_id: fields.product_category_id,
+                minimum_price: s.number("Minimum product price."),
+                maximum_price: s.number("Maximum product price."),
+            }, { required: ["agency_id"] }),
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "agency_profile_overview",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read an MCN agency's profile and performance overview.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: agencyFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "agency_rank_top",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Rank MCN agencies for a completed week or month.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", { ...rankingFields, region: fields.region }, { required: [] }),
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "agency_search",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search MCN agencies by name and region.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                region: fields.region,
+                search_keyword: s.string("Agency name or search keyword."),
+            }, { required: [] }),
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "agency_shop_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze shops associated with an MCN agency.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                agency_id: fields.agency_id,
+                product_category_id: fields.product_category_id,
+                time_range_days: periodFields.time_range_days,
+            }, { required: ["agency_id"] }),
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "market_category_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze a market category by region and period.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            analysis_type: s.string("Category analysis type."),
+            filter: s.object("Filter parameters.", { category_id: fields.category_id, ...rankingFields, region: fields.region }, { required: [] }),
+            lang: fields.lang,
+        }, { required: ["analysis_type", "filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "market_category_author_sales_matrix",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read the creator sales matrix for a market category.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                category_id: fields.category_id,
+                date_value: rankingFields.date_value,
+                region: fields.region,
+                sold_type: s.integer("Sales metric selector."),
+            }, { required: [] }),
+            lang: fields.lang,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "market_category_ranking",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Rank market categories by performance for a completed period.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                category_id: fields.category_id,
+                ...rankingFields,
+                region: fields.region,
+            }, { required: [] }),
+            lang: fields.lang,
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "credit_usage_summary",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read the connected account's FastMoss Credits usage.",
+        inputSchema: s.object("No input is required.", {}),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "fastmoss_detail_url_examples",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read FastMoss detail-page URL examples for research results.",
+        inputSchema: s.object("No input is required.", {}),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "search_category_by_words",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Resolve category names or keywords to FastMoss category IDs.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            query: querySchema,
+            max_total_results: s.integer("Maximum total results."),
+            top_k: s.integer("Number of matches per query."),
+        }, { required: ["query"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "search_fastmoss_documents",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search FastMoss documentation for metrics, filters and research guidance.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            query: querySchema,
+            source_file: s.string("Documentation source file filter."),
+            top_k: s.integer("Number of matches per query."),
+        }, { required: ["query"] }),
+        outputSchema: resultSchema,
+    }),
+];

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

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

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

@@ -0,0 +1,142 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { bounds, fields, pagination, periodFields, rankingFields, resultSchema, shopPeriodFilter } from "./schemas.js";
+export const shopActions = [
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_base_info",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a shop's profile and basic information.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: s.object("Filter parameters.", { seller_id: fields.seller_id }, { required: ["seller_id"] }) }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_creator_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze creators promoting a shop's products.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                seller_id: fields.seller_id,
+                time_range_days: periodFields.time_range_days,
+                author_product_type: s.integer("Selling mode: 1 video, 2 live."),
+                follower_count_range: fields.follower_count_range,
+                sold_count_range: s.object("Units sold range.", bounds, { required: [] }),
+            }, { required: ["seller_id"] }),
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_data_trends",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a shop's performance trends over a date range.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: shopPeriodFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_investment_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze a shop's advertising investment over a date range.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: shopPeriodFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_sale_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze a shop's sales over a date range.",
+        inputSchema: s.object("FastMoss request parameters.", { filter: shopPeriodFilter }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_live_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze live sessions associated with a shop.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                seller_id: fields.seller_id,
+                ...periodFields,
+                is_shop: s.integer("Live type: 0 all, 1 shop live, 2 affiliate live."),
+            }, { required: ["seller_id"] }),
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_product_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze a shop's products by category and listing age.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                seller_id: fields.seller_id,
+                ...periodFields,
+                category_id: fields.category_id,
+                listing_time_range_days: s.integer("Product listing age in days."),
+            }, { required: ["seller_id"] }),
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_rank_top_selling",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Rank shops by sales for a completed period.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                ...rankingFields,
+                category_id: fields.category_id,
+                is_cross_border: fields.is_cross_border,
+                region: fields.region,
+                shop_type: fields.shop_type,
+            }, { required: ["date_type", "date_value"] }),
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_search",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search shops by name, region, category and creator relationships.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                brand_name: s.string("Brand name."),
+                category_id: fields.category_id,
+                creator_range: s.object("Creator count range.", bounds, { required: [] }),
+                creator_uid: s.string("Creator UID."),
+                creator_unique_id: s.string("Creator handle."),
+                is_fully_managed: fields.is_fully_managed,
+                is_local: s.boolean("Whether the shop is local."),
+                rating_range: s.object("Shop rating range.", bounds, { required: [] }),
+                region: fields.region,
+                seller_id: fields.seller_id,
+                shop_name: s.string("Shop name."),
+            }, { required: [] }),
+            keywords: fields.keywords,
+            ...pagination,
+        }, { required: [] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction("fastmoss_mcp", {
+        name: "shop_video_analysis",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Analyze videos promoting a shop's products.",
+        inputSchema: s.object("FastMoss request parameters.", {
+            filter: s.object("Filter parameters.", {
+                seller_id: fields.seller_id,
+                ...periodFields,
+                is_ad: fields.is_ad,
+                publish_time_range_days: s.integer("Video publish age in days."),
+            }, { required: ["seller_id"] }),
+            ...pagination,
+        }, { required: ["filter"] }),
+        outputSchema: resultSchema,
+    }),
+];

package/src/providers/fastmoss_mcp/actions.js

@@ -1,18 +1,17 @@
 import { s } from "../../core/json-schema.js";
 import { defineProviderAction } from "../../core/provider-definition.js";
-import officialTools from "./official-tools.json" with { type: "json" };
-const resultSchema = s.object("The FastMoss 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 FastMoss account."),
-}, { optional: [] });
+import { contentActions } from "./actions-content.js";
+import { creatorActions } from "./actions-creator.js";
+import { productActions } from "./actions-product.js";
+import { researchActions } from "./actions-research.js";
+import { shopActions } from "./actions-shop.js";
+import { resultSchema } from "./schemas.js";
 export const fastmossMcpActions = [
-    ...officialTools.map((tool) => defineProviderAction("fastmoss_mcp", {
-        name: tool.name,
-        operationType: "read",
-        description: tool.description,
-        requiredScopes: [],
-        inputSchema: tool.inputSchema,
-        outputSchema: resultSchema,
-    })),
+    ...productActions,
+    ...creatorActions,
+    ...shopActions,
+    ...contentActions,
+    ...researchActions,
     defineProviderAction("fastmoss_mcp", {
         name: "list_tools",
         operationType: "read",

package/src/providers/fastmoss_mcp/schemas.d.ts

@@ -0,0 +1,51 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const resultSchema: JsonSchema;
+export declare const pagination: {
+    orderby: JsonSchema;
+    page: JsonSchema;
+    pagesize: JsonSchema;
+};
+export declare const dateFields: {
+    start_date: JsonSchema;
+    end_date: JsonSchema;
+};
+export declare const periodFields: {
+    start_date: JsonSchema;
+    end_date: JsonSchema;
+    time_range_days: JsonSchema;
+};
+export declare const rankingFields: {
+    date_type: JsonSchema;
+    date_value: JsonSchema;
+};
+export declare const bounds: {
+    min: JsonSchema;
+    max: JsonSchema;
+};
+export declare const fields: {
+    product_id: JsonSchema;
+    uid: JsonSchema;
+    seller_id: JsonSchema;
+    video_id: JsonSchema;
+    agency_id: JsonSchema;
+    room_id: JsonSchema;
+    region: JsonSchema;
+    category_id: JsonSchema;
+    product_category_id: JsonSchema;
+    creator_category_id: JsonSchema;
+    category_path: JsonSchema;
+    keywords: JsonSchema;
+    lang: JsonSchema;
+    shop_type: JsonSchema;
+    is_cross_border: JsonSchema;
+    is_fully_managed: JsonSchema;
+    is_ad: JsonSchema;
+    follower_count_range: JsonSchema;
+    create_time_range: JsonSchema;
+    play_count_range: JsonSchema;
+};
+export declare const productFilter: JsonSchema;
+export declare const creatorFilter: JsonSchema;
+export declare const shopPeriodFilter: JsonSchema;
+export declare const videoPeriodFilter: JsonSchema;
+export declare const agencyFilter: JsonSchema;

package/src/providers/fastmoss_mcp/schemas.js

@@ -0,0 +1,52 @@
+import { s } from "../../core/json-schema.js";
+export const resultSchema = s.object("The FastMoss 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 FastMoss account."),
+}, { required: ["result"] });
+export const pagination = {
+    orderby: s.array("Sort options.", s.unknown("An item accepted by the live FastMoss tool schema.")),
+    page: s.integer("Page number. Default 1, max 10.", { minimum: 1, maximum: 10 }),
+    pagesize: s.integer("Page size. Default 10, max 10.", { minimum: 1, maximum: 10 }),
+};
+export const dateFields = {
+    start_date: s.string("Start date, YYYY-MM-DD."),
+    end_date: s.string("End date, YYYY-MM-DD."),
+};
+export const periodFields = {
+    ...dateFields,
+    time_range_days: s.integer("Days: 7/14/28/90; recent=28; -1=cumulative."),
+};
+export const rankingFields = {
+    date_type: s.string("Ranking period: day, week, or month; MCN agency rankings support only week/month."),
+    date_value: s.string("Completed period only: yesterday YYYY-MM-DD, last week YYYY-ww or YYYY-Www, last month YYYY-MM; do not use the current period."),
+};
+export const bounds = {
+    min: s.number("Minimum value."),
+    max: s.number("Maximum value."),
+};
+export const fields = {
+    product_id: s.string("Product ID; use product_search first if only a product name is known."),
+    uid: s.string("Creator UID; use creator_search first if only a handle/nickname is known."),
+    seller_id: s.string("Shop seller_id; use shop_search first if only a shop name is known."),
+    video_id: s.string("Video ID; use video_search first if only a title/creator is known."),
+    agency_id: s.string("Unique MCN agency ID; use agency_search first when only the agency name is known."),
+    room_id: s.string("Live room ID."),
+    region: s.string("Country or region code, e.g. US, UK, ID."),
+    category_id: s.integer("Category ID; confirm category first if only a category name is known."),
+    product_category_id: s.integer("Product category ID."),
+    creator_category_id: s.integer("Creator category ID."),
+    category_path: s.array("Category path from level 1 to level 3, e.g. [100, 200, 300].", s.unknown("An item accepted by the live FastMoss tool schema.")),
+    keywords: s.string("Search keywords: product, shop, creator, video, live, or category terms."),
+    lang: s.string("Language. Default EN_US, optional ZH_CN."),
+    shop_type: s.integer("Shop type: 1 brand shop, 2 retail shop."),
+    is_cross_border: s.boolean("Whether it is cross-border."),
+    is_fully_managed: s.boolean("Whether it is fully managed."),
+    is_ad: s.boolean("Whether it uses ad traffic."),
+    follower_count_range: s.object("Follower count range.", bounds, { required: [] }),
+    create_time_range: s.object("Creation or publish time range in Unix timestamps.", bounds, { required: [] }),
+    play_count_range: s.object("Video play-count range.", bounds, { required: [] }),
+};
+export const productFilter = s.object("Filter parameters.", { product_id: fields.product_id }, { required: ["product_id"] });
+export const creatorFilter = s.object("Filter parameters.", { uid: fields.uid }, { required: ["uid"] });
+export const shopPeriodFilter = s.object("Filter parameters.", { seller_id: fields.seller_id, ...periodFields }, { required: ["seller_id"] });
+export const videoPeriodFilter = s.object("Filter parameters.", { video_id: fields.video_id, ...periodFields }, { required: ["video_id"] });
+export const agencyFilter = s.object("Filter parameters.", { agency_id: fields.agency_id, time_range_days: periodFields.time_range_days }, { required: ["agency_id"] });

package/src/providers/feishu_app_bot/trigger-on-event.js

@@ -1,10 +1,12 @@
 import { PermanentIntegrationError } from "../../triggers/common/integration.js";
 import { isJsonObject } from "../../triggers/common/json.js";
+import { feishuApplication } from "../../triggers/sources/feishu.js";
 import { additionalSnapshot0 } from "./trigger-on-event.definition.js";
 import { feishuSubscriptions, feishuResponse } from "./trigger-subscriptions.js";
 export const feishuEvents = [
     {
         eventSource: "feishu",
+        source: feishuApplication,
         resources: { subscriptions: (config) => feishuSubscriptions(config, "feishu_app_bot"), response: feishuResponse },
         snapshot: additionalSnapshot0,
         receive(context) {

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

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

package/src/providers/fireflies/executors.js

@@ -1,5 +1,6 @@
 import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { firefliesActionHandlers, firefliesGraphqlBaseUrl, validateFirefliesCredential } from "./runtime.js";
+import { firefliesMeetingReady } from "./trigger-on-meeting-ready.js";
 const service = "fireflies";
 export const executors = defineApiKeyProviderExecutors(service, firefliesActionHandlers);
 export const proxy = defineProviderProxy({
@@ -13,3 +14,4 @@ export const credentialValidators = {
         return validateFirefliesCredential(input.apiKey, fetcher, signal);
     },
 };
+export const triggers = [firefliesMeetingReady];