@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/qiuxiaoce/executors.js

@@ -0,0 +1,76 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { qiuxiaoceActions } from "./actions.js";
+import { qiuxiaoceRoutes } from "./routes.js";
+const baseUrl = "https://www.qiuxiaoce.com/wp-json/abv2-creator/v1";
+const defaultHeaders = { accept: "application/json" };
+async function request({ route, input, apiKey, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "QiuXiaoCe" }, async (signal) => {
+        const pathId = route.includes("{id}");
+        const url = new URL(`${baseUrl}${pathId ? route.replace("{id}", encodeURIComponent(String(input.id))) : route}`);
+        for (const [key, value] of Object.entries(input)) {
+            if (value != null && !(pathId && key === "id"))
+                url.searchParams.set(key, String(value));
+        }
+        const response = await fetcher(url.toString(), {
+            method: "GET",
+            headers: { ...defaultHeaders, "X-API-Key": apiKey },
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const body = optionalRecord(payload);
+        if (!response.ok || body?.success === false || (body?.code != null && body?.success !== true)) {
+            const code = optionalRawString(body?.code) ?? optionalRawString(body?.error);
+            const message = optionalRawString(body?.message) ?? optionalRawString(body?.error);
+            const detail = [code, message].filter(Boolean).join(": ") || `HTTP ${response.status}`;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `QiuXiaoCe request failed: ${detail.split(apiKey).join("[REDACTED]")}`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return requiredResponseRecord(payload, "QiuXiaoCe response");
+    });
+}
+const handlers = mapProviderActionHandlers("qiuxiaoce", qiuxiaoceActions, (action) => async (dataInput, context) => {
+    const route = qiuxiaoceRoutes[action.name];
+    return request({
+        route: route,
+        input: dataInput,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("qiuxiaoce", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request({
+            route: "/quota",
+            input: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return { profile: { displayName: "QiuXiaoCe API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "qiuxiaoce",
+    baseUrl,
+    auth: { type: "api_key_header", name: "X-API-Key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

package/src/providers/qiuxiaoce/routes.d.ts

@@ -0,0 +1 @@
+export declare const qiuxiaoceRoutes: Record<string, string>;

package/src/providers/qiuxiaoce/routes.js

@@ -0,0 +1,20 @@
+export const qiuxiaoceRoutes = {
+    get_quota: "/quota",
+    get_daily_digest: "/today/digest",
+    list_fixtures: "/fixtures",
+    get_fixture: "/fixtures/{id}",
+    get_fixture_stats: "/fixtures/{id}/stats",
+    get_fixture_events: "/fixtures/{id}/events",
+    get_fixture_lineups: "/fixtures/{id}/lineups",
+    get_fixture_players: "/fixtures/{id}/players",
+    search_teams: "/teams",
+    get_team: "/teams/{id}",
+    list_leagues: "/leagues",
+    get_league: "/leagues/{id}",
+    get_standings: "/standings",
+    list_league_fixtures: "/leagues/{id}/fixtures",
+    list_league_teams: "/leagues/{id}/teams",
+    list_league_top_scorers: "/leagues/{id}/topscorers",
+    list_league_top_assists: "/leagues/{id}/topassists",
+    list_league_seasons: "/leagues/{id}/seasons",
+};

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

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

package/src/providers/qqmusic/actions.js

@@ -0,0 +1,229 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { dayReport, weekReport, monthReport } from "./report-schema.js";
+const page = s.integer("Zero-based page number; defaults to 0.", { minimum: 0, default: 0 });
+const traceId = s.string("Request trace ID.");
+const responseTimestamp = s.integer("Response timestamp in milliseconds.");
+const gatewayCode = s.integer("Gateway result code; nonzero indicates failure.");
+const businessCode = s.integer("Business result code; nonzero indicates failure.");
+const providerMessage = s.string("Provider message.");
+const songMid = s.string("Song MID.");
+const songName = s.string("Song name.");
+const singerName = s.string("Singer name.");
+const songUrl = s.string("Song listening page URL.");
+const song = s.looseObject("A song with its listening page.", { songMid, songName, singerName, songH5Url: songUrl });
+const albumMid = s.string("Album or radio MID.");
+const albumName = s.string("Album or radio name.");
+const publicationDate = s.string("Publication date.");
+const listenCount = s.integer("Listen count.");
+const albumCategory = s.string("Album category.");
+const albumDescription = s.string("Album or radio description.");
+const album = s.looseObject("Album or radio metadata.", {
+    albumMid,
+    albumName,
+    singerName,
+    publicTime: publicationDate,
+    listenNum: listenCount,
+    category: albumCategory,
+    albumDesc: albumDescription,
+});
+const playlistId = s.integer("Playlist ID.");
+const playlistName = s.string("Playlist name.");
+const playlistDescription = s.string("Playlist description.");
+const creatorName = s.string("Creator name; may be empty for AI playlists.");
+const playlist = s.looseObject("Playlist metadata.", {
+    dissId: playlistId,
+    dissName: playlistName,
+    dissDesc: playlistDescription,
+    creatorName,
+});
+const hasMore = s.boolean("Whether another page exists.");
+const emptyInput = s.object("No input parameters.", {}, { required: [] });
+const recommendedSongs = s.array("Recommended songs.", song);
+const recommendationOutput = s.looseObject("QQ Music response with upstream fields preserved.", {
+    traceId,
+    ts: responseTimestamp,
+    ret: gatewayCode,
+    sub_ret: businessCode,
+    msg: providerMessage,
+    songlist: recommendedSongs,
+});
+const chartId = s.integer("Chart ID returned by list_charts.");
+const chartName = s.string("Chart name.");
+const listenerCount = s.integer("Listener count.");
+const totalSongs = s.integer("Total song count.");
+const tracks = s.array("Songs on this page.", song);
+export const qqmusicActions = [
+    defineProviderAction("qqmusic", {
+        operationType: "read",
+        requiredScopes: [],
+        name: "search",
+        description: "Search songs, albums, playlists, music videos, radios, or singers. Increment page while hasMore is true.",
+        inputSchema: s.object("Search parameters.", {
+            keyword: s.string("Search keywords.", { minLength: 1 }),
+            type: {
+                ...s.string("Search type: 0 songs, 1 albums, 2 playlists, 3 music videos, 4 radios, 5 singers. Defaults to 0.", { default: "0" }),
+                enum: ["0", "1", "2", "3", "4", "5"],
+            },
+            page,
+        }, { required: ["keyword"] }),
+        outputSchema: s.looseObject("QQ Music response with upstream fields preserved.", {
+            traceId,
+            ts: responseTimestamp,
+            ret: gatewayCode,
+            sub_ret: businessCode,
+            msg: providerMessage,
+            songs: s.nullable(s.array("Matching songs; other result types may be null.", song)),
+            albums: s.nullable(s.array("Matching albums.", album)),
+            playlists: s.nullable(s.array("Matching playlists.", playlist)),
+            mvs: s.nullable(s.array("Matching music videos.", s.looseObject("Music video metadata.", {
+                mvVid: s.string("Music video ID."),
+                mvName: s.string("Music video name."),
+                singerName,
+                playCount: s.integer("Play count."),
+                publicTime: publicationDate,
+                mvUrl: s.string("Music video page URL."),
+            }))),
+            radios: s.nullable(s.array("Matching radios.", album)),
+            singers: s.nullable(s.array("Matching singers.", s.looseObject("Singer metadata.", {
+                singerMid: s.string("Singer MID."),
+                singerName,
+                songNum: s.integer("Song count."),
+                albumNum: s.integer("Album count."),
+            }))),
+            hasMore,
+        }),
+    }),
+    defineProviderAction("qqmusic", {
+        operationType: "read",
+        requiredScopes: [],
+        name: "get_daily_mix",
+        description: "Get the daily personalized song recommendations.",
+        inputSchema: emptyInput,
+        outputSchema: recommendationOutput,
+    }),
+    defineProviderAction("qqmusic", {
+        operationType: "read",
+        requiredScopes: [],
+        name: "get_radio",
+        description: "Get songs from the personalized radio.",
+        inputSchema: emptyInput,
+        outputSchema: recommendationOutput,
+    }),
+    defineProviderAction("qqmusic", {
+        operationType: "read",
+        requiredScopes: [],
+        name: "list_ai_playlists",
+        description: "List AI-recommended playlists. This endpoint does not accept a prompt or create a playlist.",
+        inputSchema: emptyInput,
+        outputSchema: s.looseObject("QQ Music response with upstream fields preserved.", {
+            traceId,
+            ts: responseTimestamp,
+            ret: gatewayCode,
+            sub_ret: businessCode,
+            msg: providerMessage,
+            playlists: s.array("AI-recommended playlists.", playlist),
+        }),
+    }),
+    defineProviderAction("qqmusic", {
+        operationType: "read",
+        requiredScopes: [],
+        name: "list_charts",
+        description: "List chart groups and chart previews. Use topId to retrieve a chart.",
+        inputSchema: emptyInput,
+        outputSchema: s.looseObject("QQ Music response with upstream fields preserved.", {
+            traceId,
+            ts: responseTimestamp,
+            ret: gatewayCode,
+            sub_ret: businessCode,
+            msg: providerMessage,
+            groupList: s.array("Chart groups.", s.looseObject("A chart group.", {
+                groupName: s.string("Group name."),
+                groupTopList: s.array("Charts in this group.", s.looseObject("Chart summary.", {
+                    topId: chartId,
+                    topName: chartName,
+                    listenNum: listenerCount,
+                    totalNum: totalSongs,
+                    songList: s.array("Preview of ranked songs.", s.looseObject("A ranked song.", {
+                        songMid,
+                        songName,
+                        singerName,
+                        songH5Url: songUrl,
+                        rank: s.integer("Song rank."),
+                    })),
+                })),
+            })),
+        }),
+    }),
+    defineProviderAction("qqmusic", {
+        operationType: "read",
+        requiredScopes: [],
+        name: "get_chart",
+        description: "Get one page of a chart. Increment page while hasMore is true.",
+        inputSchema: s.object("Chart query parameters.", { topId: chartId, page: page }, { required: ["topId"] }),
+        outputSchema: s.looseObject("QQ Music response with upstream fields preserved.", {
+            traceId,
+            ts: responseTimestamp,
+            ret: gatewayCode,
+            sub_ret: businessCode,
+            msg: providerMessage,
+            topId: chartId,
+            topName: chartName,
+            listenNum: listenerCount,
+            totalNum: totalSongs,
+            topType: s.integer("Chart type."),
+            topDesc: s.string("Chart description."),
+            topHeaderPic: s.string("Chart header image URL."),
+            topBannerPic: s.string("Chart banner image URL."),
+            updateTime: s.string("Chart update time."),
+            hasMore,
+            trackList: tracks,
+        }),
+    }),
+    defineProviderAction("qqmusic", {
+        operationType: "read",
+        requiredScopes: [],
+        name: "get_playlist",
+        description: "Get one page of a playlist. Increment page while hasMore is true.",
+        inputSchema: s.object("Playlist query parameters.", { dissId: playlistId, page: page }, { required: ["dissId"] }),
+        outputSchema: s.looseObject("QQ Music response with upstream fields preserved.", {
+            traceId,
+            ts: responseTimestamp,
+            ret: gatewayCode,
+            sub_ret: businessCode,
+            msg: providerMessage,
+            dissId: playlistId,
+            dissName: playlistName,
+            desc: playlistDescription,
+            picUrl: s.string("Playlist cover image URL."),
+            totalNum: totalSongs,
+            hasMore,
+            trackList: tracks,
+        }),
+    }),
+    defineProviderAction("qqmusic", {
+        operationType: "read",
+        requiredScopes: [],
+        name: "get_listening_report",
+        description: "Get personal daily, weekly, or monthly listening statistics. Only the selected time dimension is populated.",
+        inputSchema: s.object("Listening report parameters.", {
+            timeKey: {
+                ...s.string("Report period: d daily, w weekly, m or empty monthly; defaults to m.", {
+                    default: "m",
+                }),
+                enum: ["d", "w", "m", ""],
+            },
+            startTime: s.integer("Unix seconds at the target day midnight or target week Monday midnight. Omit for today or this week; ignored for monthly reports."),
+        }, { required: [] }),
+        outputSchema: s.looseObject("QQ Music response with upstream fields preserved.", {
+            traceId,
+            ts: responseTimestamp,
+            ret: gatewayCode,
+            sub_ret: businessCode,
+            msg: providerMessage,
+            dayData: dayReport,
+            weekData: weekReport,
+            monthData: monthReport,
+        }),
+    }),
+];

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

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/qqmusic/executors.js

@@ -0,0 +1,92 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, isAbortLikeError, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { qqmusicActions } from "./actions.js";
+const baseUrl = "https://a.y.qq.com";
+const skillVersion = "0.0.3";
+const defaultHeaders = { "content-type": "application/json" };
+const routes = {
+    search: "/discover/search",
+    get_daily_mix: "/discover/daily-mix",
+    get_radio: "/discover/radio",
+    list_ai_playlists: "/discover/ai-playlists",
+    list_charts: "/charts",
+    get_chart: "/charts/detail",
+    get_playlist: "/playlists/detail",
+    get_listening_report: "/me/report",
+};
+async function request({ route, params, apiKey, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "QQ Music" }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${route}`, {
+            method: "POST",
+            signal,
+            headers: { ...defaultHeaders, authorization: `Bearer ${apiKey}` },
+            body: JSON.stringify({ params, comm: { skill_version: skillVersion } }),
+        });
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch (error) {
+            if (isAbortLikeError(error))
+                throw error;
+            payload = undefined;
+        }
+        const record = optionalRecord(payload);
+        const codes = [record?.ret, record?.sub_ret];
+        if (!response.ok || codes.some((code) => code != null && code !== 0 && code !== "0")) {
+            const detail = optionalRawString(record?.msg) || `HTTP ${response.status}`;
+            const codeDetails = codes
+                .filter((code) => code != null)
+                .map(String)
+                .join("/");
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `QQ Music request failed${codeDetails ? ` (${codeDetails})` : ""}: ${detail}`.split(apiKey).join("[REDACTED]"), undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return requiredResponseRecord(payload, "QQ Music response");
+    });
+}
+const handlers = mapProviderActionHandlers("qqmusic", qqmusicActions, (action) => async (dataInput, context) => {
+    const route = routes[action.name];
+    const params = dataInput;
+    if (action.name === "search")
+        params.type ??= "0";
+    if (action.name === "get_listening_report")
+        params.timeKey ??= "m";
+    if (action.name === "list_ai_playlists")
+        params.reqType = "all";
+    return request({
+        route: route,
+        params: params,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("qqmusic", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request({
+            route: "/skill/version",
+            params: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return { profile: { displayName: "QQ Music API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "qqmusic",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ "content-type": "application/json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

package/src/providers/qqmusic/report-schema.d.ts

@@ -0,0 +1,4 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const dayReport: JsonSchema;
+export declare const weekReport: JsonSchema;
+export declare const monthReport: JsonSchema;

package/src/providers/qqmusic/report-schema.js

@@ -0,0 +1,119 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const songFields = {
+    songMid: s.string("Song MID."),
+    songName: s.string("Song name."),
+    singerMid: s.string("Singer MID."),
+    singerName: s.string("Singer name."),
+};
+const songCounts = s.looseObject("A song listening count.", {
+    ...songFields,
+    sum: s.integer("Number of plays."),
+});
+const singerTimes = s.looseObject("A singer listening duration.", {
+    ...songFields,
+    sum: s.integer("Listening time in seconds."),
+});
+const indexedDuration = s.looseObject("An indexed time-slot value; identify the slot by its array index.", {
+    sum: s.integer("Listening duration in seconds."),
+});
+const averageTimes = s.array("Average listening time by time slot; slots are identified by array index.", s.looseObject("Current and recent average listening time for a slot.", {
+    currentAverage: indexedDuration,
+    nearAverage: indexedDuration,
+}));
+const songMetric = s.looseObject("A monthly song metric.", {
+    ...songFields,
+    sum: s.integer("Provider-defined song metric; units depend on the containing section."),
+});
+const dailyActivity = s.looseObject("A representative song for one day.", {
+    ...songFields,
+    sum: s.integer("Activity flag: 1 means listened on this day, 0 means no listening."),
+});
+const singerStreak = s.looseObject("Singer with the longest listening streak.", {
+    ...songFields,
+    sum: s.integer("Consecutive days listening to this singer."),
+});
+export const dayReport = s.nullable(s.looseObject("Daily listening report.", {
+    listenTime: s.integer("Total listening time for this day in seconds."),
+    activeHour: s.integer("Active hour of the day, 0 through 23."),
+    averageTime: averageTimes,
+    singerListen: s.array("Top singers; sum is listening time in seconds.", singerTimes),
+    songListen: s.array("Top songs; sum is the play count.", songCounts),
+}));
+export const weekReport = s.nullable(s.looseObject("Weekly listening report.", {
+    listenTime: s.integer("Daily average listening time for this week in seconds."),
+    floatNumber: s.number("Change ratio compared with last week; positive means an increase."),
+    averageTime: averageTimes,
+    singerListen: s.array("Top singers; sum is listening time in seconds.", singerTimes),
+    songListen: s.array("Top songs; sum is the play count.", songCounts),
+}));
+export const monthReport = s.nullable(s.looseObject("Monthly listening statistics and preferences.", {
+    monthDetailList: s.array("Monthly listening details.", s.looseObject("Details for one month.", {
+        listenCount: s.integer("Total plays in the month."),
+        dataTime: s.string("Month of the data."),
+        exportTime: s.string("Data export time."),
+        songs: s.array("Songs in the monthly details.", songMetric),
+    })),
+    topDataList: s.array("Top statistics, one entry per month.", s.looseObject("Top statistics for one month.", {
+        selectType: s.integer("Provider data dimension type."),
+        month: s.string("Month represented by these statistics."),
+        topSinger: s.array("Top singers; sum is listening time in seconds.", singerTimes),
+        topSong: s.array("Top songs; sum is the play count.", songCounts),
+        favSongMid: s.string("Favorite song MID."),
+        favSongName: s.string("Favorite song name."),
+        favSingerMid: s.string("Singer MID of the favorite song."),
+        favSingerName: s.string("Singer name of the favorite song."),
+        repeatSong: s.looseObject("Most repeated song.", {
+            ...songFields,
+            listenDate: s.string("Date of repeated listening."),
+            count: s.integer("Repeat count."),
+        }),
+        midnightSong: s.looseObject("Late-night song.", {
+            ...songFields,
+            month: s.integer("Month number."),
+            hour: s.integer("Listening hour, 0 through 23."),
+        }),
+    })),
+    topSinger: s.array("Top singers; sum is listening time in seconds.", singerTimes),
+    topSong: s.array("Top songs; sum is the play count.", songCounts),
+    preferHour: s.looseObject("Preferred listening hour.", {
+        preferHour: s.integer("Preferred hour, 0 through 23."),
+        preferInfo: s.array("Listening details indexed by time slot; only sum is populated.", indexedDuration),
+        songListen: s.array("Favorite songs in this time slot.", songMetric),
+    }),
+    consDays: s.looseObject("Consecutive listening statistics.", {
+        conDays: s.integer("Consecutive listening days."),
+        conInfoList: s.array("Daily listening activity and representative songs.", dailyActivity),
+        topListen: s.integer("Maximum song count in one day."),
+        singerDay: singerStreak,
+        songListen: s.array("Songs during the listening streak.", songMetric),
+    }),
+    topGenre: s.looseObject("Preferred genres.", {
+        genreId: s.integer("Preferred genre ID."),
+        genre2Count: s.array("Genre metrics over the past six months.", s.looseObject("A named genre metric.", {
+            name: s.string("Genre name."),
+            sum: s.integer("Genre occurrence count over the past six months."),
+        })),
+        genreSong: s.array("Representative songs for the genre.", songMetric),
+    }),
+    nicheSongs: s.looseObject("Niche and popular music preferences.", {
+        nichePercent: s.integer("Niche song percentage, 0 through 100."),
+        list: s.array("Representative niche songs.", songMetric),
+        hotPercent: s.integer("Popular song percentage, 0 through 100."),
+    }),
+    newSongs: s.looseObject("New music exploration.", {
+        newSongCount: s.integer("New songs explored this month."),
+        floatNumber: s.number("Change ratio compared with last month."),
+        lastNewSongCount: s.integer("New songs explored last month."),
+        list: s.array("Representative newly explored songs.", songMetric),
+    }),
+    listenCityInfo: s.array("Listening cities ordered by unlock time.", s.looseObject("A listening city.", {
+        cityId: s.integer("City ID."),
+        cityName: s.string("City name."),
+        provinceId: s.integer("Province ID."),
+        provinceName: s.string("Province name."),
+        countryId: s.integer("Country ID."),
+        countryName: s.string("Country name."),
+        unlockTime: s.integer("City unlock Unix timestamp in seconds."),
+        cityRank: s.integer("City rank."),
+    })),
+}));

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

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

package/src/providers/rakuraku_seisan/actions.js

@@ -0,0 +1,50 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+export const rakurakuSeisanActions = [
+    defineProviderAction("rakuraku_seisan", {
+        name: "download_journal_file",
+        operationType: "read",
+        description: "Download the latest automatically generated journal file for an export configuration. Historical files are unavailable. Preserves CSV/TXT MS932 encoding or ZIP bytes in transit storage, up to 64 MiB or the configured storage limit.",
+        inputSchema: s.actionInput({ fileGenerateId: s.integer("Automatic file export configuration ID shown in the administration screen.") }, ["fileGenerateId"]),
+        outputSchema: s.actionOutput({
+            file: s.actionOutput({
+                fileId: s.string("Transit file identifier."),
+                downloadUrl: s.url("Temporary download URL."),
+                name: s.string("Export filename."),
+                mimeType: s.string("File MIME type."),
+                sizeBytes: s.nonNegativeInteger("File size in bytes."),
+            }, "Downloaded journal file in transit storage."),
+        }),
+    }),
+    defineProviderAction("rakuraku_seisan", {
+        name: "import_master_csv",
+        operationType: "write",
+        description: "Schedule a master CSV import from a public URL. Requires MS932 encoding, official column names in the first row, at most 5 MB and 50,000 rows. Creates or updates records without deleting them. Poll get_import_status for completion and failed record counts.",
+        inputSchema: s.actionInput({
+            fileUrl: s.url("Public URL of the MS932 CSV file, including its header row."),
+            masterId: s.integer("Official master ID: 0 employees, 1 departments, 2 positions, 3 payees, 4 projects, 18 approvers, 81-85 general masters. For other supported masters such as exchange rates, use the ID supplied by Rakuraku Seisan."),
+            duplicateKey: s.withEnum(s.integer("Duplicate record handling: 0 skip, 1 update. Defaults to 0, or 1 for approvers (masterId 18)."), [0, 1]),
+            sendPasswordEmail: s.boolean("Send password setup emails when importing employees. Defaults to false."),
+            createCategory: s.boolean("Create missing categories for payees, projects, or general masters. Defaults to false."),
+        }, ["fileUrl", "masterId"]),
+        outputSchema: s.actionOutput({ processId: s.string("Import process ID used to poll the result.") }),
+        asyncLifecycle: {
+            startActionId: "rakuraku_seisan.import_master_csv",
+            statusActionId: "rakuraku_seisan.get_import_status",
+        },
+    }),
+    defineProviderAction("rakuraku_seisan", {
+        name: "get_import_status",
+        operationType: "read",
+        description: "Get a CSV import result. A complete process may still contain failed records; inspect failureCount and obtain error reports from the Rakuraku Seisan CSV import status screen.",
+        inputSchema: s.actionInput({ processId: s.nonEmptyString("Process ID returned by import_master_csv.") }, [
+            "processId",
+        ]),
+        outputSchema: s.actionOutput({
+            processStatus: s.string("Provider process state: wait, active, complete, abort, or error."),
+            successCount: s.nonNegativeInteger("Successfully imported record count, when supplied."),
+            failureCount: s.nonNegativeInteger("Failed record count, when supplied."),
+            raw: s.unknownObject("Original provider response, including additional fields."),
+        }, "CSV import status.", ["processStatus", "raw"]),
+    }),
+];

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

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/rakuraku_seisan/executors.js

@@ -0,0 +1,40 @@
+import { defineProviderExecutors, defineProviderProxy, requireApiKeyCredential, mapProviderActionHandlers, requiredInputString, } from "../provider-runtime.js";
+import { rakurakuSeisanActions } from "./actions.js";
+import { normalizeBaseUrl, executeRakurakuSeisanAction, readRakurakuError } from "./runtime.js";
+export const executors = defineProviderExecutors({
+    service: "rakuraku_seisan",
+    handlers: mapProviderActionHandlers("rakuraku_seisan", rakurakuSeisanActions, (action) => (input, context) => executeRakurakuSeisanAction(action.name, input, context)),
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, "rakuraku_seisan");
+        return {
+            apiKey: credential.apiKey,
+            baseUrl: normalizeBaseUrl(credential.values.baseUrl),
+            fetcher,
+            signal: context.signal,
+            transitFiles: context.transitFiles,
+        };
+    },
+});
+export const credentialValidators = {
+    async apiKey(input) {
+        requiredInputString(input.apiKey, "apiKey");
+        const baseUrl = normalizeBaseUrl(input.values.baseUrl);
+        return {
+            profile: {
+                accountId: baseUrl,
+                displayName: `Rakuraku Seisan ${new URL(baseUrl).host}${new URL(baseUrl).pathname}`,
+            },
+            grantedScopes: [],
+            metadata: { baseUrl, credentialValidation: "on_first_request" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "rakuraku_seisan",
+    async baseUrl(context) {
+        const credential = await requireApiKeyCredential(context, "rakuraku_seisan");
+        return `${normalizeBaseUrl(credential.values.baseUrl)}/api/v1`;
+    },
+    auth: { type: "api_key_header", name: "X-RS-apitoken" },
+    readError: readRakurakuError,
+});