agent-wire-cli 0.2.1__py3-none-any.whl

agent_wire/channels/tier2_pro/markets.py

@@ -0,0 +1,207 @@
+"""Markets: Yahoo Finance (global), NSE India, Screener.in ratios, CoinGecko crypto."""
+
+import asyncio
+from urllib.parse import parse_qs, quote, urlsplit
+
+from curl_cffi.requests.exceptions import RequestException
+from selectolax.lexbor import LexborHTMLParser
+
+from agent_wire.channels.base import Channel, WireUnsupported, ts
+from agent_wire.engine.http_pool import Fetched
+from agent_wire.engine.waterfall import WireFetchError
+from agent_wire.firewall.outbound_privacy import parse_json
+from agent_wire.models import WireSearchHit
+
+YF = "https://query1.finance.yahoo.com"
+CG = "https://api.coingecko.com/api/v3"
+ERRORS = (WireFetchError, RequestException, ValueError, KeyError, IndexError, TypeError)
+
+
+def _num(v, digits=2):
+    if v is None:
+        return "—"
+    if isinstance(v, int | float) and abs(v) >= 1e9:
+        return f"{v / 1e9:.{digits}f}B"
+    if isinstance(v, int | float) and abs(v) >= 1e6:
+        return f"{v / 1e6:.{digits}f}M"
+    return f"{v:,.{digits}f}" if isinstance(v, int | float) else str(v)
+
+
+def yahoo_row(chart: dict, summary: dict | None = None) -> dict:
+    meta = chart["chart"]["result"][0]["meta"]
+    price, prev = (
+        meta.get("regularMarketPrice"),
+        meta.get("chartPreviousClose") or meta.get("previousClose"),
+    )
+    detail = (summary or {}).get("summaryDetail", {})
+    raw = lambda k: (
+        (detail.get(k) or {}).get("raw") if isinstance(detail.get(k), dict) else detail.get(k)
+    )
+    return {
+        "symbol": meta.get("symbol"), "name": meta.get("longName") or meta.get("shortName"),
+        "price": price, "currency": meta.get("currency"),
+        "change_pct": (price - prev) / prev * 100 if price and prev else None,
+        "high52": meta.get("fiftyTwoWeekHigh"), "low52": meta.get("fiftyTwoWeekLow"),
+        "pe": raw("trailingPE"), "mcap": raw("marketCap"), "exchange": meta.get("fullExchangeName"),
+    }  # fmt: skip
+
+
+def nse_row(data: dict) -> dict:
+    info, price = data.get("info", {}), data.get("priceInfo", {})
+    hl = price.get("weekHighLow", {})
+    return {"symbol": info.get("symbol"), "name": info.get("companyName"), "price": price.get("lastPrice"),
+            "currency": "INR", "change_pct": price.get("pChange"), "high52": hl.get("max"), "low52": hl.get("min"),
+            "pe": data.get("metadata", {}).get("pdSymbolPe"), "mcap": None, "exchange": "NSE"}  # fmt: skip
+
+
+def coingecko_row(m: dict) -> dict:
+    return {"symbol": (m.get("symbol") or "").upper(), "name": m.get("name"), "price": m.get("current_price"),
+            "currency": "USD", "change_pct": m.get("price_change_percentage_24h"), "high52": m.get("ath"),
+            "low52": m.get("atl"), "pe": None, "mcap": m.get("market_cap"), "exchange": "CoinGecko (ATH/ATL)"}  # fmt: skip
+
+
+def screener_ratios(html: str) -> dict[str, str]:
+    out = {}
+    for li in LexborHTMLParser(html).css("#top-ratios li"):
+        name, value = li.css_first(".name"), li.css_first(".value")
+        if name and value:
+            out[name.text(strip=True)] = " ".join(value.text(strip=True).split())
+    return out
+
+
+def table(rows: list[dict]) -> str:
+    lines = [
+        "| Symbol | Name | Price | Chg % | 52W H / L | P/E | Mkt cap |",
+        "|---|---|---|---|---|---|---|",
+    ]
+    for r in rows:
+        chg = f"{r['change_pct']:+.2f}%" if isinstance(r.get("change_pct"), int | float) else "—"
+        lines.append(f"| {r['symbol']} | {r.get('name') or ''} | {_num(r['price'])} {r.get('currency') or ''} | {chg} "
+                     f"| {_num(r.get('high52'))} / {_num(r.get('low52'))} | {_num(r.get('pe'))} | {_num(r.get('mcap'))} |")  # fmt: skip
+    return "\n".join(lines)
+
+
+class MarketsChannel(Channel):
+    name = "markets"
+
+    def __init__(self, ctx):
+        super().__init__(ctx)
+        self._crumb: str | None = None
+
+    async def _chrome(self, url: str, **kw) -> Fetched:
+        """Anonymous shared chrome session: Yahoo/NSE need the cookies they set on a first visit."""
+        return await self.ctx.pool.get(url, impersonate="chrome", **kw)
+
+    async def _yahoo(self, sym: str) -> tuple[dict, Fetched]:
+        f = await self._chrome(f"{YF}/v8/finance/chart/{quote(sym)}?range=5d&interval=1d")
+        if not f.ok:
+            raise WireFetchError(f"yahoo {sym}: HTTP {f.status}")
+        chart = parse_json(f.content)
+        summary = None
+        try:
+            if not self._crumb:
+                await self._chrome("https://fc.yahoo.com/")
+                self._crumb = (await self._chrome(f"{YF}/v1/test/getcrumb")).text.strip() or None
+            if self._crumb:
+                s = await self._chrome(f"{YF}/v10/finance/quoteSummary/{quote(sym)}?modules=summaryDetail"
+                                       f"&crumb={quote(self._crumb)}")  # fmt: skip
+                summary = parse_json(s.content)["quoteSummary"]["result"][0] if s.ok else None
+        except ERRORS:
+            summary = None  # P/E and market cap are a bonus over the chart quote
+        return yahoo_row(chart, summary), f
+
+    async def _nse(self, sym: str) -> tuple[dict, Fetched]:
+        await self._chrome("https://www.nseindia.com/")
+        f = await self._chrome(f"https://www.nseindia.com/api/quote-equity?symbol={quote(sym)}",
+                               headers={"Referer": f"https://www.nseindia.com/get-quotes/equity?symbol={sym}"})  # fmt: skip
+        if not f.ok:
+            raise WireFetchError(f"nse {sym}: HTTP {f.status}")
+        return nse_row(parse_json(f.content)), f
+
+    async def _coin(self, ident: str) -> tuple[dict, Fetched]:
+        coin_id = ident.lower()
+        found, _ = await self.fetch_json(f"{CG}/search?query={quote(coin_id)}")
+        if found.get("coins"):
+            coin_id = found["coins"][0]["id"]
+        data, f = await self.fetch_json(f"{CG}/coins/markets?vs_currency=usd&ids={quote(coin_id)}")
+        if not data:
+            raise WireUnsupported(f"no CoinGecko coin for {ident!r}")
+        return coingecko_row(data[0]), f
+
+    async def quote(self, token: str) -> tuple[dict, Fetched]:
+        t = token.strip()
+        prefix, _, rest = t.partition(":")
+        if rest and prefix.lower() in ("crypto", "cg", "coin"):
+            return await self._coin(rest)
+        if rest and prefix.lower() == "nse":
+            try:
+                return await self._nse(rest.upper())
+            except ERRORS:  # NSE's Akamai front blocks many networks; Yahoo carries NSE listings
+                return await self._yahoo(f"{rest.upper()}.NS")
+        return await self._yahoo(t.upper())
+
+    async def _news(self, sym: str) -> str:
+        try:
+            data, _ = await self.fetch_json(
+                f"{YF}/v1/finance/search?q={quote(sym)}&newsCount=5&quotesCount=0"
+            )
+        except ERRORS:
+            return ""
+        return "\n".join(f"- [{n['title']}]({n['link']}) · {n.get('publisher', '')} · "
+                         f"{ts(n.get('providerPublishTime')).date() if n.get('providerPublishTime') else ''}"
+                         for n in data.get("news", []))  # fmt: skip
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        p = urlsplit(url)
+        host, segs = (p.hostname or "").removeprefix("www."), [s for s in p.path.split("/") if s]
+        if host == "screener.in" and segs[:1] == ["company"] and len(segs) > 1:
+            f = await self.fetch(url, archive=False)
+            ratios = screener_ratios(f.text)
+            body = "\n".join(f"- {k}: {v}" for k, v in ratios.items())
+            return self.doc(
+                f,
+                url,
+                title=f"{segs[1]} · Screener.in",
+                body=body,
+                metadata={"source": "screener.in"},
+            )
+        if host == "nseindia.com":
+            token = "nse:" + parse_qs(p.query).get("symbol", [""])[0]
+        elif host == "coingecko.com":
+            token = "crypto:" + segs[-1]
+        else:  # finance.yahoo.com/quote/SYM
+            token = segs[segs.index("quote") + 1] if "quote" in segs else segs[-1]
+        row, f = await self.quote(token)
+        news = await self._news(row["symbol"]) if host == "finance.yahoo.com" else ""
+        body = table([row]) + (f"\n\n## News\n{news}" if news else "")
+        return self.doc(f, url, title=f"{row.get('name') or row['symbol']} quote", body=body,
+                        metadata={"exchange": row.get("exchange")})  # fmt: skip
+
+    async def feed(self, target, *, sort="hot", limit=10):
+        tokens = [t for t in target.replace(";", ",").split(",") if t.strip()][:limit]
+        results = await asyncio.gather(*(self.quote(t) for t in tokens), return_exceptions=True)
+        rows, errors, last = [], [], None
+        for tok, r in zip(tokens, results, strict=True):
+            if isinstance(r, BaseException):
+                if not isinstance(r, ERRORS + (WireUnsupported,)):
+                    raise r
+                errors.append(f"{tok.strip()}: {type(r).__name__}")
+            else:
+                rows.append(r[0])
+                last = r[1]
+        if not rows:
+            raise WireUnsupported("no quotes resolved: " + "; ".join(errors))
+        body = table(rows) + (f"\n\nUnavailable: {'; '.join(errors)}" if errors else "")
+        return self.doc(last, "https://finance.yahoo.com/", title="Watchlist", body=body)
+
+    async def search(self, query, *, limit=5, sort="relevance"):
+        data, _ = await self.fetch_json(
+            f"{YF}/v1/finance/search?q={quote(query)}&quotesCount={limit}&newsCount=0"
+        )
+        return [WireSearchHit(url=f"https://finance.yahoo.com/quote/{q['symbol']}",
+                              title=f"{q['symbol']} · {q.get('shortname') or q.get('longname') or ''}",
+                              snippet=f"{q.get('quoteType', '')} on {q.get('exchDisp', '')}", source="yahoo")
+                for q in data.get("quotes", [])[:limit] if q.get("symbol")]  # fmt: skip
+
+
+CHANNEL = MarketsChannel

agent_wire/channels/tier2_pro/meta_social.py

@@ -0,0 +1,104 @@
+"""Instagram and Facebook: public embeds / web-profile API / OpenGraph, cookie escalation if logged in."""
+
+import re
+from urllib.parse import urlsplit
+
+from selectolax.lexbor import LexborHTMLParser
+
+from agent_wire.channels.base import Channel, WireUnsupported, compact_count, json_ld, meta_tags, ts
+from agent_wire.engine.waterfall import WireFetchError
+
+IG_APP_ID = "936619743392459"  # public id the Instagram web app sends with every request
+_IG_POST = re.compile(r"/(?:p|reel|reels|tv)/([\w-]+)")
+
+
+def parse_ig_embed(html: str) -> dict:
+    tree = LexborHTMLParser(html)
+    cap = tree.css_first(".Caption")
+    user = tree.css_first(".CaptionUsername, .UsernameText")
+    text = cap.text(separator=" ", strip=True) if cap else ""
+    name = user.text(strip=True) if user else None
+    if name and text.startswith(name):
+        text = text[len(name) :].strip()
+    likes = tree.css_first(".SocialProof a, .likes")
+    return {"author_handle": name, "body": text,
+            "metadata": {"likes": compact_count(likes.text()) if likes else None}}  # fmt: skip
+
+
+def parse_og_social(html: str) -> dict:
+    """og:description like '1,234 likes, 56 comments - user on June 1, 2025: "caption"'."""
+    m = meta_tags(html)
+    desc = m.get("og:description") or m.get("description") or ""
+    if not desc and not m.get("og:title"):
+        raise WireUnsupported("login wall; run `wire auth login instagram.com` (or facebook.com)")
+    likes = re.search(r"([\d.,KM]+)\s+likes?", desc)
+    comments = re.search(r"([\d.,KM]+)\s+comments?", desc)
+    caption = re.search(r':\s*"(.*)"\s*\.?$', desc, re.DOTALL)
+    return {"title": m.get("og:title"), "body": caption[1] if caption else desc,
+            "metadata": {"likes": compact_count(likes[1]) if likes else None,
+                         "comments": compact_count(comments[1]) if comments else None}}  # fmt: skip
+
+
+def parse_ig_profile(data: dict) -> dict:
+    u = data.get("data", {}).get("user") or {}
+    posts = [e["node"] for e in (u.get("edge_owner_to_timeline_media") or {}).get("edges", [])]
+    lines = [u.get("biography") or ""]
+    for p in posts[:12]:
+        caps = (p.get("edge_media_to_caption") or {}).get("edges") or [{}]
+        cap = (caps[0].get("node") or {}).get("text", "")
+        likes = (p.get("edge_liked_by") or p.get("edge_media_preview_like") or {}).get("count")
+        lines.append(
+            f"- https://www.instagram.com/p/{p.get('shortcode')}/ · ♥{likes} · {cap[:160]}"
+        )
+    return {"title": f"{u.get('full_name') or u.get('username')} (@{u.get('username')})",
+            "author_handle": u.get("username"), "body": "\n".join(x for x in lines if x),
+            "metadata": {"followers": (u.get("edge_followed_by") or {}).get("count"),
+                         "following": (u.get("edge_follow") or {}).get("count"),
+                         "posts": (u.get("edge_owner_to_timeline_media") or {}).get("count")}}  # fmt: skip
+
+
+class MetaSocialChannel(Channel):
+    name = "meta_social"
+
+    async def _ig(self, url: str, **kw):
+        # Fetch as the "instagram" channel so the outbound firewall applies its login-only rules.
+        return await self.fetch(url, channel="instagram", archive=False, **kw)
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        p = urlsplit(url)
+        host = (p.hostname or "").removeprefix("www.").removeprefix("m.")
+        if host == "instagram.com":
+            if m := _IG_POST.search(p.path):
+                code = m[1]
+                try:
+                    f = await self._ig(f"https://www.instagram.com/p/{code}/embed/captioned/")
+                    post = parse_ig_embed(f.text)
+                    if post["body"]:
+                        return self.doc(
+                            f, url, title=f"@{post['author_handle']} on Instagram", **post
+                        )
+                except WireFetchError:
+                    pass
+                f = await self._ig(url)
+                return self.doc(f, url, **parse_og_social(f.text))
+            user = p.path.strip("/").split("/")[0]
+            if user:
+                try:
+                    data, f = await self.fetch_json(
+                        f"https://www.instagram.com/api/v1/users/web_profile_info/?username={user}",
+                        headers={"x-ig-app-id": IG_APP_ID}, channel="instagram",
+                    )  # fmt: skip
+                    return self.doc(f, url, **parse_ig_profile(data))
+                except (WireFetchError, ValueError):
+                    f = await self._ig(url)
+                    return self.doc(f, url, **parse_og_social(f.text))
+        f = await self.fetch(url, archive=False)  # facebook public pages / posts / watch
+        for item in json_ld(f.text):
+            if item.get("articleBody") or item.get("description"):
+                return self.doc(f, url, title=item.get("headline") or item.get("name"),
+                                body=item.get("articleBody") or item.get("description"),
+                                timestamp=ts(item.get("datePublished")))  # fmt: skip
+        return self.doc(f, url, **parse_og_social(f.text))
+
+
+CHANNEL = MetaSocialChannel

agent_wire/channels/tier2_pro/news.py

@@ -0,0 +1,173 @@
+"""News: Google News RSS search (date-windowed) and the Techmeme river, no keys.
+
+Google News items link to news.google.com/rss/articles/<id>, which only redirects with JavaScript.
+decode() resolves the publisher URL the way that page does: read its signature + timestamp, then
+ask the batchexecute endpoint for the target.
+"""
+
+import asyncio
+import json
+import re
+import xml.etree.ElementTree as ET
+from datetime import UTC, datetime, timedelta
+from email.utils import parsedate_to_datetime
+from urllib.parse import quote
+
+from curl_cffi.requests.exceptions import RequestException
+
+from agent_wire.channels.base import Channel, WireUnsupported, html_text, listing
+from agent_wire.engine.waterfall import WireFetchError
+from agent_wire.models import WireSearchHit
+
+GNEWS = "https://news.google.com/rss/search?q={q}&hl=en-US&gl=US&ceid=US:en"
+GN_ARTICLE = re.compile(r"^https://news\.google\.com/(?:rss/)?(?:articles|read)/([\w-]+)")
+BATCH = "https://news.google.com/_/DotsSplashUi/data/batchexecute"
+_SG = re.compile(rb'data-n-a-sg="([^"]+)"')
+_TS = re.compile(rb'data-n-a-ts="(\d+)"')
+DECODE_TIMEOUT_S = 10
+TECHMEME = "https://www.techmeme.com/feed.xml"
+_HREF = re.compile(r'href="(https?://[^"]+)"')
+_WORD = re.compile(r"[a-z0-9+#]+")
+_OUTLET = re.compile(r"\s*\((?:[A-Z][\w.&' -]{1,40})\)\s*$")  # "... (Bloomberg)"
+
+
+def _date(text: str | None) -> datetime | None:
+    try:
+        return parsedate_to_datetime(text) if text else None
+    except (TypeError, ValueError):
+        return None
+
+
+def parse_rss_items(content: bytes) -> list[dict]:
+    try:
+        root = ET.fromstring(content)
+    except ET.ParseError as e:
+        raise WireUnsupported(f"news feed unreadable ({e})") from e
+    out = []
+    for it in root.iter("item"):
+        src = it.find("source")
+        out.append({"title": (it.findtext("title") or "").strip(), "url": it.findtext("link") or "",
+                    "date": _date(it.findtext("pubDate")), "desc": it.findtext("description") or "",
+                    "source": src.text if src is not None else None})  # fmt: skip
+    return out
+
+
+def gnews_hits(items: list[dict]) -> list[WireSearchHit]:
+    hits = []
+    for it in items:
+        title, outlet = it["title"], it["source"]
+        if outlet and title.endswith(f" - {outlet}"):
+            title = title[: -len(outlet) - 3]
+        hits.append(WireSearchHit(url=it["url"], title=title, snippet=outlet or "", source="news",
+                                  timestamp=it["date"], author=outlet))  # fmt: skip
+    return hits
+
+
+def techmeme_hits(items: list[dict]) -> list[WireSearchHit]:
+    hits = []
+    for it in items:
+        links = [u for u in _HREF.findall(it["desc"]) if "techmeme.com" not in u]
+        hits.append(WireSearchHit(url=it["url"], title=_OUTLET.sub("", it["title"]), snippet=html_text(it["desc"])[:300],
+                                  source="techmeme", timestamp=it["date"],
+                                  link=links[0] if links else None))  # fmt: skip
+    return hits
+
+
+def batch_form(gid: str, stamp: str, sig: str) -> dict:
+    inner = ["garturlreq", [["X", "X", ["X", "X"], None, None, 1, 1, "US:en", None, 1, None, None,
+                             None, None, None, 0, 1], "X", "X", 1, [1, 1, 1], 1, 1, None, 0, 0, None, 0],
+             gid, int(stamp), sig]  # fmt: skip
+    return {"f.req": json.dumps([[["Fbv4je", json.dumps(inner), None, "generic"]]])}
+
+
+def parse_batch(text: str) -> str | None:
+    try:
+        rows = json.loads(text.split("\n\n", 1)[1])
+        url = json.loads(rows[0][2])[1]
+    except (IndexError, ValueError, TypeError):
+        return None
+    return url if isinstance(url, str) and url.startswith("http") else None
+
+
+def matches(hit: WireSearchHit, query: str) -> bool:
+    """Every content word of the query appears in the title or snippet."""
+    words = [w for w in _WORD.findall(query.lower()) if len(w) > 1]
+    text = f"{hit.title} {hit.snippet}".lower()
+    return bool(words) and all(w in text for w in words)
+
+
+class NewsChannel(Channel):
+    name = "news"
+
+    async def _items(self, url: str) -> list[dict]:
+        f = await self.fetch(url, archive=False, browser=False)
+        return parse_rss_items(f.content)
+
+    async def techmeme(self, query: str | None = None, since=None) -> list[WireSearchHit]:
+        hits = techmeme_hits(await self._items(TECHMEME))
+        if since:
+            hits = [h for h in hits if h.timestamp is None or h.timestamp >= since]
+        return [h for h in hits if matches(h, query)] if query else hits
+
+    async def search(self, query, *, limit=5, sort="relevance", since=None):
+        q = query
+        if since:
+            q = f"{query} when:{max(1, (datetime.now(UTC) - since).days)}d"
+        hits = gnews_hits(await self._items(GNEWS.format(q=quote(q))))
+        if sort in ("new", "date", "recent"):
+            hits.sort(key=lambda h: h.timestamp or datetime.min.replace(tzinfo=UTC), reverse=True)
+        try:
+            tm = await self.techmeme(query, since)
+        except (WireFetchError, WireUnsupported):  # Techmeme is a bonus; Google News answered
+            tm = []
+        out = (tm + hits)[:limit]
+        real = await asyncio.gather(*(self.decode(h.url) for h in out))
+        return [h.model_copy(update={"url": u}) for h, u in zip(out, real, strict=True)]
+
+    async def decode(self, url: str) -> str:
+        """Publisher URL behind a Google News link; the link itself when it can't be resolved."""
+        m = GN_ARTICLE.match(url)
+        if not m or self.ctx.pool is None:
+            return url
+        try:
+            return await asyncio.wait_for(self._decode(m[1]), DECODE_TIMEOUT_S) or url
+        except (RequestException, TimeoutError, ValueError):
+            return url
+
+    async def _decode(self, gid: str) -> str | None:
+        page = await self.ctx.pool.get(f"https://news.google.com/rss/articles/{gid}")
+        sig, stamp = _SG.search(page.content), _TS.search(page.content)
+        if not (sig and stamp):
+            return None
+        r = await self.ctx.pool.get(
+            BATCH, method="POST", data=batch_form(gid, stamp[1].decode(), sig[1].decode()),
+            headers={"Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"},
+        )  # fmt: skip
+        return parse_batch(r.content.decode("utf-8", "replace")) if r.ok else None
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        from agent_wire.router import route_url  # router imports the channel registry
+
+        target = await self.decode(url)
+        if target == url:
+            raise WireUnsupported(f"news: could not resolve the Google News link {url}")
+        return await self.ctx.channel(route_url(target)).read(
+            target, query=query, section=section, include_comments=include_comments
+        )
+
+    async def feed(self, target="techmeme", *, sort="hot", limit=10):
+        key = target.strip().lower()
+        if key in ("techmeme", "tech", ""):
+            hits = (await self.techmeme())[:limit]
+            title, url = "Techmeme", "https://www.techmeme.com/"
+        else:
+            hits = await self.search(
+                target, limit=limit, since=datetime.now(UTC) - timedelta(days=7)
+            )
+            title, url = f"News · {target}", GNEWS.format(q=quote(target))
+        items = [{"title": h.title, "url": h.link or h.url, "snippet": h.snippet,
+                  "meta": [h.timestamp.date().isoformat() if h.timestamp else None]} for h in hits]  # fmt: skip
+        return self.doc(None, url, title=title, body=listing(items))
+
+
+CHANNEL = NewsChannel

agent_wire/channels/tier2_pro/polymarket.py

@@ -0,0 +1,105 @@
+"""Polymarket prediction markets (public Gamma API, no key): what money says about a topic."""
+
+import json
+from urllib.parse import quote, urlsplit
+
+from agent_wire.channels.base import Channel, WireUnsupported, listing, ts
+from agent_wire.models import WireSearchHit
+
+GAMMA = "https://gamma-api.polymarket.com"
+EVENT = "https://polymarket.com/event/"
+
+
+def _odds(market: dict) -> str:
+    """'Yes 62% · No 38%' from the JSON-in-a-string outcome fields."""
+    try:
+        names = json.loads(market.get("outcomes") or "[]")
+        prices = [float(p) for p in json.loads(market.get("outcomePrices") or "[]")]
+    except (ValueError, TypeError):
+        return ""
+    label = market.get("groupItemTitle")
+    odds = " · ".join(f"{n} {round(p * 100)}%" for n, p in zip(names, prices, strict=False))
+    return f"{label}: {odds}" if label else odds
+
+
+def _movement(market: dict) -> str:
+    d = market.get("oneWeekPriceChange") or market.get("oneDayPriceChange")
+    if not isinstance(d, int | float) or not d:
+        return ""
+    return f"({'+' if d > 0 else ''}{round(d * 100)} pts)"
+
+
+def event_summary(event: dict, max_markets: int = 4) -> list[str]:
+    markets = sorted(event.get("markets") or [], key=lambda m: -float(m.get("volume") or 0))
+    lines = (" ".join(filter(None, (_odds(m), _movement(m)))) for m in markets[:max_markets])
+    return [line for line in lines if line]
+
+
+def event_hit(event: dict) -> WireSearchHit:
+    vol24 = int(float(event.get("volume24hr") or 0))
+    return WireSearchHit(
+        url=EVENT + event.get("slug", ""), title=event.get("title") or "",
+        snippet=" | ".join(event_summary(event, 3)), source="polymarket",
+        rank_score=float(vol24),  # undated: a market is live until it resolves, so "freshness" is moot
+        engagement={"volume": int(float(event.get("volume") or 0)), "volume24h": vol24,
+                    "liquidity": int(float(event.get("liquidity") or 0)),
+                    "comments": event.get("commentCount") or 0},
+    )  # fmt: skip
+
+
+class PolymarketChannel(Channel):
+    name = "polymarket"
+
+    async def search(self, query, *, limit=5, sort="relevance", since=None):
+        data, _ = await self.fetch_json(
+            f"{GAMMA}/public-search?q={quote(query)}&limit_per_type={max(limit, 5)}&events_status=active"
+        )
+        events = [e for e in data.get("events") or [] if not e.get("closed")]
+        if since:  # markets that resolved before the window opened are history, not news
+            events = [e for e in events if (t := ts(e.get("endDate"))) is None or t >= since]
+        return [event_hit(e) for e in events[:limit]]
+
+    async def feed(self, target="trending", *, sort="hot", limit=10):
+        if target.strip().lower() not in ("trending", "hot", "top", "movers", ""):
+            hits = await self.search(target, limit=limit)
+            body = listing([{"title": h.title, "url": h.url, "snippet": h.snippet,
+                             "meta": [f"${h.engagement['volume24h']:,} 24h"]} for h in hits])  # fmt: skip
+            return self.doc(None, f"https://polymarket.com/search?q={quote(target)}",
+                            title=f"Polymarket · {target}", body=body)  # fmt: skip
+        data, f = await self.fetch_json(
+            f"{GAMMA}/events?limit={limit}&active=true&closed=false&order=volume24hr&ascending=false"
+        )
+        items = [{"title": e.get("title"), "url": EVENT + e.get("slug", ""),
+                  "meta": [f"${int(float(e.get('volume24hr') or 0)):,} 24h"],
+                  "snippet": " | ".join(event_summary(e, 2))} for e in data]  # fmt: skip
+        return self.doc(
+            f, "https://polymarket.com/", title="Polymarket · trending", body=listing(items)
+        )
+
+    async def trending_hits(self, limit=10) -> list[WireSearchHit]:
+        data, _ = await self.fetch_json(
+            f"{GAMMA}/events?limit={limit}&active=true&closed=false&order=volume24hr&ascending=false"
+        )
+        return [event_hit(e) for e in data]
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        parts = [p for p in urlsplit(url).path.split("/") if p]
+        if not parts:  # the front page: trending markets
+            return await self.feed("trending")
+        if len(parts) < 2 or parts[0] not in ("event", "market"):
+            raise WireUnsupported("polymarket: only /event/<slug> URLs and the front page")
+        data, f = await self.fetch_json(f"{GAMMA}/events?slug={quote(parts[1])}")
+        if not data:
+            raise WireUnsupported(f"polymarket: no event {parts[1]!r}")
+        e = data[0]
+        lines = [f"- {line}" for line in event_summary(e, 20)]
+        body = "\n".join([e.get("description") or "", "", "Markets:", *lines]).strip()
+        hit = event_hit(e)
+        return self.doc(
+            f, url, title=e.get("title"), timestamp=ts(e.get("startDate")), body=body,
+            metadata={"volume": hit.engagement["volume"], "volume_24h": hit.engagement["volume24h"],
+                      "ends": (e.get("endDate") or "")[:10] or None},
+        )  # fmt: skip
+
+
+CHANNEL = PolymarketChannel