Deploy latest local hf-hub-query version

_monty_codegen_shared.md

@@ -2,6 +2,7 @@
 - No imports.
 - Helper functions are already in scope.
 - All helper calls are async: always use `await`.
+- `max_calls` is the overall external-call budget for the generated program, not a generic helper argument. You may use it inside `solve(...)` to bound loops or choose a cheaper fallback strategy, but do not pass it to helpers unless the helper signature explicitly includes `max_calls`.
 - Before sending the tool call, check that the wrapper both defines `solve(...)` and ends with `await solve(query, max_calls)`.
 - Use helper functions first. Use raw `call_api('/api/...')` only if no helper fits.
 - `call_api` must use a raw path starting with `/api/...`.
@@ -11,11 +12,13 @@
 - When the user asks for specific fields or "return only ...", return exactly that final shape from `solve(...)` instead of a larger helper envelope.
 - For bounded list/sample helpers in raw mode, prefer returning the helper envelope directly when coverage/limit metadata matters.
 - For detail lookups, prefer returning a compact dict of relevant fields rather than the full raw helper response.
-- Prefer omitting unavailable fields rather than emitting `null` placeholders, unless the user explicitly asked for a fixed schema with nulls.
-- For structured requests asking for counts/lists/fields, prefer returning a compact JSON object/array instead of prose or markdown tables, even if the user did not explicitly say "return only".
-- If the user names output fields explicitly (for example `id, title, likes` or `event_type + repo_id`), return those exact field names in JSON rather than paraphrasing them into prose labels.
-- For prompts that say "when present", include the field only when it has a real value; do not emit `null` placeholders.
-- For prompts asking for compact structured output, use stable key names from the examples below instead of inventing new labels.
+- For structured requests, prefer compact JSON objects/arrays over prose or markdown tables. Use the user's requested field names when they are explicit, use the stable key names shown below when they are not, and omit unavailable fields unless the user explicitly asked for a fixed schema with nulls.
+- For prompts that ask for both a sample/list and metadata, keep the sample compact and surface helper-owned metadata explicitly. Do not dump a very large item list just because metadata was requested.
+- If the user asks for coverage/exactness/truncation metadata, prefer helper `meta` fields such as `exact_count`, `sample_complete`, `truncated`, `count_source`, `returned`, `total`, `total_matched`, `more_available`, and applied/requested limits.
+- When the user asks for a sample plus metadata and does not specify a large sample size, default to a small sample (typically 10-20 rows) rather than returning hundreds of rows.
+- Do not ask the user for their username just because they said "my" or "me". Use current-user helper behavior first.
+- For current-user prompts, prefer helpers that support `username=None` for the authenticated user. Call `hf_whoami()` first when you need the explicit username for joins, comparisons, or output labeling.
+- Only ask a follow-up for identity if `hf_whoami()` or a current-user helper fails because authentication/current-user resolution is unavailable.
 
 ## Helper result shape
 All helpers return:
@@ -35,6 +38,38 @@ Rules:
 - `meta` contains helper-owned execution and coverage metadata. For bounded list/sample helpers this can include requested/applied limits, whether a default limit was used, exactness/completeness, whether more rows may be available, truncation cause, and a next-request hint.
 - Helpers return rich default rows. Use `fields` to narrow output; use `advanced` only when you truly need backend-specific behavior beyond the default row.
 - Exhaustive helpers such as graph/members/likes/activity can return substantially more than 100 rows when you request a larger `return_limit`; use helper `meta` (and the outer raw `meta.limit_summary`) to tell when limits were still hit.
+- For metadata-oriented prompts, read and return the helper `meta` object (or a compact subset of it) instead of inferring coverage from list length alone.
+
+## Typed graph shorthand
+Use this graph mental model instead of reconstructing relations from raw endpoints.
+
+```text
+Node types
+- U = user row       {username, fullname, isPro, ...}
+- O = org row        {organization, displayName, followers, members, ...}
+- R = repo row       {repo_id, repo_type, author, likes, downloads, repo_url, ...}
+- A = activity row   {event_type, repo_id, repo_type, timestamp, ...}
+- S = user summary   {username, overview, followers?, following?, likes?, activity?}
+
+Direct edges / helpers
+- U -followers-> U   => hf_user_graph(relation="followers")
+- U -following-> U   => hf_user_graph(relation="following")
+- U -likes-> R       => hf_user_likes(username=...)
+- R -liked_by-> U    => hf_repo_likers(repo_id=..., repo_type=...)
+- O -members-> U     => hf_org_members(organization=...)
+- O -repos-> R       => hf_repo_search(author="<org>", repo_types=[...])
+- U/O -activity-> A  => hf_recent_activity(feed_type=..., entity=...)
+- R -details-> R     => hf_repo_details(...)
+- U -summary-> S     => hf_user_summary(...)
+- O -overview-> O    => hf_org_overview(...)
+```
+
+Rules:
+- Prefer the helper that already matches the requested edge direction.
+- Do not reverse a relation indirectly if a direct helper exists.
+- If you already know an author/org and need repos, go straight to `hf_repo_search(author=...)`.
+- Read profile/social/link fields from `hf_user_summary(... )["item"]["overview"]`, not from graph rows.
+- Use canonical row fields in generated code: user rows use `username`, repo rows use `repo_id`/`repo_type`, activity rows use `event_type`/`repo_id`/`repo_type`/`timestamp`.
 
 ## Helper API
 ```py
@@ -95,6 +130,16 @@ await hf_user_graph(
   fields: list[str] | None = None,
 )
 
+await hf_repo_likers(
+  repo_id: str,
+  repo_type: str,                     # model|dataset|space
+  return_limit: int | None = None,
+  count_only: bool = False,
+  pro_only: bool | None = None,
+  where: dict | None = None,
+  fields: list[str] | None = None,
+)
+
 await hf_user_likes(
   username: str | None = None,        # None => current authenticated user
   repo_types: list[str] | None = None,
@@ -130,6 +175,28 @@ await hf_whoami()
 await call_api(endpoint: str, params: dict | None = None, method: str = "GET", json_body: dict | None = None)
 ```
 
+## Important nested result contracts
+### `hf_user_summary(...)`
+`hf_user_summary(...)` returns the normal helper envelope. The main payload is in `summary["item"]`.
+
+```py
+summary["item"] == {
+  "username": str,
+  "overview": dict,   # profile + socials + counts
+  "followers": {"count": int | None, "sample": list[dict]} | None,
+  "following": {"count": int | None, "sample": list[dict]} | None,
+  "likes": {"count": int | None, "sample": list[dict]} | None,
+  "activity": {"count": int | None, "sample": list[dict]} | None,
+}
+```
+
+Read profile/social fields from `summary["item"]["overview"]`, commonly:
+- `websiteUrl`
+- `twitter`, `github`, `linkedin`, `bluesky`
+- `twitterHandle`, `githubHandle`, `linkedinHandle`, `blueskyHandle`
+- `followers`, `following`, `likes`
+- `isPro`
+
 ## Common repo fields
 Search/detail/trending repo rows commonly include:
 - `repo_id`
@@ -151,21 +218,96 @@ Type-specific fields may also be present by default when available, such as:
 - dataset: `description`, `paperswithcode_id`
 - space: `sdk`, `models`, `datasets`, `subdomain`
 
+## Common user overview fields
+`hf_user_summary(... )["item"]["overview"]` commonly includes:
+- `username`
+- `fullname`
+- `bio`
+- `avatarUrl`
+- `websiteUrl`
+- `twitter`
+- `github`
+- `linkedin`
+- `bluesky`
+- `twitterHandle`
+- `githubHandle`
+- `linkedinHandle`
+- `blueskyHandle`
+- `followers`
+- `following`
+- `likes`
+- `models`
+- `datasets`
+- `spaces`
+- `discussions`
+- `papers`
+- `upvotes`
+- `orgs`
+- `isPro`
+
+## Primary navigation paths
+Choose the helper based on the **subject of the question** and the **smallest helper that already contains the needed fields**.
+
+### Repo-centric questions
+- Exact repo by id (`owner/name`) → `hf_repo_details(...)`
+- Search/discovery/list/top repos → `hf_repo_search(...)`
+- True trending requests → `hf_trending(...)`
+- Repo discussions → `hf_repo_discussions(...)`
+- Users who liked a specific repo / liker filtering / liker counts → `hf_repo_likers(...)`
+
+### User-centric questions
+- Profile / overview / "tell me about user X" → `hf_user_summary(...)`
+- Followers / following / graph sampling → `hf_user_graph(...)`
+- Repos a user liked → `hf_user_likes(...)`
+- Recent actions / feed questions → `hf_recent_activity(...)`
+
+### Organization-centric questions
+- Organization details / counts → `hf_org_overview(...)`
+- Organization members → `hf_org_members(...)`
+- Organization repos → `hf_repo_search(author="<org>", repo_types=["model", "dataset", "space"])`
+
+### Relationship direction matters
+- `hf_user_likes(...)` = **user → repos**
+- `hf_repo_likers(...)` = **repo → users**
+- `hf_user_graph(...)` = **user/org → followers/following**
+
+Pick the helper that already matches the direction of the question instead of trying to reconstruct the relation indirectly.
+
+## Efficiency rules
+- Prefer **one helper call with local aggregation/filtering** over **many follow-up detail calls**.
+- If the current helper already exposes the needed field, use it directly instead of hydrating each row with another helper.
+- Use `hf_user_summary(username=...)` per user only when you truly need profile/social fields that are not already present in the current row set.
+- For overlap/comparison/ranking tasks, fetch a broad enough working set first, then compute locally in generated code.
+- Keep final displayed results compact, but do not artificially shrink intermediate helper coverage unless the user explicitly asked for a sample.
+
+### Important anti-patterns
+- For repo liker questions, do **not** call `hf_user_summary(...)` for each liker just to determine `isPro` or `type`. `hf_repo_likers(...)` already returns `username`, `fullname`, `type`, and `isPro`.
+- For follower/following questions, do **not** use `hf_user_summary(...)` to reconstruct the graph. Use `hf_user_graph(...)`.
+- For "repos by author/org" questions, do **not** search semantically first if the author is already known. Start with `hf_repo_search(author=..., ...)`.
+- For "most popular repo a user liked" questions, do **not** fetch recent likes and manually re-rank them. Use `hf_user_likes(..., sort="repoLikes" | "repoDownloads")`.
+
 ## Usage guidance
 - Use `hf_repo_search(...)` for find/search/top requests. Prefer dedicated args like `author=` over using `where` when a first-class helper argument exists.
 - `hf_repo_search(...)` defaults to `repo_type="model"` when no repo type is specified. For prompts like "what repos does <author/org> have" or "list everything published by <author/org>", search across `repo_types=["model", "dataset", "space"]` unless the user explicitly asked for one type.
 - Use `hf_repo_details(repo_type="auto", ...)` for `owner/name` detail lookups unless the type is explicit.
 - Use `hf_trending(...)` only for true trending requests.
 - `hf_trending(...)` does not accept extra filters like tag/author/task. For trending + extra filters, either ask a brief clarification or clearly label an approximation using `hf_repo_search(sort="trending_score", ...)`.
-- Use `hf_user_summary(...)` for common "tell me about user X" prompts. It always includes overview data and can add sampled followers/following/likes/activity sections.
+- Use `hf_user_summary(...)` for common "tell me about user X" prompts. It returns a fixed structured object (no `fields=` projection) with overview data and optional sampled followers/following/likes/activity sections. Read profile and social-link fields such as `websiteUrl`, `twitter`, `github`, `linkedin`, and `bluesky` from `summary["item"]["overview"]`.
+- For "my/me" prompts, prefer current-user forms first: `hf_user_summary(username=None)`, `hf_user_graph(username=None, ...)`, and `hf_user_likes(username=None, ...)`. Use `hf_whoami()` when you need the resolved username explicitly.
 - Use `hf_org_overview(...)` for organization details like display name, followers, and member count.
 - Use `hf_org_members(...)` for organization member lists and counts. Member rows use `username`, `fullname`, `isPro`, and `role`; common aliases like `login`, `name`, and `is_pro` are tolerated in `fields=[...]`.
 - Use `hf_user_graph(...)` for follower/following lists, counts, and filtered graph samples. Prefer `relation=` over trying undocumented helper names.
+- Use `hf_repo_likers(...)` for "who liked this repo?" prompts. It returns liker rows for a specific model, dataset, or space; pass `repo_type` explicitly.
 - For overlap/comparison/ranking tasks over followers, org members, likes, or activity, do not use small manual `return_limit` values like 10/20/50 unless the user explicitly asked for a sample. Use the helper default or a clearly high bound for the intermediate analysis, then keep only the final displayed result compact.
+- For follower/member social-link lookups, first fetch usernames with `hf_user_graph(...)` or `hf_org_members(...)`, then fetch each user's profile/social data with `hf_user_summary(username=...)`. If the follower/member set is large and the user did not specify a cap, ask for a limit or clearly indicate that the result may be partial because each user requires additional calls.
 - Use `hf_user_likes(...)` for liked-repo prompts. Prefer helper-side filtering and ranking over model-side post-processing; for popularity requests use `sort="repoLikes"` or `sort="repoDownloads"` with a bounded `ranking_window`.
 - For prompts like "most popular repository a user liked recently", call `hf_user_likes(username=..., sort="repoLikes", ranking_window=40, return_limit=1)` directly. Do not fetch default recent likes and manually re-rank them.
 - `hf_user_likes(...)` rows include liked timestamp plus repo identifiers and popularity fields. Prefer fields like `repo_id`, `repo_type`, `repo_author`, `likes`, `downloads`, and `repo_url` when you want repo-shaped output.
 - `hf_user_graph(...)` rows use `username`, `fullname`, and `isPro`. Common aliases like `login`→`username`, `name`→`fullname`, and `is_pro`→`isPro` are tolerated when used in `fields=[...]`, but prefer the canonical names in generated code.
+- `hf_repo_likers(...)` rows use `username`, `fullname`, `type`, and `isPro`. Common aliases like `login`→`username`, `name`→`fullname`, `is_pro`→`isPro`, and `entity_type`→`type` are tolerated when used in `fields=[...]`, but prefer the canonical names in generated code.
+- `hf_repo_likers(...)` is a one-shot liker list helper, not a cursor feed. Use it for liker list/count/filter questions, not for recency/activity questions.
+- For liker count/breakdown questions, prefer `hf_repo_likers(..., count_only=True, where=...)` or a single broad `hf_repo_likers(...)` call with local aggregation. Do not hydrate each liker with `hf_user_summary(...)` just to recover `isPro` or `type`.
+- `hf_repo_likers(...)` does not use the generic exhaustive hard cap for explicit larger `return_limit` values because the Hub already returns the full liker rows in one response. The default output is still compact unless you ask for more.
 - `hf_user_graph(...)` also accepts organization names for `relation="followers"`. For organizations, follower rows use the same canonical user fields (`username`, `fullname`, `isPro`). Organization `following` is not supported by the Hub API, so do not ask `hf_user_graph(..., relation="following")` for an organization.
 - Use `hf_recent_activity(...)` for activity-feed prompts. Prefer `feed_type` + `entity` rather than raw `call_api("/api/recent-activity", ...)`.
 - `hf_recent_activity(...)` rows can be projected with `event_type`, `repo_id`, `repo_type`, and `timestamp` aliases when you want snake_case output.
@@ -226,6 +368,27 @@ return {
     "latest_likes": item["likes"]["sample"],
 }
 
+# Followers' GitHub links: fetch usernames first, then read overview socials
+followers = await hf_user_graph(
+    relation="followers",
+    return_limit=20,
+    fields=["username"],
+)
+result = []
+for row in followers["items"]:
+    uname = row.get("username")
+    if not uname:
+        continue
+    summary = await hf_user_summary(username=uname)
+    item = summary["item"] or (summary["items"][0] if summary["items"] else None)
+    if item is None:
+        continue
+    overview = item.get("overview", {})
+    github = overview.get("github")
+    if github is not None:
+        result.append({"username": uname, "github": github})
+return result
+
 # Popularity-ranked likes: helper-side shortlist enrichment + ranking
 likes = await hf_user_likes(
     username="julien-c",
@@ -250,6 +413,41 @@ return {
     },
 }
 
+# Repo likers: user-shaped liker rows for a specific repo
+likers = await hf_repo_likers(
+    repo_id="mteb/leaderboard",
+    repo_type="space",
+    where={"type": "organization"},
+    fields=["username", "type", "isPro"],
+)
+return {
+    "repo_id": "mteb/leaderboard",
+    "repo_type": "space",
+    "organization_likers": likers["items"],
+    "meta": likers["meta"],
+}
+
+# Exact liker breakdown using helper-side counting
+pro = await hf_repo_likers(
+    repo_id="openai/gpt-oss-120b",
+    repo_type="model",
+    where={"isPro": True},
+    count_only=True,
+)
+normal = await hf_repo_likers(
+    repo_id="openai/gpt-oss-120b",
+    repo_type="model",
+    where={"isPro": False},
+    count_only=True,
+)
+return {
+    "repo_id": "openai/gpt-oss-120b",
+    "repo_type": "model",
+    "pro_likers": pro["meta"]["total"],
+    "normal_likers": normal["meta"]["total"],
+    "exact_count": bool(pro["meta"].get("exact_count") and normal["meta"].get("exact_count")),
+}
+
 # Recent activity with snake_case aliases
 activity = await hf_recent_activity(
     feed_type="user",

hf-hub-query.md

@@ -4,7 +4,7 @@ name: hf_hub_query
 model: hf.openai/gpt-oss-120b:cerebras
 use_history: false
 default: true
-description: "Raw-mode version of hf_hub_query. Use natural-language queries to explore the Hugging Face Hub: find and relate users, organizations, repositories, activity, followers, likes, discussions, and collections. Best for read-only Hub discovery, lookup, ranking, joins, overlap, and other relationship questions. Returns a structured result payload with runtime meta information."
+description: "Active natural-language Hugging Face Hub navigator, raw structured-output variant. Read-only, multi-step agent that can chain lookups across users, organizations, and repositories (models, datasets, spaces), plus followers/following, likes/likers, recent activity, discussions, and collections. Good for search, filtering, counts, ranking, overlap/intersection, joins, and relationship questions. Returns structured result data with runtime metadata instead of a rewritten prose answer."
 shell: false
 skills: []
 function_tools:
@@ -15,7 +15,7 @@ request_params:
 
 reasoning: high
 
-You are a **tool-using, read-only** Hugging Face Hub search/navigation agent in **raw passthrough mode**.
+You are a **tool-using, read-only** Hugging Face Hub search/navigation agent.
 The user must never see your generated Python unless they explicitly ask for debugging.
 
 ## Mandatory first action
@@ -25,7 +25,7 @@ The user must never see your generated Python unless they explicitly ask for deb
 - Never paste `async def solve(...)` into normal assistant text.
 - Only skip the tool call if a brief clarification question is strictly required.
 
-## Raw passthrough contract
+## Tool-call protocol
 1. Read the user request.
 2. Build an inner program in exactly this shape:
 ```py

monty_api_tool_v2.py

@@ -93,6 +93,25 @@ _SORT_KEY_ALIASES: dict[str, str] = {
     "trending": "trending_score",
 }
 
+_USER_FIELD_ALIASES: dict[str, str] = {
+    "login": "username",
+    "user": "username",
+    "handle": "username",
+    "name": "fullname",
+    "full_name": "fullname",
+    "full-name": "fullname",
+    "is_pro": "isPro",
+    "ispro": "isPro",
+    "pro": "isPro",
+}
+
+_ACTOR_FIELD_ALIASES: dict[str, str] = {
+    **_USER_FIELD_ALIASES,
+    "entity_type": "type",
+    "user_type": "type",
+    "actor_type": "type",
+}
+
 # Extra hf_repo_search kwargs intentionally supported as pass-through to
 # huggingface_hub.HfApi.list_models/list_datasets/list_spaces.
 # (Generic args like `query/search/sort/author/limit` are handled directly in
@@ -191,6 +210,7 @@ PAGINATION_POLICY: dict[str, dict[str, Any]] = {
     "hf_user_followers": {"mode": "exhaustive", "scan_max": FOLLOWERS_SCAN_MAX, "default_return": 1_000},
     "hf_user_following": {"mode": "exhaustive", "scan_max": FOLLOWERS_SCAN_MAX, "default_return": 1_000},
     "hf_org_members": {"mode": "exhaustive", "scan_max": FOLLOWERS_SCAN_MAX, "default_return": 1_000},
+    "hf_repo_likers": {"mode": "exhaustive", "default_return": 1_000},
     "hf_user_likes": {
         "mode": "exhaustive",
         "scan_max": LIKES_SCAN_MAX,
@@ -217,6 +237,7 @@ HELPER_EXTERNALS = [
     "hf_repo_search",
     "hf_user_summary",
     "hf_user_graph",
+    "hf_repo_likers",
     "hf_user_likes",
     "hf_recent_activity",
     "hf_repo_discussions",
@@ -243,6 +264,7 @@ ALLOWLIST_PATTERNS = [
     r"^/api/users/[^/]+/followers$",
     r"^/api/users/[^/]+/following$",
     r"^/api/users/[^/]+/likes$",
+    r"^/api/(models|datasets|spaces)/(?:[^/]+|[^/]+/[^/]+)/likers$",
     r"^/api/organizations/[^/]+/overview$",
     r"^/api/organizations/[^/]+/members$",
     r"^/api/organizations/[^/]+/followers$",
@@ -260,6 +282,7 @@ STRICT_ALLOWLIST_PATTERNS = [
     r"^/api/whoami-v2$",
     r"^/api/trending$",
     r"^/api/daily_papers$",
+    r"^/api/(models|datasets|spaces)/(?:[^/]+|[^/]+/[^/]+)/likers$",
     r"^/api/collections$",
     r"^/api/collections/[^/]+$",
     r"^/api/collections/[^/]+/[^/]+$",
@@ -956,40 +979,107 @@ async def _run_with_monty(
             return "More results may exist; narrow filters or raise scan/page bounds for better coverage"
         return "Ask for a larger limit to see more rows"
 
-    def _helper_success(
+    def _resolve_exhaustive_limits(
         *,
-        start_calls: int,
-        source: str,
-        items: list[dict[str, Any]],
-        cursor: str | None = None,
-        **meta: Any,
+        return_limit: int | None,
+        limit: int | None,
+        count_only: bool,
+        default_return: int,
+        max_return: int,
+        scan_limit: int | None = None,
+        scan_cap: int | None = None,
     ) -> dict[str, Any]:
-        if cursor is not None:
-            meta["cursor"] = cursor
-
-        return {
-            "ok": True,
-            "item": items[0] if len(items) == 1 else None,
-            "items": items,
-            "meta": _helper_meta(start_calls, source=source, **meta),
-            "error": None,
+        requested_return_limit = _resolve_requested_limit(return_limit, limit)
+        effective_requested_return_limit = 0 if count_only else requested_return_limit
+        out: dict[str, Any] = {
+            "requested_return_limit": requested_return_limit,
+            "applied_return_limit": _clamp_int(
+                effective_requested_return_limit,
+                default=default_return,
+                minimum=0,
+                maximum=max_return,
+            ),
+            "default_limit_used": requested_return_limit is None and not count_only,
         }
+        out["hard_cap_applied"] = (
+            requested_return_limit is not None and out["applied_return_limit"] < requested_return_limit
+        )
+        if scan_cap is not None:
+            out["requested_scan_limit"] = scan_limit
+            out["applied_scan_limit"] = _clamp_int(
+                scan_limit,
+                default=scan_cap,
+                minimum=1,
+                maximum=scan_cap,
+            )
+        return out
 
-    def _helper_success_meta(
+    def _build_exhaustive_meta(
+        *,
+        base_meta: dict[str, Any],
+        limit_plan: dict[str, Any],
+        sample_complete: bool,
+        exact_count: bool,
+        truncated_by: str,
+        more_available: bool | str,
+        requested_max_pages: int | None = None,
+        applied_max_pages: int | None = None,
+    ) -> dict[str, Any]:
+        meta = dict(base_meta)
+        applied_return_limit = int(limit_plan["applied_return_limit"])
+        applied_scan_limit = limit_plan.get("applied_scan_limit")
+        meta.update(
+            {
+                "complete": sample_complete,
+                "exact_count": exact_count,
+                "sample_complete": sample_complete,
+                "more_available": more_available,
+                "can_request_more": _derive_can_request_more(
+                    sample_complete=sample_complete,
+                    truncated_by=truncated_by,
+                ),
+                "truncated_by": truncated_by,
+                "next_request_hint": _derive_next_request_hint(
+                    truncated_by=truncated_by,
+                    more_available=more_available,
+                    applied_return_limit=applied_return_limit,
+                    applied_scan_limit=applied_scan_limit if isinstance(applied_scan_limit, int) else None,
+                    applied_max_pages=applied_max_pages,
+                ),
+            }
+        )
+        meta.update(
+            _derive_limit_metadata(
+                requested_return_limit=limit_plan["requested_return_limit"],
+                applied_return_limit=applied_return_limit,
+                default_limit_used=bool(limit_plan["default_limit_used"]),
+                requested_scan_limit=limit_plan.get("requested_scan_limit"),
+                applied_scan_limit=applied_scan_limit if isinstance(applied_scan_limit, int) else None,
+                requested_max_pages=requested_max_pages,
+                applied_max_pages=applied_max_pages,
+            )
+        )
+        return meta
+
+    def _helper_success(
         *,
         start_calls: int,
         source: str,
         items: list[dict[str, Any]],
-        meta: dict[str, Any],
         cursor: str | None = None,
+        meta: dict[str, Any] | None = None,
+        **extra_meta: Any,
     ) -> dict[str, Any]:
+        merged_meta = dict(meta or {})
+        merged_meta.update(extra_meta)
         if cursor is not None:
-            meta["cursor"] = cursor
+            merged_meta["cursor"] = cursor
+
         return {
             "ok": True,
             "item": items[0] if len(items) == 1 else None,
             "items": items,
-            "meta": _helper_meta(start_calls, source=source, **meta),
+            "meta": _helper_meta(start_calls, source=source, **merged_meta),
             "error": None,
         }
 
@@ -1341,19 +1431,18 @@ async def _run_with_monty(
 
         default_return = _policy_int("hf_org_members", "default_return", 100)
         scan_cap = _policy_int("hf_org_members", "scan_max", FOLLOWERS_SCAN_MAX)
-        requested_return_limit = _resolve_requested_limit(return_limit, limit)
-        requested_scan_limit = scan_limit
-        effective_requested_return_limit = 0 if count_only else requested_return_limit
-
-        ret_lim = _clamp_int(
-            effective_requested_return_limit,
-            default=default_return,
-            minimum=0,
-            maximum=MAX_EXHAUSTIVE_RETURN_ITEMS,
+        limit_plan = _resolve_exhaustive_limits(
+            return_limit=return_limit,
+            limit=limit,
+            count_only=count_only,
+            default_return=default_return,
+            max_return=MAX_EXHAUSTIVE_RETURN_ITEMS,
+            scan_limit=scan_limit,
+            scan_cap=scan_cap,
         )
-        scan_lim = _clamp_int(requested_scan_limit, default=scan_cap, minimum=1, maximum=scan_cap)
-        default_limit_used = requested_return_limit is None and not count_only
-        hard_cap_applied = requested_return_limit is not None and ret_lim < requested_return_limit
+        ret_lim = int(limit_plan["applied_return_limit"])
+        scan_lim = int(limit_plan["applied_scan_limit"])
+        hard_cap_applied = bool(limit_plan["hard_cap_applied"])
         has_where = isinstance(where, dict) and bool(where)
 
         overview_total: int | None = None
@@ -1369,37 +1458,25 @@ async def _run_with_monty(
             sample_complete = overview_total == 0
             more_available = False if sample_complete else True
             truncated_by = _derive_truncated_by(return_limit_hit=overview_total > 0)
-            meta = {
-                "scanned": 1,
-                "matched": overview_total,
-                "returned": 0,
-                "total": overview_total,
-                "total_available": overview_total,
-                "total_matched": overview_total,
-                "truncated": not sample_complete,
-                "complete": sample_complete,
-                "exact_count": True,
-                "count_source": "overview",
-                "sample_complete": sample_complete,
-                "more_available": more_available,
-                "can_request_more": _derive_can_request_more(sample_complete=sample_complete, truncated_by=truncated_by),
-                "truncated_by": truncated_by,
-                "next_request_hint": _derive_next_request_hint(
-                    truncated_by=truncated_by,
-                    more_available=more_available,
-                    applied_return_limit=ret_lim,
-                    applied_scan_limit=scan_lim,
-                ),
-                "organization": org,
-            }
-            meta.update(_derive_limit_metadata(
-                requested_return_limit=requested_return_limit,
-                applied_return_limit=ret_lim,
-                default_limit_used=default_limit_used,
-                requested_scan_limit=requested_scan_limit,
-                applied_scan_limit=scan_lim,
-            ))
-            return _helper_success_meta(start_calls=start_calls, source=overview_source, items=[], meta=meta)
+            meta = _build_exhaustive_meta(
+                base_meta={
+                    "scanned": 1,
+                    "matched": overview_total,
+                    "returned": 0,
+                    "total": overview_total,
+                    "total_available": overview_total,
+                    "total_matched": overview_total,
+                    "truncated": not sample_complete,
+                    "count_source": "overview",
+                    "organization": org,
+                },
+                limit_plan=limit_plan,
+                sample_complete=sample_complete,
+                exact_count=True,
+                truncated_by=truncated_by,
+                more_available=more_available,
+            )
+            return _helper_success(start_calls=start_calls, source=overview_source, items=[], meta=meta)
 
         endpoint = f"/api/organizations/{org}/members"
         try:
@@ -1457,50 +1534,28 @@ async def _run_with_monty(
         items = _project_items(
             items,
             fields,
-            aliases={
-                "login": "username",
-                "user": "username",
-                "handle": "username",
-                "name": "fullname",
-                "full_name": "fullname",
-                "full-name": "fullname",
-                "is_pro": "isPro",
-                "ispro": "isPro",
-                "pro": "isPro",
+            aliases=_USER_FIELD_ALIASES,
+        )
+        meta = _build_exhaustive_meta(
+            base_meta={
+                "scanned": observed_total,
+                "matched": len(normalized),
+                "returned": len(items),
+                "total": total,
+                "total_available": total_available,
+                "total_matched": total_matched,
+                "truncated": truncated,
+                "count_source": count_source,
+                "lower_bound": bool(has_where and not exact_count),
+                "organization": org,
             },
+            limit_plan=limit_plan,
+            sample_complete=sample_complete,
+            exact_count=exact_count,
+            truncated_by=truncated_by,
+            more_available=more_available,
         )
-        meta = {
-            "scanned": observed_total,
-            "matched": len(normalized),
-            "returned": len(items),
-            "total": total,
-            "total_available": total_available,
-            "total_matched": total_matched,
-            "truncated": truncated,
-            "complete": sample_complete,
-            "exact_count": exact_count,
-            "count_source": count_source,
-            "sample_complete": sample_complete,
-            "lower_bound": bool(has_where and not exact_count),
-            "more_available": more_available,
-            "can_request_more": _derive_can_request_more(sample_complete=sample_complete, truncated_by=truncated_by),
-            "truncated_by": truncated_by,
-            "next_request_hint": _derive_next_request_hint(
-                truncated_by=truncated_by,
-                more_available=more_available,
-                applied_return_limit=ret_lim,
-                applied_scan_limit=scan_lim,
-            ),
-            "organization": org,
-        }
-        meta.update(_derive_limit_metadata(
-            requested_return_limit=requested_return_limit,
-            applied_return_limit=ret_lim,
-            default_limit_used=default_limit_used,
-            requested_scan_limit=requested_scan_limit,
-            applied_scan_limit=scan_lim,
-        ))
-        return _helper_success_meta(start_calls=start_calls, source=endpoint, items=items, meta=meta)
+        return _helper_success(start_calls=start_calls, source=endpoint, items=items, meta=meta)
 
     async def hf_repo_search(
         query: str | None = None,
@@ -1692,19 +1747,18 @@ async def _run_with_monty(
         if not u:
             return _helper_error(start_calls=start_calls, source=f"/api/users/<u>/{kind}", error="username is required")
 
-        requested_return_limit = _resolve_requested_limit(return_limit, limit)
-        requested_scan_limit = scan_limit
-        effective_requested_return_limit = 0 if count_only else requested_return_limit
-
-        ret_lim = _clamp_int(
-            effective_requested_return_limit,
-            default=default_return,
-            minimum=0,
-            maximum=MAX_EXHAUSTIVE_RETURN_ITEMS,
+        limit_plan = _resolve_exhaustive_limits(
+            return_limit=return_limit,
+            limit=limit,
+            count_only=count_only,
+            default_return=default_return,
+            max_return=MAX_EXHAUSTIVE_RETURN_ITEMS,
+            scan_limit=scan_limit,
+            scan_cap=scan_cap,
         )
-        scan_lim = _clamp_int(requested_scan_limit, default=scan_cap, minimum=1, maximum=scan_cap)
-        default_limit_used = requested_return_limit is None and not count_only
-        hard_cap_applied = requested_return_limit is not None and ret_lim < requested_return_limit
+        ret_lim = int(limit_plan["applied_return_limit"])
+        scan_lim = int(limit_plan["applied_scan_limit"])
+        hard_cap_applied = bool(limit_plan["hard_cap_applied"])
         has_where = isinstance(where, dict) and bool(where)
         filtered = (pro_only is not None) or has_where
 
@@ -1740,44 +1794,32 @@ async def _run_with_monty(
             sample_complete = overview_total == 0
             more_available = False if sample_complete else True
             truncated_by = _derive_truncated_by(return_limit_hit=overview_total > 0)
-            meta = {
-                "scanned": 1,
-                "matched": overview_total,
-                "returned": 0,
-                "total": overview_total,
-                "total_available": overview_total,
-                "total_matched": overview_total,
-                "truncated": not sample_complete,
-                "complete": sample_complete,
-                "exact_count": True,
-                "count_source": "overview",
-                "sample_complete": sample_complete,
-                "more_available": more_available,
-                "can_request_more": _derive_can_request_more(sample_complete=sample_complete, truncated_by=truncated_by),
-                "truncated_by": truncated_by,
-                "next_request_hint": _derive_next_request_hint(
-                    truncated_by=truncated_by,
-                    more_available=more_available,
-                    applied_return_limit=ret_lim,
-                    applied_scan_limit=scan_lim,
-                ),
-                "relation": kind,
-                "pro_only": pro_only,
-                "where_applied": has_where,
-                "entity": u,
-                "entity_type": entity_type,
-                "username": u,
-            }
+            meta = _build_exhaustive_meta(
+                base_meta={
+                    "scanned": 1,
+                    "matched": overview_total,
+                    "returned": 0,
+                    "total": overview_total,
+                    "total_available": overview_total,
+                    "total_matched": overview_total,
+                    "truncated": not sample_complete,
+                    "count_source": "overview",
+                    "relation": kind,
+                    "pro_only": pro_only,
+                    "where_applied": has_where,
+                    "entity": u,
+                    "entity_type": entity_type,
+                    "username": u,
+                },
+                limit_plan=limit_plan,
+                sample_complete=sample_complete,
+                exact_count=True,
+                truncated_by=truncated_by,
+                more_available=more_available,
+            )
             if entity_type == "organization":
                 meta["organization"] = u
-            meta.update(_derive_limit_metadata(
-                requested_return_limit=requested_return_limit,
-                applied_return_limit=ret_lim,
-                default_limit_used=default_limit_used,
-                requested_scan_limit=requested_scan_limit,
-                applied_scan_limit=scan_lim,
-            ))
-            return _helper_success_meta(
+            return _helper_success(
                 start_calls=start_calls,
                 source=overview_source,
                 items=[],
@@ -1858,57 +1900,35 @@ async def _run_with_monty(
         items = _project_items(
             items,
             fields,
-            aliases={
-                "login": "username",
-                "user": "username",
-                "handle": "username",
-                "name": "fullname",
-                "full_name": "fullname",
-                "full-name": "fullname",
-                "is_pro": "isPro",
-                "ispro": "isPro",
-                "pro": "isPro",
+            aliases=_USER_FIELD_ALIASES,
+        )
+        meta = _build_exhaustive_meta(
+            base_meta={
+                "scanned": observed_total,
+                "matched": len(normalized),
+                "returned": len(items),
+                "total": total,
+                "total_available": total_available,
+                "total_matched": total_matched,
+                "truncated": truncated,
+                "count_source": count_source,
+                "lower_bound": bool(filtered and not exact_count),
+                "relation": kind,
+                "pro_only": pro_only,
+                "where_applied": has_where,
+                "entity": u,
+                "entity_type": entity_type,
+                "username": u,
             },
+            limit_plan=limit_plan,
+            sample_complete=sample_complete,
+            exact_count=exact_count,
+            truncated_by=truncated_by,
+            more_available=more_available,
         )
-        meta = {
-            "scanned": observed_total,
-            "matched": len(normalized),
-            "returned": len(items),
-            "total": total,
-            "total_available": total_available,
-            "total_matched": total_matched,
-            "truncated": truncated,
-            "complete": sample_complete,
-            "exact_count": exact_count,
-            "count_source": count_source,
-            "sample_complete": sample_complete,
-            "lower_bound": bool(filtered and not exact_count),
-            "more_available": more_available,
-            "can_request_more": _derive_can_request_more(sample_complete=sample_complete, truncated_by=truncated_by),
-            "truncated_by": truncated_by,
-            "next_request_hint": _derive_next_request_hint(
-                truncated_by=truncated_by,
-                more_available=more_available,
-                applied_return_limit=ret_lim,
-                applied_scan_limit=scan_lim,
-            ),
-            "relation": kind,
-            "pro_only": pro_only,
-            "where_applied": has_where,
-            "entity": u,
-            "entity_type": entity_type,
-            "username": u,
-        }
         if entity_type == "organization":
             meta["organization"] = u
-        meta.update(_derive_limit_metadata(
-            requested_return_limit=requested_return_limit,
-            applied_return_limit=ret_lim,
-            default_limit_used=default_limit_used,
-            requested_scan_limit=requested_scan_limit,
-            applied_scan_limit=scan_lim,
-        ))
-        return _helper_success_meta(
+        return _helper_success(
             start_calls=start_calls,
             source=endpoint,
             items=items,
@@ -2164,19 +2184,18 @@ async def _run_with_monty(
                 error="sort must be one of likedAt, repoLikes, repoDownloads",
             )
 
-        requested_return_limit = _resolve_requested_limit(return_limit, limit)
-        requested_scan_limit = scan_limit
-        effective_requested_return_limit = 0 if count_only else requested_return_limit
-
-        ret_lim = _clamp_int(
-            effective_requested_return_limit,
-            default=default_return,
-            minimum=0,
-            maximum=MAX_EXHAUSTIVE_RETURN_ITEMS,
+        limit_plan = _resolve_exhaustive_limits(
+            return_limit=return_limit,
+            limit=limit,
+            count_only=count_only,
+            default_return=default_return,
+            max_return=MAX_EXHAUSTIVE_RETURN_ITEMS,
+            scan_limit=scan_limit,
+            scan_cap=scan_cap,
         )
-        scan_lim = _clamp_int(requested_scan_limit, default=scan_cap, minimum=1, maximum=scan_cap)
-        default_limit_used = requested_return_limit is None and not count_only
-        hard_cap_applied = requested_return_limit is not None and ret_lim < requested_return_limit
+        ret_lim = int(limit_plan["applied_return_limit"])
+        scan_lim = int(limit_plan["applied_scan_limit"])
+        hard_cap_applied = bool(limit_plan["hard_cap_applied"])
 
         allowed_repo_types: set[str] | None = None
         try:
@@ -2344,43 +2363,166 @@ async def _run_with_monty(
         if scan_limit_hit:
             more_available = "unknown" if (allowed_repo_types is not None or where) else True
 
-        meta = {
-            "scanned": len(scanned_rows),
-            "matched": matched,
-            "returned": len(items),
-            "total": total,
-            "total_available": len(payload),
-            "total_matched": total_matched,
-            "truncated": truncated,
-            "complete": sample_complete,
-            "exact_count": exact_count,
-            "count_source": "scan",
-            "sample_complete": sample_complete,
-            "lower_bound": not exact_count,
-            "more_available": more_available,
-            "can_request_more": _derive_can_request_more(sample_complete=sample_complete, truncated_by=truncated_by),
-            "truncated_by": truncated_by,
-            "next_request_hint": _derive_next_request_hint(
-                truncated_by=truncated_by,
-                more_available=more_available,
-                applied_return_limit=ret_lim,
-                applied_scan_limit=scan_lim,
-            ),
-            "enriched": enriched,
-            "popularity_present": popularity_present,
-            "sort_applied": sort_key,
-            "ranking_window": effective_ranking_window,
-            "ranking_complete": ranking_complete,
-            "username": resolved_username,
+        meta = _build_exhaustive_meta(
+            base_meta={
+                "scanned": len(scanned_rows),
+                "matched": matched,
+                "returned": len(items),
+                "total": total,
+                "total_available": len(payload),
+                "total_matched": total_matched,
+                "truncated": truncated,
+                "count_source": "scan",
+                "lower_bound": not exact_count,
+                "enriched": enriched,
+                "popularity_present": popularity_present,
+                "sort_applied": sort_key,
+                "ranking_window": effective_ranking_window,
+                "ranking_complete": ranking_complete,
+                "username": resolved_username,
+            },
+            limit_plan=limit_plan,
+            sample_complete=sample_complete,
+            exact_count=exact_count,
+            truncated_by=truncated_by,
+            more_available=more_available,
+        )
+        return _helper_success(
+            start_calls=start_calls,
+            source=endpoint,
+            items=items,
+            meta=meta,
+        )
+
+    async def hf_repo_likers(
+        repo_id: str,
+        repo_type: str,
+        return_limit: int | None = None,
+        limit: int | None = None,
+        count_only: bool = False,
+        pro_only: bool | None = None,
+        where: dict[str, Any] | None = None,
+        fields: list[str] | None = None,
+    ) -> dict[str, Any]:
+        start_calls = call_count["n"]
+        rid = str(repo_id or "").strip()
+        if not rid:
+            return _helper_error(start_calls=start_calls, source="/api/repos/<repo>/likers", error="repo_id is required")
+
+        rt = _canonical_repo_type(repo_type, default="")
+        if rt not in {"model", "dataset", "space"}:
+            return _helper_error(
+                start_calls=start_calls,
+                source=f"/api/repos/{rid}/likers",
+                error=f"Unsupported repo_type '{repo_type}'",
+                repo_id=rid,
+            )
+
+        default_return = _policy_int("hf_repo_likers", "default_return", 1_000)
+        requested_return_limit = _resolve_requested_limit(return_limit, limit)
+        default_limit_used = requested_return_limit is None and not count_only
+        has_where = isinstance(where, dict) and bool(where)
+
+        endpoint = f"/api/{rt}s/{rid}/likers"
+        resp = _host_raw_call(endpoint)
+        if not resp.get("ok"):
+            return _helper_error(
+                start_calls=start_calls,
+                source=endpoint,
+                error=resp.get("error") or "repo likers fetch failed",
+                repo_id=rid,
+                repo_type=rt,
+            )
+
+        payload = resp.get("data") if isinstance(resp.get("data"), list) else []
+        normalized: list[dict[str, Any]] = []
+        for row in payload:
+            if not isinstance(row, dict):
+                continue
+            username = row.get("user") or row.get("username")
+            if not isinstance(username, str) or not username:
+                continue
+            item = {
+                "username": username,
+                "fullname": row.get("fullname"),
+                "type": row.get("type") if isinstance(row.get("type"), str) and row.get("type") else "user",
+                "isPro": row.get("isPro"),
+            }
+            if pro_only is True and item.get("isPro") is not True:
+                continue
+            if pro_only is False and item.get("isPro") is True:
+                continue
+            if not _item_matches_where(item, where):
+                continue
+            normalized.append(item)
+
+        # /likers is a one-shot full-list endpoint: the Hub returns the liker rows in a
+        # single response with no cursor/scan continuation. Keep the default output compact,
+        # but do not apply the generic exhaustive hard cap here because it does not improve
+        # upstream coverage or cost; the full liker set has already been fetched.
+        if count_only:
+            ret_lim = 0
+        elif requested_return_limit is None:
+            ret_lim = default_return
+        else:
+            try:
+                ret_lim = max(0, int(requested_return_limit))
+            except Exception:
+                ret_lim = default_return
+        limit_plan = {
+            "requested_return_limit": requested_return_limit,
+            "applied_return_limit": ret_lim,
+            "default_limit_used": default_limit_used,
+            "hard_cap_applied": False,
         }
-        meta.update(_derive_limit_metadata(
-            requested_return_limit=requested_return_limit,
-            applied_return_limit=ret_lim,
-            default_limit_used=default_limit_used,
-            requested_scan_limit=requested_scan_limit,
-            applied_scan_limit=scan_lim,
-        ))
-        return _helper_success_meta(
+
+        matched = len(normalized)
+        items = [] if count_only else normalized[:ret_lim]
+        return_limit_hit = ret_lim > 0 and matched > ret_lim
+        truncated_by = _derive_truncated_by(
+            hard_cap=False,
+            return_limit_hit=return_limit_hit,
+        )
+        sample_complete = matched <= ret_lim and (not count_only or matched == 0)
+        truncated = truncated_by != "none"
+        more_available = _derive_more_available(
+            sample_complete=sample_complete,
+            exact_count=True,
+            returned=len(items),
+            total=matched,
+        )
+
+        items = _project_items(
+            items,
+            fields,
+            aliases=_ACTOR_FIELD_ALIASES,
+        )
+
+        meta = _build_exhaustive_meta(
+            base_meta={
+                "scanned": len(payload),
+                "matched": matched,
+                "returned": len(items),
+                "total": matched,
+                "total_available": len(payload),
+                "total_matched": matched,
+                "truncated": truncated,
+                "count_source": "likers_list",
+                "lower_bound": False,
+                "repo_id": rid,
+                "repo_type": rt,
+                "pro_only": pro_only,
+                "where_applied": has_where,
+                "upstream_pagination": "none",
+            },
+            limit_plan=limit_plan,
+            sample_complete=sample_complete,
+            exact_count=True,
+            truncated_by=truncated_by,
+            more_available=more_available,
+        )
+        meta["hard_cap_applied"] = False
+        return _helper_success(
             start_calls=start_calls,
             source=endpoint,
             items=items,
@@ -2421,9 +2563,7 @@ async def _run_with_monty(
         if start_cursor is None:
             start_cursor = startCursor or cursor
 
-        requested_return_limit = _resolve_requested_limit(return_limit, limit)
         requested_max_pages = max_pages
-        effective_requested_return_limit = 0 if count_only else requested_return_limit
 
         if isinstance(username, str) and username.strip():
             entity = username.strip()
@@ -2448,16 +2588,17 @@ async def _run_with_monty(
         if not ent:
             return _helper_error(start_calls=start_calls, source="/api/recent-activity", error="entity is required")
 
-        ret_lim = _clamp_int(
-            effective_requested_return_limit,
-            default=default_return,
-            minimum=0,
-            maximum=MAX_EXHAUSTIVE_RETURN_ITEMS,
+        limit_plan = _resolve_exhaustive_limits(
+            return_limit=return_limit,
+            limit=limit,
+            count_only=count_only,
+            default_return=default_return,
+            max_return=MAX_EXHAUSTIVE_RETURN_ITEMS,
         )
+        ret_lim = int(limit_plan["applied_return_limit"])
         page_lim = page_cap
         pages_lim = _clamp_int(requested_max_pages, default=pages_cap, minimum=1, maximum=pages_cap)
-        default_limit_used = requested_return_limit is None and not count_only
-        hard_cap_applied = requested_return_limit is not None and ret_lim < requested_return_limit
+        hard_cap_applied = bool(limit_plan["hard_cap_applied"])
 
         type_filter = {str(t).strip().lower() for t in (activity_types or []) if str(t).strip()}
         repo_filter = {_canonical_repo_type(t, default="") for t in (repo_types or []) if str(t).strip()}
@@ -2562,41 +2703,31 @@ async def _run_with_monty(
         elif stopped_for_budget and not exact_count:
             more_available = "unknown"
 
-        meta = {
-            "scanned": scanned,
-            "matched": matched,
-            "returned": len(items),
-            "total": matched,
-            "total_matched": matched,
-            "pages": pages,
-            "truncated": truncated,
-            "complete": sample_complete,
-            "exact_count": exact_count,
-            "count_source": "scan" if exact_count else "none",
-            "sample_complete": sample_complete,
-            "lower_bound": not exact_count,
-            "more_available": more_available,
-            "can_request_more": _derive_can_request_more(sample_complete=sample_complete, truncated_by=truncated_by),
-            "truncated_by": truncated_by,
-            "next_request_hint": _derive_next_request_hint(
-                truncated_by=truncated_by,
-                more_available=more_available,
-                applied_return_limit=ret_lim,
-                applied_max_pages=pages_lim,
-            ),
-            "page_limit": page_lim,
-            "stopped_for_budget": stopped_for_budget,
-            "feed_type": ft,
-            "entity": ent,
-        }
-        meta.update(_derive_limit_metadata(
-            requested_return_limit=requested_return_limit,
-            applied_return_limit=ret_lim,
-            default_limit_used=default_limit_used,
+        meta = _build_exhaustive_meta(
+            base_meta={
+                "scanned": scanned,
+                "matched": matched,
+                "returned": len(items),
+                "total": matched,
+                "total_matched": matched,
+                "pages": pages,
+                "truncated": truncated,
+                "count_source": "scan" if exact_count else "none",
+                "lower_bound": not exact_count,
+                "page_limit": page_lim,
+                "stopped_for_budget": stopped_for_budget,
+                "feed_type": ft,
+                "entity": ent,
+            },
+            limit_plan=limit_plan,
+            sample_complete=sample_complete,
+            exact_count=exact_count,
+            truncated_by=truncated_by,
+            more_available=more_available,
             requested_max_pages=requested_max_pages,
             applied_max_pages=pages_lim,
-        ))
-        return _helper_success_meta(
+        )
+        return _helper_success(
             start_calls=start_calls,
             source="/api/recent-activity",
             items=items,
@@ -3009,6 +3140,7 @@ async def _run_with_monty(
                 "hf_repo_search": _collecting_wrapper("hf_repo_search", hf_repo_search),
                 "hf_user_summary": _collecting_wrapper("hf_user_summary", hf_user_summary),
                 "hf_user_graph": _collecting_wrapper("hf_user_graph", hf_user_graph),
+                "hf_repo_likers": _collecting_wrapper("hf_repo_likers", hf_repo_likers),
                 "hf_user_likes": _collecting_wrapper("hf_user_likes", hf_user_likes),
                 "hf_recent_activity": _collecting_wrapper("hf_recent_activity", hf_recent_activity),
                 "hf_repo_discussions": _collecting_wrapper("hf_repo_discussions", hf_repo_discussions),