prompture 1.13.5.dev3__tar.gz → 1.13.6.dev1__tar.gz

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.13.5.dev3
+Version: 1.13.6.dev1
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT
@@ -188,7 +188,7 @@ prompture mcp add --preset exa                 # mount MCP servers by name
 prompture skill install                        # teach your coding agent all of this
 ```
 
-- **Web:** keyless search, fetch and readers for YouTube, GitHub, Hacker News, arXiv, Wikipedia, feeds and podcasts
+- **Web:** keyless search, fetch and readers for YouTube, GitHub, Hacker News, arXiv, Wikipedia, AniList, feeds and podcasts
 - **Fails over instead of failing:** search, fetch and the readers try the next backend on auth, quota or rate-limit errors and tell you which one served the result
 - **Cached locally:** repeat searches and static pages come back instantly; weather, prices and news expire in minutes, papers and transcripts in days
 - **Safe by default:** public URLs only, size caps, secret scrubbing, and audio never goes to a second provider without your consent
@@ -237,7 +237,7 @@ No setup: Desk runs `prompture companion` (Prompture 1.13+) on localhost for you
 - `generate_qa_dataset()` — synthetic JSONL datasets ready for Unsloth, Axolotl, TRL
 
 **Capabilities** — see [Capabilities](#capabilities)
-- Keyless `web_search`, `web_fetch` and `read_url` (YouTube, GitHub, HN, arXiv, Wikipedia, feeds, podcasts), with failover across keyed providers
+- Keyless `web_search`, `web_fetch` and `read_url` (YouTube, GitHub, HN, arXiv, Wikipedia, AniList, feeds, podcasts), with failover across keyed providers
 - Local web cache with content-aware lifetimes: minutes for weather, prices and news, days for papers and transcripts
 - `transcribe` / `summarize_media` for video, podcasts and audio, with timestamped key points
 - `ResearchAgent` / `prompture research` — cited multi-source reports within fetch, token, cost and time budgets
@@ -2132,7 +2132,7 @@ agent = Agent("openai/gpt-4o", tools=["web:all"])
 |---|---|
 | `web_search` | `tavily` ▸ `exa` ▸ `serper` ▸ `brave` ▸ `jina` ▸ `searxng` ▸ `exa_mcp` (keyless) |
 | `web_fetch` | `jina_reader` (keyless) ▸ `direct` (safe GET + HTML to Markdown) |
-| `read_url` | YouTube, GitHub, Hacker News, arXiv, Wikipedia, podcasts, RSS/Atom readers ▸ `web_fetch` |
+| `read_url` | YouTube, GitHub, Hacker News, arXiv, Wikipedia, AniList, podcasts, RSS/Atom readers ▸ `web_fetch` |
 | `search_platform` | YouTube (`yt-dlp`), GitHub, Hacker News (Algolia), arXiv |
 
 - Auth, quota and rate-limit errors fail over immediately; timeouts and 5xx
@@ -2155,7 +2155,7 @@ entry lives as long as that kind of content stays true:
 | Platform search (GitHub, HN, arXiv, YouTube) | 30 min |
 | Ordinary pages / searches within `recency_days <= 7` | 1 h |
 | Other searches | 6 h |
-| Wikipedia, podcast episodes | 1 day |
+| Wikipedia, AniList, podcast episodes | 1 day |
 | Papers, PDFs, DOIs, commit-pinned GitHub files, YouTube transcripts | 7 days |
 
 Cached results say so (`route["cached"]`, `cache_age_s`, and "cached 3 min

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/README.md

@@ -71,7 +71,7 @@ prompture mcp add --preset exa                 # mount MCP servers by name
 prompture skill install                        # teach your coding agent all of this
 ```
 
-- **Web:** keyless search, fetch and readers for YouTube, GitHub, Hacker News, arXiv, Wikipedia, feeds and podcasts
+- **Web:** keyless search, fetch and readers for YouTube, GitHub, Hacker News, arXiv, Wikipedia, AniList, feeds and podcasts
 - **Fails over instead of failing:** search, fetch and the readers try the next backend on auth, quota or rate-limit errors and tell you which one served the result
 - **Cached locally:** repeat searches and static pages come back instantly; weather, prices and news expire in minutes, papers and transcripts in days
 - **Safe by default:** public URLs only, size caps, secret scrubbing, and audio never goes to a second provider without your consent
@@ -120,7 +120,7 @@ No setup: Desk runs `prompture companion` (Prompture 1.13+) on localhost for you
 - `generate_qa_dataset()` — synthetic JSONL datasets ready for Unsloth, Axolotl, TRL
 
 **Capabilities** — see [Capabilities](#capabilities)
-- Keyless `web_search`, `web_fetch` and `read_url` (YouTube, GitHub, HN, arXiv, Wikipedia, feeds, podcasts), with failover across keyed providers
+- Keyless `web_search`, `web_fetch` and `read_url` (YouTube, GitHub, HN, arXiv, Wikipedia, AniList, feeds, podcasts), with failover across keyed providers
 - Local web cache with content-aware lifetimes: minutes for weather, prices and news, days for papers and transcripts
 - `transcribe` / `summarize_media` for video, podcasts and audio, with timestamped key points
 - `ResearchAgent` / `prompture research` — cited multi-source reports within fetch, token, cost and time budgets
@@ -2015,7 +2015,7 @@ agent = Agent("openai/gpt-4o", tools=["web:all"])
 |---|---|
 | `web_search` | `tavily` ▸ `exa` ▸ `serper` ▸ `brave` ▸ `jina` ▸ `searxng` ▸ `exa_mcp` (keyless) |
 | `web_fetch` | `jina_reader` (keyless) ▸ `direct` (safe GET + HTML to Markdown) |
-| `read_url` | YouTube, GitHub, Hacker News, arXiv, Wikipedia, podcasts, RSS/Atom readers ▸ `web_fetch` |
+| `read_url` | YouTube, GitHub, Hacker News, arXiv, Wikipedia, AniList, podcasts, RSS/Atom readers ▸ `web_fetch` |
 | `search_platform` | YouTube (`yt-dlp`), GitHub, Hacker News (Algolia), arXiv |
 
 - Auth, quota and rate-limit errors fail over immediately; timeouts and 5xx
@@ -2038,7 +2038,7 @@ entry lives as long as that kind of content stays true:
 | Platform search (GitHub, HN, arXiv, YouTube) | 30 min |
 | Ordinary pages / searches within `recency_days <= 7` | 1 h |
 | Other searches | 6 h |
-| Wikipedia, podcast episodes | 1 day |
+| Wikipedia, AniList, podcast episodes | 1 day |
 | Papers, PDFs, DOIs, commit-pinned GitHub files, YouTube transcripts | 7 days |
 
 Cached results say so (`route["cached"]`, `cache_age_s`, and "cached 3 min

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/prompture/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.13.5.dev3'
-__version_tuple__ = version_tuple = (1, 13, 5, 'dev3')
+__version__ = version = '1.13.6.dev1'
+__version_tuple__ = version_tuple = (1, 13, 6, 'dev1')
 
 __commit_id__ = commit_id = None

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/prompture/capabilities/__init__.py

@@ -5,11 +5,12 @@
 * :mod:`.health` — :class:`HealthStatus` and the capability registry doctor walks.
 * :mod:`.url_safety` — :func:`normalize_public_http_url` public-URL guard.
 * :mod:`.http` — :func:`safe_get` redirect-checked, size-capped GET.
-* :mod:`.challenge` — :func:`is_challenge_page` interstitial detection.
+* :mod:`.challenge` — :func:`is_challenge_page` interstitial detection and
+  :func:`is_js_shell_page` for pages that are only a "needs JavaScript" shell.
 """
 
 from .backends import Backend, BackendChain, BaseBackend, ChainResult, order_backends, parse_override
-from .challenge import is_challenge_page
+from .challenge import is_challenge_page, is_js_shell_page
 from .errors import (
     AllBackendsFailedError,
     BackendUnavailableError,
@@ -52,6 +53,7 @@ __all__ = [
     "check_capabilities",
     "clear_probe_cache",
     "is_challenge_page",
+    "is_js_shell_page",
     "is_public_http_url",
     "is_public_ip",
     "list_capabilities",

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/prompture/capabilities/challenge.py

@@ -73,3 +73,32 @@ def is_challenge_page(
     score = challenge_score(text)
     threshold = 2 if status in _CHALLENGE_STATUSES else 3
     return score >= threshold
+
+
+# The first characters of a page rendered without its scripts: an app shell
+# that only says the content needs JavaScript or a newer browser.
+SHELL_SCAN_CHARS = 1000
+
+_SHELL_MARKERS = (
+    "requires a modern browser",
+    "upgrade to a newer web browser",
+    "you need to enable javascript to run this app",
+    "please enable javascript to continue",
+    "this site requires javascript",
+    "this page requires javascript",
+    "javascript is required to view",
+    "javascript is disabled in your browser",
+)
+
+
+def is_js_shell_page(text: str | bytes) -> bool:
+    """Return ``True`` when the start of *text* is a "needs JavaScript" app shell.
+
+    Only the opening :data:`SHELL_SCAN_CHARS` are checked, so a real article
+    that mentions JavaScript further down (a comments widget, say) still counts
+    as content.
+    """
+    if isinstance(text, bytes):
+        text = text[: SHELL_SCAN_CHARS * 4].decode("utf-8", errors="ignore")
+    head = text[:SHELL_SCAN_CHARS].lower()
+    return any(m in head for m in _SHELL_MARKERS)

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/prompture/tools/web/__init__.py

@@ -3,7 +3,8 @@
 * :func:`web_search` — ordered search backends with failover; keyless Exa MCP floor.
 * :func:`web_fetch` — URL → Markdown (Jina reader ▸ direct), paging, 10-minute cache.
 * :func:`read_url` — URL-routed readers (YouTube, GitHub, Hacker News, arXiv,
-  Wikipedia, podcasts, feeds) with ``web_fetch`` fallback.
+  Wikipedia, AniList, podcasts, feeds) with ``web_fetch`` fallback.
+* :func:`search_anilist` — find an anime / manga by title (its URL reads the cast).
 * :func:`search_platform` — YouTube / GitHub / Hacker News / arXiv search.
 * :class:`WebToolkit` — the above as agent tools; ``tools=["web:all"]``.
 
@@ -47,6 +48,7 @@ from .readers import (
     list_readers,
     read_url,
     register_reader,
+    search_anilist,
     unregister_reader,
 )
 from .search import (
@@ -112,6 +114,7 @@ __all__ = [
     "read_url",
     "register_reader",
     "resolve_web_tools",
+    "search_anilist",
     "search_chain",
     "search_platform",
     "unregister_reader",

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/prompture/tools/web/cache.py

@@ -126,7 +126,7 @@ def read_ttl(url: str, reader: str, kind: str = "page") -> int:
         return 7 * DAY  # a published video's transcript doesn't change
     if reader == "arxiv":
         return 7 * DAY
-    if reader == "wikipedia":
+    if reader in ("wikipedia", "anilist"):
         return DAY
     if reader == "podcasts":
         return DAY

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/prompture/tools/web/fetch.py

@@ -28,7 +28,7 @@ from typing import Any
 import requests
 
 from ...capabilities.backends import BackendChain, BaseBackend
-from ...capabilities.challenge import is_challenge_page
+from ...capabilities.challenge import is_challenge_page, is_js_shell_page
 from ...capabilities.errors import ChallengePageError, HTTPStatusError
 from ...capabilities.http import safe_get
 from ...capabilities.url_safety import normalize_public_http_url
@@ -174,6 +174,8 @@ class JinaReaderBackend(FetchBackend):
             raise RequestRejectedError(self.name, "empty content")
         if is_challenge_page(content) or title.strip().lower() in _CHALLENGE_TITLES:
             raise ChallengePageError(f"{url} returned a bot challenge via {self.name}")
+        if is_js_shell_page(content):
+            raise RequestRejectedError(self.name, "page is a JavaScript app shell with no content")
         ctype = "application/pdf" if url.lower().split("?", 1)[0].endswith(".pdf") else "text/html"
         return FetchedPage(url=url, final_url=final_url, title=title, content=content.strip(), content_type=ctype)
 
@@ -209,6 +211,8 @@ class DirectBackend(FetchBackend):
             html = resp.text
             info = scan_head(html, resp.url)
             content = html_to_markdown(html, base_url=resp.url)
+            if is_js_shell_page(content):
+                raise RequestRejectedError(self.name, "page is a JavaScript app shell with no content")
             return FetchedPage(url, resp.url, info.title, content, "text/html")
         if ctype == "application/json" or ctype.endswith("+json"):
             try:

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/prompture/tools/web/readers/__init__.py

@@ -5,7 +5,7 @@ matches and that has a usable backend reads the URL. When none matches (or
 every matching reader fails), :func:`read_url` falls back to
 :func:`~prompture.tools.web.fetch.web_fetch`.
 
-Built-in order: YouTube, GitHub, Hacker News, arXiv, Wikipedia, Podcasts,
+Built-in order: YouTube, GitHub, Hacker News, arXiv, Wikipedia, AniList, Podcasts,
 Feeds. Add your own with :func:`register_reader` (``first=True`` to take
 precedence over the built-ins).
 """
@@ -25,6 +25,7 @@ from ....resilience.errors import classify_error
 from .. import cache as web_cache
 from .._common import error_text, page
 from ..fetch import web_fetch
+from .anilist import AniListReader, search_anilist
 from .arxiv import ArxivReader
 from .base import BaseReader, Reader, ReadResult, StepBackend
 from .feeds import FeedReader
@@ -270,6 +271,7 @@ def _register_builtins() -> None:
         HackerNewsReader(),
         ArxivReader(),
         WikipediaReader(),
+        AniListReader(),
         PodcastReader(),
         FeedReader(),
     ):
@@ -279,6 +281,7 @@ def _register_builtins() -> None:
 _register_builtins()
 
 __all__ = [
+    "AniListReader",
     "ArxivReader",
     "BaseReader",
     "FeedReader",
@@ -296,5 +299,6 @@ __all__ = [
     "matching_readers",
     "read_url",
     "register_reader",
+    "search_anilist",
     "unregister_reader",
 ]

prompture-1.13.6.dev1/prompture/tools/web/readers/anilist.py

@@ -0,0 +1,376 @@
+"""AniList reader: anime / manga / character pages → structured cast Markdown.
+
+anilist.co renders in the browser, so fetching the page returns an app shell.
+This reader asks AniList's public GraphQL API instead (keyless, rate-limited
+per IP). A title page (``/anime/<id>``, ``/manga/<id>``, with or without
+``/characters``) becomes the title's details plus its characters in role
+order, each with gender, age, description and voice actors; a
+``/character/<id>`` page becomes that character with the titles it appears in.
+``meta`` carries the same data as plain dicts for programmatic use.
+
+Reader options: ``max_characters`` (default 50), ``spoilers`` (default
+``False`` — AniList ``~!spoiler!~`` passages are dropped) and
+``voice_language`` (``"JAPANESE"`` by default; ``None`` for every language).
+
+:func:`search_anilist` finds titles by name, for callers that start from a
+title rather than a URL.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+import unicodedata
+from typing import Any
+from urllib.parse import urlsplit
+
+import requests
+
+from ....capabilities.http import proxies_for
+from .._common import API_USER_AGENT, BackendUnavailableError, RequestRejectedError, default_session, host_of
+from .._common import raise_for_status as _raise_for_status
+from .base import BaseReader, ReadResult, StepBackend, clip
+
+API = "https://graphql.anilist.co"
+SITE = "https://anilist.co"
+_PATH_RE = re.compile(r"^/(anime|manga|character)/(\d+)(?:/|$)")
+_SPOILER_RE = re.compile(r"~!.*?!~", re.DOTALL)
+_TAG_RE = re.compile(r"<br\s*/?>", re.IGNORECASE)
+PAGE_SIZE = 25
+
+_CHARACTER_FIELDS = """
+  id siteUrl gender age
+  name { full native alternative }
+  image { medium }
+  description(asHtml: false)
+"""
+
+_MEDIA_QUERY = (
+    """
+query ($id: Int, $page: Int, $perPage: Int, $lang: StaffLanguage) {
+  Media(id: $id) {
+    id type format status episodes chapters seasonYear siteUrl
+    title { romaji english native }
+    description(asHtml: false)
+    characters(page: $page, perPage: $perPage, sort: [ROLE, RELEVANCE, ID]) {
+      pageInfo { hasNextPage }
+      edges {
+        role
+        node {"""
+    + _CHARACTER_FIELDS
+    + """}
+        voiceActors(language: $lang) { name { full native } languageV2 }
+      }
+    }
+  }
+}
+"""
+)
+
+_CHARACTER_QUERY = (
+    """
+query ($id: Int) {
+  Character(id: $id) {"""
+    + _CHARACTER_FIELDS
+    + """
+    media(perPage: 25, sort: [POPULARITY_DESC]) {
+      edges {
+        characterRole
+        node { id type format seasonYear siteUrl title { romaji english native } }
+        voiceActors { name { full native } languageV2 }
+      }
+    }
+  }
+}
+"""
+)
+
+_SEARCH_QUERY = """
+query ($search: String, $type: MediaType, $perPage: Int) {
+  Page(perPage: $perPage) {
+    media(search: $search, type: $type, sort: [SEARCH_MATCH]) {
+      id type format episodes seasonYear siteUrl
+      title { romaji english native }
+      synonyms
+    }
+  }
+}
+"""
+
+
+def anilist_id(url: str) -> tuple[str, int] | None:
+    """``(kind, id)`` for an AniList title or character URL, else ``None``.
+
+    *kind* is ``"anime"``, ``"manga"`` or ``"character"``.
+    """
+    if host_of(url) not in ("anilist.co", "www.anilist.co"):
+        return None
+    try:
+        m = _PATH_RE.match(urlsplit(url).path)
+    except ValueError:
+        return None
+    return (m.group(1), int(m.group(2))) if m else None
+
+
+def graphql(query: str, variables: dict[str, Any], *, session: Any = None, timeout: float = 20.0) -> dict[str, Any]:
+    """POST one query to the AniList API and return its ``data``."""
+    sess = session or default_session()
+    resp = sess.post(
+        API,
+        json={"query": query, "variables": variables},
+        headers={"Accept": "application/json", "Content-Type": "application/json", "User-Agent": API_USER_AGENT},
+        timeout=timeout,
+        proxies=proxies_for("anilist"),
+    )
+    _raise_for_status(resp, "anilist")
+    body = resp.json() or {}
+    if body.get("errors"):
+        message = str(body["errors"][0].get("message") or "unknown error")
+        if "not found" in message.lower():
+            raise RequestRejectedError("anilist", message)
+        raise BackendUnavailableError(f"AniList API error: {message}")
+    return body.get("data") or {}
+
+
+def clean_description(text: str | None, *, spoilers: bool = False) -> str:
+    """AniList description text without HTML entities and (by default) spoilers."""
+    if not text:
+        return ""
+    if not spoilers:
+        text = _SPOILER_RE.sub("", text)
+    text = html.unescape(_TAG_RE.sub("\n", text.replace("~!", "").replace("!~", "")))
+    return re.sub(r"\n{3,}", "\n\n", text).strip()
+
+
+def _title(media: dict[str, Any]) -> str:
+    t = media.get("title") or {}
+    return str(t.get("english") or t.get("romaji") or t.get("native") or "")
+
+
+def _voices(entries: list[dict[str, Any]] | None) -> list[dict[str, str]]:
+    return [
+        {
+            "name": str((v.get("name") or {}).get("full") or ""),
+            "native": str((v.get("name") or {}).get("native") or ""),
+            "language": str(v.get("languageV2") or ""),
+        }
+        for v in entries or []
+    ]
+
+
+def _character(node: dict[str, Any], *, spoilers: bool) -> dict[str, Any]:
+    name = node.get("name") or {}
+    return {
+        "id": node.get("id"),
+        "name": str(name.get("full") or ""),
+        "native": str(name.get("native") or ""),
+        "alternative": [a for a in name.get("alternative") or [] if a],
+        "gender": node.get("gender"),
+        "age": node.get("age"),
+        "description": clean_description(node.get("description"), spoilers=spoilers),
+        "image": (node.get("image") or {}).get("medium"),
+        "url": node.get("siteUrl"),
+    }
+
+
+def _character_lines(c: dict[str, Any], head: str) -> list[str]:
+    facts = [f for f in (c.get("role"), c.get("gender"), f"age {c['age']}" if c.get("age") else None) if f]
+    lines = [f"{head} {c['name']}" + (f" ({c['native']})" if c.get("native") else "")]
+    if facts:
+        lines.append("- " + " · ".join(str(f) for f in facts))
+    if c.get("voice_actors"):
+        lines.append(
+            "- Voice: "
+            + ", ".join(v["name"] + (f" ({v['language']})" if v["language"] else "") for v in c["voice_actors"])
+        )
+    if c.get("description"):
+        lines.append("")
+        lines.append(clip(c["description"], 600))
+    lines.append("")
+    return lines
+
+
+def fold_title(text: str) -> str:
+    """*text* with accents on Latin letters removed ("Shippūden" → "Shippuden").
+
+    AniList's search matches romanized titles without macrons and misses them
+    with. Marks on other scripts (a kana's dakuten) are kept.
+    """
+    out: list[str] = []
+    for ch in unicodedata.normalize("NFKD", text):
+        if unicodedata.combining(ch) and out and out[-1].isascii():
+            continue
+        out.append(ch)
+    return unicodedata.normalize("NFC", "".join(out))
+
+
+def search_anilist(
+    query: str,
+    *,
+    media_type: str | None = "ANIME",
+    max_results: int = 5,
+    session: Any = None,
+    timeout: float = 20.0,
+) -> list[dict[str, Any]]:
+    """Titles matching *query*, best match first.
+
+    Each item has ``id``, ``type``, ``format``, ``episodes``, ``year``,
+    ``title`` (display), ``titles`` (romaji / english / native), ``synonyms``
+    and ``url`` — pass the ``url`` to ``read_url`` for the cast.
+
+    Accented Latin letters are folded first (AniList misses "Shippūden" but
+    finds "Shippuden"); the query as given is tried when that finds nothing.
+    """
+    variables: dict[str, Any] = {"perPage": max(1, min(max_results, 25))}
+    if media_type:
+        variables["type"] = media_type.upper()
+    media: list[dict[str, Any]] = []
+    for attempt in dict.fromkeys([fold_title(query), query]):
+        data = graphql(_SEARCH_QUERY, {**variables, "search": attempt}, session=session, timeout=timeout)
+        media = (data.get("Page") or {}).get("media") or []
+        if media:
+            break
+    return [
+        {
+            "id": m.get("id"),
+            "type": m.get("type"),
+            "format": m.get("format"),
+            "episodes": m.get("episodes"),
+            "year": m.get("seasonYear"),
+            "title": _title(m),
+            "titles": m.get("title") or {},
+            "synonyms": m.get("synonyms") or [],
+            "url": m.get("siteUrl"),
+        }
+        for m in media
+    ]
+
+
+class AniListReader(BaseReader):
+    """AniList anime, manga and character pages via the public GraphQL API."""
+
+    name = "anilist"
+    description = "AniList titles and characters → cast with roles, gender, age and voice actors"
+
+    def can_handle(self, url: str) -> bool:
+        return anilist_id(url) is not None
+
+    def steps(self) -> list[StepBackend]:
+        return [
+            StepBackend(
+                "graphql",
+                self._via_graphql,
+                live=lambda: graphql("query { Media(id: 1) { id } }", {}),
+            )
+        ]
+
+    def _via_graphql(
+        self,
+        url: str,
+        *,
+        session: requests.Session | None = None,
+        max_characters: int = 50,
+        spoilers: bool = False,
+        voice_language: str | None = "JAPANESE",
+        **_: Any,
+    ) -> ReadResult:
+        parsed = anilist_id(url)
+        if parsed is None:
+            raise RequestRejectedError("graphql", "not an AniList title or character URL")
+        kind, item_id = parsed
+        if kind == "character":
+            return self._read_character(url, item_id, session=session, spoilers=spoilers)
+        return self._read_media(
+            url,
+            item_id,
+            session=session,
+            max_characters=max_characters,
+            spoilers=spoilers,
+            voice_language=voice_language,
+        )
+
+    def _read_media(
+        self,
+        url: str,
+        media_id: int,
+        *,
+        session: Any,
+        max_characters: int,
+        spoilers: bool,
+        voice_language: str | None,
+    ) -> ReadResult:
+        media: dict[str, Any] = {}
+        characters: list[dict[str, Any]] = []
+        page_no = 1
+        more = True
+        while more and len(characters) < max_characters:
+            variables: dict[str, Any] = {"id": media_id, "page": page_no, "perPage": PAGE_SIZE}
+            if voice_language:
+                variables["lang"] = voice_language.upper()
+            media = graphql(_MEDIA_QUERY, variables, session=session).get("Media") or {}
+            if not media:
+                raise RequestRejectedError("graphql", f"AniList has no title {media_id}")
+            block = media.get("characters") or {}
+            for edge in block.get("edges") or []:
+                c = _character(edge.get("node") or {}, spoilers=spoilers)
+                c["role"] = edge.get("role")
+                c["voice_actors"] = _voices(edge.get("voiceActors"))
+                characters.append(c)
+            more = bool((block.get("pageInfo") or {}).get("hasNextPage"))
+            page_no += 1
+        characters = characters[:max_characters]
+
+        title = _title(media)
+        facts = [media.get("format"), media.get("seasonYear")]
+        if media.get("episodes"):
+            facts.append(f"{media['episodes']} episodes")
+        lines = ["_" + " · ".join(str(f) for f in facts if f) + "_", ""]
+        about = clean_description(media.get("description"), spoilers=spoilers)
+        if about:
+            lines += [clip(about, 1200), ""]
+        lines += [f"## Characters ({len(characters)}{'+' if more else ''})", ""]
+        for c in characters:
+            lines += _character_lines(c, "###")
+        meta = {
+            "id": media.get("id"),
+            "type": media.get("type"),
+            "format": media.get("format"),
+            "status": media.get("status"),
+            "episodes": media.get("episodes"),
+            "chapters": media.get("chapters"),
+            "year": media.get("seasonYear"),
+            "titles": media.get("title") or {},
+            "page_url": media.get("siteUrl") or url,
+            "characters": characters,
+            "more_characters": more,
+        }
+        return ReadResult(url, title, "\n".join(lines).strip(), self.name, "cast", meta)
+
+    def _read_character(self, url: str, character_id: int, *, session: Any, spoilers: bool) -> ReadResult:
+        node = graphql(_CHARACTER_QUERY, {"id": character_id}, session=session).get("Character") or {}
+        if not node:
+            raise RequestRejectedError("graphql", f"AniList has no character {character_id}")
+        c = _character(node, spoilers=spoilers)
+        appearances = []
+        for edge in (node.get("media") or {}).get("edges") or []:
+            m = edge.get("node") or {}
+            appearances.append(
+                {
+                    "id": m.get("id"),
+                    "title": _title(m),
+                    "type": m.get("type"),
+                    "format": m.get("format"),
+                    "year": m.get("seasonYear"),
+                    "role": edge.get("characterRole"),
+                    "url": m.get("siteUrl"),
+                    "voice_actors": _voices(edge.get("voiceActors")),
+                }
+            )
+        lines = _character_lines(c, "##")[1:]  # the title already names the character
+        if appearances:
+            lines += ["## Appears in", ""]
+            for a in appearances:
+                facts = ", ".join(str(f) for f in (a["format"], a["year"], a["role"]) if f)
+                lines.append(f"- {a['title']}" + (f" ({facts})" if facts else ""))
+        meta = {**c, "page_url": c.get("url") or url, "appearances": appearances}
+        return ReadResult(url, c["name"], "\n".join(lines).strip(), self.name, "character", meta)

{prompture-1.13.5.dev3 → prompture-1.13.6.dev1}/prompture.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.13.5.dev3
+Version: 1.13.6.dev1
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT
@@ -188,7 +188,7 @@ prompture mcp add --preset exa                 # mount MCP servers by name
 prompture skill install                        # teach your coding agent all of this
 ```
 
-- **Web:** keyless search, fetch and readers for YouTube, GitHub, Hacker News, arXiv, Wikipedia, feeds and podcasts
+- **Web:** keyless search, fetch and readers for YouTube, GitHub, Hacker News, arXiv, Wikipedia, AniList, feeds and podcasts
 - **Fails over instead of failing:** search, fetch and the readers try the next backend on auth, quota or rate-limit errors and tell you which one served the result
 - **Cached locally:** repeat searches and static pages come back instantly; weather, prices and news expire in minutes, papers and transcripts in days
 - **Safe by default:** public URLs only, size caps, secret scrubbing, and audio never goes to a second provider without your consent
@@ -237,7 +237,7 @@ No setup: Desk runs `prompture companion` (Prompture 1.13+) on localhost for you
 - `generate_qa_dataset()` — synthetic JSONL datasets ready for Unsloth, Axolotl, TRL
 
 **Capabilities** — see [Capabilities](#capabilities)
-- Keyless `web_search`, `web_fetch` and `read_url` (YouTube, GitHub, HN, arXiv, Wikipedia, feeds, podcasts), with failover across keyed providers
+- Keyless `web_search`, `web_fetch` and `read_url` (YouTube, GitHub, HN, arXiv, Wikipedia, AniList, feeds, podcasts), with failover across keyed providers
 - Local web cache with content-aware lifetimes: minutes for weather, prices and news, days for papers and transcripts
 - `transcribe` / `summarize_media` for video, podcasts and audio, with timestamped key points
 - `ResearchAgent` / `prompture research` — cited multi-source reports within fetch, token, cost and time budgets
@@ -2132,7 +2132,7 @@ agent = Agent("openai/gpt-4o", tools=["web:all"])
 |---|---|
 | `web_search` | `tavily` ▸ `exa` ▸ `serper` ▸ `brave` ▸ `jina` ▸ `searxng` ▸ `exa_mcp` (keyless) |
 | `web_fetch` | `jina_reader` (keyless) ▸ `direct` (safe GET + HTML to Markdown) |
-| `read_url` | YouTube, GitHub, Hacker News, arXiv, Wikipedia, podcasts, RSS/Atom readers ▸ `web_fetch` |
+| `read_url` | YouTube, GitHub, Hacker News, arXiv, Wikipedia, AniList, podcasts, RSS/Atom readers ▸ `web_fetch` |
 | `search_platform` | YouTube (`yt-dlp`), GitHub, Hacker News (Algolia), arXiv |
 
 - Auth, quota and rate-limit errors fail over immediately; timeouts and 5xx
@@ -2155,7 +2155,7 @@ entry lives as long as that kind of content stays true:
 | Platform search (GitHub, HN, arXiv, YouTube) | 30 min |
 | Ordinary pages / searches within `recency_days <= 7` | 1 h |
 | Other searches | 6 h |
-| Wikipedia, podcast episodes | 1 day |
+| Wikipedia, AniList, podcast episodes | 1 day |
 | Papers, PDFs, DOIs, commit-pinned GitHub files, YouTube transcripts | 7 days |
 
 Cached results say so (`route["cached"]`, `cache_age_s`, and "cached 3 min