@relvo/mcp 0.1.1 → 0.1.3

package/dist/schema/cronValidator.js

@@ -0,0 +1,150 @@
+const STRICT_CRON_RE = /^([\*0-9A-Za-z,\-\/]+)\s+([\*0-9A-Za-z,\-\/]+)\s+([\*0-9A-Za-z,\-\/]+)\s+([\*0-9A-Za-z,\-\/]+)\s+([\*0-9A-Za-z,\-\/]+)$/;
+export function isStrictCron5Field(cron) {
+    if (typeof cron !== "string")
+        return false;
+    return STRICT_CRON_RE.test(cron.trim());
+}
+const RANGES = {
+    minute: { min: 0, max: 59 },
+    hour: { min: 0, max: 23 },
+    dayOfMonth: { min: 1, max: 31 },
+    month: { min: 1, max: 12 },
+    dayOfWeek: { min: 0, max: 6 },
+};
+const MONTH_NAMES = {
+    JAN: 1, FEB: 2, MAR: 3, APR: 4, MAY: 5, JUN: 6,
+    JUL: 7, AUG: 8, SEP: 9, OCT: 10, NOV: 11, DEC: 12,
+};
+const DOW_NAMES = {
+    SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6,
+};
+function normalizeToken(token, names) {
+    if (!names)
+        return token;
+    const upper = token.trim().toUpperCase();
+    return upper in names ? String(names[upper]) : token;
+}
+function expandField(field, range, names) {
+    const out = new Set();
+    for (const part of field.split(",")) {
+        const stepMatch = part.match(/^(.+)\/(\d+)$/);
+        let base = part;
+        let step = 1;
+        if (stepMatch) {
+            base = stepMatch[1];
+            step = Number.parseInt(stepMatch[2], 10);
+            if (!Number.isFinite(step) || step <= 0)
+                return null;
+        }
+        let lo;
+        let hi;
+        if (base === "*") {
+            lo = range.min;
+            hi = range.openMax ?? range.max;
+        }
+        else if (base.includes("-")) {
+            const [a, b] = base.split("-");
+            lo = Number.parseInt(normalizeToken(a ?? "", names), 10);
+            hi = Number.parseInt(normalizeToken(b ?? "", names), 10);
+            if (!Number.isFinite(lo) || !Number.isFinite(hi))
+                return null;
+        }
+        else {
+            const v = Number.parseInt(normalizeToken(base, names), 10);
+            if (!Number.isFinite(v))
+                return null;
+            lo = v;
+            hi = stepMatch ? (range.openMax ?? range.max) : v;
+        }
+        if (lo < range.min || hi > range.max || lo > hi)
+            return null;
+        for (let i = lo; i <= hi; i += step)
+            out.add(i);
+    }
+    return out.size > 0 ? out : null;
+}
+export function parseCron(cron) {
+    if (!isStrictCron5Field(cron))
+        return null;
+    const [minute, hour, dom, month, dow] = cron.trim().split(/\s+/);
+    const minutes = expandField(minute, RANGES.minute);
+    const hours = expandField(hour, RANGES.hour);
+    const daysOfMonth = expandField(dom, RANGES.dayOfMonth);
+    const months = expandField(month, RANGES.month, MONTH_NAMES);
+    const dowRaw = expandField(dow, { min: RANGES.dayOfWeek.min, max: 7, openMax: RANGES.dayOfWeek.max }, DOW_NAMES);
+    const dowExpanded = dowRaw && new Set([...dowRaw].map((d) => (d === 7 ? 0 : d)));
+    if (!minutes || !hours || !daysOfMonth || !months || !dowExpanded)
+        return null;
+    return {
+        minutes,
+        hours,
+        daysOfMonth,
+        months,
+        daysOfWeek: dowExpanded,
+        dayRestrictionOr: dom !== "*" && dow !== "*",
+    };
+}
+export function isValidCron(cron) {
+    if (typeof cron !== "string")
+        return false;
+    return parseCron(cron) !== null;
+}
+export function isCronTooFrequent(cron, minIntervalMinutes) {
+    const fields = cron.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return true;
+    const minutes = expandField(fields[0], RANGES.minute);
+    const hours = expandField(fields[1], RANGES.hour);
+    if (!minutes || !hours)
+        return true;
+    const slots = [];
+    for (const h of hours) {
+        for (const m of minutes)
+            slots.push(h * 60 + m);
+    }
+    slots.sort((a, b) => a - b);
+    for (let i = 1; i < slots.length; i++) {
+        if (slots[i] - slots[i - 1] < minIntervalMinutes)
+            return true;
+    }
+    return slots[0] + 1440 - slots[slots.length - 1] < minIntervalMinutes;
+}
+function matches(parsed, d) {
+    if (!parsed.minutes.has(d.getMinutes()))
+        return false;
+    if (!parsed.hours.has(d.getHours()))
+        return false;
+    if (!parsed.months.has(d.getMonth() + 1))
+        return false;
+    const domMatch = parsed.daysOfMonth.has(d.getDate());
+    const dowMatch = parsed.daysOfWeek.has(d.getDay());
+    if (parsed.dayRestrictionOr)
+        return domMatch || dowMatch;
+    return domMatch && dowMatch;
+}
+export function findNextFires(cron, from, deadline, max = 30) {
+    const parsed = parseCron(cron);
+    if (!parsed)
+        return [];
+    if (!(deadline.getTime() > from.getTime()))
+        return [];
+    const fires = [];
+    const cursor = new Date(from.getTime());
+    cursor.setSeconds(0, 0);
+    cursor.setTime(cursor.getTime() + 60_000);
+    const HARD_CAP_MINUTES = 370 * 24 * 60;
+    let ticks = 0;
+    while (cursor.getTime() <= deadline.getTime() && ticks < HARD_CAP_MINUTES) {
+        if (matches(parsed, cursor)) {
+            fires.push(new Date(cursor.getTime()));
+            if (fires.length >= max)
+                break;
+        }
+        cursor.setTime(cursor.getTime() + 60_000);
+        ticks++;
+    }
+    return fires;
+}
+export function cronFiresBeforeDeadline(cron, deadline, from = new Date()) {
+    return findNextFires(cron, from, deadline, 1).length > 0;
+}

package/dist/schema/platformApiKey.js

@@ -1,13 +1,13 @@
-export const PLATFORM_KEY_PREFIXES = { noimos: "nmp_", relvo: "rlv_", toolhub: "thk_" };
-export const PLATFORM_API_KEY_PATTERN = /^(?:nmp|rlv|thk)_[A-Za-z0-9_-]{43}$/;
-export const PLATFORM_CLIENT_HEADERS = { noimos: "x-noimos-client", relvo: "x-relvo-client", toolhub: "x-toolhub-client" };
+export const PLATFORM_KEY_PREFIXES = { noimos: "nmp_", relvo: "rlv_" };
+export const PLATFORM_API_KEY_PATTERN = /^(?:nmp|rlv)_[A-Za-z0-9_-]{43}$/;
+export const PLATFORM_CLIENT_HEADERS = { noimos: "x-noimos-client", relvo: "x-relvo-client" };
 export const PLATFORM_PRODUCT_NAMES = { noimos: "NoimosAI Platform", relvo: "Relvo" };
 export function isRelvoProduct(product) {
-    return product === "relvo" || product === "toolhub";
+    return product === "relvo";
 }
 export function platformKeyProduct(key) {
     for (const product of Object.keys(PLATFORM_KEY_PREFIXES))
         if (key.startsWith(PLATFORM_KEY_PREFIXES[product]))
-            return product === "toolhub" ? "relvo" : product;
+            return product;
     return null;
 }

package/dist/schema/platformBillingConstants.js

@@ -0,0 +1,3 @@
+export const PLATFORM_CHECKOUT_MIN_CENTS = 500;
+export const PLATFORM_SETTLEMENT_MIN_CENTS = 100;
+export const PLATFORM_FREE_TOOL_OVERAGE_MICROS = 300;

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;
+}