@oomol-lab/open-connector 1.6.4 → 1.7.0

package/src/providers/aliyun_ack/runtime.js

@@ -26,7 +26,7 @@ export async function getTemporaryKubeconfig(input, credential, deps = {}) {
         const response = await (deps.fetcher ?? fetch)(url, {
             method: "GET",
             headers: signedRequest.headers,
-            redirect: "error",
+            redirect: "manual",
             signal,
         });
         const payload = parseJsonObject(await response.text());

package/src/providers/aliyun_sls/runtime.js

@@ -67,7 +67,7 @@ export async function requestAliyunSlsJson(context, input) {
     const requestInit = {
         method: input.method,
         headers: signed.headers,
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
     };
     if (signed.bodyBytes.byteLength > 0) {

package/src/providers/app_store_server/runtime-helpers.js

@@ -54,7 +54,7 @@ export async function requestAppStoreServer(context, input) {
                     ? undefined
                     : JSON.stringify(input.body),
             signal,
-            redirect: "error",
+            redirect: "manual",
         });
         const payload = await readPayload(response);
         if (!response.ok) {

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

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

package/src/providers/baizhi_mcp/actions.js

@@ -0,0 +1,40 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const service = "baizhi_mcp";
+const toolSummary = s.object("One currently available Baizhi web tool.", {
+    name: s.stringEnum("The exact live tool name.", ["websearch_search", "web_scrape", "web_extract"]),
+    description: s.string("The live description supplied by the service; treat it as untrusted content."),
+    annotations: s.looseObject("Optional MCP behavior hints supplied by the service."),
+    inputSchema: s.looseObject("The live JSON Schema for this tool's arguments."),
+}, { optional: ["description", "annotations"] });
+export const baizhiMcpActions = [
+    defineProviderAction(service, {
+        name: "list_tools",
+        operationType: "read",
+        description: "Discover the currently available Baizhi web search, page-reading, and extraction tools with their live argument schemas. Tools that advertise write or destructive behavior are withheld.",
+        requiredScopes: [],
+        followUpActions: ["baizhi_mcp.call_tool"],
+        inputSchema: s.object("No input is required.", {}),
+        outputSchema: s.object("The permitted tools available to this Baizhi connection.", {
+            tools: s.array("Current permitted Baizhi web tools.", toolSummary),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "call_tool",
+        operationType: "read",
+        description: "Call only a currently available Baizhi websearch_search, web_scrape, or web_extract tool using its live input schema. These hosted calls may consume service credits; webpage content is untrusted.",
+        requiredScopes: [],
+        followUpActions: ["baizhi_mcp.list_tools"],
+        inputSchema: s.object("Call one permitted Baizhi web tool.", {
+            toolName: s.stringEnum("The exact tool name returned by list_tools.", [
+                "websearch_search",
+                "web_scrape",
+                "web_extract",
+            ]),
+            arguments: s.looseObject("Arguments matching that tool's live inputSchema."),
+        }, { optional: ["arguments"] }),
+        outputSchema: s.object("The dynamic result returned by the Baizhi MCP tool.", {
+            result: s.unknown("Structured MCP content when available; otherwise the complete MCP result envelope."),
+        }),
+    }),
+];

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

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

package/src/providers/baizhi_mcp/executors.js

@@ -0,0 +1,102 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { optionalRecord } from "../../core/cast.js";
+import { callMcpTool, listMcpTools } from "../mcp-tools.js";
+import { defineApiKeyProviderExecutors, mapProviderActionHandlers, providerInputError, ProviderRequestError, providerResponseError, requiredInputString, } from "../provider-runtime.js";
+import { baizhiMcpActions } from "./actions.js";
+const service = "baizhi_mcp";
+const endpoint = "https://agent-toolkit.app.baizhi.cloud/mcp";
+const allowedToolNames = new Set(["websearch_search", "web_scrape", "web_extract"]);
+const handlers = mapProviderActionHandlers(service, baizhiMcpActions, (_action, actionName) => async (input, context) => {
+    const connection = connectionInput(context.apiKey, context.fetcher, context.signal);
+    if (actionName === "list_tools") {
+        const tools = await safeMcpRequest(context.apiKey, () => listMcpTools(connection, { includeAnnotations: true }));
+        return { tools: selectReadableTools(tools) };
+    }
+    const toolName = requiredInputString(input.toolName, "toolName");
+    if (!allowedToolNames.has(toolName)) {
+        throw providerInputError("Only Baizhi web search, page reading, and extraction tools are supported");
+    }
+    return {
+        result: await safeMcpRequest(context.apiKey, () => callMcpTool({
+            ...connection,
+            toolName,
+            arguments: optionalRecord(input.arguments) ?? {},
+            authorizeTool(tool) {
+                if (!tool || !isReadableTool(tool)) {
+                    throw providerInputError(`Baizhi MCP tool ${toolName} is unavailable or not read-only`);
+                }
+            },
+        })),
+    };
+});
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const key = requiredInputString(input.apiKey, "Baizhi API Key");
+        const tools = await safeMcpRequest(key, () => listMcpTools(connectionInput(key, fetcher, signal), { includeAnnotations: true }));
+        if (selectReadableTools(tools).length === 0) {
+            throw providerInputError("Baizhi MCP did not advertise a supported read-only web tool");
+        }
+        const hash = sha256Hex(key).slice(0, 16);
+        return {
+            profile: { accountId: `baizhi-mcp:${hash}`, displayName: `Baizhi Cloud · ${hash.slice(-6)}` },
+            metadata: { mcpEndpoint: endpoint },
+        };
+    },
+};
+function connectionInput(key, fetcher, signal) {
+    const apiKey = requiredInputString(key, "Baizhi API Key");
+    if (/^Bearer\s+/i.test(apiKey)) {
+        throw providerInputError("Paste the Baizhi API Key without the Bearer prefix");
+    }
+    return {
+        endpoint,
+        service: "Baizhi",
+        fetcher,
+        headers: { authorization: `Bearer ${apiKey}` },
+        // Cloudflare Workers rejects `redirect: "error"`; a 3xx under "manual" still fails the MCP request.
+        redirect: "manual",
+        terminateSession: true,
+        signal,
+        maxResponseBytes: 8 * 1024 * 1024,
+        toolListMaxBytes: 2 * 1024 * 1024,
+        toolListMaxPages: 20,
+        toolListMaxTools: 1_000,
+    };
+}
+function isReadableTool(tool) {
+    return (allowedToolNames.has(tool.name) &&
+        tool.annotations?.readOnlyHint !== false &&
+        tool.annotations?.destructiveHint !== true);
+}
+function selectReadableTools(tools) {
+    const selected = tools.filter((tool) => allowedToolNames.has(tool.name));
+    const names = new Set();
+    for (const tool of selected) {
+        if (names.has(tool.name)) {
+            throw providerResponseError("Baizhi MCP tools/list returned duplicate web tool names");
+        }
+        names.add(tool.name);
+    }
+    return selected.filter(isReadableTool);
+}
+/**
+ * Redact the API Key from MCP errors, which can echo upstream response bodies.
+ * The shared MCP mapper tags 401/403 as provider_error; clearing that code lets
+ * the runtime report them as authorization_failed.
+ */
+async function safeMcpRequest(key, request) {
+    try {
+        return await request();
+    }
+    catch (error) {
+        if (!(error instanceof ProviderRequestError))
+            throw error;
+        const rawKey = key.trim();
+        const message = error.message.split(rawKey).join("[redacted]").split(encodeURIComponent(rawKey)).join("[redacted]");
+        const code = error.status === 401 || error.status === 403 ? undefined : error.code;
+        throw new ProviderRequestError(error.status, message, error.details, code);
+    }
+}

package/src/providers/bazhuayu/runtime.js

@@ -208,7 +208,7 @@ async function requestApi(method, path, parameters, context, parameterLocation =
 async function requestApiWithToken(method, path, accessToken, parameters, context, parameterLocation) {
     const url = new URL(path, bazhuayuApiBaseUrl);
     const headers = new Headers({ accept: "application/json", authorization: `Bearer ${accessToken}` });
-    const init = { method, redirect: "error", headers };
+    const init = { method, redirect: "manual", headers };
     if (parameterLocation === "query") {
         for (const [key, value] of Object.entries(parameters)) {
             if (value !== undefined)
@@ -257,7 +257,7 @@ function requestNewToken(credential, fetcher, phase, signal) {
 async function requestToken(body, fetcher, phase, signal, fallbackRefreshToken = "") {
     const envelope = await requestJson(new URL("/token", bazhuayuApiBaseUrl), {
         method: "POST",
-        redirect: "error",
+        redirect: "manual",
         headers: { accept: "application/json", "content-type": "application/json" },
         body: JSON.stringify(body),
     }, fetcher, phase, signal);

package/src/providers/bilibili/articles.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderActionHandlerSubset } from "../provider-runtime.ts";
+import type { BilibiliActionHandler } from "./runtime.ts";
+export declare const bilibiliArticleActionHandlers: ProviderActionHandlerSubset<"bilibili", BilibiliActionHandler>;

package/src/providers/bilibili/articles.js

@@ -0,0 +1,369 @@
+import { compactObject, looseArray, optionalBoolean, optionalNumber, optionalRecord, optionalString, optionalStringArray, positiveInteger, } from "../../core/cast.js";
+import { providerInputError, providerResponseError, readTransitFileInput, requiredInputNumber, requiredInputString, requiredResponseRecord, } from "../provider-runtime.js";
+import { assertAnyInputField, bilibiliApiRequest, bilibiliFormRequest, readBilibiliReplyIncrement } from "./runtime.js";
+import { uploadBilibiliArticleImage } from "./upload.js";
+export const bilibiliArticleActionHandlers = {
+    async list_article_categories(_input, context) {
+        const data = await bilibiliApiRequest(context, {
+            path: "/article/categories",
+            label: "Bilibili article category list",
+        });
+        return { categories: looseArray(data) };
+    },
+    async upload_article_image(input, context) {
+        const image = await readTransitFileInput(input.file, context);
+        return uploadBilibiliArticleImage(context, image.file, optionalBoolean(input.watermark));
+    },
+    async submit_article(input, context) {
+        const data = requiredResponseRecord(await bilibiliFormRequest(context, {
+            path: "/article/add",
+            fields: readArticleFormFields(input),
+            label: "Bilibili article submit",
+        }), "Bilibili article submit");
+        return { articleId: positiveInteger(data.id, "id", providerResponseError) };
+    },
+    async edit_article(input, context) {
+        const articleId = requiredInputNumber(input.articleId, "articleId");
+        assertAnyInputField(input, [
+            "title",
+            "categoryId",
+            "templateId",
+            "summary",
+            "content",
+            "bannerUrl",
+            "original",
+            "imageUrls",
+            "tags",
+            "anthologyId",
+            "upClosedReply",
+            "topVideoBvid",
+        ]);
+        // Fail fast on an explicit mutually exclusive pair before reading anything.
+        assertArticleCoverChoice(input);
+        // Bilibili replaces every field on edit, so unchanged fields are refilled
+        // from the current article before submitting.
+        const current = requiredResponseRecord(await bilibiliApiRequest(context, {
+            path: "/article/detail",
+            query: { id: String(articleId) },
+            label: "Bilibili article detail",
+        }), "Bilibili article detail");
+        const currentCategory = optionalRecord(current.category);
+        const currentAnthology = optionalRecord(current.list);
+        await bilibiliFormRequest(context, {
+            path: "/article/edit",
+            fields: readArticleFormFields(input, {
+                id: articleId,
+                title: optionalString(current.title),
+                category: optionalNumber(currentCategory?.id),
+                template_id: optionalNumber(current.template_id),
+                summary: optionalString(current.summary),
+                content: optionalString(current.content),
+                banner_url: optionalString(current.banner_url),
+                original: optionalNumber(current.original),
+                image_urls: optionalStringArray(current.image_urls)?.join(","),
+                tags: readArticleTagNames(current.tags),
+                list_id: optionalNumber(currentAnthology?.id),
+                top_video_bvid: optionalString(current.top_video_bvid),
+            }),
+            label: "Bilibili article edit",
+        });
+        return { articleId };
+    },
+    async delete_articles(input, context) {
+        const ids = readArticleIdList(input.articleIds);
+        await bilibiliFormRequest(context, {
+            path: "/article/delete",
+            fields: { ids: ids.join(",") },
+            label: "Bilibili article delete",
+        });
+        return { articleIds: ids, deleted: true };
+    },
+    async get_article(input, context) {
+        const articleId = requiredInputNumber(input.articleId, "articleId");
+        const data = await bilibiliApiRequest(context, {
+            path: "/article/detail",
+            query: { id: String(articleId) },
+            label: "Bilibili article detail",
+        });
+        return normalizeBilibiliArticle(data);
+    },
+    async list_articles(input, context) {
+        const sort = optionalNumber(input.sort);
+        const group = optionalNumber(input.group);
+        const category = optionalNumber(input.categoryId);
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, {
+            path: "/article/list",
+            query: {
+                pn: String(optionalNumber(input.pn) ?? 1),
+                ps: String(optionalNumber(input.ps) ?? 10),
+                sort: sort === undefined ? undefined : String(sort),
+                group: group === undefined ? undefined : String(group),
+                category: category === undefined ? undefined : String(category),
+            },
+            label: "Bilibili article list",
+        }), "Bilibili article list");
+        const page = optionalRecord(data.artPage);
+        const counts = optionalRecord(data.creationArtsType);
+        return {
+            articles: looseArray(data.articles).map(normalizeBilibiliArticle),
+            page: compactObject({
+                pn: optionalNumber(page?.pn),
+                ps: optionalNumber(page?.ps),
+                total: optionalNumber(page?.total),
+            }),
+            counts: compactObject({
+                all: optionalNumber(counts?.all),
+                audit: optionalNumber(counts?.audit),
+                passed: optionalNumber(counts?.passed),
+                notPassed: optionalNumber(counts?.notPassed),
+            }),
+        };
+    },
+    async get_article_card_snippet(input, context) {
+        const resourceId = requiredInputString(input.resourceId, "resourceId");
+        // The document's formal URL field says /article/card while its own curl
+        // sample calls /article/cards; this follows the documented field.
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, {
+            path: "/article/card",
+            query: { resource_id: resourceId },
+            label: "Bilibili article card",
+        }), "Bilibili article card");
+        return compactObject({ snippet: optionalString(data.snippet) });
+    },
+    async create_anthology(input, context) {
+        const data = requiredResponseRecord(await bilibiliFormRequest(context, {
+            path: "/article/anthology/add",
+            fields: {
+                name: requiredInputString(input.name, "name"),
+                summary: optionalString(input.summary),
+                image_url: optionalString(input.imageUrl),
+            },
+            label: "Bilibili anthology create",
+        }), "Bilibili anthology create");
+        return compactObject({
+            anthologyId: optionalNumber(data.id),
+            name: optionalString(data.name),
+        });
+    },
+    async edit_anthology(input, context) {
+        const anthologyId = requiredInputNumber(input.anthologyId, "anthologyId");
+        assertAnyInputField(input, ["name", "summary", "imageUrl"]);
+        // Same full-field replacement semantics as article editing: unchanged
+        // fields are refilled from the current anthology.
+        const current = requiredResponseRecord(await bilibiliApiRequest(context, {
+            path: "/article/anthology/detail",
+            query: { id: String(anthologyId) },
+            label: "Bilibili anthology detail",
+        }), "Bilibili anthology detail");
+        const anthology = optionalRecord(current.list) ?? current;
+        const name = optionalString(input.name) ?? optionalString(anthology.name);
+        if (!name) {
+            throw providerInputError("name is required when the current anthology does not provide it.");
+        }
+        await bilibiliFormRequest(context, {
+            path: "/article/anthology/edit",
+            fields: {
+                list_id: String(anthologyId),
+                name,
+                summary: optionalString(input.summary) ?? optionalString(anthology.summary),
+                image_url: optionalString(input.imageUrl) ?? optionalString(anthology.image_url),
+            },
+            label: "Bilibili anthology edit",
+        });
+        return { anthologyId };
+    },
+    async delete_anthology(input, context) {
+        const anthologyId = requiredInputNumber(input.anthologyId, "anthologyId");
+        await bilibiliFormRequest(context, {
+            path: "/article/anthology/delete",
+            fields: { id: String(anthologyId) },
+            label: "Bilibili anthology delete",
+        });
+        return { anthologyId, deleted: true };
+    },
+    async list_anthologies(_input, context) {
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, { path: "/article/anthology/list", label: "Bilibili anthology list" }), "Bilibili anthology list");
+        return {
+            anthologies: looseArray(data.lists).map(normalizeBilibiliAnthology),
+            total: optionalNumber(data.total),
+        };
+    },
+    async get_anthology(input, context) {
+        const anthologyId = requiredInputNumber(input.anthologyId, "anthologyId");
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, {
+            path: "/article/anthology/detail",
+            query: { id: String(anthologyId) },
+            label: "Bilibili anthology detail",
+        }), "Bilibili anthology detail");
+        return {
+            anthology: normalizeBilibiliAnthology(optionalRecord(data.list) ?? {}),
+            articles: looseArray(data.articles).map((article) => {
+                const record = optionalRecord(article) ?? {};
+                return compactObject({
+                    articleId: optionalNumber(record.id),
+                    title: optionalString(record.title),
+                    state: optionalNumber(record.state),
+                    publishTime: optionalNumber(record.publish_time),
+                });
+            }),
+            total: optionalNumber(data.total),
+        };
+    },
+    async set_anthology_articles(input, context) {
+        const anthologyId = requiredInputNumber(input.anthologyId, "anthologyId");
+        // An empty list clears the anthology; otherwise the given list replaces the current one.
+        const articleIds = readArticleIdList(input.articleIds, { allowEmpty: true });
+        await bilibiliFormRequest(context, {
+            path: "/article/belong",
+            fields: { list_id: String(anthologyId), article_ids: articleIds.join(",") },
+            label: "Bilibili anthology article update",
+        });
+        return { anthologyId, articleIds };
+    },
+    async get_article_stats(input, context) {
+        const ids = readArticleIdList(input.articleIds);
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, {
+            path: "/data/art/stat",
+            query: { ids: ids.join(",") },
+            label: "Bilibili article stats",
+        }), "Bilibili article stats");
+        return {
+            articles: Object.entries(data).map(([id, article]) => ({
+                articleId: Number(id),
+                ...normalizeBilibiliArticle(article),
+            })),
+        };
+    },
+    async get_article_inc_stats(_input, context) {
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, { path: "/data/art/inc-stats", label: "Bilibili article incremental stats" }), "Bilibili article incremental stats");
+        return compactObject({
+            incRead: optionalNumber(data.inc_read),
+            incReply: readBilibiliReplyIncrement(data),
+            incFavorite: optionalNumber(data.inc_fav),
+            incLikes: optionalNumber(data.inc_likes),
+            incShare: optionalNumber(data.inc_share),
+            incCoin: optionalNumber(data.inc_coin),
+        });
+    },
+};
+/** Reject an explicit bannerUrl+topVideoBvid pair; the document makes them mutually exclusive. */
+function assertArticleCoverChoice(input) {
+    if (optionalString(input.bannerUrl) && optionalString(input.topVideoBvid)) {
+        throw providerInputError("bannerUrl and topVideoBvid are mutually exclusive.");
+    }
+}
+/** Build the multipart form fields of an article add/edit request, merging over `current` when editing. */
+function readArticleFormFields(input, current = {}) {
+    const original = optionalBoolean(input.original);
+    const upClosedReply = optionalBoolean(input.upClosedReply);
+    const anthologyId = optionalNumber(input.anthologyId);
+    const imageUrls = input.imageUrls === undefined ? undefined : readArticleImageUrls(input.imageUrls);
+    assertArticleCoverChoice(input);
+    // An explicit input replaces the inherited counterpart so editing can switch.
+    const inputBannerUrl = optionalString(input.bannerUrl);
+    const inputTopVideoBvid = optionalString(input.topVideoBvid);
+    const bannerUrl = inputBannerUrl ?? (inputTopVideoBvid ? undefined : current.banner_url?.toString());
+    const topVideoBvid = inputTopVideoBvid ?? (inputBannerUrl ? undefined : current.top_video_bvid?.toString());
+    return {
+        id: current.id === undefined ? undefined : String(current.id),
+        title: optionalString(input.title) ?? requiredInputString(current.title, "title"),
+        category: String(optionalNumber(input.categoryId) ?? requiredInputNumber(current.category, "category")),
+        template_id: String(optionalNumber(input.templateId) ?? requiredInputNumber(current.template_id, "templateId")),
+        summary: optionalString(input.summary) ?? requiredInputString(current.summary, "summary"),
+        content: optionalString(input.content) ?? requiredInputString(current.content, "content"),
+        banner_url: bannerUrl,
+        original: original === undefined ? current.original?.toString() : original ? "1" : "0",
+        image_urls: imageUrls ?? current.image_urls?.toString(),
+        tags: optionalString(input.tags) ?? current.tags?.toString(),
+        list_id: anthologyId === undefined ? current.list_id?.toString() : String(anthologyId),
+        up_closed_reply: upClosedReply === undefined ? undefined : upClosedReply ? "1" : "0",
+        top_video_bvid: topVideoBvid,
+    };
+}
+function readArticleImageUrls(value) {
+    const urls = optionalStringArray(value);
+    if (!urls || urls.length === 0) {
+        throw providerInputError("imageUrls must be a non-empty array of Bilibili-hosted image URLs.");
+    }
+    return urls.join(",");
+}
+function readArticleIdList(value, options = {}) {
+    const ids = Array.isArray(value) ? value.map((id) => positiveInteger(id, "articleIds", providerInputError)) : [];
+    if (ids.length === 0 && !options.allowEmpty) {
+        throw providerInputError("articleIds must be a non-empty array of article ids.");
+    }
+    return ids;
+}
+function readArticleTagNames(value) {
+    const tags = looseArray(value)
+        .map((tag) => optionalString(optionalRecord(tag)?.name))
+        .filter((name) => name !== undefined);
+    return tags.length > 0 ? tags.join(",") : undefined;
+}
+function normalizeBilibiliArticle(value) {
+    const record = optionalRecord(value) ?? {};
+    const category = optionalRecord(record.category);
+    const stats = optionalRecord(record.stats);
+    const anthology = optionalRecord(record.list);
+    return compactObject({
+        articleId: optionalNumber(record.id),
+        title: optionalString(record.title),
+        summary: optionalString(record.summary),
+        content: optionalString(record.content),
+        bannerUrl: optionalString(record.banner_url),
+        templateId: optionalNumber(record.template_id),
+        state: optionalNumber(record.state),
+        reason: optionalString(record.reason),
+        imageUrls: optionalStringArray(record.image_urls),
+        publishTime: optionalNumber(record.publish_time),
+        ctime: optionalNumber(record.ctime),
+        words: optionalNumber(record.words),
+        original: optionalNumber(record.original),
+        topVideoBvid: optionalString(record.top_video_bvid),
+        type: optionalNumber(record.type),
+        category: category === undefined
+            ? undefined
+            : compactObject({
+                id: optionalNumber(category.id),
+                parentId: optionalNumber(category.parent_id),
+                name: optionalString(category.name),
+            }),
+        stats: stats === undefined
+            ? undefined
+            : compactObject({
+                view: optionalNumber(stats.view),
+                favorite: optionalNumber(stats.favorite),
+                like: optionalNumber(stats.like),
+                dislike: optionalNumber(stats.dislike),
+                reply: optionalNumber(stats.reply),
+                share: optionalNumber(stats.share),
+                coin: optionalNumber(stats.coin),
+            }),
+        tags: looseArray(record.tags).map((tag) => {
+            const item = optionalRecord(tag) ?? {};
+            return compactObject({ tid: optionalNumber(item.tid), name: optionalString(item.name) });
+        }),
+        anthology: anthology === undefined
+            ? undefined
+            : compactObject({ anthologyId: optionalNumber(anthology.id), name: optionalString(anthology.name) }),
+    });
+}
+function normalizeBilibiliAnthology(value) {
+    const record = optionalRecord(value) ?? {};
+    return compactObject({
+        anthologyId: optionalNumber(record.id),
+        name: optionalString(record.name),
+        imageUrl: optionalString(record.image_url),
+        summary: optionalString(record.summary),
+        words: optionalNumber(record.words),
+        read: optionalNumber(record.read),
+        state: optionalNumber(record.state),
+        reason: optionalString(record.reason),
+        total: optionalNumber(record.total),
+        ctime: optionalNumber(record.ctime),
+        publishTime: optionalNumber(record.publish_time),
+        updateTime: optionalNumber(record.update_time),
+        applyTime: optionalString(record.apply_time),
+        checkTime: optionalString(record.check_time),
+    });
+}

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

@@ -0,0 +1,8 @@
+import type { CredentialValidators, ProviderExecutors } from "../../core/types.ts";
+import type { ProviderOAuthRuntime } from "../../oauth/oauth-token.ts";
+import type { ProviderActionHandlers } from "../provider-runtime.ts";
+import type { BilibiliActionHandler } from "./runtime.ts";
+export declare const bilibiliActionHandlers: ProviderActionHandlers<"bilibili", BilibiliActionHandler>;
+export declare const executors: ProviderExecutors;
+export declare const oauth: ProviderOAuthRuntime;
+export declare const credentialValidators: CredentialValidators;