@relvo/mcp 0.1.2 → 0.1.3

package/dist/schema/platformCapabilityFamilies.js

@@ -0,0 +1,217 @@
+export const AUTO_CAPABILITY_VARIANTS = {
+    generate_video: ["generate_openrouter_video"],
+    generate_avatar_video: ["animate_kling_avatar", "generate_omnihuman_video"],
+    search_people: ["apollo_people_search", "anyapi_apollo_people_search", "anyapi_people_search_ai_ark", "anyapi_people_search_crustdata",
+        "anyapi_people_search_crustdata_v3", "anyapi_people_search_fullenrich", "anyapi_people_search_lusha", "anyapi_people_search_peopledatalabs",
+        "anyapi_people_search_prospeo", "anyapi_people_search_quickenrich", "pdl_people_search", "prospeo_people_search",
+        "firecrawl_fullenrich_people_search", "brightdata_business_people_search"],
+    search_organizations: ["apollo_company_search", "anyapi_apollo_organizations_search", "anyapi_company_search_ai_ark",
+        "anyapi_company_search_crustdata", "anyapi_company_search_crustdata_v3", "anyapi_company_search_fullenrich",
+        "anyapi_company_search_peopledatalabs", "anyapi_company_search_prospeo", "anyapi_company_search_quickenrich", "pdl_company_search",
+        "prospeo_company_search", "firecrawl_fullenrich_companies_search", "brightdata_business_company_search",
+        "predictleads_discover_companies", "predictleads_discover_extended_companies"],
+    find_companies: ["hunter_discover", "hunter_discover_people"],
+    enrich_organization: ["apollo_company_enrich", "apollo_companies_enrich", "anyapi_apollo_organization_enrich",
+        "anyapi_apollo_organizations_bulk_enrich", "anyapi_company_enrichment_crustdata", "anyapi_company_enrichment_crustdata_v3",
+        "anyapi_company_enrichment_lusha", "anyapi_company_enrichment_peopledatalabs", "anyapi_company_enrichment_prospeo", "pdl_company_enrich",
+        "pdl_companies_bulk_enrich", "prospeo_company_enrich", "prospeo_companies_enrich", "hunter_company_enrich", "findymail_company_enrich",
+        "firecrawl_datalegion_companies_enrich_base", "firecrawl_datalegion_companies_enrich_premium", "firecrawl_fullenrich_companies_lookup",
+        "predictleads_company", "predictleads_extended_company"],
+    get_organization_job_postings: ["apollo_company_jobs", "anyapi_apollo_organization_jobs"],
+    find_work_email: ["hunter_email_find", "findymail_email_find", "findymail_email_find_profile", "anyapi_email_find",
+        "anyapi_email_finding_dropleads", "anyapi_email_finding_icypeas", "anyapi_email_finding_quickenrich", "anyapi_email_finding_zerobounce",
+        "anyapi_linkedin_email", "anyapi_person_enrichment_bettercontact"],
+    find_company_emails: ["hunter_domain_search", "anyapi_email_finding_hunter_domain", "findymail_domain_contacts",
+        "anyapi_people_search_quickenrich_company"],
+    verify_email: ["hunter_email_verify", "debounce_email_verify", "findymail_email_verify", "anyapi_email_verify",
+        "anyapi_email_verification_allegrow", "anyapi_email_verification_bounceban", "anyapi_email_verification_icypeas",
+        "anyapi_email_verification_zerobounce"],
+    search_x_posts: ["anyapi_twitter_search", "tikhub_x_web_fetch_search_timeline"],
+    fetch_x_posts: ["tikhub_x_web_fetch_tweet_detail"],
+    fetch_x_posts_by_url: ["anyapi_twitter_tweet", "brightdata_twitter_posts_collect_by_url"],
+    get_x_post_comments: ["anyapi_twitter_replies", "tikhub_x_web_fetch_post_comments"],
+    get_x_profile: ["anyapi_twitter_profile", "tikhub_x_web_fetch_user_profile", "brightdata_twitter_profiles_collect_by_url"],
+    get_x_trends: ["anyapi_twitter_trends", "tikhub_x_web_fetch_trending"],
+    search_x_communities: ["anyapi_twitter_search_communities", "tikhub_x_web_fetch_search_communities"],
+    get_x_community_posts: ["anyapi_twitter_community_tweets", "tikhub_x_web_fetch_community_timeline"],
+    search_threads: ["anyapi_threads_search", "apify_threads_search", "tikhub_threads_web_search_posts", "tikhub_threads_web_search_top",
+        "tikhub_threads_web_search_recent"],
+    search_threads_profiles: ["anyapi_threads_search_users", "tikhub_threads_web_search_profiles"],
+    fetch_threads_post: ["anyapi_threads_post", "tikhub_threads_web_fetch_post_detail", "tikhub_threads_web_fetch_post_detail_v2",
+        "brightdata_threads_posts_collect_by_url"],
+    get_bluesky_profile: ["anyapi_bluesky_profile"],
+    get_instagram_profile: ["anyapi_instagram_profile", "anyapi_instagram_basic_profile", "tikhub_instagram_v1_fetch_user_info_by_username",
+        "tikhub_instagram_v1_fetch_user_info_by_username_v2", "tikhub_instagram_v1_fetch_user_info_by_username_v3",
+        "tikhub_instagram_v2_fetch_user_info", "tikhub_instagram_v3_get_user_profile", "apify_instagram_profile",
+        "brightdata_instagram_profiles_collect_by_url", "brightdata_instagram_profiles_discover_by_username", "searchapi_instagram_profile", "serpapi_instagram_profile",
+        "firecrawl_oriane_instagram_profile_lookup"],
+    search_instagram_posts: ["anyapi_instagram_user_posts", "tikhub_instagram_v1_fetch_user_posts", "tikhub_instagram_v1_fetch_user_posts_v2",
+        "tikhub_instagram_v2_fetch_user_posts", "tikhub_instagram_v3_get_user_posts", "apify_instagram_posts",
+        "brightdata_instagram_posts_discover_by_url"],
+    search_instagram_reels: ["anyapi_instagram_user_reels", "tikhub_instagram_v1_fetch_user_reels", "tikhub_instagram_v2_fetch_user_reels",
+        "tikhub_instagram_v3_get_user_reels", "apify_instagram_reels", "brightdata_instagram_reels_discover_by_url",
+        "brightdata_instagram_reels_discover_by_url_all_reels"],
+    search_instagram_by_keyword: ["anyapi_instagram_hashtag_recent_posts", "anyapi_instagram_hashtag_top_posts", "anyapi_instagram_search_hashtag",
+        "tikhub_instagram_v1_fetch_hashtag_posts", "tikhub_instagram_v2_fetch_hashtag_posts", "tikhub_instagram_v3_get_hashtag_posts",
+        "apify_instagram_hashtags"],
+    search_instagram_keyword: ["anyapi_instagram_search", "tikhub_instagram_v1_fetch_search", "tikhub_instagram_v2_search_users",
+        "tikhub_instagram_v2_search_hashtags", "tikhub_instagram_v3_search_users", "tikhub_instagram_v3_search_hashtags"],
+    search_instagram_phrase: ["tikhub_instagram_v2_general_search", "tikhub_instagram_v3_general_search"],
+    search_instagram_places: ["anyapi_instagram_search_locations", "tikhub_instagram_v2_search_locations",
+        "tikhub_instagram_v2_search_by_coordinates", "tikhub_instagram_v3_search_by_coordinates"],
+    search_instagram_audio: ["anyapi_instagram_audio_reels", "tikhub_instagram_v1_fetch_music_posts", "tikhub_instagram_v2_fetch_music_posts",
+        "tikhub_instagram_v3_get_music_posts", "tikhub_instagram_v2_search_music"],
+    get_instagram_post_comments: ["anyapi_instagram_post_comments", "tikhub_instagram_v1_fetch_post_comments_v2",
+        "tikhub_instagram_v2_fetch_post_comments", "tikhub_instagram_v3_get_post_comments", "brightdata_instagram_comments_collect_by_url",
+        "searchapi_instagram_comments"],
+    get_instagram_comment_replies: ["anyapi_instagram_comment_replies", "tikhub_instagram_v1_fetch_comment_replies",
+        "tikhub_instagram_v2_fetch_comment_replies", "tikhub_instagram_v3_get_comment_replies"],
+    get_instagram_stories: ["anyapi_instagram_stories_full", "anyapi_instagram_stories_thin", "tikhub_instagram_v2_fetch_user_stories",
+        "tikhub_instagram_v3_get_user_stories"],
+    get_instagram_highlights: ["anyapi_instagram_user_highlights", "tikhub_instagram_v2_fetch_user_highlights",
+        "tikhub_instagram_v3_get_user_highlights"],
+    get_instagram_tagged_posts: ["anyapi_instagram_tagged_posts", "tikhub_instagram_v1_fetch_user_tagged_posts",
+        "tikhub_instagram_v2_fetch_user_tagged_posts", "tikhub_instagram_v3_get_user_tagged_posts"],
+    get_instagram_former_usernames: ["tikhub_instagram_v3_get_user_former_usernames"],
+    get_instagram_account_network: ["anyapi_instagram_followers", "anyapi_instagram_following", "tikhub_instagram_v2_fetch_user_followers",
+        "tikhub_instagram_v2_fetch_user_following", "tikhub_instagram_v3_get_user_followers", "tikhub_instagram_v3_get_user_following"],
+    get_instagram_reposts: ["anyapi_instagram_user_reposts", "tikhub_instagram_v1_fetch_user_reposts"],
+    find_similar_instagram_accounts: ["anyapi_instagram_similar_profiles", "tikhub_instagram_v1_fetch_related_profiles",
+        "tikhub_instagram_v2_fetch_similar_users", "tikhub_instagram_v3_get_similar_users"],
+    scrape_facebook: ["anyapi_facebook_profile", "brightdata_facebook_pages_and_profiles_collect_by_url", "searchapi_facebook_business_page",
+        "serpapi_facebook_profile"],
+    scrape_facebook_posts: ["anyapi_facebook_profile_posts", "apify_facebook_posts", "brightdata_facebook_pages_posts_collect_by_url"],
+    search_facebook: ["anyapi_facebook_search_pages", "anyapi_facebook_page_lookup", "apify_facebook_search"],
+    search_facebook_posts: ["anyapi_facebook_search_posts", "apify_facebook_post_search"],
+    search_facebook_people: ["apify_facebook_people_search"],
+    fetch_facebook_post: ["anyapi_facebook_post", "brightdata_facebook_posts_collect_by_url"],
+    search_tiktok_posts: ["anyapi_tiktok_search_keyword", "anyapi_tiktok_search_top", "anyapi_tiktok_search_hashtag", "anyapi_tiktok_hashtag_videos",
+        "anyapi_tiktok_profile_videos", "tikhub_tiktok_app_v3_fetch_video_search_result", "tikhub_tiktok_web_fetch_search_video",
+        "tikhub_tiktok_app_v3_fetch_hashtag_video_list", "tikhub_tiktok_web_fetch_tag_post", "tikhub_tiktok_app_v3_fetch_user_post_videos",
+        "tikhub_tiktok_app_v3_fetch_user_post_videos_v2", "tikhub_tiktok_app_v3_fetch_user_post_videos_v3", "tikhub_tiktok_web_fetch_user_post",
+        "searchapi_tiktok_search", "searchapi_tiktok_profile_videos", "brightdata_tiktok_posts_discover_by_keyword",
+        "brightdata_tiktok_posts_discover_by_profile_url", "brightdata_tiktok_posts_by_profile_fast_api_collect_by_url",
+        "firecrawl_oriane_tiktok_posts_search", "apify_tiktok_scrape"],
+    get_tiktok_profile: ["anyapi_tiktok_profile", "tikhub_tiktok_web_fetch_user_profile", "tikhub_tiktok_app_v3_handler_user_profile",
+        "searchapi_tiktok_profile", "brightdata_tiktok_profiles_collect_by_url", "firecrawl_oriane_tiktok_profile_lookup"],
+    get_tiktok_comments: ["anyapi_tiktok_video_comments", "tiktok_comments", "tikhub_tiktok_web_fetch_post_comment",
+        "tikhub_tiktok_app_v3_fetch_video_comments", "searchapi_tiktok_comments", "brightdata_tiktok_comments_collect_by_url"],
+    get_tiktok_comment_replies: ["anyapi_tiktok_comment_replies", "tikhub_tiktok_web_fetch_post_comment_reply",
+        "tikhub_tiktok_app_v3_fetch_video_comment_replies"],
+    get_tiktok_video_metrics: ["tikhub_tiktok_analytics_fetch_video_metrics", "anyapi_tiktok_video", "tikhub_tiktok_app_v3_fetch_one_video",
+        "tikhub_tiktok_app_v3_fetch_one_video_v2", "tikhub_tiktok_app_v3_fetch_one_video_v3", "tikhub_tiktok_web_fetch_post_detail",
+        "tikhub_tiktok_web_fetch_post_detail_v2", "searchapi_tiktok_video", "brightdata_tiktok_posts_collect_by_url",
+        "firecrawl_oriane_tiktok_video_lookup"],
+    get_tiktok_video_transcript: ["anyapi_tiktok_video_transcript", "anyapi_tiktok_video_transcript_full", "searchapi_tiktok_transcripts",
+        "apify_tiktok_transcript"],
+    get_tiktok_sound_posts: ["anyapi_tiktok_song_videos", "tikhub_tiktok_app_v3_fetch_music_video_list"],
+    get_tiktok_sounds: ["tikhub_tiktok_app_v3_fetch_music_search_result", "tikhub_tiktok_app_v3_fetch_music_chart_list"],
+    get_tiktok_trends: ["apify_tiktok_trends", "anyapi_tiktok_trending_feed"],
+    get_tiktok_trending_hashtags: ["anyapi_tiktok_trending_hashtags", "tikhub_tiktok_ads_get_trends_hashtag_list"],
+    get_tiktok_hashtag_trend_detail: ["tikhub_tiktok_ads_get_trends_hashtag_detail"],
+    get_tiktok_search_insights: ["tikhub_tiktok_app_v3_fetch_creator_search_insights"],
+    get_tiktok_search_insight_detail: ["tikhub_tiktok_app_v3_fetch_creator_search_insights_detail"],
+    get_tiktok_comment_themes: ["tikhub_tiktok_analytics_fetch_comment_keywords"],
+    get_tiktok_video_article: ["tikhub_tiktok_web_fetch_post_ai_article"],
+    check_tiktok_video_authenticity: ["tikhub_tiktok_analytics_detect_fake_views"],
+    find_similar_tiktok_accounts: ["tikhub_tiktok_app_v3_fetch_similar_user_recommendations"],
+    search_tiktok_creators: ["anyapi_tiktok_search_users", "tikhub_tiktok_app_v3_fetch_user_search_result"],
+    get_tiktok_account_region: ["anyapi_tiktok_profile_region"],
+    get_tiktok_ad_detail: ["tikhub_tiktok_ads_get_ads_detail"],
+    search_tiktok_top_ads: ["anyapi_tiktok_top_ads_search", "tikhub_tiktok_ads_search_ads"],
+    search_tiktok_shop_products: ["anyapi_tiktok_shop_search", "tikhub_tiktok_shop_web_fetch_search_products_list",
+        "tikhub_tiktok_shop_web_fetch_search_products_list_v2", "brightdata_tiktok_shop_discover_by_keyword"],
+    get_tiktok_shop_product: ["anyapi_tiktok_shop_product", "tikhub_tiktok_shop_web_fetch_product_detail",
+        "tikhub_tiktok_shop_web_fetch_product_detail_v3"],
+    get_tiktok_shop_product_reviews: ["anyapi_tiktok_shop_product_reviews", "tikhub_tiktok_shop_web_fetch_product_reviews_v2"],
+    search_youtube: ["dataforseo_serp_youtube_organic_advanced", "anyapi_youtube_search", "tikhub_youtube_web_search_video", "tikhub_youtube_web_v2_get_general_search_v2",
+        "brightdata_youtube_videos_discover_by_keyword", "searchapi_youtube", "serpapi_youtube"],
+    search_youtube_channels: ["tikhub_youtube_web_search_channel", "tikhub_youtube_web_v2_search_channels",
+        "brightdata_youtube_channels_discover_by_keyword"],
+    search_youtube_shorts: ["anyapi_youtube_search_shorts", "tikhub_youtube_web_v2_get_shorts_search", "tikhub_youtube_web_v2_get_shorts_search_v2"],
+    get_youtube_video_info: ["dataforseo_serp_youtube_video_info_advanced", "anyapi_youtube_video", "tikhub_youtube_web_v2_get_video_info", "tikhub_youtube_web_v2_get_video_info_v2",
+        "brightdata_youtube_videos_collect_by_url", "searchapi_youtube_video", "serpapi_youtube_video"],
+    get_youtube_comments: ["dataforseo_serp_youtube_video_comments_advanced", "anyapi_youtube_video_comments", "tikhub_youtube_web_v2_get_video_comments", "searchapi_youtube_comments",
+        "brightdata_youtube_comments_collect_by_url"],
+    get_youtube_comment_replies: ["anyapi_youtube_comment_replies", "tikhub_youtube_web_v2_get_video_comment_replies",
+        "tikhub_youtube_web_v2_get_post_comment_replies"],
+    get_youtube_channel_about: ["tikhub_youtube_web_v2_get_channel_description", "tikhub_youtube_web_get_channel_info", "anyapi_youtube_channel",
+        "searchapi_youtube_channel", "serpapi_youtube_channel"],
+    get_youtube_channel_shorts: ["anyapi_youtube_channel_shorts", "tikhub_youtube_web_v2_get_channel_shorts",
+        "tikhub_youtube_web_get_channel_short_videos", "searchapi_youtube_channel_shorts"],
+    get_youtube_community_posts: ["anyapi_youtube_channel_community_posts", "tikhub_youtube_web_v2_get_channel_community_posts",
+        "searchapi_youtube_channel_posts"],
+    get_youtube_related_videos: ["tikhub_youtube_web_get_relate_video", "tikhub_youtube_web_v2_get_related_videos"],
+    get_youtube_transcript: ["dataforseo_serp_youtube_video_subtitles_advanced", "anyapi_youtube_video_transcript", "anyapi_youtube_video_transcript_full", "searchapi_youtube_transcripts",
+        "serpapi_youtube_video_transcript"],
+    get_youtube_trends: ["searchapi_youtube_trends"],
+    search_reddit: ["anyapi_reddit_search", "tikhub_reddit_app_fetch_dynamic_search", "brightdata_reddit_posts_discover_by_keyword",
+        "apify_reddit_scrape"],
+    fetch_reddit_post: ["anyapi_reddit_post", "tikhub_reddit_app_fetch_post_details", "brightdata_reddit_posts_collect_by_url"],
+    get_reddit_post_comments: ["anyapi_reddit_post_comments", "tikhub_reddit_app_fetch_post_comments", "brightdata_reddit_comments_collect_by_url"],
+    get_subreddit_posts: ["anyapi_reddit_subreddit_posts", "tikhub_reddit_app_fetch_subreddit_feed",
+        "brightdata_reddit_posts_discover_by_subreddit_url"],
+    get_subreddit_info: ["anyapi_reddit_subreddit_details", "tikhub_reddit_app_fetch_subreddit_info"],
+    get_reddit_popular_posts: ["tikhub_reddit_app_fetch_popular_feed", "anyapi_reddit_trending_posts"],
+    get_reddit_trending_searches: ["tikhub_reddit_app_fetch_trending_searches"],
+    get_reddit_user_profile: ["anyapi_reddit_profile", "tikhub_reddit_app_fetch_user_profile", "brightdata_reddit_profiles_1c7f260527ac"],
+    get_reddit_user_posts: ["anyapi_reddit_user_posts", "tikhub_reddit_app_fetch_user_posts"],
+    get_reddit_user_comments: ["anyapi_reddit_user_comments", "tikhub_reddit_app_fetch_user_comments"],
+    fetch_linkedin_post: ["anyapi_linkedin_post", "tikhub_linkedin_web_v2_get_post_detail", "brightdata_linkedin_posts_collect_by_url"],
+    get_linkedin_post_comments: ["anyapi_linkedin_post_comments", "tikhub_linkedin_web_v2_get_post_comments"],
+    get_linkedin_job_posting: ["anyapi_linkedin_job", "tikhub_linkedin_web_v2_get_job_detail", "searchapi_linkedin_job_details",
+        "brightdata_linkedin_jobs_collect_by_url"],
+    search_linkedin_job_postings: ["anyapi_linkedin_jobs", "anyapi_linkedin_jobs_thin", "tikhub_linkedin_web_v2_search_jobs",
+        "searchapi_linkedin_jobs", "brightdata_linkedin_jobs_discover_by_keyword"],
+    get_substack_post: ["firecrawl_substack_com_newsletters_post"],
+    list_substack_posts: ["firecrawl_substack_com_newsletters_archive", "anyapi_substack_posts"],
+    search_podcasts: ["firecrawl_particle_podcasts_search"],
+    search_podcast_episodes: ["firecrawl_particle_podcasts_episodes_search"],
+    get_podcast_show: ["firecrawl_particle_podcasts_show", "anyapi_spotify_podcast"],
+    get_podcast_episodes: ["firecrawl_particle_podcasts_show_episodes", "anyapi_spotify_podcast_episodes"],
+    web_search: ["search_web", "exa_search", "brave_web", "anyapi_brave_search", "crawl4ai_search"],
+    search_news: ["dataforseo_serp_google_news_advanced", "dataforseo_serp_google_news_html", "anyapi_google_news", "searchapi_google_news", "searchapi_google_news_light", "searchapi_bing_news", "brave_news",
+        "anyapi_hackernews_search", "serpapi_google_news", "serpapi_google_news_light", "serpapi_bing_news", "serpapi_duckduckgo_news", "serpapi_baidu_news"],
+    search_image: ["dataforseo_serp_google_images_advanced", "dataforseo_serp_google_images_html", "brave_images", "anyapi_google_images", "searchapi_google_images", "searchapi_google_images_light", "searchapi_bing_images",
+        "searchapi_duckduckgo_images", "serpapi_google_images", "serpapi_google_images_light", "serpapi_bing_images", "serpapi_yahoo_images", "serpapi_yandex_images"],
+    search_maps: ["dataforseo_serp_google_maps_advanced", "dataforseo_serp_google_local_finder_advanced", "dataforseo_serp_google_local_finder_html",
+        "dataforseo_business_business_listings_search", "anyapi_maps_search", "searchapi_google_maps", "firecrawl_firecrawl_maps_businesses_search", "serpapi_google_maps", "serpapi_google_local",
+        "serpapi_bing_maps", "serpapi_apple_maps", "serpapi_duckduckgo_maps", "serpapi_naver_maps"],
+    search_github: ["searchapi_github_search"],
+    serp_lookup: ["dataforseo_serp_google_organic_advanced", "dataforseo_serp_google_organic_regular", "dataforseo_serp_google_organic_html",
+        "dataforseo_serp_bing_organic_advanced", "dataforseo_serp_bing_organic_regular", "dataforseo_serp_bing_organic_html",
+        "dataforseo_serp_yahoo_organic_advanced", "dataforseo_serp_yahoo_organic_regular", "dataforseo_serp_yahoo_organic_html",
+        "dataforseo_serp_baidu_organic_advanced", "dataforseo_serp_baidu_organic_regular", "dataforseo_serp_baidu_organic_html",
+        "dataforseo_serp_naver_organic_advanced", "dataforseo_serp_naver_organic_regular", "dataforseo_serp_naver_organic_html",
+        "dataforseo_serp_seznam_organic_advanced", "dataforseo_serp_seznam_organic_regular", "dataforseo_serp_seznam_organic_html", "anyapi_google_search", "anyapi_google_search_100", "anyapi_bing_search", "searchapi_google", "searchapi_google_light",
+        "searchapi_google_rank_tracking", "searchapi_bing", "searchapi_naver", "serpapi_google", "serpapi_google_light", "serpapi_bing", "serpapi_naver", "crawl4ai_serp"],
+    google_ai_mode: ["dataforseo_serp_google_ai_mode_advanced", "dataforseo_serp_google_ai_mode_html", "anyapi_google_ai_mode", "searchapi_google_ai_mode", "serpapi_google_ai_mode"],
+    google_ai_overview: ["anyapi_google_ai_overview", "searchapi_google_ai_overview", "serpapi_google_ai_overview"],
+    google_trends: ["searchapi_google_trends_trending_now", "firecrawl_firecrawl_trends_trends_trending_now", "serpapi_google_trends_trending_now"],
+    google_trends_interest: ["dataforseo_keywords_google_trends_explore", "dataforseo_keywords_dataforseo_trends_explore", "anyapi_google_trends", "searchapi_google_trends", "firecrawl_firecrawl_trends_trends_interest_over_time", "serpapi_google_trends"],
+    seo_keyword_metrics: ["dataforseo_labs_google_keyword_overview", "dataforseo_keywords_google_ads_search_volume", "dataforseo_labs_google_bulk_keyword_difficulty"],
+    seo_domain_overview: ["dataforseo_labs_google_domain_rank_overview", "dataforseo_labs_google_bulk_traffic_estimation"],
+    seo_domain_keywords: ["dataforseo_labs_google_ranked_keywords", "dataforseo_labs_google_keywords_for_site"],
+    get_website_traffic: ["anyapi_similarweb_overview", "firecrawl_similarweb_web_traffic"],
+    search_meta_ads_library: ["anyapi_facebook_ads_search", "anyapi_facebook_company_ads", "searchapi_meta_ad_library",
+        "brightdata_meta_ad_library__fe525218deb2", "apify_facebook_ads"],
+    search_meta_ad_library_details: ["anyapi_facebook_ad_details", "anyapi_facebook_ad_details_full", "searchapi_meta_ad_library_ad_details"],
+    search_meta_ad_library_pages: ["anyapi_facebook_search_companies", "searchapi_meta_ad_library_page_search"],
+    search_google_ads_transparency: ["anyapi_google_ads_company_ads", "anyapi_google_ads_search", "searchapi_google_ads_transparency_center",
+        "serpapi_google_ads_transparency_center"],
+    search_google_ads_transparency_details: ["anyapi_google_ads_ad_details", "searchapi_google_ads_transparency_center_ad_details",
+        "serpapi_google_ads_transparency_center_ad_details"],
+    search_linkedin_ads_library: ["anyapi_linkedin_ads_search", "anyapi_linkedin_ad", "searchapi_linkedin_ad_library",
+        "searchapi_linkedin_ad_library_ad_details"],
+    search_tiktok_ads_library: ["anyapi_tiktok_ad_library_search", "searchapi_tiktok_ads_library"],
+    search_tiktok_ads_library_details: ["anyapi_tiktok_ad_library_ad", "searchapi_tiktok_ads_library_ad_details"],
+    search_mobile_apps: ["dataforseo_app_data_apple_app_searches_advanced", "dataforseo_app_data_google_app_searches_advanced", "dataforseo_app_data_google_app_searches_html",
+        "dataforseo_app_data_apple_app_listings_search", "dataforseo_app_data_google_app_listings_search", "anyapi_appstore_search", "anyapi_playstore_search", "searchapi_apple_app_store", "searchapi_google_play_store",
+        "firecrawl_apps_apple_com_apps_search", "firecrawl_play_google_com_media_app_search", "serpapi_apple_app_store", "serpapi_google_play"],
+    get_mobile_app: ["dataforseo_app_data_apple_app_info_advanced", "dataforseo_app_data_google_app_info_advanced", "dataforseo_app_data_google_app_info_html", "anyapi_appstore_app", "anyapi_playstore_app", "searchapi_google_play_product", "firecrawl_apps_apple_com_apps_app",
+        "firecrawl_play_google_com_media_app", "serpapi_google_play_product", "serpapi_apple_product"],
+    get_public_reviews: ["dataforseo_business_google_reviews", "dataforseo_business_google_extended_reviews", "dataforseo_business_trustpilot_reviews",
+        "dataforseo_business_tripadvisor_reviews", "anyapi_trustpilot_reviews", "anyapi_g2_reviews", "anyapi_maps_reviews", "brightdata_trustpilot_reviews_collect_by_url",
+        "brightdata_g2_reviews_collect_by_url", "brightdata_google_maps_reviews_collect_by_url", "searchapi_google_maps_reviews", "serpapi_google_maps_reviews",
+        "firecrawl_firecrawl_maps_businesses_reviews"],
+};

package/dist/schema/platformConnectionCatalog.js

@@ -1,20 +1,37 @@
 import { z } from "zod";
 import { TOOL_RESULT_CONTEXT_MAX_BYTES } from "./toolResultContext.js";
+import { platformConnectionPolicySchema } from "./platformConnectionPolicy.js";
+import { platformAppApiPathSchema } from "./platformHttpConstraints.js";
+export { platformOAuthScopeAlternativesSchema, platformOAuthPermissionSchema } from "./platformOAuth.js";
+export const PLATFORM_APP_ID_PATTERN = /^[a-z0-9][a-z0-9_]{0,63}$/;
+export const platformAppIdSchema = z.string().regex(PLATFORM_APP_ID_PATTERN);
+export const platformAppConnectionProviderSchema = z.templateLiteral(["app:", platformAppIdSchema]);
 export const platformConnectionProviderSchema = z.enum(["x", "gsc", "ga", "google", "github", "notion", "slack", "linear", "linkedin", "pinterest", "tiktok", "microsoftAds", "amazonAds"]);
+export const platformAnyConnectionProviderSchema = z.union([platformConnectionProviderSchema, platformAppConnectionProviderSchema]);
 export function platformConnectionOAuthProvider(provider) {
     return provider === "gsc" || provider === "ga" ? "google" : provider === "microsoftAds" ? "microsoft" : provider === "amazonAds" ? "amazon" : provider;
 }
-export const PLATFORM_CONNECTION_CATALOG_LIMITS = { maxRows: 20, responseBytes: 65_536, metadataBytes: 60_000, contextBytes: TOOL_RESULT_CONTEXT_MAX_BYTES };
+export const PLATFORM_CONNECTION_CATALOG_LIMITS = { maxRows: 20, responseBytes: 65_536, metadataBytes: 60_000, policyBytes: 8192, contextBytes: TOOL_RESULT_CONTEXT_MAX_BYTES };
 export const PLATFORM_CONNECTION_PAGE_MAX = PLATFORM_CONNECTION_CATALOG_LIMITS.maxRows;
 export const platformConnectionCatalogQuerySchema = z.object({
-    provider: platformConnectionProviderSchema.optional(),
+    provider: platformAnyConnectionProviderSchema.optional(),
     offset: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
     limit: z.number().int().min(1).max(PLATFORM_CONNECTION_PAGE_MAX).default(10),
 }).strict();
+export const platformConnectionAppSchema = z.object({ id: platformAppIdSchema, name: z.string(), docs: z.string(), baseUrl: z.string(),
+    baseUrls: z.array(z.string()).optional(),
+    apiPaths: z.array(platformAppApiPathSchema).optional(),
+    uploadUrls: z.array(z.object({ prefix: z.string(), credentials: z.boolean() })).optional(),
+    transport: z.literal("mcp").optional() });
 export const platformConnectionCatalogSchema = z.object({
     connections: z.array(z.object({
-        id: z.string(), provider: platformConnectionProviderSchema, label: z.string(),
+        id: z.string(), provider: platformAnyConnectionProviderSchema, label: z.string(),
         status: z.enum(["connected", "reauth_required"]), scopes: z.array(z.string()),
+        scopeSyncedAt: z.iso.datetime().nullable().default(null),
+        personal: z.boolean().optional(),
+        policy: platformConnectionPolicySchema.nullable().optional(),
+        policyRestricted: z.boolean().optional(),
+        app: platformConnectionAppSchema.optional(),
     })).max(PLATFORM_CONNECTION_PAGE_MAX),
     total: z.number().int().nonnegative(), nextOffset: z.number().int().nonnegative().nullable(),
 });

package/dist/schema/platformConnectionPolicy.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { ACCOUNT_REQUEST_HTTP_METHODS } from "./accountRequestMethods.js";
+export const PLATFORM_CONNECTION_POLICY_LIMITS = { rules: 64, subjects: 100, conditions: 16, pathChars: 2048, pointerChars: 256, valueChars: 2048, jsonChars: 12_000,
+    operations: 2_000, operationChars: 128, signInOperationsChars: 32_000 };
+const limits = PLATFORM_CONNECTION_POLICY_LIMITS;
+const ids = z.array(z.string().min(1).max(128)).min(1).max(limits.subjects);
+const condition = z.object({ pointer: z.string().startsWith("/").max(limits.pointerChars),
+    operator: z.enum(["equals", "prefix"]).default("equals"), value: z.union([z.string().max(limits.valueChars), z.number().finite(), z.boolean()]) }).strict()
+    .refine(value => value.operator !== "prefix" || typeof value.value === "string", "A prefix is a string");
+const common = { effect: z.enum(["allow", "deny"]).default("allow"), memberIds: ids.optional(), apiKeyIds: ids.optional(),
+    directoryGroupIds: ids.optional(),
+    conditions: z.array(condition).max(limits.conditions).default([]), approvalRequired: z.boolean().default(false) };
+const path = z.string().startsWith("/").max(limits.pathChars).refine(value => !/[?#\\\u0000-\u001f\u007f]/.test(value) && !value.includes("//") && !value.split("/").some(part => part === "." || part === ".."));
+export const platformConnectionPolicyRuleSchema = z.discriminatedUnion("kind", [
+    z.object({ ...common, kind: z.literal("http"), methods: z.array(z.enum(ACCOUNT_REQUEST_HTTP_METHODS)).min(1).max(ACCOUNT_REQUEST_HTTP_METHODS.length),
+        path, prefix: z.boolean().default(false), baseUrl: z.string().max(limits.pathChars).optional() }).strict(),
+    z.object({ ...common, kind: z.literal("mcp"), tool: z.string().min(1).max(256) }).strict(),
+    z.object({ ...common, kind: z.literal("database"), operations: z.array(z.enum(["schema", "query", "execute"])).min(1).max(3) }).strict(),
+    z.object({ ...common, kind: z.literal("operation"), action: z.string().min(1).max(128) }).strict(),
+]).refine(rule => rule.effect !== "deny" || !rule.approvalRequired, "A refusal cannot be approved");
+export const PLATFORM_CONNECTION_READ_OPERATIONS = "reads";
+const operationNames = z.array(z.string().min(1).max(limits.operationChars)).max(limits.operations);
+export const platformConnectionOperationsSchema = z.object({ allow: operationNames.optional(), deny: operationNames.default([]) }).strict();
+export const platformConnectionPolicySchema = z.object({ version: z.literal(1), defaultEffect: z.enum(["allow", "deny"]).default("deny"),
+    rules: z.array(platformConnectionPolicyRuleSchema).max(limits.rules), operations: platformConnectionOperationsSchema.optional() }).strict()
+    .refine(value => JSON.stringify({ ...value, operations: undefined }).length <= limits.jsonChars, "Policy is too large");

package/dist/schema/platformCustomTools.js

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { projectScopeSchema, platformJsonObjectSchema, PLATFORM_SANDBOX_LIMITS } from "./platformPublicExecution.js";
+import { PLATFORM_APP_HOST_PATTERN, PLATFORM_APP_RESERVED_HEADERS } from "./platformHttpConstraints.js";
+import { platformTeamSecretNameSchema } from "./platformTeamSecretName.js";
+export const PLATFORM_CUSTOM_TOOL_PREFIX = "custom__";
+export const PLATFORM_CUSTOM_TOOL_LIMITS = {
+    perProject: 100,
+    versions: 50,
+    titleChars: 80,
+    descriptionChars: 1_000,
+    codeChars: 40_000,
+    schemaBytes: 16_384,
+    inputBytes: 16_384,
+};
+export const PLATFORM_CUSTOM_ENDPOINT_LIMITS = { bindings: 5, baseUrlChars: 2_048, nameChars: 64, templateChars: 256, secretChars: 4_096 };
+export const platformCustomToolKindSchema = z.enum(["python", "http"]);
+export const platformCustomEndpointLocationSchema = z.enum(["header", "query"]);
+const HEADER_NAME = /^[A-Za-z0-9_-]{1,64}$/;
+const QUERY_NAME = /^[A-Za-z0-9_.$-]{1,64}$/;
+const FORBIDDEN_BINDING_HEADER = /^(?:keep-alive|trailer|proxy-.*|x-forwarded-.*|x-real-ip|set-cookie|accept-encoding|content-type|accept)$/i;
+const CONTROL = /[\u0000-\u001f\u007f]/;
+export const PLATFORM_CUSTOM_ENDPOINT_SECRET_PLACEHOLDER = "{secret}";
+export function isPlatformCustomEndpointBaseUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:" && !url.username && !url.password && !url.hash && !url.search && !value.includes("?") && !value.includes("#")
+            && PLATFORM_APP_HOST_PATTERN.test(url.host) && !/(?:^|\/)\.{1,2}(?:\/|$)/.test(url.pathname) && !/[\\\s]/.test(value) && !CONTROL.test(value);
+    }
+    catch {
+        return false;
+    }
+}
+export const platformCustomEndpointBaseUrlSchema = z.string().trim().min(1).max(PLATFORM_CUSTOM_ENDPOINT_LIMITS.baseUrlChars)
+    .refine(isPlatformCustomEndpointBaseUrl, "An https URL on a public host name, without credentials, a query or a fragment")
+    .describe("The API root, e.g. https://api.example.com or https://api.example.com/v1. Requests go to a path under it.");
+const bindingTemplateSchema = z.string().min(1).max(PLATFORM_CUSTOM_ENDPOINT_LIMITS.templateChars)
+    .refine(value => value.includes(PLATFORM_CUSTOM_ENDPOINT_SECRET_PLACEHOLDER) && value.replaceAll(PLATFORM_CUSTOM_ENDPOINT_SECRET_PLACEHOLDER, "").search(/[{}]/) === -1 && !CONTROL.test(value), "The template contains {secret} and no other braces or control characters");
+const bindingNameCheck = (binding) => binding.location === "header"
+    ? HEADER_NAME.test(binding.name) && !PLATFORM_APP_RESERVED_HEADERS.has(binding.name.toLowerCase()) && !FORBIDDEN_BINDING_HEADER.test(binding.name)
+    : QUERY_NAME.test(binding.name);
+const bindingLocation = platformCustomEndpointLocationSchema.describe("header or query: where Relvo puts the credential on every request.");
+const bindingName = z.string().min(1).max(PLATFORM_CUSTOM_ENDPOINT_LIMITS.nameChars).describe("The header or query parameter name, e.g. Authorization or api_key.");
+export const platformCustomEndpointBindingInputSchema = z.object({
+    id: z.string().regex(/^[a-z0-9]{8,32}$/).optional().describe("Only when editing: the id of a saved binding whose secret is kept when no new secret is sent."),
+    location: bindingLocation,
+    name: bindingName,
+    template: bindingTemplateSchema.default(PLATFORM_CUSTOM_ENDPOINT_SECRET_PLACEHOLDER).describe("The value sent, with {secret} where the secret goes, e.g. Bearer {secret}."),
+    secret: z.string().min(1).max(PLATFORM_CUSTOM_ENDPOINT_LIMITS.secretChars).refine(value => !CONTROL.test(value), "The secret has no control characters").optional()
+        .describe("The credential. Required for a new binding without secretRef; sent again only to replace it. Relvo never returns it."),
+    secretRef: platformTeamSecretNameSchema.optional().describe("The name of a saved team secret to use instead of an inline secret. Only the console may set it."),
+}).strict().refine(bindingNameCheck, "A valid header or query parameter name that is not reserved")
+    .refine(binding => binding.id !== undefined || binding.secret !== undefined || binding.secretRef !== undefined, "A new binding needs its secret")
+    .refine(binding => binding.secret === undefined || binding.secretRef === undefined, "A binding takes a secret or a secretRef, not both");
+export const platformCustomEndpointBindingSchema = z.object({ id: z.string(), location: bindingLocation, name: bindingName, template: bindingTemplateSchema,
+    maskedSecret: z.string().nullable(), secretRef: platformTeamSecretNameSchema.nullable().default(null) }).strict();
+export const platformCustomEndpointSchema = z.object({ baseUrl: platformCustomEndpointBaseUrlSchema,
+    bindings: z.array(platformCustomEndpointBindingSchema).min(1).max(PLATFORM_CUSTOM_ENDPOINT_LIMITS.bindings) }).strict();
+export const platformCustomToolSlugSchema = z.string().regex(/^[a-z][a-z0-9_]{1,39}$/)
+    .describe("Lowercase letters, digits and underscores, starting with a letter; the tool is named custom__<slug>.");
+export const PLATFORM_CUSTOM_TOOL_NAME = /^custom__[a-z][a-z0-9_]{1,39}$/;
+export const platformCustomToolNameSchema = z.string().regex(PLATFORM_CUSTOM_TOOL_NAME);
+export const isPlatformCustomToolName = (name) => PLATFORM_CUSTOM_TOOL_NAME.test(name);
+export const platformCustomToolInputSchemaSchema = platformJsonObjectSchema
+    .refine(schema => schema.type === "object" && schema.properties !== null && typeof schema.properties === "object" && !Array.isArray(schema.properties), "The input schema is an object schema with properties")
+    .refine(schema => new TextEncoder().encode(JSON.stringify(schema)).byteLength <= PLATFORM_CUSTOM_TOOL_LIMITS.schemaBytes, "The input schema is too large");
+export const platformCustomToolDefinitionSchema = z.object({
+    kind: z.literal("python").default("python"),
+    title: z.string().trim().min(1).max(PLATFORM_CUSTOM_TOOL_LIMITS.titleChars),
+    description: z.string().trim().min(1).max(PLATFORM_CUSTOM_TOOL_LIMITS.descriptionChars).describe("What the tool does and returns; agents choose tools by it."),
+    inputSchema: platformCustomToolInputSchemaSchema.describe("JSON Schema of the input object, e.g. {\"type\":\"object\",\"properties\":{\"days\":{\"type\":\"integer\"}},\"required\":[\"days\"]}."),
+    code: z.string().min(1).max(PLATFORM_CUSTOM_TOOL_LIMITS.codeChars)
+        .describe("Python. The validated input is the dict `input`; print the result (JSON is easiest to read back). Files of sourceExecutionIds are listed in /home/user/tool-results/manifest.json. No credentials are present."),
+    timeoutMs: z.number().int().min(1000).max(PLATFORM_SANDBOX_LIMITS.timeoutMs).default(30_000),
+    enabled: z.boolean().default(true),
+}).strict();
+const uniqueBindings = (bindings) => new Set(bindings.map(binding => `${binding.location}:${binding.name.toLowerCase()}`)).size === bindings.length;
+export const platformCustomEndpointDefinitionSchema = z.object({
+    kind: z.literal("http"),
+    title: z.string().trim().min(1).max(PLATFORM_CUSTOM_TOOL_LIMITS.titleChars),
+    description: z.string().trim().min(1).max(PLATFORM_CUSTOM_TOOL_LIMITS.descriptionChars).describe("What the API is and when to use it; agents choose tools by it."),
+    baseUrl: platformCustomEndpointBaseUrlSchema,
+    bindings: z.array(platformCustomEndpointBindingInputSchema).min(1).max(PLATFORM_CUSTOM_ENDPOINT_LIMITS.bindings).refine(uniqueBindings, "Each header or query parameter is bound once")
+        .describe("Credentials Relvo adds to every request, in the header or query parameter named. Agents never see them."),
+    enabled: z.boolean().default(true),
+}).strict();
+const slugged = { slug: platformCustomToolSlugSchema };
+const versioned = { expectedVersion: z.number().int().min(1) };
+export const platformCustomToolCreateSchema = z.union([platformCustomToolDefinitionSchema.extend(slugged).strict(), platformCustomEndpointDefinitionSchema.extend(slugged).strict()]);
+export const platformCustomToolUpdateSchema = z.union([platformCustomToolDefinitionSchema.extend(versioned).strict(), platformCustomEndpointDefinitionSchema.extend(versioned).strict()]);
+export const platformCustomToolRestoreSchema = z.object({ version: z.number().int().min(1), expectedVersion: z.number().int().min(1) }).strict();
+export const platformCustomToolSchema = z.object({
+    kind: platformCustomToolKindSchema.default("python"), endpoint: platformCustomEndpointSchema.nullable().default(null),
+    name: platformCustomToolNameSchema, slug: platformCustomToolSlugSchema, title: z.string(), description: z.string(), inputSchema: platformJsonObjectSchema,
+    code: z.string(), timeoutMs: z.number().int(), enabled: z.boolean(), version: z.number().int().min(1), createdAt: z.string(), updatedAt: z.string(),
+});
+export const platformCustomToolSummarySchema = platformCustomToolSchema.omit({ code: true, inputSchema: true });
+export const platformCustomToolVersionSchema = z.object({ version: z.number().int().min(1), title: z.string(), createdAt: z.string() });
+export const platformVersionAuthorSchema = z.object({ email: z.string().nullable(), apiKey: z.string().nullable() }).strict();
+export const platformCustomToolHistorySchema = platformCustomToolVersionSchema.extend({ author: platformVersionAuthorSchema });
+export const platformCustomToolVersionDetailSchema = platformCustomToolSchema.pick({ kind: true, endpoint: true, title: true, description: true, inputSchema: true, code: true, timeoutMs: true, enabled: true })
+    .extend({ version: z.number().int().min(1), createdAt: z.string(), author: platformVersionAuthorSchema });
+const toolInput = projectScopeSchema.extend({ name: platformCustomToolNameSchema });
+const toolResult = z.object({ tool: platformCustomToolSchema }).strict();
+export const platformCustomToolContracts = {
+    listDeveloperCustomTools: { input: projectScopeSchema.strict(), output: z.object({ tools: z.array(platformCustomToolSummarySchema) }).strict() },
+    getDeveloperCustomTool: { input: toolInput.strict(), output: toolResult },
+    createDeveloperCustomTool: { input: projectScopeSchema.extend({ tool: platformCustomToolCreateSchema }).strict(), output: toolResult },
+    updateDeveloperCustomTool: { input: toolInput.extend({ tool: platformCustomToolUpdateSchema }).strict(), output: toolResult },
+    restoreDeveloperCustomTool: { input: toolInput.merge(platformCustomToolRestoreSchema).strict(), output: toolResult },
+    deleteDeveloperCustomTool: { input: toolInput.strict(), output: z.object({ success: z.literal(true) }).strict() },
+    listDeveloperCustomToolVersions: { input: toolInput.strict(), output: z.object({ versions: z.array(platformCustomToolHistorySchema) }).strict() },
+    getDeveloperCustomToolVersion: { input: toolInput.extend({ version: z.number().int().min(1) }).strict(), output: z.object({ version: platformCustomToolVersionDetailSchema }).strict() },
+};

package/dist/schema/platformFunding.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { PLATFORM_CHECKOUT_MIN_CENTS } from "./platformBillingConstants.js";
+const micros = z.string().regex(/^\d{1,20}$/);
+export const platformFundingShortfallSchema = z.object({
+    reason: z.enum(["balance", "organization_monthly_limit", "project_monthly_limit", "organization_daily_limit", "api_key_daily_limit"]),
+    requiredMicros: micros,
+    availableMicros: micros,
+});
+export const PLATFORM_WALLET_TOP_UP_MIN_CENTS = PLATFORM_CHECKOUT_MIN_CENTS;

package/dist/schema/platformHttpConstraints.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { ACCOUNT_REQUEST_HTTP_METHODS } from "./accountRequestMethods.js";
+export const PLATFORM_APP_HOST_PATTERN = /^(?=[^:]{4,253}(?::|$))(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z][a-z0-9-]{0,61}[a-z0-9](?::[1-9][0-9]{0,4})?$/;
+export const PLATFORM_APP_RESERVED_HEADERS = new Set(["host", "cookie", "content-length", "transfer-encoding", "connection", "proxy-authorization", "forwarded", "te", "upgrade", "expect"]);
+export const platformAppApiPathSchema = z.object({ baseUrl: z.number().int().min(0).max(8), method: z.enum(ACCOUNT_REQUEST_HTTP_METHODS),
+    path: z.string().startsWith("/").max(2048).refine(path => !/[?#\\\s\u0000-\u001f]/.test(path) && !path.includes("//")
+        && path.split("/").every(segment => segment !== "." && segment !== ".." && (!/[{}]/.test(segment) || /^\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(segment)))) }).strict();

package/dist/schema/platformMcpTools.js

@@ -0,0 +1,7 @@
+export const PLATFORM_MCP_DIRECT_TOOLS_MAX = 20;
+export function platformMcpDirectToolNames(list) {
+    const names = [...new Set((list ?? "").split(",").map(name => name.trim()).filter(Boolean))];
+    if (names.length > PLATFORM_MCP_DIRECT_TOOLS_MAX || names.some(name => !/^[a-z][a-z0-9_]{1,63}$/u.test(name)))
+        throw new Error(`Name at most ${PLATFORM_MCP_DIRECT_TOOLS_MAX} catalog tools, separated by commas.`);
+    return names;
+}

package/dist/schema/platformMetaTools.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
-import { platformCatalogSchema, platformCreateExecutionSchema, platformExecutionIdSchema, platformExecutionStatusSchema, platformMicrosSchema, platformQuoteSchema, platformToolNameSchema, platformToolSessionIdSchema, platformOptionalToolSessionIdSchema, PLATFORM_SANDBOX_LIMITS, platformExecutionSchema, platformExecutionContextSchema, platformRequestIntentSchema } from "./platformPublicExecution.js";
-import { platformConnectionCatalogSchema, platformConnectionProviderSchema } from "./platformConnectionCatalog.js";
+import { platformCatalogSchema, platformCreateExecutionSchema, platformExecutionIdSchema, platformExecutionStatusSchema, platformMicrosSchema, platformQuoteSchema, platformToolNameSchema, platformToolSessionIdSchema, platformOptionalToolSessionIdSchema, PLATFORM_SANDBOX_LIMITS, platformExecutionSchema, platformExecutionContextSchema, platformRequestIntentSchema, validatePlatformArgumentIdentifiers } from "./platformPublicExecution.js";
+import { platformAnyConnectionProviderSchema, platformConnectionCatalogSchema } from "./platformConnectionCatalog.js";
 import { toolDiscoveryInputSchema, toolDiscoveryResultSchema } from "./toolDiscovery.js";
+export { PLATFORM_MCP_DIRECT_TOOLS_MAX, platformMcpDirectToolNames } from "./platformMcpTools.js";
 export const PLATFORM_META_LIMITS = { queries: 4, schemas: 12, batch: 50, concurrency: 4, contextBytes: 24_000,
     requestBytes: 1_048_576, requestTimeoutMs: 90_000, sessionLifetimeMs: 86_400_000, activeSessions: 100,
     codeChars: PLATFORM_SANDBOX_LIMITS.code, commandChars: 16_000, sourceExecutions: PLATFORM_SANDBOX_LIMITS.sourceExecutions, timeoutMs: PLATFORM_SANDBOX_LIMITS.timeoutMs };
@@ -21,15 +22,16 @@ export const platformMetaSchemasSchema = z.object({ ...sessionInput,
 export const platformMetaSchemasResultSchema = z.object({ session: platformToolSessionSchema,
     tools: platformCatalogSchema.shape.tools, remaining: z.array(platformToolNameSchema) });
 export const platformMetaConnectionsSchema = z.object({ ...sessionInput,
-    providers: z.array(platformConnectionProviderSchema).max(platformConnectionProviderSchema.options.length).default([])
-        .describe("OAuth providers to inspect. Empty means all supported providers. Data-provider API keys are managed by Relvo.") }).strict();
+    providers: z.array(platformAnyConnectionProviderSchema).max(32).default([])
+        .describe("Providers to inspect: OAuth providers or connected apps as app:<id> (e.g. app:airtable). Empty means every connection. Data-provider API keys are managed by Relvo.") }).strict();
 export const platformMetaConnectionsResultSchema = z.object({ session: platformToolSessionSchema,
     developerOrganizationId: z.string(), developerProjectId: z.string(),
     manageUrl: z.url(), connections: platformConnectionCatalogSchema.shape.connections,
-    total: z.number().int().nonnegative(), providers: z.array(z.object({ provider: platformConnectionProviderSchema,
+    total: z.number().int().nonnegative(), providers: z.array(z.object({ provider: platformAnyConnectionProviderSchema,
         status: z.enum(["connected", "reauth_required", "not_connected"]) })),
     instruction: z.string() });
-const item = platformCreateExecutionSchema.omit({ sessionId: true }).extend({ idempotencyKey: z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/) }).strict();
+const item = z.object(platformCreateExecutionSchema.shape).omit({ sessionId: true }).extend({ idempotencyKey: z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/) }).strict()
+    .superRefine((value, context) => validatePlatformArgumentIdentifiers(value.tool, value.arguments, context));
 export const platformMetaExecuteSchema = z.object({ ...sessionInput,
     maximumChargeMicros: platformMicrosSchema.describe("Accepted total reservation ceiling across this batch, in addition to each accepted quote."),
     tools: z.array(item).min(1).max(PLATFORM_META_LIMITS.batch)

package/dist/schema/platformMonitorSchedule.js

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import { isCronTooFrequent, isValidCron, parseCron } from "./cronValidator.js";
+import { ScheduleTimeZone } from "./scheduleTimeZone.js";
+export const PLATFORM_MONITOR_INTERVALS = { "15m": 900, "1h": 3600, "1d": 86_400 };
+export const platformMonitorIntervalSchema = z.enum(["15m", "1h", "1d"]);
+export const PLATFORM_MONITOR_DEFAULT_INTERVAL = "1h";
+export const PLATFORM_MONITOR_DEFAULT_TIME_ZONE = "UTC";
+export const PLATFORM_MONITOR_MIN_CRON_MINUTES = 15;
+export const PLATFORM_MONITOR_CRON_CHARS = 100;
+const cronText = z.string().trim().max(PLATFORM_MONITOR_CRON_CHARS)
+    .refine(isValidCron, "platform_monitor_cron_invalid")
+    .refine(cron => !isCronTooFrequent(cron, PLATFORM_MONITOR_MIN_CRON_MINUTES), "platform_monitor_cron_too_frequent");
+export const platformMonitorCronSchema = z.union([z.literal(""), cronText]);
+export const platformMonitorTimeZoneSchema = z.union([z.literal(""), ScheduleTimeZone]);
+export const normalizeMonitorCron = (cron) => cron.trim().split(/\s+/).map(field => field.toUpperCase()).join(" ");
+export class PlatformMonitorScheduleError extends Error {
+}
+export function resolvePlatformMonitorSchedule(input, after = Date.now()) {
+    if (!input.cron) {
+        if (input.timeZone)
+            throw new PlatformMonitorScheduleError("platform_monitor_time_zone_needs_cron");
+        return { interval: input.interval ?? PLATFORM_MONITOR_DEFAULT_INTERVAL };
+    }
+    if (input.interval)
+        throw new PlatformMonitorScheduleError("platform_monitor_schedule_conflict");
+    const zone = ScheduleTimeZone.safeParse(input.timeZone || PLATFORM_MONITOR_DEFAULT_TIME_ZONE);
+    if (!zone.success)
+        throw new PlatformMonitorScheduleError("platform_monitor_time_zone_invalid");
+    const cron = normalizeMonitorCron(input.cron), timeZone = zone.data;
+    if (nextCronFire(cron, timeZone, after) === null)
+        throw new PlatformMonitorScheduleError("platform_monitor_cron_never_runs");
+    return { cron, timeZone };
+}
+const MINUTE = 60_000, HOUR = 3_600_000, DAY = 86_400_000;
+const SEARCH_DAYS = 366 * 8;
+const formatters = new Map();
+function offsetAt(timeZone, at) {
+    let format = formatters.get(timeZone);
+    if (!format) {
+        format = new Intl.DateTimeFormat("en-US", { timeZone, hourCycle: "h23", year: "numeric", month: "numeric", day: "numeric", hour: "numeric", minute: "numeric", second: "numeric" });
+        formatters.set(timeZone, format);
+    }
+    const part = {};
+    for (const { type, value } of format.formatToParts(at))
+        if (type !== "literal")
+            part[type] = Number(value);
+    return Date.UTC(part.year, part.month - 1, part.day, part.hour, part.minute, part.second) - Math.floor(at / 1000) * 1000;
+}
+function instantOf(timeZone, wall) {
+    const before = offsetAt(timeZone, wall - DAY), after = offsetAt(timeZone, wall + DAY);
+    const candidates = [...new Set([wall - before, wall - after])].sort((a, b) => a - b);
+    const valid = candidates.filter(at => offsetAt(timeZone, at) === wall - at);
+    if (valid.length)
+        return valid[0];
+    let low = candidates[0], high = candidates[candidates.length - 1];
+    if (low === high)
+        return low;
+    const lowOffset = offsetAt(timeZone, low);
+    while (high - low > MINUTE) {
+        const mid = low + Math.floor((high - low) / (2 * MINUTE)) * MINUTE;
+        if (offsetAt(timeZone, mid) === lowOffset)
+            low = mid;
+        else
+            high = mid;
+    }
+    return high;
+}
+const dayMatches = (parsed, year, month, day) => {
+    if (!parsed.months.has(month))
+        return false;
+    const dom = parsed.daysOfMonth.has(day), dow = parsed.daysOfWeek.has(new Date(Date.UTC(year, month - 1, day)).getUTCDay());
+    return parsed.dayRestrictionOr ? dom || dow : dom && dow;
+};
+const ascending = (values) => [...values].sort((a, b) => a - b);
+export function nextCronFire(cron, timeZone, after) {
+    const parsed = parseCron(cron);
+    if (!parsed)
+        return null;
+    const hours = ascending(parsed.hours), minutes = ascending(parsed.minutes);
+    const wallAfter = after + offsetAt(timeZone, after);
+    const first = new Date(wallAfter);
+    const start = Date.UTC(first.getUTCFullYear(), first.getUTCMonth(), first.getUTCDate()) - DAY;
+    for (let index = 0; index < SEARCH_DAYS; index++) {
+        const dayStart = start + index * DAY, date = new Date(dayStart);
+        if (!dayMatches(parsed, date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate()))
+            continue;
+        for (const hour of hours)
+            for (const minute of minutes) {
+                const wall = dayStart + hour * HOUR + minute * MINUTE;
+                if (wall < wallAfter - 6 * HOUR)
+                    continue;
+                const at = instantOf(timeZone, wall);
+                if (at > after)
+                    return at;
+            }
+    }
+    return null;
+}
+export function upcomingCronFires(cron, timeZone, after, count) {
+    const fires = [];
+    for (let at = after; fires.length < count;) {
+        const next = nextCronFire(cron, timeZone, at);
+        if (next === null)
+            break;
+        fires.push(next);
+        at = next;
+    }
+    return fires;
+}
+export function monitorRunsPerMonth(schedule) {
+    if (!("cron" in schedule))
+        return Math.round((365 / 12) * 86_400 / PLATFORM_MONITOR_INTERVALS[schedule.interval]);
+    const parsed = parseCron(schedule.cron);
+    if (!parsed)
+        return 0;
+    let days = 0;
+    for (let index = 0; index < 365; index++) {
+        const date = new Date(Date.UTC(2026, 0, 1 + index));
+        if (dayMatches(parsed, date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate()))
+            days++;
+    }
+    return Math.round(days * parsed.hours.size * parsed.minutes.size / 12);
+}