@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/redfox/routes.js

@@ -0,0 +1,329 @@
+export const redfoxRoutes = {
+    search_douyin_users: { path: "/story/api/dyData/searchUser" },
+    search_douyin_users_broad: { path: "/story/api/dy/data/searchAccount", directResponse: true },
+    list_douyin_user_works: { path: "/story/api/dyData/queryWorkList" },
+    list_douyin_user_works_broad: {
+        path: "/story/api/dy/data/listWorkByAccount",
+        directResponse: true,
+    },
+    search_douyin_works: { path: "/story/api/dyData/searchArticle" },
+    search_douyin_works_broad: { path: "/story/api/dy/data/searchWork", directResponse: true },
+    get_douyin_work: { path: "/story/api/dyData/queryWork" },
+    get_douyin_work_broad: { path: "/story/api/dy/data/workDetail", directResponse: true },
+    list_douyin_hot_users: { path: "/story/api/dyData/query" },
+    list_douyin_hot_works: { path: "/story/api/dy/search/likesRank", directResponse: true },
+    get_douyin_user: { path: "/story/api/dyData/queryUser" },
+    search_douyin_ai_creations: { path: "/story/api/parseWork/queryDyAiMsgs" },
+    list_douyin_daily_rising_works: {
+        path: "/story/api/dy/search/getDailyRank",
+        directResponse: true,
+    },
+    list_douyin_weekly_rising_works: {
+        path: "/story/api/dy/search/getWeeklyRank",
+        directResponse: true,
+    },
+    list_xiaohongshu_hot_users: { path: "/story/api/xhsData/query" },
+    get_xiaohongshu_user: { path: "/story/api/xhsUser/queryAccountDetail" },
+    get_xiaohongshu_work: { path: "/story/api/xhsUser/queryWorkDetail" },
+    search_xiaohongshu_users: { path: "/story/api/xhsUser/searchUser" },
+    search_xiaohongshu_works: { path: "/story/api/xhsUser/searchArticle" },
+    search_xiaohongshu_ai_creations: { path: "/story/api/parseWork/queryXhsAiMsgs" },
+    search_xiaohongshu_viral_notes: { path: "/story/api/xhs/search/search", directResponse: true },
+    list_xiaohongshu_weekly_viral_notes: {
+        path: "/story/api/cozeSkill/getXhsCozeSkillDataSeven",
+        method: "GET",
+        credentialQuery: true,
+    },
+    list_xiaohongshu_user_works: { path: "/story/api/xhsUser/queryWorkList" },
+    list_xiaohongshu_breakout_notes: { path: "/story/api/cozeSkill/getLowPowderExplosiveArticle" },
+    list_xiaohongshu_daily_viral_notes: {
+        path: "/story/api/cozeSkill/getXhsCozeSkillDataOne",
+        method: "GET",
+        credentialQuery: true,
+    },
+    get_wechat_account: { path: "/story/api/gzhData/queryUser" },
+    get_wechat_account_broad: { path: "/story/api/gzh/data/accountInfo" },
+    get_wechat_article: { path: "/story/api/gzhData/queryWork" },
+    get_wechat_article_broad: { path: "/story/api/gzh/data/workDetail" },
+    search_wechat_accounts: { path: "/story/api/gzhData/searchUser" },
+    search_wechat_accounts_broad: { path: "/story/api/gzh/data/searchUser" },
+    search_wechat_articles: { path: "/story/api/gzhData/searchArticle" },
+    search_wechat_articles_broad: { path: "/story/api/gzh/data/searchArticle" },
+    list_wechat_account_articles: { path: "/story/api/gzhData/queryWorkList" },
+    list_wechat_account_articles_broad: { path: "/story/api/gzh/data/queryWorkList" },
+    search_wechat_ai_creations: { path: "/story/api/parseWork/queryAiMsgs" },
+    get_wechat_article_by_url: {
+        path: "/story/api/gzh/ability/temp/article/content",
+        successCodes: [2000, 200],
+    },
+    list_wechat_high_read_articles: {
+        path: "/story/api/cozeSkill/getTenWReadingRank",
+        directResponse: true,
+    },
+    list_wechat_original_viral_articles: { path: "/story/api/cozeSkill/getOriginalRank" },
+    list_wechat_reading_growth: {
+        path: "/story/api/cozeSkill/getGzhCozeSkillDataRaise",
+        method: "GET",
+        credentialQuery: true,
+    },
+    list_wechat_account_rankings: {
+        path: "/story/api/cozeSkill/getGzhCozeSkillDataIndex",
+        method: "GET",
+        credentialQuery: true,
+    },
+    list_wechat_headline_growth: { path: "/story/api/gzh/heima/rankList", directResponse: true },
+    search_wechat_channel_works: { path: "/story/api/sphAllData/searchWork", directResponse: true },
+    search_wechat_channel_users: { path: "/story/api/sphAllData/searchUser", directResponse: true },
+    get_wechat_channel_work: { path: "/story/api/sphAllData/queryWorkDetail", directResponse: true },
+    list_wechat_channel_user_works: {
+        path: "/story/api/sphAllData/queryWorkList",
+        directResponse: true,
+    },
+    get_wechat_channel_work_by_url: {
+        path: "/story/api/sph/ability/workLinkDetail",
+        directResponse: true,
+    },
+    search_kuaishou_users: { path: "/story/api/ksAllData/searchUser" },
+    list_kuaishou_user_works: { path: "/story/api/ksAllData/queryWorkList" },
+    get_kuaishou_work: { path: "/story/api/ksAllData/queryWorkDetail" },
+    search_kuaishou_works: { path: "/story/api/ksAllData/searchWork" },
+    get_bilibili_work: { path: "/story/api/bili/data/workDetail" },
+    get_bilibili_user: { path: "/story/api/bili/data/accountDetail" },
+    search_bilibili_users: { path: "/story/api/bili/data/accountSearch" },
+    search_bilibili_works: { path: "/story/api/bili/data/workSearch" },
+    list_bilibili_user_works: { path: "/story/api/bili/data/accountWorkList" },
+    search_toutiao_works: { path: "/story/api/toutiao/searchWork" },
+    get_toutiao_work: { path: "/story/api/toutiao/workDetail" },
+    list_toutiao_work_comments: { path: "/story/api/toutiao/workComment", directResponse: true },
+    search_toutiao_users: { path: "/story/api/toutiao/searchAccount", directResponse: true },
+    list_toutiao_user_works: { path: "/story/api/toutiao/userWorkList" },
+    get_tiktok_work: { path: "/story/api/tiktok/ability/awemeDetail", directResponse: true },
+    list_tiktok_user_works: { path: "/story/api/tiktok/ability/userAwemeList", directResponse: true },
+    search_tiktok_works: { path: "/story/api/tiktok/ability/searchVideo", directResponse: true },
+    search_tiktok_users: { path: "/story/api/tiktok/ability/searchUser" },
+    list_tiktok_topic_works: {
+        path: "/story/api/tiktok/ability/topicAwemeList",
+        directResponse: true,
+    },
+    search_tiktok_topics: { path: "/story/api/tiktok/ability/searchTopic", directResponse: true },
+    list_tiktok_user_following: { path: "/story/api/tiktok/ability/userFollowing" },
+    list_tiktok_user_liked_works: {
+        path: "/story/api/tiktok/ability/userFavoriteAwemeList",
+        directResponse: true,
+    },
+    list_tiktok_work_comments: {
+        path: "/story/api/tiktok/ability/commentList",
+        directResponse: true,
+    },
+    list_tiktok_comment_replies: { path: "/story/api/tiktok/ability/commentReply" },
+    list_x_post_comments: { path: "/story/api/x/tweetComments", directResponse: true },
+    get_x_user: { path: "/story/api/x/userInfo" },
+    search_x_posts: { path: "/story/api/x/search" },
+    get_x_post: { path: "/story/api/x/tweetDetail" },
+    list_x_hot_users: { path: "/story/api/x/hotAccount/rankList", directResponse: true },
+    list_x_user_following: { path: "/story/api/x/userFollowing" },
+    list_x_user_posts: { path: "/story/api/x/userTimeline" },
+    get_youtube_transcript: { path: "/story/api/youtube/transcript" },
+    search_youtube_videos: { path: "/story/api/youtube/searchVideo" },
+    get_youtube_video: { path: "/story/api/youtube/videoDetail" },
+    list_youtube_video_comments: { path: "/story/api/youtube/videoComments" },
+    get_youtube_subtitles: { path: "/story/api/youtube/info" },
+    search_instagram: { path: "/story/api/ins/search" },
+    get_instagram_user: { path: "/story/api/ins/userInfo" },
+    get_instagram_post: { path: "/story/api/ins/postDetail" },
+    list_instagram_post_comments: { path: "/story/api/ins/postComment" },
+    search_autohome_works: { path: "/story/api/autohome/searchWork" },
+    get_autohome_article: { path: "/story/api/autohome/articleDetail" },
+    get_autohome_video: { path: "/story/api/autohome/videoDetail" },
+    list_autohome_user_works: { path: "/story/api/autohome/workList" },
+    search_dongchedi_works: { path: "/story/api/dongchedi/searchWork", successCodes: [2000, 200] },
+    get_dongchedi_work: { path: "/story/api/dongchedi/workDetail", successCodes: [2000, 200] },
+    search_dongchedi_users: { path: "/story/api/dongchedi/searchUser" },
+    get_dongchedi_user_works: { path: "/story/api/dongchedi/accountWorks" },
+    get_yiche_video: { path: "/story/api/yiche/videoDetail" },
+    search_yiche_users: { path: "/story/api/yiche/searchAccount" },
+    list_yiche_user_works: { path: "/story/api/yiche/workList" },
+    search_yiche_works: { path: "/story/api/yiche/searchWork" },
+    get_yiche_article: { path: "/story/api/yiche/articleDetailV2" },
+    get_weibo_work: { path: "/story/api/weibo/ability/opusDetail", directResponse: true },
+    get_weibo_user: { path: "/story/api/weibo/ability/userDetail", directResponse: true },
+    search_weibo_users: { path: "/story/api/weibo/ability/accountSearch", directResponse: true },
+    search_weibo_works: { path: "/story/api/weibo/ability/searchWork", directResponse: true },
+    list_weibo_hot_searches: { path: "/story/api/weibo/ability/hotSearch", directResponse: true },
+    get_baijiahao_article: { path: "/story/api/bjh/ability/opusHtml", directResponse: true },
+    get_baijiahao_video: { path: "/story/api/bjh/ability/videoDetail", directResponse: true },
+    get_baijiahao_user: { path: "/story/api/bjh/ability/accountDetail", directResponse: true },
+    search_baijiahao_works: { path: "/story/api/bjh/ability/searchWork", directResponse: true },
+    search_baijiahao_users: { path: "/story/api/bjh/ability/accountSearch", directResponse: true },
+    search_zhihu_works: { path: "/story/api/zhihu/ability/searchWork", directResponse: true },
+    get_bilibili_audio: { path: "/story/api/parseWork/audioExtract/bilibili" },
+    parse_video: { path: "/story/api/parseWork/parse" },
+    get_youtube_video_download: {
+        path: "/story/api/parseWork/videoDownload/youtube",
+        directResponse: true,
+    },
+    get_x_video_download: { path: "/story/api/parseWork/videoDownload/x", directResponse: true },
+    get_tiktok_video_download: {
+        path: "/story/api/parseWork/videoDownload/tiktok",
+        directResponse: true,
+    },
+    get_xiaohongshu_video_download: {
+        path: "/story/api/parseWork/videoDownload/xhs",
+        directResponse: true,
+    },
+    get_wechat_channel_video_download: {
+        path: "/story/api/parseWork/videoDownload/sph",
+        directResponse: true,
+    },
+    get_douyin_video_download: {
+        path: "/story/api/parseWork/videoDownload/douyin",
+        directResponse: true,
+    },
+    get_kuaishou_video_download: {
+        path: "/story/api/parseWork/videoDownload/kuaishou",
+        directResponse: true,
+    },
+    get_bilibili_video_download: {
+        path: "/story/api/parseWork/videoDownload/bilibili",
+        directResponse: true,
+    },
+    get_instagram_video_download: {
+        path: "/story/api/parseWork/videoDownload/instagram",
+        directResponse: true,
+    },
+    list_aggregated_hot_topics: { path: "/story/api/hotKeyword/list", directResponse: true },
+    search_hot_topics: {
+        path: "/story/api/hotSpot/getListByPlatformWithKeyword",
+        directResponse: true,
+    },
+    list_platform_hot_topics: {
+        path: "/story/api/hotSpot/getListByPlatform",
+        method: "GET",
+        credentialQuery: true,
+    },
+    submit_douyin_transcription: {
+        path: "/story/api/parseWork/audioTextExtract/submit/douyin",
+        taskRole: "submit",
+    },
+    get_douyin_transcription: {
+        path: "/story/api/parseWork/audioTextExtract/result/douyin",
+        directResponse: true,
+        taskRole: "result",
+    },
+    submit_xiaohongshu_comments: { path: "/story/api/xhs/commentSubmit", taskRole: "submit" },
+    get_xiaohongshu_comments: { path: "/story/api/xhs/commentResult", taskRole: "result" },
+    submit_xiaohongshu_transcription: {
+        path: "/story/api/parseWork/audioTextExtract/submit/xhs",
+        taskRole: "submit",
+    },
+    get_xiaohongshu_transcription: {
+        path: "/story/api/parseWork/audioTextExtract/result/xhs",
+        directResponse: true,
+        taskRole: "result",
+    },
+    submit_wechat_channel_transcription: {
+        path: "/story/api/parseWork/sphSubtitle/submit",
+        taskRole: "submit",
+    },
+    get_wechat_channel_transcription: {
+        path: "/story/api/parseWork/sphSubtitle/result",
+        directResponse: true,
+        taskRole: "result",
+    },
+    submit_kuaishou_transcription: {
+        path: "/story/api/parseWork/audioTextExtract/submit/kuaishou",
+        taskRole: "submit",
+    },
+    get_kuaishou_transcription: {
+        path: "/story/api/parseWork/audioTextExtract/result/kuaishou",
+        directResponse: true,
+        taskRole: "result",
+    },
+    submit_bilibili_transcription: {
+        path: "/story/api/parseWork/bilibiliSubtitle/submit",
+        taskRole: "submit",
+    },
+    get_bilibili_transcription: {
+        path: "/story/api/parseWork/bilibiliSubtitle/result",
+        taskRole: "result",
+    },
+    submit_gpt_image_2_generation: {
+        path: "/story/api/parseWork/imageGen/gptImage2Submit",
+        taskRole: "submit",
+    },
+    get_gpt_image_2_generation: {
+        path: "/story/api/parseWork/imageGen/gptImage2Result",
+        taskRole: "result",
+    },
+    submit_gpt_image_2_5_generation: {
+        path: "/story/api/parseWork/imageGen/gptImage25Submit",
+        taskRole: "submit",
+    },
+    get_gpt_image_2_5_generation: {
+        path: "/story/api/parseWork/imageGen/gptImage25Result",
+        taskRole: "result",
+    },
+    submit_gemini_banana_2_1_generation: {
+        path: "/story/api/parseWork/imageGen/geminiBanana21Submit",
+        taskRole: "submit",
+    },
+    get_gemini_banana_2_1_generation: {
+        path: "/story/api/parseWork/imageGen/geminiBanana21Result",
+        taskRole: "result",
+    },
+    submit_seedream_pro_generation: {
+        path: "/story/api/parseWork/imageGen/arkProSubmit",
+        taskRole: "submit",
+        parseImageUrls: true,
+    },
+    get_seedream_pro_generation: {
+        path: "/story/api/parseWork/imageGen/arkProResult",
+        taskRole: "result",
+        parseImageUrls: true,
+    },
+    submit_seedream_lite_generation: {
+        path: "/story/api/parseWork/imageGen/arkSubmit",
+        taskRole: "submit",
+        parseImageUrls: true,
+    },
+    get_seedream_lite_generation: {
+        path: "/story/api/parseWork/imageGen/arkResult",
+        taskRole: "result",
+        parseImageUrls: true,
+    },
+    submit_seedance_video_generation: {
+        path: "/story/api/parseWork/videoGen/seedanceSubmit",
+        validateImageRoles: true,
+        taskRole: "submit",
+    },
+    get_seedance_video_generation: {
+        path: "/story/api/parseWork/videoGen/seedanceResult",
+        taskRole: "result",
+    },
+    submit_kimi_search: { path: "/story/api/kimi/submit", directResponse: true, taskRole: "submit" },
+    get_kimi_search: { path: "/story/api/kimi/result", directResponse: true, taskRole: "result" },
+    submit_yuanbao_search: { path: "/story/api/deepSearch/ybSubmit", taskRole: "submit" },
+    get_yuanbao_search: { path: "/story/api/deepSearch/ybResult", taskRole: "result" },
+    submit_qwen_search: { path: "/story/api/deepSearch/qwSubmit", taskRole: "submit" },
+    get_qwen_search: { path: "/story/api/deepSearch/qwResult", taskRole: "result" },
+    submit_baidu_search: { path: "/story/api/deepSearch/bdSubmit", taskRole: "submit" },
+    get_baidu_search: { path: "/story/api/deepSearch/bdResult", taskRole: "result" },
+    submit_doubao_search: { path: "/story/api/deepSearch/dbSubmit", taskRole: "submit" },
+    get_doubao_search: { path: "/story/api/deepSearch/dbResult", taskRole: "result" },
+    submit_deepseek_search: { path: "/story/api/deepSearch/dsSubmit", taskRole: "submit" },
+    get_deepseek_search: {
+        path: "/story/api/deepSearch/dsResult",
+        successCodes: [2000, 200],
+        taskRole: "result",
+    },
+    get_account_balance: {
+        path: "/story/web/points/api-key/balance",
+        method: "GET",
+        credentialQuery: true,
+    },
+    list_api_usage: {
+        path: "/story/web/points/api-key/consume-flows",
+        method: "GET",
+        credentialQuery: true,
+    },
+};

package/src/providers/redfox/runtime.d.ts

@@ -0,0 +1,6 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext } from "../provider-runtime.ts";
+import type { RedfoxRoute } from "./routes.ts";
+export declare const redfoxApiBaseUrl = "https://redfox.hk";
+export declare function validateRedfoxCredential(input: Record<string, string>, fetcher: typeof fetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export declare function executeRedfoxAction(endpoint: RedfoxRoute, input: Record<string, unknown>, context: ApiKeyProviderContext): Promise<unknown>;

package/src/providers/redfox/runtime.js

@@ -0,0 +1,151 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { ProviderRequestError, requiredInputString, requiredResponseRecord, providerUserAgent, runProviderRequest, } from "../provider-runtime.js";
+import { redfoxRoutes } from "./routes.js";
+export const redfoxApiBaseUrl = "https://redfox.hk";
+const validationEndpoint = "/story/web/points/api-key/balance";
+export async function validateRedfoxCredential(input, fetcher, signal) {
+    const endpoint = redfoxRoutes.get_account_balance;
+    await requestRedfox({
+        endpoint,
+        input: {},
+        apiKey: requiredInputString(input.apiKey, "API Key"),
+        fetcher,
+        parentSignal: signal,
+    });
+    return {
+        profile: { displayName: "RedFoxHub API Key" },
+        grantedScopes: [],
+        metadata: {
+            apiBaseUrl: redfoxApiBaseUrl,
+            validationEndpoint,
+        },
+    };
+}
+export async function executeRedfoxAction(endpoint, input, context) {
+    if (endpoint.validateImageRoles)
+        validateImageRoles(input);
+    return requestRedfox({
+        endpoint,
+        input,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+}
+async function requestRedfox({ endpoint, input, apiKey, fetcher, parentSignal }) {
+    try {
+        return await runProviderRequest({ label: "RedFoxHub", signal: parentSignal }, async (signal) => {
+            const url = new URL(endpoint.path, redfoxApiBaseUrl);
+            const method = endpoint.method ?? "POST";
+            if (method === "GET") {
+                for (const [key, value] of Object.entries(input)) {
+                    if (value !== undefined)
+                        url.searchParams.set(key, String(value));
+                }
+            }
+            if (endpoint.credentialQuery)
+                url.searchParams.set("apiKey", apiKey);
+            const response = await fetcher(url, {
+                method,
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/json",
+                    REDFOX_API_KEY: apiKey,
+                    "user-agent": providerUserAgent,
+                },
+                body: method === "POST" ? JSON.stringify(input) : undefined,
+                signal,
+            });
+            const text = await response.text();
+            let payload;
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                if (!response.ok) {
+                    throw redfoxError(response.status, `RedFoxHub request failed with ${response.status}`, response.status);
+                }
+                throw new ProviderRequestError(502, "RedFoxHub returned invalid JSON", undefined, "provider_error");
+            }
+            const record = optionalRecord(payload);
+            const message = optionalRawString(record?.msg) ?? optionalRawString(record?.message) ?? optionalRawString(record?.error);
+            if (!response.ok) {
+                throw redfoxError(response.status, message, response.status);
+            }
+            let normalizedPayload = payload;
+            if (endpoint.directResponse && record?.code === undefined) {
+                if (payload === null || (record === undefined && !Array.isArray(payload))) {
+                    throw new ProviderRequestError(502, "RedFoxHub returned an invalid response", undefined, "provider_error");
+                }
+                normalizedPayload = { code: 2000, msg: "成功", data: payload };
+            }
+            const wrapper = requiredResponseRecord(normalizedPayload, "RedFoxHub response");
+            const code = typeof wrapper.code === "number" ? wrapper.code : Number(optionalRawString(wrapper.code) ?? Number.NaN);
+            if (!Number.isInteger(code)) {
+                throw new ProviderRequestError(502, "RedFoxHub response did not include code", undefined, "provider_error");
+            }
+            if (!(endpoint.successCodes ?? [2000]).includes(code)) {
+                throw redfoxError(code, message);
+            }
+            let data = wrapper.data;
+            if (endpoint.taskRole) {
+                const taskData = requiredResponseRecord(data, "RedFoxHub task data");
+                if (endpoint.taskRole === "submit" && !optionalRawString(taskData.taskId)?.trim()) {
+                    throw new ProviderRequestError(502, "RedFoxHub did not return a taskId", undefined, "provider_error");
+                }
+                if (endpoint.taskRole === "result" && !optionalRawString(taskData.status)?.trim()) {
+                    throw new ProviderRequestError(502, "RedFoxHub did not return a task status", undefined, "provider_error");
+                }
+                if (endpoint.parseImageUrls && typeof taskData.imageUrls === "string") {
+                    let imageUrls;
+                    try {
+                        imageUrls = JSON.parse(taskData.imageUrls);
+                    }
+                    catch {
+                        throw new ProviderRequestError(502, "RedFoxHub returned invalid imageUrls JSON", undefined, "provider_error");
+                    }
+                    if (!Array.isArray(imageUrls) || imageUrls.some((item) => typeof item !== "string")) {
+                        throw new ProviderRequestError(502, "RedFoxHub returned invalid imageUrls", undefined, "provider_error");
+                    }
+                    data = { ...taskData, imageUrls };
+                }
+            }
+            return { ...wrapper, code, msg: optionalRawString(wrapper.msg) ?? message ?? "", data };
+        });
+    }
+    catch (error) {
+        if (error instanceof ProviderRequestError) {
+            const message = error.message
+                .replaceAll(apiKey, "[REDACTED]")
+                .replaceAll(encodeURIComponent(apiKey), "[REDACTED]");
+            if (message !== error.message) {
+                throw new ProviderRequestError(error.status, message, error.details, error.code);
+            }
+        }
+        throw error;
+    }
+}
+function redfoxError(code, message, httpStatus) {
+    const text = message || `RedFoxHub returned code ${code}`;
+    if (code === 429)
+        return new ProviderRequestError(429, text, undefined, "rate_limited");
+    if ([400, 404, 422].includes(code))
+        return new ProviderRequestError(400, text, undefined, "invalid_input");
+    return new ProviderRequestError(httpStatus ?? 502, text, {
+        upstreamCode: code,
+    }, "provider_error");
+}
+function validateImageRoles(input) {
+    const images = input.imageWithRoles;
+    if (!Array.isArray(images))
+        return;
+    for (const [role, maximum] of [
+        ["first_frame", 1],
+        ["last_frame", 1],
+        ["reference_image", 9],
+    ]) {
+        if (images.filter((image) => optionalRecord(image)?.role === role).length > maximum) {
+            throw new ProviderRequestError(400, `${role} allows at most ${maximum} images`, undefined, "invalid_input");
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const responseSchema: JsonSchema;
+export declare const taskInputSchema: JsonSchema;
+export declare const taskSubmissionSchema: JsonSchema;
+export declare const searchResultSchema: JsonSchema;
+export declare const transcriptionResultSchema: JsonSchema;
+export declare const commentsResultSchema: JsonSchema;
+export declare const videoResultSchema: JsonSchema;
+export declare const imageResultSchema: JsonSchema;

package/src/providers/redfox/schemas.js

@@ -0,0 +1,40 @@
+import { s } from "../../core/json-schema.js";
+function responseWithData(data) {
+    return s.looseRequiredObject("The normalized RedFoxHub response.", {
+        code: s.integer("Upstream business status code; 2000 or an endpoint-specific 200 means success."),
+        msg: s.string("Upstream response message."),
+        data,
+    });
+}
+export const responseSchema = responseWithData(s.unknown("The upstream payload, including pagination and platform-specific fields."));
+export const taskInputSchema = s.object("Request parameters.", {
+    taskId: s.nonEmptyString("Task ID returned by the corresponding submit action."),
+}, { required: ["taskId"] });
+export const taskSubmissionSchema = responseWithData(s.looseRequiredObject("Task metadata and results. Additional upstream fields are preserved.", {
+    taskId: s.string("Task ID returned by the submit action."),
+}));
+function taskResult(properties) {
+    return responseWithData(s.object("Task metadata and results. Additional upstream fields are preserved.", {
+        taskId: s.string("Task ID returned by the submit action."),
+        status: s.string("Upstream task status; see the action polling lifecycle."),
+        failReason: s.nullableString("Reason the task failed."),
+        ...properties,
+    }, { required: ["status"], additionalProperties: true }));
+}
+export const searchResultSchema = taskResult({
+    result: s.unknown("AI search results, including content and source references."),
+});
+export const transcriptionResultSchema = taskResult({
+    text: s.string("Extracted transcript text."),
+    stampSents: s.array("Transcript segments with timestamps.", s.unknown("Transcript segment.")),
+});
+export const commentsResultSchema = taskResult({
+    commentList: s.array("Collected comments.", s.unknown("Comment data.")),
+});
+export const videoResultSchema = taskResult({
+    videoUrl: s.nullableString("Generated video URL."),
+    lastFrameUrl: s.nullableString("Generated last-frame image URL."),
+});
+export const imageResultSchema = taskResult({
+    imageUrls: s.nullable(s.array("Generated image URLs.", s.string("Generated image URL."))),
+});