@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/weread/actions.js

@@ -0,0 +1,424 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+export const wereadActions = [
+    defineProviderAction("weread", {
+        name: "search",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search WeRead. Choose scope explicitly; use the last searchIdx as maxIdx for the next page. Response group scope may differ from request scope.",
+        inputSchema: s.object("Parameters for search.", {
+            keyword: s.string("Search keywords.", { minLength: 1 }),
+            scope: {
+                ...s.integer("Search type: 0 all, 10 ebooks, 16 web novels, 14 audio, 6 authors, 12 full text, 13 book lists, 2 public accounts, 4 articles."),
+                enum: [0, 10, 16, 14, 6, 12, 13, 2, 4],
+            },
+            maxIdx: s.integer("Pagination offset from the previous page; initially 0.", { minimum: 0 }),
+            count: s.integer("Page size; omit to use the upstream default.", { minimum: 1 }),
+        }, { required: ["keyword", "scope"] }),
+        outputSchema: s.looseObject("Search response.", {
+            sid: s.string("Search session ID."),
+            hasMore: s.integer("Whether another page exists: 1 means yes, 0 means no."),
+            results: s.array("Result groups; do not filter groups by the requested scope.", s.looseObject("A search result group.", {
+                scope: s.integer("Response group type; ebook groups can use 17."),
+                books: s.array("Results in this group.", s.looseObject("A search result.", {
+                    searchIdx: s.integer("Pagination offset from the previous page; initially 0.", {
+                        minimum: 0,
+                    }),
+                    bookInfo: s.looseObject("Book metadata, including any upstream links and additional fields.", {
+                        bookId: s.string("The book ID returned by search or the shelf.", {
+                            minLength: 1,
+                        }),
+                        title: s.string("Book title."),
+                        author: s.string("Book author."),
+                        readerLink: s.string("Use this upstream reader URL to open the book; do not construct a URL."),
+                        deepLink: s.string("Book details link; use when readerLink is absent."),
+                    }),
+                })),
+            })),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "get_book",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get book details by ID.",
+        inputSchema: s.object("Parameters for get_book.", { bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }) }, { required: ["bookId"] }),
+        outputSchema: s.looseObject("Book metadata, including any upstream links and additional fields.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            title: s.string("Book title."),
+            author: s.string("Book author."),
+            readerLink: s.string("Use this upstream reader URL to open the book; do not construct a URL."),
+            deepLink: s.string("Book details link; use when readerLink is absent."),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "list_chapters",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List a book's chapter table of contents.",
+        inputSchema: s.object("Parameters for list_chapters.", { bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }) }, { required: ["bookId"] }),
+        outputSchema: s.looseObject("Chapter listing.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+            chapters: s.array("Chapters in the book.", s.looseObject("Chapter details.", {
+                chapterUid: s.integer("The chapter UID returned by list_chapters."),
+                title: s.string("Chapter title."),
+                chapterIdx: s.integer("Chapter order."),
+                level: s.integer("Heading level, starting at 1."),
+            })),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "get_reading_progress",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get reading progress. Progress 1 means 1%; completion requires progress 100 and finishTime.",
+        inputSchema: s.object("Parameters for get_reading_progress.", { bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }) }, { required: ["bookId"] }),
+        outputSchema: s.looseObject("Reading progress response.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            book: s.looseObject("Reading progress and timestamps.", {
+                progress: s.integer("Reading percentage from 0 to 100, not a fraction."),
+                recordReadingTime: s.number("Accumulated reading time in seconds."),
+                finishTime: s.integer("Completion Unix timestamp, present only after finishing."),
+                chapterUid: s.integer("The chapter UID returned by list_chapters."),
+            }),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "get_shelf",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read the shelf. Visible entries equal books.length + albums.length + 1 when mp is nonempty; bookCount excludes audio and mp.",
+        inputSchema: s.object("Parameters for get_shelf.", {}, { required: [] }),
+        outputSchema: s.looseObject("Shelf response.", {
+            books: s.array("Ebooks and imported books, excluding audio albums and the mp entry.", s.looseObject("Book metadata, including any upstream links and additional fields.", {
+                bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+                title: s.string("Book title."),
+                author: s.string("Book author."),
+                readerLink: s.string("Use this upstream reader URL to open the book; do not construct a URL."),
+                deepLink: s.string("Book details link; use when readerLink is absent."),
+            })),
+            albums: s.array("Audiobook albums, which also count as shelf entries.", s.looseObject("Audio album metadata and listening state.", {})),
+            mp: s.looseObject("Article collection entry; a nonempty object counts as one private shelf entry.", {}),
+            archive: s.array("Book list folders.", s.looseObject("Folder name and book IDs.", {})),
+            bookCount: s.integer("Ebook count only; not the total shelf count."),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "list_notebooks",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List notebook summaries. Next lastSort is the final book's sort. Total notes include reviewCount + noteCount + bookmarkCount.",
+        inputSchema: s.object("Parameters for list_notebooks.", {
+            count: s.integer("Page size; omit to use the upstream default.", { minimum: 1 }),
+            lastSort: s.integer("The last book's sort value from the previous page; omit on the first page."),
+        }, { required: [] }),
+        outputSchema: s.looseObject("Notebook summaries and pagination.", {
+            totalBookCount: s.integer("Total number of books with notes."),
+            totalNoteCount: s.integer("Total highlights, personal reviews and bookmarks combined."),
+            hasMore: s.integer("Whether another page exists: 1 means yes, 0 means no."),
+            books: s.array("Books with notes.", s.looseObject("A notebook summary.", {
+                bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+                book: s.looseObject("Book metadata, including any upstream links and additional fields.", {
+                    bookId: s.string("The book ID returned by search or the shelf.", {
+                        minLength: 1,
+                    }),
+                    title: s.string("Book title."),
+                    author: s.string("Book author."),
+                    readerLink: s.string("Use this upstream reader URL to open the book; do not construct a URL."),
+                    deepLink: s.string("Book details link; use when readerLink is absent."),
+                }),
+                sort: s.integer("Cursor for the next lastSort request."),
+                noteCount: s.integer("Highlight count only, not the total note count."),
+                reviewCount: s.integer("Personal thoughts and reviews combined; do not count reviews twice."),
+                bookmarkCount: s.integer("Reading-position bookmark count; bookmark content cannot be exported."),
+            })),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "list_highlights",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List personal highlights in a book, excluding reading-position bookmarks. Query list_my_reviews as well to retrieve all exportable note content.",
+        inputSchema: s.object("Parameters for list_highlights.", { bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }) }, { required: ["bookId"] }),
+        outputSchema: s.looseObject("Personal highlight content.", {
+            updated: s.array("Highlights only; upstream filters out type 0 bookmarks.", s.looseObject("A personal highlight.", {
+                bookmarkId: s.string("Highlight ID."),
+                markText: s.string("Highlighted source text."),
+                chapterUid: s.integer("The chapter UID returned by list_chapters."),
+                createTime: s.integer("Creation Unix timestamp in seconds."),
+            })),
+            chapters: s.array("Chapter information used to locate highlights.", s.looseObject("Chapter metadata.", {})),
+            book: s.looseObject("Book metadata, including any upstream links and additional fields.", {
+                bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+                title: s.string("Book title."),
+                author: s.string("Book author."),
+                readerLink: s.string("Use this upstream reader URL to open the book; do not construct a URL."),
+                deepLink: s.string("Book details link; use when readerLink is absent."),
+            }),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "list_my_reviews",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List personal thoughts, chapter comments and book reviews. Continue with the returned synckey while hasMore is 1.",
+        inputSchema: s.object("Parameters for list_my_reviews.", {
+            bookid: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+            count: s.integer("Page size; omit to use the upstream default.", { minimum: 1 }),
+        }, { required: ["bookid"] }),
+        outputSchema: s.looseObject("Personal reviews and pagination.", {
+            reviews: s.array("Personal review entries.", s.looseObject("Personal review wrapper.", {
+                review: s.looseObject("Review details, including conditional abstract, range, content and author fields.", {
+                    content: s.string("Review text."),
+                    abstract: s.string("Highlighted source text, when this review refers to a passage."),
+                    range: s.string("Position range of the source passage, when available."),
+                }),
+            })),
+            totalCount: s.integer("Total personal review count."),
+            hasMore: s.integer("Whether another page exists: 1 means yes, 0 means no."),
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "get_underline_stats",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get chapter highlight popularity statistics without source text.",
+        inputSchema: s.object("Parameters for get_underline_stats.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            chapterUid: s.integer("The chapter UID returned by list_chapters."),
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+        }, { required: ["bookId", "chapterUid"] }),
+        outputSchema: s.looseObject("Chapter highlight statistics.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            chapterUid: s.integer("The chapter UID returned by list_chapters."),
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+            underlines: s.array("Highlight counts and scores, without text.", s.looseObject("Highlight range, count, score and type.", {})),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "list_popular_highlights",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get up to 20 popular highlights with source text. The upstream result is fixed-size and does not support pagination.",
+        inputSchema: s.object("Parameters for list_popular_highlights.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            chapterUid: s.integer("Chapter UID; 0 means all chapters and is the default."),
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+        }, { required: ["bookId"] }),
+        outputSchema: s.looseObject("Popular highlights.", {
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+            totalCount: s.integer("Total popular highlight count, possibly larger than this fixed-size result."),
+            items: s.array("Popular highlight entries.", s.looseObject("A popular highlight.", {
+                chapterUid: s.integer("The chapter UID returned by list_chapters."),
+                range: s.string("Highlight position range for list_highlight_reviews."),
+                markText: s.string("Highlighted source text."),
+                totalCount: s.integer("Number of readers highlighting this passage."),
+            })),
+            chapters: s.array("Chapter information used to locate highlights.", s.looseObject("Chapter metadata.", {})),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "list_highlight_reviews",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List thoughts on specified highlight ranges, preserving per-range pagination.",
+        inputSchema: s.object("Parameters for list_highlight_reviews.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            chapterUid: s.integer("The chapter UID returned by list_chapters."),
+            reviews: s.array("Highlight ranges and their independent page cursors.", s.object("A highlight range query.", {
+                range: s.string("Position range returned by list_popular_highlights.", {
+                    minLength: 1,
+                }),
+                maxIdx: s.integer("Pagination offset from the previous page; initially 0.", {
+                    minimum: 0,
+                }),
+                count: s.integer("Page size; values above 20 are truncated by the upstream service.", { minimum: 1 }),
+                synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+            }, { required: ["range"] })),
+        }, { required: ["bookId", "chapterUid", "reviews"] }),
+        outputSchema: s.looseObject("Thoughts for each requested range.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            chapterUid: s.integer("The chapter UID returned by list_chapters."),
+            reviews: s.array("Per-range results and cursors.", s.looseObject("A range result.", {
+                range: s.string("Highlight position range."),
+                hasMore: s.integer("Whether another page exists: 1 means yes, 0 means no."),
+                maxIdx: s.integer("Pagination offset from the previous page; initially 0.", {
+                    minimum: 0,
+                }),
+                synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+                totalCount: s.integer("Total thoughts for this range."),
+                pageReviews: s.array("Thoughts on this page.", s.looseObject("Thought wrapper.", {
+                    review: s.looseObject("Review details, including conditional abstract, range, content and author fields.", {
+                        content: s.string("Review text."),
+                        abstract: s.string("Highlighted source text, when this review refers to a passage."),
+                        range: s.string("Position range of the source passage, when available."),
+                    }),
+                })),
+            })),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "get_review",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get a single thought or review with optional comments and likes.",
+        inputSchema: s.object("Parameters for get_review.", {
+            reviewId: s.string("Thought or review ID.", { minLength: 1 }),
+            commentsCount: s.integer("Number of comments to fetch; default 10.", { minimum: 0 }),
+            commentsDirection: {
+                ...s.integer("Comment order: 0 descending, 1 ascending."),
+                enum: [0, 1],
+            },
+            likesCount: s.integer("Number of likes to fetch; default 10.", { minimum: 0 }),
+            likesDirection: {
+                ...s.integer("Like order; only 0 (descending) is documented."),
+                enum: [0],
+            },
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+        }, { required: ["reviewId"] }),
+        outputSchema: s.looseObject("Thought or review details.", {
+            reviewId: s.string("Thought or review ID."),
+            review: s.looseObject("Review details, including conditional abstract, range, content and author fields.", {
+                content: s.string("Review text."),
+                abstract: s.string("Highlighted source text, when this review refers to a passage."),
+                range: s.string("Position range of the source passage, when available."),
+            }),
+            htmlContent: s.string("Upstream rich-text HTML."),
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "get_reading_stats",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get reading statistics for one period. Durations are seconds; annual mode covers only the selected calendar year.",
+        inputSchema: s.object("Parameters for get_reading_stats.", {
+            mode: s.stringEnum("Period: weekly, monthly (default), annually or overall.", [
+                "weekly",
+                "monthly",
+                "annually",
+                "overall",
+            ]),
+            baseTime: s.integer("Unix timestamp in the desired period; 0 selects the current period. Overall always uses 0."),
+        }, { required: [] }),
+        outputSchema: s.looseObject("Reading statistics; fields vary with mode and available data.", {
+            baseTime: s.integer("Normalized period start Unix timestamp; 0 for overall."),
+            totalReadTime: s.number("Total reading and listening time in seconds for this period; prefer this over summing buckets."),
+            dayAverageReadTime: s.number("Average seconds per calendar day, not per active reading day."),
+            readDays: s.integer("Effective reading days, currently days with at least one minute of reading."),
+            readTimes: s.record("Bucket start timestamps mapped to reading seconds.", s.number("Reading seconds in this bucket.")),
+            dailyReadTimes: s.record("Optional daily timestamp-to-seconds map in annual mode.", s.number("Reading seconds on this day.")),
+            preferTime: s.array("Hourly reading seconds ordered from 06:00 through 05:00 the next day.", s.number("Reading seconds in this hour.")),
+            preferAuthor: s.array("Preferred authors.", s.looseObject("Author preference.", {
+                name: s.string("Author name."),
+                readTime: s.string("Formatted duration text, not a number of seconds."),
+            })),
+            readLongest: s.array("Top books or audio albums by reading time, up to 10 entries.", s.looseObject("A reading-time ranking entry.", {
+                book: s.looseObject("Book metadata, including any upstream links and additional fields.", {
+                    bookId: s.string("The book ID returned by search or the shelf.", {
+                        minLength: 1,
+                    }),
+                    title: s.string("Book title."),
+                    author: s.string("Book author."),
+                    readerLink: s.string("Use this upstream reader URL to open the book; do not construct a URL."),
+                    deepLink: s.string("Book details link; use when readerLink is absent."),
+                }),
+                albumInfo: s.looseObject("Audio album metadata when this is audio content.", {}),
+                readTime: s.number("Reading or listening time in seconds for this period."),
+            })),
+            readStat: s.array("Upstream reading summary labels and formatted counts.", s.looseObject("Summary stat, counts and optional scheme.", {})),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "list_book_reviews",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List public book reviews. Continue with the last idx and returned synckey. Content is nested at reviews[].review.review.",
+        inputSchema: s.object("Parameters for list_book_reviews.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            reviewListType: {
+                ...s.integer("Filter: 0 all, 1 recommended, 2 negative, 3 newest, 4 average."),
+                enum: [0, 1, 2, 3, 4],
+            },
+            count: s.integer("Page size; omit to use the upstream default.", { minimum: 1 }),
+            maxIdx: s.integer("Pagination offset from the previous page; initially 0.", { minimum: 0 }),
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+        }, { required: ["bookId"] }),
+        outputSchema: s.looseObject("Public reviews and pagination.", {
+            synckey: s.integer("The sync or pagination key returned by the previous response; initially 0."),
+            reviewsCnt: s.integer("Total public review count."),
+            reviewsHasMore: s.integer("Whether another page exists: 1 means yes, 0 means no."),
+            reviews: s.array("Public review entries with two review wrappers.", s.looseObject("Public review list entry.", {
+                idx: s.integer("Pagination offset from the previous page; initially 0.", {
+                    minimum: 0,
+                }),
+                review: s.looseObject("Public review wrapper.", {
+                    reviewId: s.string("Review ID."),
+                    review: s.looseObject("Public review body.", {
+                        content: s.string("Review text."),
+                        star: s.integer("Rating: 20, 40, 60, 80 and 100 correspond to one through five stars."),
+                    }),
+                }),
+            })),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "list_recommendations",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List personalized book recommendations. Continue with the last book's searchIdx as maxIdx.",
+        inputSchema: s.object("Parameters for list_recommendations.", {
+            count: s.integer("Page size; omit to use the upstream default.", { minimum: 1 }),
+            maxIdx: s.integer("Pagination offset from the previous page; initially 0.", { minimum: 0 }),
+        }, { required: [] }),
+        outputSchema: s.looseObject("Personalized recommendations.", {
+            books: s.array("Recommended books.", s.looseObject("A recommended book.", {
+                bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+                title: s.string("Book title."),
+                author: s.string("Book author."),
+                readerLink: s.string("Use this upstream reader URL to open the book; do not construct a URL."),
+                deepLink: s.string("Book details link; use when readerLink is absent."),
+                searchIdx: s.integer("Pagination offset from the previous page; initially 0.", {
+                    minimum: 0,
+                }),
+                reason: s.string("Recommendation reason."),
+            })),
+        }),
+    }),
+    defineProviderAction("weread", {
+        name: "list_similar_books",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List similar books. Defaults to count 12 and maxIdx 0; continue with the last idx and returned sessionId.",
+        inputSchema: s.object("Parameters for list_similar_books.", {
+            bookId: s.string("The book ID returned by search or the shelf.", { minLength: 1 }),
+            count: s.integer("Page size; omit to use the upstream default.", { minimum: 1 }),
+            maxIdx: s.integer("Pagination offset from the previous page; initially 0.", { minimum: 0 }),
+            sessionId: s.string("Session ID from the previous page; omit on the first page."),
+        }, { required: ["bookId"] }),
+        outputSchema: s.looseObject("Similar book recommendations.", {
+            booksimilar: s.looseObject("Similar books and their session.", {
+                sessionId: s.string("Session ID to send with the next page."),
+                books: s.array("Similar book entries.", s.looseObject("A similar book result.", {
+                    idx: s.integer("Pagination offset from the previous page; initially 0.", {
+                        minimum: 0,
+                    }),
+                    book: s.looseObject("Book result wrapper.", {
+                        bookInfo: s.looseObject("Book metadata, including any upstream links and additional fields.", {
+                            bookId: s.string("The book ID returned by search or the shelf.", {
+                                minLength: 1,
+                            }),
+                            title: s.string("Book title."),
+                            author: s.string("Book author."),
+                            readerLink: s.string("Use this upstream reader URL to open the book; do not construct a URL."),
+                            deepLink: s.string("Book details link; use when readerLink is absent."),
+                        }),
+                    }),
+                })),
+            }),
+        }),
+    }),
+];

package/src/providers/weread/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/weread/executors.js

@@ -0,0 +1,98 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { wereadActions } from "./actions.js";
+const baseUrl = "https://i.weread.qq.com";
+const skillVersion = "1.0.5";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const routes = {
+    search: "/store/search",
+    get_book: "/book/info",
+    list_chapters: "/book/chapterinfo",
+    get_reading_progress: "/book/getprogress",
+    get_shelf: "/shelf/sync",
+    list_notebooks: "/user/notebooks",
+    list_highlights: "/book/bookmarklist",
+    list_my_reviews: "/review/list/mine",
+    get_underline_stats: "/book/underlines",
+    list_popular_highlights: "/book/bestbookmarks",
+    list_highlight_reviews: "/book/readreviews",
+    get_review: "/review/single",
+    get_reading_stats: "/readdata/detail",
+    list_book_reviews: "/review/list",
+    list_recommendations: "/book/recommend",
+    list_similar_books: "/book/similar",
+};
+async function request({ apiName, fields, apiKey, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "WeRead" }, async (signal) => {
+        const response = await fetcher(`${baseUrl}/api/agent/gateway`, {
+            method: "POST",
+            signal,
+            headers: { ...defaultHeaders, authorization: `Bearer ${apiKey}` },
+            body: JSON.stringify({ ...fields, api_name: apiName, skill_version: skillVersion }),
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const record = optionalRecord(payload);
+        const code = record?.errcode;
+        if (!response.ok || (code !== undefined && code !== 0 && code !== "0")) {
+            const detail = optionalRawString(record?.errmsg) || optionalRawString(record?.message) || optionalRawString(record?.error);
+            const message = `WeRead request failed${code === undefined ? "" : ` (errcode ${String(code)})`}: ${detail || (record ? `HTTP ${response.status}` : text) || `HTTP ${response.status}`}`;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, message.split(apiKey).join("[REDACTED]"), undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        const result = requiredResponseRecord(payload, "WeRead response");
+        if (result.upgrade_info != null) {
+            const message = optionalRawString(optionalRecord(result.upgrade_info)?.message);
+            throw new ProviderRequestError(502, `WeRead integration version ${skillVersion} requires an update${message ? `: ${message.split(apiKey).join("[REDACTED]")}` : ""}`, undefined, "provider_error");
+        }
+        return result;
+    });
+}
+const handlers = mapProviderActionHandlers("weread", wereadActions, (action) => async (dataInput, context) => {
+    const route = routes[action.name];
+    const fields = dataInput;
+    const body = action.name === "list_similar_books"
+        ? { ...fields, count: fields.count ?? 12, maxIdx: fields.maxIdx ?? 0 }
+        : fields;
+    return request({
+        apiName: route,
+        fields: body,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("weread", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request({
+            apiName: "/_list",
+            fields: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return { profile: { displayName: "WeRead API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "weread",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json", "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/whatsapp/runtime.js

@@ -762,10 +762,15 @@ function normalizePaging(value) {
             after: readString(cursorsRecord.after),
         })
         : undefined;
+    const next = readString(record.next);
     return compactObject({
         cursors,
         previous: readString(record.previous),
-        next: readString(record.next),
+        next,
+        // Meta keeps `cursors.after` on the final page and signals the end by
+        // omitting `next`; a caller walking `after` alone cannot tell the last
+        // page from a middle one, so the end is spelled out as a boolean.
+        hasMore: next !== undefined,
     });
 }
 function requireWabaId(input, context, actionName) {

package/src/providers/workast/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const workastApiBaseUrl = "https://api.todobot.io";
 const taskWriteKeys = ["text", "description", "startDate", "dueDate", "dueDateTimezone", "dueDateTime"];
 export const workastActionHandlers = {
@@ -89,7 +89,7 @@ export const workastActionHandlers = {
         const taskId = requireString(input.taskId, "taskId");
         const body = compactObject(pickTaskWriteFields(input));
         if (Object.keys(body).length == 0) {
-            throw providerError("invalid_input", "update_task requires at least one field to update", 400);
+            throw providerInputError("update_task requires at least one field to update");
         }
         const task = await requestWorkastJson({
             apiKey: context.apiKey,
@@ -164,17 +164,14 @@ async function requestWorkastJson(options) {
         if (error instanceof ProviderRequestError)
             throw error;
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw providerError("provider_error", "Workast request timed out", 504);
+            throw new ProviderRequestError(504, "Workast request timed out");
         }
-        throw providerError("provider_error", error instanceof Error ? `Workast request failed: ${error.message}` : "Workast request failed", 502);
+        throw providerResponseError(error instanceof Error ? `Workast request failed: ${error.message}` : "Workast request failed");
     }
     finally {
         timeout.cleanup();
     }
 }
-function providerError(_code, message, status) {
-    return new ProviderRequestError(status, message);
-}
 function appendQuery(url, query) {
     for (const [name, value] of Object.entries(query ?? {})) {
         if (value !== undefined)
@@ -189,22 +186,20 @@ async function readResponsePayload(response) {
         return JSON.parse(text);
     }
     catch {
-        throw providerError("provider_error", "Workast returned invalid JSON", 502);
+        throw providerResponseError("Workast returned invalid JSON");
     }
 }
 function mapWorkastError(status, payload, phase) {
     const message = readErrorMessage(payload) ?? `Workast API request failed with status ${status}`;
     if (status == 401 || status == 403) {
-        return phase == "validate"
-            ? providerError("invalid_input", message, 400)
-            : providerError("credential_expired", message, 401);
+        return phase == "validate" ? providerInputError(message) : new ProviderRequestError(401, message);
     }
     if (status == 429)
-        return providerError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message);
     if (status == 400 || status == 404 || status == 409 || status == 422) {
-        return providerError("invalid_input", message, 400);
+        return providerInputError(message);
     }
-    return providerError("provider_error", message, 502);
+    return providerResponseError(message);
 }
 function readErrorMessage(payload) {
     const record = optionalRecord(payload);
@@ -213,7 +208,7 @@ function readErrorMessage(payload) {
 function requireArrayPayload(payload, fieldName) {
     const candidate = Array.isArray(payload) ? payload : optionalRecord(payload)?.[fieldName];
     if (!Array.isArray(candidate)) {
-        throw providerError("provider_error", `Workast returned an invalid ${fieldName} payload`, 502);
+        throw providerResponseError(`Workast returned an invalid ${fieldName} payload`);
     }
     return candidate.map((item) => requireObjectPayload(item, fieldName));
 }
@@ -222,13 +217,13 @@ function requireObjectPayload(payload, fieldName) {
     const nested = optionalRecord(record?.[fieldName]);
     const candidate = nested ?? record;
     if (!candidate) {
-        throw providerError("provider_error", `Workast returned an invalid ${fieldName} payload`, 502);
+        throw providerResponseError(`Workast returned an invalid ${fieldName} payload`);
     }
     return candidate;
 }
 function requireString(value, fieldName) {
     if (typeof value != "string" || value.trim() == "") {
-        throw providerError("invalid_input", `${fieldName} must be a non-empty string`, 400);
+        throw providerInputError(`${fieldName} must be a non-empty string`);
     }
     return value;
 }