@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/provider-runtime.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderErrorCode } from "../core/provider-error-codes.ts";
 import type { ProviderDispatchContext, ProviderHttpDispatchOptions } from "../core/provider-http-dispatch.ts";
 import type { ActionExecutor, ExecutionContext, ExecutionResult, ProviderExecutors, ProviderProxyExecutor, ProxyExecutionResult, ProxyResponse, ResolvedCredential, TransitFileWriter } from "../core/types.ts";
 import type { ProviderActionNames } from "./action-contracts.generated.ts";
@@ -149,8 +150,8 @@ export interface ProviderInputFile {
 export declare class ProviderRequestError extends Error {
     readonly status: number;
     readonly details?: unknown;
-    readonly code?: string;
-    constructor(status: number, message: string, details?: unknown, code?: string);
+    readonly code?: ProviderErrorCode;
+    constructor(status: number, message: string, details?: unknown, code?: ProviderErrorCode);
 }
 /** A dispatch denial is retryable and must not be wrapped as a bad provider credential. */
 export declare class ProviderDispatchRequestError extends ProviderRequestError {

package/src/providers/pushover/runtime.js

@@ -1,7 +1,7 @@
 import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
 import { compactObject, optionalString, requiredString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, mapProviderActionSources, ProviderRequestError, providerUserAgent, readTransitFileInput, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, mapProviderActionSources, ProviderRequestError, providerUserAgent, readTransitFileInput, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const pushoverApiBaseUrl = "https://api.pushover.net";
 export const pushoverVersionedApiBaseUrl = `${pushoverApiBaseUrl}/1`;
 const pushoverIconBaseUrl = `${pushoverApiBaseUrl}/icons`;
@@ -12,9 +12,6 @@ const pushoverDefaultRealtimeTimeoutSeconds = 60;
 const pushoverMaxRealtimeTimeoutSeconds = 300;
 const pushoverMaxAttachmentBytes = 5 * 1024 * 1024;
 const pushoverOpenClientOsCode = "O";
-function pushoverError(_code, message, status = 500, details) {
-    return new ProviderRequestError(status, message, details);
-}
 function createTimeoutSignal(input) {
     const controller = new AbortController();
     let didTimeout = false;
@@ -123,7 +120,7 @@ export const pushoverActionHandlers = {
 };
 const pushoverExecutorHandlers = mapProviderActionSources("pushover", pushoverActionHandlers, (_name, handler) => (input, context) => handler({ apiKey: context.apiKey, values: {}, input, transitFiles: context.transitFiles }, context.fetcher));
 export async function validatePushoverCredential(input, fetcher) {
-    const apiKey = requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message));
+    const apiKey = requiredString(input.apiKey, "apiKey", providerInputError);
     const appLimits = await requestPushoverJson({
         path: "/apps/limits.json",
         query: {
@@ -301,9 +298,9 @@ async function getPushoverAppIconImage(input, fetcher) {
             signal: timeout.signal,
         });
         if (!response.ok) {
-            throw pushoverError(response.status === 404 ? "invalid_input" : "provider_error", response.status === 404
+            throw new ProviderRequestError(response.status === 404 ? 400 : 502, response.status === 404
                 ? `unknown pushover icon: ${parsed.icon}`
-                : `pushover icon request failed with ${response.status} ${response.statusText}`.trim(), response.status === 404 ? 400 : 502);
+                : `pushover icon request failed with ${response.status} ${response.statusText}`.trim());
         }
         const bytes = Buffer.from(await response.arrayBuffer());
         return {
@@ -562,7 +559,7 @@ async function renamePushoverGroup(input, fetcher) {
 async function assignPushoverLicense(input, fetcher) {
     const parsed = input.input;
     if (!parsed.user && !parsed.email) {
-        throw pushoverError("invalid_input", "user or email is required", 400);
+        throw providerInputError("user or email is required");
     }
     const appToken = resolveAppToken(input, parsed.token);
     const payload = await requestPushoverJson({
@@ -728,7 +725,7 @@ async function acknowledgePushoverClientMessages(input, fetcher) {
 async function listenPushoverClientWebsocket(input) {
     const parsed = input.input;
     if (typeof globalThis.WebSocket !== "function") {
-        throw pushoverError("provider_not_configured", "WebSocket is unavailable in this runtime");
+        throw new ProviderRequestError(500, "WebSocket is unavailable in this runtime");
     }
     const timeoutSeconds = Math.min(Math.max(parsed.timeout ?? pushoverDefaultRealtimeTimeoutSeconds, 1), pushoverMaxRealtimeTimeoutSeconds);
     return new Promise((resolve, reject) => {
@@ -780,7 +777,7 @@ async function listenPushoverClientWebsocket(input) {
             }
         });
         socket.addEventListener("error", () => {
-            settleReject(pushoverError("provider_error", "pushover realtime websocket connection failed", 502));
+            settleReject(providerResponseError("pushover realtime websocket connection failed"));
         });
         socket.addEventListener("close", () => {
             settleResolve();
@@ -806,7 +803,7 @@ async function requestPushoverJson(input) {
         const text = await response.text();
         const payload = parseJsonObject(text);
         if (!payload) {
-            throw pushoverError("provider_error", `pushover request returned a non-JSON response from ${input.path}`, 502);
+            throw providerResponseError(`pushover request returned a non-JSON response from ${input.path}`);
         }
         const status = readOptionalInteger(payload.status);
         if (response.ok && status === 1) {
@@ -826,9 +823,9 @@ async function requestPushoverJson(input) {
             throw error;
         }
         if (timeout.didTimeout) {
-            throw pushoverError("provider_error", `pushover request timed out after ${(input.timeoutMs ?? pushoverDefaultTimeoutMs) / 1000} seconds`, 504);
+            throw new ProviderRequestError(504, `pushover request timed out after ${(input.timeoutMs ?? pushoverDefaultTimeoutMs) / 1000} seconds`);
         }
-        throw pushoverError("provider_error", error instanceof Error ? error.message : "pushover request failed", 502);
+        throw providerResponseError(error instanceof Error ? error.message : "pushover request failed");
     }
     finally {
         timeout.cleanup();
@@ -850,24 +847,24 @@ function normalizePushoverRequestError(input) {
             ? "two-factor authentication code required"
             : `pushover request failed with ${input.response.status}`);
     if (input.response.status === 429) {
-        return pushoverError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message);
     }
     if (input.phase === "validate") {
-        return pushoverError("invalid_input", message, 400);
+        return providerInputError(message);
     }
     if (isCredentialProblem(input.payload, input.response.status, input.credentialKind)) {
         if (input.credentialKind === "client_secret" || input.credentialKind === "public") {
-            return pushoverError("invalid_input", message, 400);
+            return providerInputError(message);
         }
         if (input.tokenSource === "connection") {
-            return pushoverError("credential_expired", message);
+            return new ProviderRequestError(500, message);
         }
-        return pushoverError("invalid_input", message, 400);
+        return providerInputError(message);
     }
     if (input.response.status >= 400 && input.response.status < 500) {
-        return pushoverError("invalid_input", message, 400);
+        return providerInputError(message);
     }
-    return pushoverError("provider_error", errors[0] ?? input.rawBody ?? message, input.response.status >= 500 ? 502 : 500);
+    return new ProviderRequestError(input.response.status >= 500 ? 502 : 500, errors[0] ?? input.rawBody ?? message);
 }
 function isCredentialProblem(payload, status, credentialKind) {
     if (status === 401 || status === 403) {
@@ -897,7 +894,7 @@ function resolveAppToken(input, override) {
         };
     }
     return {
-        token: requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message)),
+        token: requiredString(input.apiKey, "apiKey", providerInputError),
         source: "connection",
     };
 }
@@ -911,7 +908,7 @@ function resolveTeamToken(input, override) {
     }
     const connectedToken = readOptionalString(input.values?.teamToken);
     if (!connectedToken) {
-        throw pushoverError("invalid_input", "team token is required; provide input.token or configure Team API Token in the provider connection", 400);
+        throw providerInputError("team token is required; provide input.token or configure Team API Token in the provider connection");
     }
     return {
         token: connectedToken,
@@ -922,7 +919,7 @@ async function resolvePushoverAttachment(input) {
     const hasTransitAttachment = input.attachment != null;
     const hasInlineAttachment = Boolean(input.attachmentBase64 || input.attachmentType);
     if (hasTransitAttachment && hasInlineAttachment) {
-        throw pushoverError("invalid_input", "provide either attachment or attachment_base64/attachment_type, not both", 400);
+        throw providerInputError("provide either attachment or attachment_base64/attachment_type, not both");
     }
     if (input.attachment) {
         const transitFile = await readTransitFileInput(input.attachment, input);
@@ -935,7 +932,7 @@ async function resolvePushoverAttachment(input) {
         return undefined;
     }
     if (!input.attachmentBase64 || !input.attachmentType) {
-        throw pushoverError("invalid_input", "attachment_base64 and attachment_type are required together", 400);
+        throw providerInputError("attachment_base64 and attachment_type are required together");
     }
     const bytes = decodeBase64Attachment(input.attachmentBase64);
     ensureAttachmentSize(bytes, "attachment");
@@ -947,7 +944,7 @@ async function resolvePushoverAttachment(input) {
 }
 function ensureAttachmentSize(bytes, name) {
     if (bytes.byteLength > pushoverMaxAttachmentBytes) {
-        throw pushoverError("invalid_input", `${name} exceeds the 5MB Pushover attachment limit`, 400);
+        throw providerInputError(`${name} exceeds the 5MB Pushover attachment limit`);
     }
 }
 function decodeBase64Attachment(value) {
@@ -957,10 +954,10 @@ function decodeBase64Attachment(value) {
         bytes = Buffer.from(normalized, "base64");
     }
     catch {
-        throw pushoverError("invalid_input", "attachment_base64 must be valid base64", 400);
+        throw providerInputError("attachment_base64 must be valid base64");
     }
     if (bytes.byteLength === 0 || bytes.toString("base64") !== normalized.replace(/\s+/g, "")) {
-        throw pushoverError("invalid_input", "attachment_base64 must be valid base64", 400);
+        throw providerInputError("attachment_base64 must be valid base64");
     }
     return Uint8Array.from(bytes);
 }
@@ -1107,7 +1104,7 @@ function readIdentifierString(preferred, fallback) {
     }
     const fallbackString = normalizeUnknownString(fallback);
     if (!fallbackString) {
-        throw pushoverError("provider_error", "pushover response is missing an identifier", 502);
+        throw providerResponseError("pushover response is missing an identifier");
     }
     return fallbackString;
 }
@@ -1134,7 +1131,7 @@ function normalizeUnknownString(value) {
 function readRequiredString(payload, key) {
     const value = normalizeUnknownString(payload[key]);
     if (!value) {
-        throw pushoverError("provider_error", `pushover response is missing ${key}`, 502);
+        throw providerResponseError(`pushover response is missing ${key}`);
     }
     return value;
 }
@@ -1148,7 +1145,7 @@ function readNullableString(value) {
 function readRequiredInteger(payload, key) {
     const value = readOptionalInteger(payload[key]);
     if (value == null) {
-        throw pushoverError("provider_error", `pushover response is missing ${key}`, 502);
+        throw providerResponseError(`pushover response is missing ${key}`);
     }
     return value;
 }
@@ -1190,7 +1187,7 @@ function readBooleanLike(value) {
             return false;
         }
     }
-    throw pushoverError("provider_error", "pushover response is missing a boolean value", 502);
+    throw providerResponseError("pushover response is missing a boolean value");
 }
 function readStringArray(value) {
     return readOptionalArray(value)

package/src/providers/qianfan/runtime.js

@@ -1,12 +1,9 @@
 import { compactObject, requiredString } from "../../core/cast.js";
 import { encodePathSegment } from "../../core/request.js";
-import { defineApiKeyProviderExecutors, mapProviderActionSources, providerUserAgent, ProviderRequestError, readTransitFileInput, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, mapProviderActionSources, providerUserAgent, ProviderRequestError, readTransitFileInput, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const qianfanApiOrigin = "https://qianfan.baidubce.com";
 export const qianfanApiBaseUrl = `${qianfanApiOrigin}/v2`;
 const qianfanUserAgent = providerUserAgent;
-function qianfanError(_code, message, status = 502) {
-    return new ProviderRequestError(status, message);
-}
 function requireApiKey(input) {
     return requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(401, message));
 }
@@ -311,7 +308,7 @@ async function qianfanRequest(apiKey, input, fetcher) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "unknown network error";
-        throw qianfanError("provider_error", `qianfan ${method} ${input.path} failed before receiving response: ${message}`);
+        throw providerResponseError(`qianfan ${method} ${input.path} failed before receiving response: ${message}`);
     }
     await assertQianfanResponse(response, input.mode ?? "execute");
     return readQianfanJson(response);
@@ -328,7 +325,7 @@ async function qianfanMultipartRequest(apiKey, input, body, fetcher) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "unknown network error";
-        throw qianfanError("provider_error", `qianfan ${method} ${input.path} failed before receiving response: ${message}`);
+        throw providerResponseError(`qianfan ${method} ${input.path} failed before receiving response: ${message}`);
     }
     await assertQianfanResponse(response, input.mode ?? "execute");
     return readQianfanJson(response);
@@ -344,7 +341,7 @@ async function qianfanTextRequest(apiKey, input, fetcher) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "unknown network error";
-        throw qianfanError("provider_error", `qianfan ${method} ${input.path} failed before receiving response: ${message}`);
+        throw providerResponseError(`qianfan ${method} ${input.path} failed before receiving response: ${message}`);
     }
     await assertQianfanResponse(response, input.mode ?? "execute");
     let text;
@@ -352,9 +349,9 @@ async function qianfanTextRequest(apiKey, input, fetcher) {
         text = await response.text();
     }
     catch (error) {
-        throw qianfanError("provider_error", error instanceof Error
+        throw new ProviderRequestError(response.status, error instanceof Error
             ? `failed to read qianfan response body: ${error.message}`
-            : "failed to read qianfan response body", response.status);
+            : "failed to read qianfan response body");
     }
     return {
         content: text,
@@ -371,7 +368,7 @@ function qianfanHeaders(apiKey, includeJsonContentType = true) {
 }
 function assertStreamingDisabled(input) {
     if (input.stream === true) {
-        throw qianfanError("invalid_input", "stream=true is not supported by connector actions", 400);
+        throw providerInputError("stream=true is not supported by connector actions");
     }
 }
 function withoutStreamOptions(input) {
@@ -383,7 +380,7 @@ function requireStringField(input, field) {
     if (typeof value === "string" && value.length > 0) {
         return value;
     }
-    throw qianfanError("invalid_input", `${field} must be a non-empty string`, 400);
+    throw providerInputError(`${field} must be a non-empty string`);
 }
 function withQianfanQuery(path, query) {
     const params = new URLSearchParams();
@@ -409,18 +406,18 @@ async function assertQianfanResponse(response, mode) {
     }
     const error = await readQianfanError(response);
     if (response.status === 429) {
-        throw qianfanError("rate_limited", error.message, 429);
+        throw new ProviderRequestError(429, error.message);
     }
     if (mode === "validate" && (response.status === 401 || response.status === 403)) {
-        throw qianfanError("invalid_input", error.message, 400);
+        throw providerInputError(error.message);
     }
     if (mode === "execute" && response.status === 401) {
-        throw qianfanError("credential_expired", error.message);
+        throw providerResponseError(error.message);
     }
     if (response.status === 400 || response.status === 422) {
-        throw qianfanError("invalid_input", error.message, 400);
+        throw providerInputError(error.message);
     }
-    throw qianfanError("provider_error", error.message, response.status);
+    throw new ProviderRequestError(response.status, error.message);
 }
 async function readQianfanJson(response) {
     let text;
@@ -428,9 +425,9 @@ async function readQianfanJson(response) {
         text = await response.text();
     }
     catch (error) {
-        throw qianfanError("provider_error", error instanceof Error
+        throw new ProviderRequestError(response.status, error instanceof Error
             ? `failed to read qianfan response body: ${error.message}`
-            : "failed to read qianfan response body", response.status);
+            : "failed to read qianfan response body");
     }
     if (response.status === 204 || text.trim() === "") {
         return {};
@@ -439,7 +436,7 @@ async function readQianfanJson(response) {
         return JSON.parse(text);
     }
     catch {
-        throw qianfanError("provider_error", `qianfan returned invalid JSON with ${response.status}: ${text.slice(0, 200)}`, response.status);
+        throw new ProviderRequestError(response.status, `qianfan returned invalid JSON with ${response.status}: ${text.slice(0, 200)}`);
     }
 }
 async function readQianfanError(response) {

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

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

package/src/providers/qiuxiaoce/actions.js

@@ -0,0 +1,248 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+export const qiuxiaoceActions = [
+    defineProviderAction("qiuxiaoce", {
+        name: "get_quota",
+        description: "Read remaining credits, expiration and today's usage without consuming credits.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_quota.", {}, { required: [] }),
+        outputSchema: s.looseObject("The get_quota response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.looseObject("Credit balance and usage.", {
+                credits_remaining: s.integer("Remaining API credits."),
+                expires_at: s.nullable(s.string("Credit expiration reported by the provider.")),
+                today_used: s.integer("Credits consumed today."),
+            }),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "get_daily_digest",
+        description: "List matches for a sales date, including fixture IDs and report availability. Omit date for the current sales day.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_daily_digest.", { date: s.string("Calendar date in YYYY-MM-DD format.", { format: "date" }) }, { required: [] }),
+        outputSchema: s.looseObject("The get_daily_digest response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            date: s.string("Calendar date in YYYY-MM-DD format.", { format: "date" }),
+            total: s.integer("Total matches."),
+            summary: s.looseObject("Report and data readiness counts."),
+            matches: s.array("Matches on the selected sales day.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "list_fixtures",
+        description: "Find fixtures by date, date range, league, team, round, status or fixture ID. Use either date or from/to.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: {
+            ...s.object("Parameters for list_fixtures.", {
+                date: s.string("Calendar date in YYYY-MM-DD format.", { format: "date" }),
+                from: s.string("Calendar date in YYYY-MM-DD format.", { format: "date" }),
+                to: s.string("Calendar date in YYYY-MM-DD format.", { format: "date" }),
+                league: s.integer("The provider entity ID returned by a discovery action."),
+                season: s.integer("Season starting year. Omit to use the provider default season."),
+                team: s.integer("The provider entity ID returned by a discovery action."),
+                round: s.string("Round name; requires league and season."),
+                status: s.stringEnum("Fixture status: not started, finished, or live.", ["NS", "FT", "LIVE"]),
+                last: s.integer("Most recent number of matches; requires team."),
+                next: s.integer("Upcoming number of matches; requires team."),
+                id: s.integer("The provider entity ID returned by a discovery action."),
+            }, { required: [] }),
+            dependentRequired: {
+                from: ["to"],
+                to: ["from"],
+                round: ["league", "season"],
+                last: ["team"],
+                next: ["team"],
+            },
+            not: { required: ["date"], anyOf: [{ required: ["from"] }, { required: ["to"] }] },
+        },
+        outputSchema: s.looseObject("The list_fixtures response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            count: s.integer("Number of returned fixtures."),
+            fixtures: s.array("Matching fixtures.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "get_fixture",
+        description: "Read a fixture's kickoff, score, status and teams.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_fixture.", { id: s.integer("The provider entity ID returned by a discovery action.") }, { required: ["id"] }),
+        outputSchema: s.looseObject("The get_fixture response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.looseObject("Upstream detail fields, preserved without filtering."),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "get_fixture_stats",
+        description: "Read post-match technical statistics for a fixture.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_fixture_stats.", { id: s.integer("The provider entity ID returned by a discovery action.") }, { required: ["id"] }),
+        outputSchema: s.looseObject("The get_fixture_stats response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.looseObject("Upstream detail fields, preserved without filtering."),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "get_fixture_events",
+        description: "Read goals, cards and substitutions for a fixture.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_fixture_events.", { id: s.integer("The provider entity ID returned by a discovery action.") }, { required: ["id"] }),
+        outputSchema: s.looseObject("The get_fixture_events response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            events: s.array("Fixture events.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "get_fixture_lineups",
+        description: "Read announced starting lineups and substitutes for a fixture.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_fixture_lineups.", { id: s.integer("The provider entity ID returned by a discovery action.") }, { required: ["id"] }),
+        outputSchema: s.looseObject("The get_fixture_lineups response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.looseObject("Upstream detail fields, preserved without filtering."),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "get_fixture_players",
+        description: "Read player-by-player post-match statistics for a fixture.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_fixture_players.", { id: s.integer("The provider entity ID returned by a discovery action.") }, { required: ["id"] }),
+        outputSchema: s.looseObject("The get_fixture_players response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.looseObject("Upstream detail fields, preserved without filtering."),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "search_teams",
+        description: "Search teams by name, including Chinese aliases. Verify the returned identity before selecting an ID.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for search_teams.", { search: s.nonEmptyString("Team name keyword, including Chinese aliases.") }, { required: ["search"] }),
+        outputSchema: s.looseObject("The search_teams response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            teams: s.array("Matching teams.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "get_team",
+        description: "Read a team's names, country, venue and founding information.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_team.", { id: s.integer("The provider entity ID returned by a discovery action.") }, { required: ["id"] }),
+        outputSchema: s.looseObject("The get_team response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.looseObject("Upstream detail fields, preserved without filtering."),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "list_leagues",
+        description: "List supported leagues, optionally searching by name or Chinese alias.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for list_leagues.", { q: s.string("Optional league name keyword.") }, { required: [] }),
+        outputSchema: s.looseObject("The list_leagues response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            leagues: s.array("Matching leagues.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "get_league",
+        description: "Read league details and current standings.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_league.", { id: s.integer("The provider entity ID returned by a discovery action.") }, { required: ["id"] }),
+        outputSchema: s.looseObject("The get_league response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.looseObject("Upstream detail fields, preserved without filtering."),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "get_standings",
+        description: "Read league standings for a season, defaulting to the latest available season.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for get_standings.", {
+            league: s.integer("The provider entity ID returned by a discovery action."),
+            season: s.integer("Season starting year. Omit to use the provider default season."),
+        }, { required: ["league"] }),
+        outputSchema: s.looseObject("The get_standings response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            season: s.integer("Season starting year. Omit to use the provider default season."),
+            data: s.array("League standings.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "list_league_fixtures",
+        description: "List all league fixtures and scores for a season.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for list_league_fixtures.", {
+            id: s.integer("The provider entity ID returned by a discovery action."),
+            season: s.integer("Season starting year. Omit to use the provider default season."),
+        }, { required: ["id"] }),
+        outputSchema: s.looseObject("The list_league_fixtures response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.array("Season records returned by the provider.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "list_league_teams",
+        description: "List participating teams for a league season.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for list_league_teams.", {
+            id: s.integer("The provider entity ID returned by a discovery action."),
+            season: s.integer("Season starting year. Omit to use the provider default season."),
+        }, { required: ["id"] }),
+        outputSchema: s.looseObject("The list_league_teams response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.array("Season records returned by the provider.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "list_league_top_scorers",
+        description: "Read a league season's top scorers.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for list_league_top_scorers.", {
+            id: s.integer("The provider entity ID returned by a discovery action."),
+            season: s.integer("Season starting year. Omit to use the provider default season."),
+        }, { required: ["id"] }),
+        outputSchema: s.looseObject("The list_league_top_scorers response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.array("Season records returned by the provider.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "list_league_top_assists",
+        description: "Read a league season's assist leaders.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for list_league_top_assists.", {
+            id: s.integer("The provider entity ID returned by a discovery action."),
+            season: s.integer("Season starting year. Omit to use the provider default season."),
+        }, { required: ["id"] }),
+        outputSchema: s.looseObject("The list_league_top_assists response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.array("Season records returned by the provider.", s.looseObject("One upstream record, including provider-specific fields.")),
+        }),
+    }),
+    defineProviderAction("qiuxiaoce", {
+        name: "list_league_seasons",
+        description: "List available season years before querying historical league data.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Parameters for list_league_seasons.", { id: s.integer("The provider entity ID returned by a discovery action.") }, { required: ["id"] }),
+        outputSchema: s.looseObject("The list_league_seasons response from QiuXiaoCe.", {
+            success: s.boolean("Whether the provider reports success."),
+            data: s.array("Available season starting years.", s.integer("Season starting year. Omit to use the provider default season.")),
+        }),
+    }),
+];

package/src/providers/qiuxiaoce/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;