Deploy gen-ui with pydantic-monty 0.0.17

.prefab/tool-cards/monty_api_tool_v2.py

@@ -18,13 +18,13 @@ HELPER_EXTERNALS = _MODULE.HELPER_EXTERNALS
 main = _MODULE.main
 
 
-async def hf_hub_query(
+def hf_hub_query(
     query: str,
     code: str,
     max_calls: int | None = None,
     timeout_sec: int | None = None,
 ) -> dict[str, Any]:
-    return await _MODULE.hf_hub_query(
+    return _MODULE.hf_hub_query(
         query=query,
         code=code,
         max_calls=max_calls,
@@ -32,13 +32,13 @@ async def hf_hub_query(
     )
 
 
-async def hf_hub_query_raw(
+def hf_hub_query_raw(
     query: str,
     code: str,
     max_calls: int | None = None,
     timeout_sec: int | None = None,
 ) -> Any:
-    return await _MODULE.hf_hub_query_raw(
+    return _MODULE.hf_hub_query_raw(
         query=query,
         code=code,
         max_calls=max_calls,

.prod/agent-cards/shared/_monty_codegen_shared.md

@@ -3,24 +3,31 @@
 - You are writing Python to be executed in a secure runtime environment.
 - **NEVER** use `import` - it is NOT available in this environment.
 - All helper calls are async: always use `await`.
-- Use this exact outer shape:
+- Write a top-level Monty Python script. Use a shape like:
 
 ```py
-async def solve(query, max_calls):
-    ...
-
-await solve(query, max_calls)
+resp = await hf_models_search(limit=min(max_calls, 10))
+result = resp["items"]
+result
 ```
 
+- `max_calls` is a runtime-provided top-level input.
 - `max_calls` is the total external-call budget for the whole program.
+- Always assign the final output to `result`.
+- End the script with a final line containing only `result`.
+- Never stop after `result = ...`; always add a final bare `result` line.
+- Do **not** define or call `solve(...)`.
 - Use only documented `hf_*` helpers.
-- Return plain Python data only: `dict`, `list`, `str`, `int`, `float`, `bool`, or `None`.
-- Do **not** hand-build JSON strings or markdown strings inside `solve(...)` unless the user explicitly asked for prose.
-- Do **not** build your own transport wrapper like `{result: ..., meta: ...}`.
-- If the user says "return only" some fields, return exactly that final shape.
-- If a helper already returns the requested row shape, return `resp["items"]` directly **only when helper coverage is clearly complete**. If helper `meta` suggests partial/unknown coverage, return `{"results": resp["items"], "coverage": resp["meta"]}` instead of bare items.
+- `result` must be plain Python data only: `dict`, `list`, `str`, `int`, `float`, `bool`, or `None`.
+- Do **not** hand-build JSON strings, markdown strings, or your own transport wrapper like `{result: ..., meta: ...}` unless the user explicitly asked for prose.
+- If the user says "return only" some fields, make `result` exactly that shape.
+- If a helper already returns the requested row shape, use `resp["items"]` directly **only when helper coverage is clearly complete**. If helper `meta` suggests partial/unknown coverage, set `result = {"results": resp["items"], "coverage": resp["meta"]}` instead of bare items.
 - For current-user prompts (`my`, `me`), try helpers with `username=None` / `handle=None` first.
-- If a current-user helper returns `ok=false`, return that helper response directly.
+- For current-user follower/following aggregation prompts, prefer `hf_user_graph(relation=..., ...)` directly instead of `hf_whoami()` plus a second graph call. This saves a call and avoids unnecessary branching.
+- If a current-user helper returns `ok=false`, assign that helper response to `result`.
+- For relationship / aggregation questions (followers, members, likes, likers, intersections), preserve attribution in `result` unless the user explicitly asked for a collapsed deduped list.
+- Do **not** choose tiny hard-coded limits like `5` for follower/member/likes aggregation unless the user explicitly asked for a tiny sample. Prefer larger limits and preserve coverage when partial.
+- If you branch on an error path, you must still end the module with a final top-level bare `result` line outside every `if` / loop.
 
 ## Search rules
 
@@ -41,35 +48,46 @@ await solve(query, max_calls)
 - `hf_user_likes(...)` already returns full normalized like rows by default; omit `fields` unless the user asked for a subset.
 - When sorting `hf_user_likes(...)` by `repo_likes` or `repo_downloads`, set `ranking_window=50` unless the user explicitly asked for a narrower recent window.
 - For human-facing follower/member/liker lists without an explicit requested count, prefer `limit=100` and return coverage when more may exist.
+- For follower/following/member/liker queries that require local filtering on actor fields such as `username` or `fullname`, prefer a bounded scan like `limit=100` / `scan_limit=100` by default, or at most about `200` when a slightly broader sample is justified. Do **not** jump to `1000` unless the user explicitly asked for exhaustive coverage or a very large sample.
 - Unknown `fields` / `where` keys now fail fast. Use only canonical field names.
-
-- Ownership phrasing like "what collections does Qwen have", "collections by Qwen", or "collections owned by Qwen" means an owner lookup, so use `hf_collections_search(owner="Qwen")`, not a keyword-only `query="Qwen"` search.
+- Ownership phrasing like "what collections does Qwen have", "collections by Qwen", or "collections owned by Qwen" means an owner lookup, so use `hf_collections_search(owner="Qwen")`, not a keyword-only `query="Qwen"` search; it filters owners case-insensitively.
 - Ownership phrasing like "what spaces does X have", "what models does X have", or "what datasets does X have" means an author/owner inventory lookup, so use `hf_spaces_search(author="X")`, `hf_models_search(author="X")`, or `hf_datasets_search(author="X")` rather than a global keyword-only search.
-- Owner/user/org handles may arrive with different casing in the user message; when a handle spelling is uncertain, prefer owner-oriented logic and, if needed, add fallback inside `solve(...)` that broadens to `query=...` and filters owners case-insensitively.
+- For profile/detail/social questions about a user or org — bio, description, display name, website, GitHub, Twitter/X, LinkedIn, Bluesky, organizations, or pro status — use `hf_profile_summary(...)` first.
+- For join-style questions that need profile details for followers, following, members, likers, or other actor lists, first fetch a **bounded** actor list, filter locally on actor fields like `username` / `fullname`, then hydrate only the bounded matches with `hf_profile_summary(...)`.
+- Do **not** set the initial actor-list limit equal to the whole remaining call budget when each match needs a follow-up profile lookup; reserve budget for the profile-detail calls and return coverage if the hydration step is partial.
 - For exact aggregate counts like "how many models/datasets/spaces does X have", prefer `hf_profile_summary(...)['item']` counts. Those overview-owned counts may differ slightly from visible public search/list results, so if the user also asked for the list, preserve that distinction.
 - For owner inventory queries without an explicit requested count, use `hf_profile_summary(...)` first when a specific owner is known. If the count is modest, use it to size the follow-up list call; otherwise return a bounded list plus coverage instead of pretending completeness.
 - Think like `huggingface_hub`: `search`, `filter`, `author`, repo-type-specific upstream params, then `fields`.
 - Push constraints upstream whenever a first-class helper argument exists.
 - `post_filter` is only for normalized row filters that cannot be pushed upstream.
+- `num_params` is a first-class upstream model-search arg; use `num_params="min:6B,max:128B"` instead of `post_filter` when possible.
+- For created/updated date constraints, pair local `post_filter` with the matching sort (`created_at` or `last_modified`). Do **not** rely on date-only `post_filter` over an unsorted repo search window.
 - Keep `post_filter` simple:
   - exact match or `in` for returned fields like `runtime_stage`
-  - `gte` / `lte` for normalized numeric fields like `num_params`, `downloads`, and `likes`
-- `num_params` is one of the main valid reasons to use `post_filter` on model search today.
-- Do **not** use `post_filter` for things that already have first-class upstream params like `author`, `pipeline_tag`, `dataset_name`, `language`, `models`, or `datasets`.
+  - `gte` / `lte` for normalized numeric fields like `downloads` and `likes`
+  - `gte` / `lte` also work for normalized ISO timestamp fields like `created_at` and `last_modified`
+- Do **not** use `post_filter` for things that already have first-class upstream params like `author`, `pipeline_tag`, `num_params` on model search, `dataset_name`, `language`, `models`, or `datasets`.
 
 Examples:
 
 ```py
-await hf_models_search(pipeline_tag="text-to-image", limit=10)
-await hf_datasets_search(search="speech", sort="downloads", limit=10)
-await hf_spaces_search(post_filter={"runtime_stage": {"in": ["BUILD_ERROR", "RUNTIME_ERROR"]}})
-await hf_models_search(
+result = await hf_models_search(pipeline_tag="text-to-image", limit=10)
+result
+```
+
+```py
+result = await hf_models_search(
     pipeline_tag="text-generation",
+    num_params="min:20B,max:80B",
     sort="trending_score",
     limit=50,
-    post_filter={"num_params": {"gte": 20_000_000_000, "lte": 80_000_000_000}},
 )
-await hf_collections_search(owner="Qwen", limit=10)
+result
+```
+
+```py
+result = await hf_collections_search(owner="Qwen", limit=10)
+result
 ```
 
 Field-only pattern:
@@ -80,7 +98,8 @@ resp = await hf_models_search(
     fields=["repo_id", "author", "likes", "downloads", "repo_url"],
     limit=3,
 )
-return resp["items"]
+result = resp["items"]
+result
 ```
 
 Coverage pattern:
@@ -93,7 +112,8 @@ resp = await hf_user_likes(
     limit=20,
     fields=["repo_id", "repo_likes", "repo_url"],
 )
-return {"results": resp["items"], "coverage": resp["meta"]}
+result = {"results": resp["items"], "coverage": resp["meta"]}
+result
 ```
 
 Owner-inventory pattern:
@@ -109,31 +129,133 @@ resp = await hf_spaces_search(
 )
 meta = resp.get("meta") or {}
 if meta.get("limit_boundary_hit") or meta.get("more_available") not in {False, None}:
-    return {"results": resp["items"], "coverage": {**meta, "profile_spaces_count": count}}
-return resp["items"]
+    result = {"results": resp["items"], "coverage": {**meta, "profile_spaces_count": count}}
+else:
+    result = resp["items"]
+result
+```
+
+Follower-profile join pattern:
+
+```py
+followers_resp = await hf_user_graph(
+    relation="followers",
+    limit=100,
+    scan_limit=100,
+    fields=["username", "fullname"],
+)
+followers = followers_resp.get("items") or []
+matches = []
+for follower in followers:
+    username = follower.get("username")
+    fullname = follower.get("fullname")
+    starts_with_b = (
+        (isinstance(username, str) and username.lower().startswith("b"))
+        or (isinstance(fullname, str) and fullname.lower().startswith("b"))
+    )
+    if starts_with_b:
+        matches.append(follower)
+remaining_profile_calls = max(0, max_calls - 1)
+results = []
+for follower in matches[:remaining_profile_calls]:
+    username = follower.get("username")
+    if not username:
+        continue
+    profile = await hf_profile_summary(handle=username)
+    item = profile.get("item") or {}
+    results.append(
+        {
+            "username": username,
+            "fullname": follower.get("fullname"),
+            "github_url": item.get("github_url"),
+        }
+    )
+result = {
+    "results": results,
+    "coverage": {
+        "followers": followers_resp.get("meta") or {},
+        "matching_followers_seen": len(matches),
+        "profile_calls_used": len(results),
+        "profile_hydration_partial": len(matches) > len(results),
+    },
+}
+result
 ```
 
-Profile-count pattern:
+Follower-likes aggregation pattern:
 
 ```py
-profile = await hf_profile_summary(handle="mishig")
-item = profile["item"] or {}
-return {
-    "followers_count": item.get("followers_count"),
-    "following_count": item.get("following_count"),
+followers_resp = await hf_user_graph(relation="followers", limit=100, fields=["username"])
+followers = followers_resp.get("items") or []
+results = []
+for follower in followers:
+    username = follower.get("username")
+    if not username:
+        continue
+    likes_resp = await hf_user_likes(
+        username=username,
+        repo_types=["model"],
+        limit=20,
+        fields=["repo_id", "liked_at"],
+    )
+    results.append(
+        {
+            "follower": username,
+            "liked_models": likes_resp.get("items") or [],
+        }
+    )
+coverage = {
+    "followers": followers_resp.get("meta") or {},
 }
+result = {"results": results, "coverage": coverage}
+result
 ```
 
-Pro-followers pattern:
+Current-user pro-follower model-likes pattern:
 
 ```py
-followers = await hf_user_graph(
+followers_resp = await hf_user_graph(
     relation="followers",
     pro_only=True,
-    limit=20,
+    limit=100,
     fields=["username"],
 )
-return followers["items"]
+followers = followers_resp.get("items") or []
+remaining_calls = max(0, max_calls - 1)
+results = {}
+partial = (
+    (followers_resp.get("meta") or {}).get("limit_boundary_hit")
+    or (followers_resp.get("meta") or {}).get("more_available") not in {False, None}
+)
+processed_followers = 0
+for follower in followers:
+    if remaining_calls <= 0:
+        partial = True
+        break
+    username = follower.get("username")
+    if not username:
+        continue
+    likes_resp = await hf_user_likes(
+        username=username,
+        repo_types=["model"],
+        limit=2,
+        fields=["repo_id", "repo_author", "liked_at"],
+    )
+    remaining_calls -= 1
+    likes_meta = likes_resp.get("meta") or {}
+    if likes_meta.get("limit_boundary_hit") or likes_meta.get("more_available") not in {False, None}:
+        partial = True
+    items = likes_resp.get("items") or []
+    if items:
+        results[username] = items
+    processed_followers += 1
+coverage = {
+    "followers": followers_resp.get("meta") or {},
+    "processed_followers": processed_followers,
+    "partial": partial,
+}
+result = {"results": results, "coverage": coverage}
+result
 ```
 
 ## Navigation graph
@@ -150,7 +272,7 @@ Use the helper that matches the question type.
 - repo discussions → `hf_repo_discussions(...)`
 - specific discussion details → `hf_repo_discussion_details(...)`
 - users who liked one repo → `hf_repo_likers(...)`
-- profile / overview / aggregate counts → `hf_profile_summary(...)`
+- profile / overview / social/detail / aggregate counts → `hf_profile_summary(...)`
 - followers / following lists → `hf_user_graph(...)`
 - repos a user liked → `hf_user_likes(...)`
 - recent activity feed → `hf_recent_activity(...)`
@@ -182,16 +304,12 @@ Rules:
 - `items` is the canonical list field.
 - `item` is just a singleton convenience.
 - `meta` contains helper-owned execution, limit, and coverage info.
-- When helper-owned coverage matters, prefer returning the helper envelope directly.
 
 ## High-signal output rules
 
 - Prefer compact dict/list outputs over prose when the user asked for fields.
-- Prefer summary helpers before detail hydration.
 - Use canonical snake_case keys in generated code and structured output.
 - Use `repo_id` as the display label for repos.
-- Use `hf_profile_summary(...)['item']` for aggregate counts such as followers, following, models, datasets, and spaces.
-- For selective one-shot search helpers, treat `meta.limit_boundary_hit=true` as a partial/unknown-coverage warning even if `meta.truncated` is still `false`.
 - For joins/intersections/rankings, fetch the needed working set first and compute locally.
 - If the result is partial, use top-level keys `results` and `coverage`.
 
@@ -207,9 +325,9 @@ await hf_collections_search(query: 'str | None' = None, owner: 'str | None' = No
 
 await hf_daily_papers(limit: 'int' = 20, where: 'dict[str, Any] | None' = None, fields: 'list[str] | None' = None) -> 'dict[str, Any]'
 
-await hf_datasets_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, benchmark: 'str | bool | None' = None, dataset_name: 'str | None' = None, gated: 'bool | None' = None, language_creators: 'str | list[str] | None' = None, language: 'str | list[str] | None' = None, multilinguality: 'str | list[str] | None' = None, size_categories: 'str | list[str] | None' = None, task_categories: 'str | list[str] | None' = None, task_ids: 'str | list[str] | None' = None, sort: 'str | None' = None, limit: 'int' = 20, expand: 'list[str] | None' = None, full: 'bool | None' = None, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
+await hf_datasets_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, benchmark: 'str | bool | None' = None, dataset_name: 'str | None' = None, gated: 'bool | None' = None, language_creators: 'str | list[str] | None' = None, language: 'str | list[str] | None' = None, multilinguality: 'str | list[str] | None' = None, size_categories: 'str | list[str] | None' = None, task_categories: 'str | list[str] | None' = None, task_ids: 'str | list[str] | None' = None, sort: 'str | None' = None, limit: 'int' = 100, expand: 'list[str] | None' = None, full: 'bool | None' = None, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
 
-await hf_models_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, apps: 'str | list[str] | None' = None, gated: 'bool | None' = None, inference: 'str | None' = None, inference_provider: 'str | list[str] | None' = None, model_name: 'str | None' = None, trained_dataset: 'str | list[str] | None' = None, pipeline_tag: 'str | None' = None, emissions_thresholds: 'tuple[float, float] | None' = None, sort: 'str | None' = None, limit: 'int' = 20, expand: 'list[str] | None' = None, full: 'bool | None' = None, card_data: 'bool' = False, fetch_config: 'bool' = False, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
+await hf_models_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, apps: 'str | list[str] | None' = None, gated: 'bool | None' = None, inference: 'str | None' = None, inference_provider: 'str | list[str] | None' = None, model_name: 'str | None' = None, trained_dataset: 'str | list[str] | None' = None, pipeline_tag: 'str | None' = None, num_params: 'str | None' = None, emissions_thresholds: 'tuple[float, float] | None' = None, sort: 'str | None' = None, limit: 'int' = 100, expand: 'list[str] | None' = None, full: 'bool | None' = None, card_data: 'bool' = False, fetch_config: 'bool' = False, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
 
 await hf_org_members(organization: 'str', limit: 'int | None' = None, scan_limit: 'int | None' = None, count_only: 'bool' = False, where: 'dict[str, Any] | None' = None, fields: 'list[str] | None' = None) -> 'dict[str, Any]'
 
@@ -225,11 +343,11 @@ await hf_repo_discussions(repo_type: 'str', repo_id: 'str', limit: 'int' = 20, f
 
 await hf_repo_likers(repo_id: 'str', repo_type: 'str', 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]'
 
-await hf_repo_search(search: 'str | None' = None, repo_type: 'str | None' = None, repo_types: 'list[str] | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, sort: 'str | None' = None, limit: 'int' = 20, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
+await hf_repo_search(search: 'str | None' = None, repo_type: 'str | None' = None, repo_types: 'list[str] | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, sort: 'str | None' = None, limit: 'int' = 100, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
 
 await hf_runtime_capabilities(section: 'str | None' = None) -> 'dict[str, Any]'
 
-await hf_spaces_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, datasets: 'str | list[str] | None' = None, models: 'str | list[str] | None' = None, linked: 'bool' = False, sort: 'str | None' = None, limit: 'int' = 20, expand: 'list[str] | None' = None, full: 'bool | None' = None, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
+await hf_spaces_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, datasets: 'str | list[str] | None' = None, models: 'str | list[str] | None' = None, linked: 'bool' = False, sort: 'str | None' = None, limit: 'int' = 100, expand: 'list[str] | None' = None, full: 'bool | None' = None, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
 
 await hf_trending(repo_type: 'str' = 'model', limit: 'int' = 20, where: 'dict[str, Any] | None' = None, fields: 'list[str] | None' = None) -> 'dict[str, Any]'
 
@@ -336,7 +454,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - supported_ops: `eq`, `in`, `contains`, `icontains`, `gte`, `lte`
   - normalized_only: `true`
 - limit_contract:
-  - default_limit: `20`
+  - default_limit: `100`
   - max_limit: `5000`
 - notes: Thin dataset-search wrapper around the Hub list_datasets path. Prefer this over hf_repo_search for dataset-only queries. This is a one-shot selective search; if meta.limit_boundary_hit is true, more rows may exist and counts are not exact.
 
@@ -350,7 +468,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - default_fields: `repo_id`, `repo_type`, `author`, `likes`, `downloads`, `trending_score`, `created_at`, `last_modified`, `pipeline_tag`, `num_params`, `repo_url`, `tags`, `library_name`, `description`, `paperswithcode_id`, `sdk`, `models`, `datasets`, `subdomain`, `runtime_stage`, `runtime`
   - guaranteed_fields: `repo_id`, `repo_type`, `author`, `repo_url`
   - optional_fields: `likes`, `downloads`, `trending_score`, `created_at`, `last_modified`, `pipeline_tag`, `num_params`, `tags`, `library_name`, `description`, `paperswithcode_id`, `sdk`, `models`, `datasets`, `subdomain`, `runtime_stage`, `runtime`
-- supported_params: `search`, `filter`, `author`, `apps`, `gated`, `inference`, `inference_provider`, `model_name`, `trained_dataset`, `pipeline_tag`, `emissions_thresholds`, `sort`, `limit`, `expand`, `full`, `card_data`, `fetch_config`, `fields`, `post_filter`
+- supported_params: `search`, `filter`, `author`, `apps`, `gated`, `inference`, `inference_provider`, `model_name`, `trained_dataset`, `pipeline_tag`, `num_params`, `emissions_thresholds`, `sort`, `limit`, `expand`, `full`, `card_data`, `fetch_config`, `fields`, `post_filter`
 - sort_values: `created_at`, `downloads`, `last_modified`, `likes`, `trending_score`
 - expand_values: `author`, `base_models`, `card_data`, `config`, `created_at`, `disabled`, `downloads`, `downloads_all_time`, `eval_results`, `gated`, `gguf`, `inference`, `inference_provider_mapping`, `last_modified`, `library_name`, `likes`, `mask_token`, `model_index`, `pipeline_tag`, `private`, `resource_group`, `safetensors`, `sha`, `siblings`, `spaces`, `tags`, `transformers_info`, `trending_score`, `widget_data`, `xet_enabled`, `gitaly_uid`
 - fields_contract:
@@ -361,7 +479,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - supported_ops: `eq`, `in`, `contains`, `icontains`, `gte`, `lte`
   - normalized_only: `true`
 - limit_contract:
-  - default_limit: `20`
+  - default_limit: `100`
   - max_limit: `5000`
 - notes: Thin model-search wrapper around the Hub list_models path. Prefer this over hf_repo_search for model-only queries. This is a one-shot selective search; if meta.limit_boundary_hit is true, more rows may exist and counts are not exact.
 
@@ -532,7 +650,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - supported_ops: `eq`, `in`, `contains`, `icontains`, `gte`, `lte`
   - normalized_only: `true`
 - limit_contract:
-  - default_limit: `20`
+  - default_limit: `100`
   - max_limit: `5000`
 - notes: Small generic repo-search helper. Prefer hf_models_search, hf_datasets_search, or hf_spaces_search for single-type queries; use hf_repo_search for intentionally cross-type search. This is a one-shot selective search; if meta.limit_boundary_hit is true, more rows may exist and counts are not exact.
 
@@ -571,7 +689,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - supported_ops: `eq`, `in`, `contains`, `icontains`, `gte`, `lte`
   - normalized_only: `true`
 - limit_contract:
-  - default_limit: `20`
+  - default_limit: `100`
   - max_limit: `5000`
 - notes: Thin space-search wrapper around the Hub list_spaces path. Prefer this over hf_repo_search for space-only queries. This is a one-shot selective search; if meta.limit_boundary_hit is true, more rows may exist and counts are not exact.
 

.prod/agent-cards/shared/_monty_codegen_shared.template.md

@@ -3,24 +3,31 @@
 - You are writing Python to be executed in a secure runtime environment.
 - **NEVER** use `import` - it is NOT available in this environment.
 - All helper calls are async: always use `await`.
-- Use this exact outer shape:
+- Write a top-level Monty Python script. Use a shape like:
 
 ```py
-async def solve(query, max_calls):
-    ...
-
-await solve(query, max_calls)
+resp = await hf_models_search(limit=min(max_calls, 10))
+result = resp["items"]
+result
 ```
 
+- `max_calls` is a runtime-provided top-level input.
 - `max_calls` is the total external-call budget for the whole program.
+- Always assign the final output to `result`.
+- End the script with a final line containing only `result`.
+- Never stop after `result = ...`; always add a final bare `result` line.
+- Do **not** define or call `solve(...)`.
 - Use only documented `hf_*` helpers.
-- Return plain Python data only: `dict`, `list`, `str`, `int`, `float`, `bool`, or `None`.
-- Do **not** hand-build JSON strings or markdown strings inside `solve(...)` unless the user explicitly asked for prose.
-- Do **not** build your own transport wrapper like `{result: ..., meta: ...}`.
-- If the user says "return only" some fields, return exactly that final shape.
-- If a helper already returns the requested row shape, return `resp["items"]` directly **only when helper coverage is clearly complete**. If helper `meta` suggests partial/unknown coverage, return `{"results": resp["items"], "coverage": resp["meta"]}` instead of bare items.
+- `result` must be plain Python data only: `dict`, `list`, `str`, `int`, `float`, `bool`, or `None`.
+- Do **not** hand-build JSON strings, markdown strings, or your own transport wrapper like `{result: ..., meta: ...}` unless the user explicitly asked for prose.
+- If the user says "return only" some fields, make `result` exactly that shape.
+- If a helper already returns the requested row shape, use `resp["items"]` directly **only when helper coverage is clearly complete**. If helper `meta` suggests partial/unknown coverage, set `result = {"results": resp["items"], "coverage": resp["meta"]}` instead of bare items.
 - For current-user prompts (`my`, `me`), try helpers with `username=None` / `handle=None` first.
-- If a current-user helper returns `ok=false`, return that helper response directly.
+- For current-user follower/following aggregation prompts, prefer `hf_user_graph(relation=..., ...)` directly instead of `hf_whoami()` plus a second graph call. This saves a call and avoids unnecessary branching.
+- If a current-user helper returns `ok=false`, assign that helper response to `result`.
+- For relationship / aggregation questions (followers, members, likes, likers, intersections), preserve attribution in `result` unless the user explicitly asked for a collapsed deduped list.
+- Do **not** choose tiny hard-coded limits like `5` for follower/member/likes aggregation unless the user explicitly asked for a tiny sample. Prefer larger limits and preserve coverage when partial.
+- If you branch on an error path, you must still end the module with a final top-level bare `result` line outside every `if` / loop.
 
 ## Search rules
 
@@ -41,35 +48,46 @@ await solve(query, max_calls)
 - `hf_user_likes(...)` already returns full normalized like rows by default; omit `fields` unless the user asked for a subset.
 - When sorting `hf_user_likes(...)` by `repo_likes` or `repo_downloads`, set `ranking_window=50` unless the user explicitly asked for a narrower recent window.
 - For human-facing follower/member/liker lists without an explicit requested count, prefer `limit=100` and return coverage when more may exist.
+- For follower/following/member/liker queries that require local filtering on actor fields such as `username` or `fullname`, prefer a bounded scan like `limit=100` / `scan_limit=100` by default, or at most about `200` when a slightly broader sample is justified. Do **not** jump to `1000` unless the user explicitly asked for exhaustive coverage or a very large sample.
 - Unknown `fields` / `where` keys now fail fast. Use only canonical field names.
-
-- Ownership phrasing like "what collections does Qwen have", "collections by Qwen", or "collections owned by Qwen" means an owner lookup, so use `hf_collections_search(owner="Qwen")`, not a keyword-only `query="Qwen"` search.
+- Ownership phrasing like "what collections does Qwen have", "collections by Qwen", or "collections owned by Qwen" means an owner lookup, so use `hf_collections_search(owner="Qwen")`, not a keyword-only `query="Qwen"` search; it filters owners case-insensitively.
 - Ownership phrasing like "what spaces does X have", "what models does X have", or "what datasets does X have" means an author/owner inventory lookup, so use `hf_spaces_search(author="X")`, `hf_models_search(author="X")`, or `hf_datasets_search(author="X")` rather than a global keyword-only search.
-- Owner/user/org handles may arrive with different casing in the user message; when a handle spelling is uncertain, prefer owner-oriented logic and, if needed, add fallback inside `solve(...)` that broadens to `query=...` and filters owners case-insensitively.
+- For profile/detail/social questions about a user or org — bio, description, display name, website, GitHub, Twitter/X, LinkedIn, Bluesky, organizations, or pro status — use `hf_profile_summary(...)` first.
+- For join-style questions that need profile details for followers, following, members, likers, or other actor lists, first fetch a **bounded** actor list, filter locally on actor fields like `username` / `fullname`, then hydrate only the bounded matches with `hf_profile_summary(...)`.
+- Do **not** set the initial actor-list limit equal to the whole remaining call budget when each match needs a follow-up profile lookup; reserve budget for the profile-detail calls and return coverage if the hydration step is partial.
 - For exact aggregate counts like "how many models/datasets/spaces does X have", prefer `hf_profile_summary(...)['item']` counts. Those overview-owned counts may differ slightly from visible public search/list results, so if the user also asked for the list, preserve that distinction.
 - For owner inventory queries without an explicit requested count, use `hf_profile_summary(...)` first when a specific owner is known. If the count is modest, use it to size the follow-up list call; otherwise return a bounded list plus coverage instead of pretending completeness.
 - Think like `huggingface_hub`: `search`, `filter`, `author`, repo-type-specific upstream params, then `fields`.
 - Push constraints upstream whenever a first-class helper argument exists.
 - `post_filter` is only for normalized row filters that cannot be pushed upstream.
+- `num_params` is a first-class upstream model-search arg; use `num_params="min:6B,max:128B"` instead of `post_filter` when possible.
+- For created/updated date constraints, pair local `post_filter` with the matching sort (`created_at` or `last_modified`). Do **not** rely on date-only `post_filter` over an unsorted repo search window.
 - Keep `post_filter` simple:
   - exact match or `in` for returned fields like `runtime_stage`
-  - `gte` / `lte` for normalized numeric fields like `num_params`, `downloads`, and `likes`
-- `num_params` is one of the main valid reasons to use `post_filter` on model search today.
-- Do **not** use `post_filter` for things that already have first-class upstream params like `author`, `pipeline_tag`, `dataset_name`, `language`, `models`, or `datasets`.
+  - `gte` / `lte` for normalized numeric fields like `downloads` and `likes`
+  - `gte` / `lte` also work for normalized ISO timestamp fields like `created_at` and `last_modified`
+- Do **not** use `post_filter` for things that already have first-class upstream params like `author`, `pipeline_tag`, `num_params` on model search, `dataset_name`, `language`, `models`, or `datasets`.
 
 Examples:
 
 ```py
-await hf_models_search(pipeline_tag="text-to-image", limit=10)
-await hf_datasets_search(search="speech", sort="downloads", limit=10)
-await hf_spaces_search(post_filter={"runtime_stage": {"in": ["BUILD_ERROR", "RUNTIME_ERROR"]}})
-await hf_models_search(
+result = await hf_models_search(pipeline_tag="text-to-image", limit=10)
+result
+```
+
+```py
+result = await hf_models_search(
     pipeline_tag="text-generation",
+    num_params="min:20B,max:80B",
     sort="trending_score",
     limit=50,
-    post_filter={"num_params": {"gte": 20_000_000_000, "lte": 80_000_000_000}},
 )
-await hf_collections_search(owner="Qwen", limit=10)
+result
+```
+
+```py
+result = await hf_collections_search(owner="Qwen", limit=10)
+result
 ```
 
 Field-only pattern:
@@ -80,7 +98,8 @@ resp = await hf_models_search(
     fields=["repo_id", "author", "likes", "downloads", "repo_url"],
     limit=3,
 )
-return resp["items"]
+result = resp["items"]
+result
 ```
 
 Coverage pattern:
@@ -93,7 +112,8 @@ resp = await hf_user_likes(
     limit=20,
     fields=["repo_id", "repo_likes", "repo_url"],
 )
-return {"results": resp["items"], "coverage": resp["meta"]}
+result = {"results": resp["items"], "coverage": resp["meta"]}
+result
 ```
 
 Owner-inventory pattern:
@@ -109,31 +129,133 @@ resp = await hf_spaces_search(
 )
 meta = resp.get("meta") or {}
 if meta.get("limit_boundary_hit") or meta.get("more_available") not in {False, None}:
-    return {"results": resp["items"], "coverage": {**meta, "profile_spaces_count": count}}
-return resp["items"]
+    result = {"results": resp["items"], "coverage": {**meta, "profile_spaces_count": count}}
+else:
+    result = resp["items"]
+result
+```
+
+Follower-profile join pattern:
+
+```py
+followers_resp = await hf_user_graph(
+    relation="followers",
+    limit=100,
+    scan_limit=100,
+    fields=["username", "fullname"],
+)
+followers = followers_resp.get("items") or []
+matches = []
+for follower in followers:
+    username = follower.get("username")
+    fullname = follower.get("fullname")
+    starts_with_b = (
+        (isinstance(username, str) and username.lower().startswith("b"))
+        or (isinstance(fullname, str) and fullname.lower().startswith("b"))
+    )
+    if starts_with_b:
+        matches.append(follower)
+remaining_profile_calls = max(0, max_calls - 1)
+results = []
+for follower in matches[:remaining_profile_calls]:
+    username = follower.get("username")
+    if not username:
+        continue
+    profile = await hf_profile_summary(handle=username)
+    item = profile.get("item") or {}
+    results.append(
+        {
+            "username": username,
+            "fullname": follower.get("fullname"),
+            "github_url": item.get("github_url"),
+        }
+    )
+result = {
+    "results": results,
+    "coverage": {
+        "followers": followers_resp.get("meta") or {},
+        "matching_followers_seen": len(matches),
+        "profile_calls_used": len(results),
+        "profile_hydration_partial": len(matches) > len(results),
+    },
+}
+result
 ```
 
-Profile-count pattern:
+Follower-likes aggregation pattern:
 
 ```py
-profile = await hf_profile_summary(handle="mishig")
-item = profile["item"] or {}
-return {
-    "followers_count": item.get("followers_count"),
-    "following_count": item.get("following_count"),
+followers_resp = await hf_user_graph(relation="followers", limit=100, fields=["username"])
+followers = followers_resp.get("items") or []
+results = []
+for follower in followers:
+    username = follower.get("username")
+    if not username:
+        continue
+    likes_resp = await hf_user_likes(
+        username=username,
+        repo_types=["model"],
+        limit=20,
+        fields=["repo_id", "liked_at"],
+    )
+    results.append(
+        {
+            "follower": username,
+            "liked_models": likes_resp.get("items") or [],
+        }
+    )
+coverage = {
+    "followers": followers_resp.get("meta") or {},
 }
+result = {"results": results, "coverage": coverage}
+result
 ```
 
-Pro-followers pattern:
+Current-user pro-follower model-likes pattern:
 
 ```py
-followers = await hf_user_graph(
+followers_resp = await hf_user_graph(
     relation="followers",
     pro_only=True,
-    limit=20,
+    limit=100,
     fields=["username"],
 )
-return followers["items"]
+followers = followers_resp.get("items") or []
+remaining_calls = max(0, max_calls - 1)
+results = {}
+partial = (
+    (followers_resp.get("meta") or {}).get("limit_boundary_hit")
+    or (followers_resp.get("meta") or {}).get("more_available") not in {False, None}
+)
+processed_followers = 0
+for follower in followers:
+    if remaining_calls <= 0:
+        partial = True
+        break
+    username = follower.get("username")
+    if not username:
+        continue
+    likes_resp = await hf_user_likes(
+        username=username,
+        repo_types=["model"],
+        limit=2,
+        fields=["repo_id", "repo_author", "liked_at"],
+    )
+    remaining_calls -= 1
+    likes_meta = likes_resp.get("meta") or {}
+    if likes_meta.get("limit_boundary_hit") or likes_meta.get("more_available") not in {False, None}:
+        partial = True
+    items = likes_resp.get("items") or []
+    if items:
+        results[username] = items
+    processed_followers += 1
+coverage = {
+    "followers": followers_resp.get("meta") or {},
+    "processed_followers": processed_followers,
+    "partial": partial,
+}
+result = {"results": results, "coverage": coverage}
+result
 ```
 
 ## Navigation graph
@@ -150,7 +272,7 @@ Use the helper that matches the question type.
 - repo discussions → `hf_repo_discussions(...)`
 - specific discussion details → `hf_repo_discussion_details(...)`
 - users who liked one repo → `hf_repo_likers(...)`
-- profile / overview / aggregate counts → `hf_profile_summary(...)`
+- profile / overview / social/detail / aggregate counts → `hf_profile_summary(...)`
 - followers / following lists → `hf_user_graph(...)`
 - repos a user liked → `hf_user_likes(...)`
 - recent activity feed → `hf_recent_activity(...)`
@@ -182,16 +304,12 @@ Rules:
 - `items` is the canonical list field.
 - `item` is just a singleton convenience.
 - `meta` contains helper-owned execution, limit, and coverage info.
-- When helper-owned coverage matters, prefer returning the helper envelope directly.
 
 ## High-signal output rules
 
 - Prefer compact dict/list outputs over prose when the user asked for fields.
-- Prefer summary helpers before detail hydration.
 - Use canonical snake_case keys in generated code and structured output.
 - Use `repo_id` as the display label for repos.
-- Use `hf_profile_summary(...)['item']` for aggregate counts such as followers, following, models, datasets, and spaces.
-- For selective one-shot search helpers, treat `meta.limit_boundary_hit=true` as a partial/unknown-coverage warning even if `meta.truncated` is still `false`.
 - For joins/intersections/rankings, fetch the needed working set first and compute locally.
 - If the result is partial, use top-level keys `results` and `coverage`.
 

.prod/agent-cards/shared/_monty_helper_contracts.md

@@ -94,7 +94,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - supported_ops: `eq`, `in`, `contains`, `icontains`, `gte`, `lte`
   - normalized_only: `true`
 - limit_contract:
-  - default_limit: `20`
+  - default_limit: `100`
   - max_limit: `5000`
 - notes: Thin dataset-search wrapper around the Hub list_datasets path. Prefer this over hf_repo_search for dataset-only queries. This is a one-shot selective search; if meta.limit_boundary_hit is true, more rows may exist and counts are not exact.
 
@@ -108,7 +108,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - default_fields: `repo_id`, `repo_type`, `author`, `likes`, `downloads`, `trending_score`, `created_at`, `last_modified`, `pipeline_tag`, `num_params`, `repo_url`, `tags`, `library_name`, `description`, `paperswithcode_id`, `sdk`, `models`, `datasets`, `subdomain`, `runtime_stage`, `runtime`
   - guaranteed_fields: `repo_id`, `repo_type`, `author`, `repo_url`
   - optional_fields: `likes`, `downloads`, `trending_score`, `created_at`, `last_modified`, `pipeline_tag`, `num_params`, `tags`, `library_name`, `description`, `paperswithcode_id`, `sdk`, `models`, `datasets`, `subdomain`, `runtime_stage`, `runtime`
-- supported_params: `search`, `filter`, `author`, `apps`, `gated`, `inference`, `inference_provider`, `model_name`, `trained_dataset`, `pipeline_tag`, `emissions_thresholds`, `sort`, `limit`, `expand`, `full`, `card_data`, `fetch_config`, `fields`, `post_filter`
+- supported_params: `search`, `filter`, `author`, `apps`, `gated`, `inference`, `inference_provider`, `model_name`, `trained_dataset`, `pipeline_tag`, `num_params`, `emissions_thresholds`, `sort`, `limit`, `expand`, `full`, `card_data`, `fetch_config`, `fields`, `post_filter`
 - sort_values: `created_at`, `downloads`, `last_modified`, `likes`, `trending_score`
 - expand_values: `author`, `base_models`, `card_data`, `config`, `created_at`, `disabled`, `downloads`, `downloads_all_time`, `eval_results`, `gated`, `gguf`, `inference`, `inference_provider_mapping`, `last_modified`, `library_name`, `likes`, `mask_token`, `model_index`, `pipeline_tag`, `private`, `resource_group`, `safetensors`, `sha`, `siblings`, `spaces`, `tags`, `transformers_info`, `trending_score`, `widget_data`, `xet_enabled`, `gitaly_uid`
 - fields_contract:
@@ -119,7 +119,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - supported_ops: `eq`, `in`, `contains`, `icontains`, `gte`, `lte`
   - normalized_only: `true`
 - limit_contract:
-  - default_limit: `20`
+  - default_limit: `100`
   - max_limit: `5000`
 - notes: Thin model-search wrapper around the Hub list_models path. Prefer this over hf_repo_search for model-only queries. This is a one-shot selective search; if meta.limit_boundary_hit is true, more rows may exist and counts are not exact.
 
@@ -290,7 +290,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - supported_ops: `eq`, `in`, `contains`, `icontains`, `gte`, `lte`
   - normalized_only: `true`
 - limit_contract:
-  - default_limit: `20`
+  - default_limit: `100`
   - max_limit: `5000`
 - notes: Small generic repo-search helper. Prefer hf_models_search, hf_datasets_search, or hf_spaces_search for single-type queries; use hf_repo_search for intentionally cross-type search. This is a one-shot selective search; if meta.limit_boundary_hit is true, more rows may exist and counts are not exact.
 
@@ -329,7 +329,7 @@ All helpers return the same envelope: `{ok, item, items, meta, error}`.
   - supported_ops: `eq`, `in`, `contains`, `icontains`, `gte`, `lte`
   - normalized_only: `true`
 - limit_contract:
-  - default_limit: `20`
+  - default_limit: `100`
   - max_limit: `5000`
 - notes: Thin space-search wrapper around the Hub list_spaces path. Prefer this over hf_repo_search for space-only queries. This is a one-shot selective search; if meta.limit_boundary_hit is true, more rows may exist and counts are not exact.
 

.prod/agent-cards/shared/_monty_helper_signatures.md

@@ -10,9 +10,9 @@ await hf_collections_search(query: 'str | None' = None, owner: 'str | None' = No
 
 await hf_daily_papers(limit: 'int' = 20, where: 'dict[str, Any] | None' = None, fields: 'list[str] | None' = None) -> 'dict[str, Any]'
 
-await hf_datasets_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, benchmark: 'str | bool | None' = None, dataset_name: 'str | None' = None, gated: 'bool | None' = None, language_creators: 'str | list[str] | None' = None, language: 'str | list[str] | None' = None, multilinguality: 'str | list[str] | None' = None, size_categories: 'str | list[str] | None' = None, task_categories: 'str | list[str] | None' = None, task_ids: 'str | list[str] | None' = None, sort: 'str | None' = None, limit: 'int' = 20, expand: 'list[str] | None' = None, full: 'bool | None' = None, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
+await hf_datasets_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, benchmark: 'str | bool | None' = None, dataset_name: 'str | None' = None, gated: 'bool | None' = None, language_creators: 'str | list[str] | None' = None, language: 'str | list[str] | None' = None, multilinguality: 'str | list[str] | None' = None, size_categories: 'str | list[str] | None' = None, task_categories: 'str | list[str] | None' = None, task_ids: 'str | list[str] | None' = None, sort: 'str | None' = None, limit: 'int' = 100, expand: 'list[str] | None' = None, full: 'bool | None' = None, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
 
-await hf_models_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, apps: 'str | list[str] | None' = None, gated: 'bool | None' = None, inference: 'str | None' = None, inference_provider: 'str | list[str] | None' = None, model_name: 'str | None' = None, trained_dataset: 'str | list[str] | None' = None, pipeline_tag: 'str | None' = None, emissions_thresholds: 'tuple[float, float] | None' = None, sort: 'str | None' = None, limit: 'int' = 20, expand: 'list[str] | None' = None, full: 'bool | None' = None, card_data: 'bool' = False, fetch_config: 'bool' = False, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
+await hf_models_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, apps: 'str | list[str] | None' = None, gated: 'bool | None' = None, inference: 'str | None' = None, inference_provider: 'str | list[str] | None' = None, model_name: 'str | None' = None, trained_dataset: 'str | list[str] | None' = None, pipeline_tag: 'str | None' = None, num_params: 'str | None' = None, emissions_thresholds: 'tuple[float, float] | None' = None, sort: 'str | None' = None, limit: 'int' = 100, expand: 'list[str] | None' = None, full: 'bool | None' = None, card_data: 'bool' = False, fetch_config: 'bool' = False, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
 
 await hf_org_members(organization: 'str', limit: 'int | None' = None, scan_limit: 'int | None' = None, count_only: 'bool' = False, where: 'dict[str, Any] | None' = None, fields: 'list[str] | None' = None) -> 'dict[str, Any]'
 
@@ -28,11 +28,11 @@ await hf_repo_discussions(repo_type: 'str', repo_id: 'str', limit: 'int' = 20, f
 
 await hf_repo_likers(repo_id: 'str', repo_type: 'str', 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]'
 
-await hf_repo_search(search: 'str | None' = None, repo_type: 'str | None' = None, repo_types: 'list[str] | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, sort: 'str | None' = None, limit: 'int' = 20, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
+await hf_repo_search(search: 'str | None' = None, repo_type: 'str | None' = None, repo_types: 'list[str] | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, sort: 'str | None' = None, limit: 'int' = 100, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
 
 await hf_runtime_capabilities(section: 'str | None' = None) -> 'dict[str, Any]'
 
-await hf_spaces_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, datasets: 'str | list[str] | None' = None, models: 'str | list[str] | None' = None, linked: 'bool' = False, sort: 'str | None' = None, limit: 'int' = 20, expand: 'list[str] | None' = None, full: 'bool | None' = None, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
+await hf_spaces_search(search: 'str | None' = None, filter: 'str | list[str] | None' = None, author: 'str | None' = None, datasets: 'str | list[str] | None' = None, models: 'str | list[str] | None' = None, linked: 'bool' = False, sort: 'str | None' = None, limit: 'int' = 100, expand: 'list[str] | None' = None, full: 'bool | None' = None, fields: 'list[str] | None' = None, post_filter: 'dict[str, Any] | None' = None) -> 'dict[str, Any]'
 
 await hf_trending(repo_type: 'str' = 'model', limit: 'int' = 20, where: 'dict[str, Any] | None' = None, fields: 'list[str] | None' = None) -> 'dict[str, Any]'
 

.prod/monty_api/helpers/repos.py

@@ -123,6 +123,9 @@ def _build_repo_search_extra_args(
             if value:
                 normalized["cardData"] = True
             continue
+        if key in {"num_params", "num_parameters"}:
+            normalized["num_parameters"] = value
+            continue
         if key in {"fetch_config", "linked"}:
             if value:
                 normalized[key] = True
@@ -180,7 +183,7 @@ async def _run_repo_search(
     extra_args_by_type: dict[str, dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     start_calls = ctx.call_count["n"]
-    default_limit = ctx._policy_int(helper_name, "default_limit", 20)
+    default_limit = ctx._policy_int(helper_name, "default_limit", 100)
     max_limit = ctx._policy_int(
         helper_name, "max_limit", SELECTIVE_ENDPOINT_RETURN_HARD_CAP
     )
@@ -340,9 +343,10 @@ async def hf_models_search(
     model_name: str | None = None,
     trained_dataset: str | list[str] | None = None,
     pipeline_tag: str | None = None,
+    num_params: str | None = None,
     emissions_thresholds: tuple[float, float] | None = None,
     sort: str | None = None,
-    limit: int = 20,
+    limit: int = 100,
     expand: list[str] | None = None,
     full: bool | None = None,
     card_data: bool = False,
@@ -370,6 +374,7 @@ async def hf_models_search(
                 "model_name": model_name,
                 "trained_dataset": trained_dataset,
                 "pipeline_tag": pipeline_tag,
+                "num_params": num_params,
                 "emissions_thresholds": emissions_thresholds,
                 "expand": expand,
                 "full": full,
@@ -395,7 +400,7 @@ async def hf_datasets_search(
     task_categories: str | list[str] | None = None,
     task_ids: str | list[str] | None = None,
     sort: str | None = None,
-    limit: int = 20,
+    limit: int = 100,
     expand: list[str] | None = None,
     full: bool | None = None,
     fields: list[str] | None = None,
@@ -439,7 +444,7 @@ async def hf_spaces_search(
     models: str | list[str] | None = None,
     linked: bool = False,
     sort: str | None = None,
-    limit: int = 20,
+    limit: int = 100,
     expand: list[str] | None = None,
     full: bool | None = None,
     fields: list[str] | None = None,
@@ -476,7 +481,7 @@ async def hf_repo_search(
     filter: str | list[str] | None = None,
     author: str | None = None,
     sort: str | None = None,
-    limit: int = 20,
+    limit: int = 100,
     fields: list[str] | None = None,
     post_filter: dict[str, Any] | None = None,
 ) -> dict[str, Any]:

.prod/monty_api/llm_time_hook.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from fast_agent.constants import FAST_AGENT_TIMING
+from fast_agent.hooks import show_hook_message
+from fast_agent.mcp.helpers.content_helpers import get_text
+
+if TYPE_CHECKING:
+    from fast_agent.hooks import HookContext
+
+
+def _timing_payload(ctx: "HookContext") -> dict[str, object] | None:
+    channels = ctx.message.channels or {}
+    timing_blocks = channels.get(FAST_AGENT_TIMING, [])
+    if not timing_blocks:
+        return None
+
+    payload_text = get_text(timing_blocks[0])
+    if not payload_text:
+        return None
+
+    try:
+        payload = json.loads(payload_text)
+    except json.JSONDecodeError:
+        return None
+
+    return payload if isinstance(payload, dict) else None
+
+
+def _coerce_float(value: object) -> float | None:
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, int | float):
+        return float(value)
+    return None
+
+
+def _format_duration_ms(duration_ms: float) -> str:
+    if duration_ms >= 1000:
+        return f"{duration_ms / 1000:.2f}s"
+    return f"{duration_ms:.0f}ms"
+
+
+async def display_llm_time(ctx: "HookContext") -> None:
+    payload = _timing_payload(ctx)
+    if payload is None:
+        return
+
+    duration_ms = _coerce_float(payload.get("duration_ms"))
+    if duration_ms is None:
+        return
+
+    show_hook_message(
+        ctx,
+        _format_duration_ms(duration_ms),
+        hook_name="llm_time",
+        hook_kind="tool",
+    )

.prod/monty_api/query_entrypoints.py

@@ -21,6 +21,7 @@ from .constants import (
 from .runtime_context import build_runtime_helper_environment
 from .validation import (
     _coerce_jsonish_python_literals,
+    _compact_result_metadata,
     _summarize_limit_hit,
     _truncate_result_payload,
     _validate_generated_code,
@@ -40,13 +41,28 @@ def _query_debug_enabled() -> bool:
     return value.strip().lower() in {"1", "true", "yes", "on"}
 
 
+def _execution_debug_enabled() -> bool:
+    value = os.environ.get("MONTY_DEBUG_EXECUTION", "")
+    if value.strip().lower() in {"1", "true", "yes", "on"}:
+        return True
+    return _query_debug_enabled()
+
+
+def _debug_log(*parts: Any) -> None:
+    if not _execution_debug_enabled():
+        return
+    print("[monty-debug]", *parts, file=sys.stderr)
+    sys.stderr.flush()
+
+
 def _log_generated_query(
-    *, query: str, code: str, max_calls: int | None, timeout_sec: int | None
+    *, query: str | None, code: str, max_calls: int | None, timeout_sec: int | None
 ) -> None:
     if not _query_debug_enabled():
         return
-    print("[monty-debug] query:", file=sys.stderr)
-    print(query, file=sys.stderr)
+    if query:
+        print("[monty-debug] query:", file=sys.stderr)
+        print(query, file=sys.stderr)
     print("[monty-debug] max_calls:", max_calls, file=sys.stderr)
     print("[monty-debug] timeout_sec:", timeout_sec, file=sys.stderr)
     print("[monty-debug] code:", file=sys.stderr)
@@ -72,11 +88,17 @@ def _introspect_helper_signatures() -> dict[str, set[str]]:
 async def _run_with_monty(
     *,
     code: str,
-    query: str,
+    query: str | None,
     max_calls: int,
     strict_mode: bool,
     timeout_sec: int,
 ) -> dict[str, Any]:
+    _debug_log(
+        "run_monty:start",
+        f"max_calls={max_calls}",
+        f"timeout_sec={timeout_sec}",
+        f"strict_mode={strict_mode}",
+    )
     try:
         import pydantic_monty
     except Exception as e:
@@ -101,10 +123,24 @@ async def _run_with_monty(
         helper_name: str, fn: Callable[..., Any]
     ) -> Callable[..., Any]:
         async def wrapped(*args: Any, **kwargs: Any) -> Any:
+            started = time.perf_counter()
+            _debug_log(
+                "helper:start",
+                helper_name,
+                f"args={len(args)}",
+                f"kwargs={sorted(kwargs)}",
+            )
             result = await fn(*args, **kwargs)
             summary = _summarize_limit_hit(helper_name, result)
             if summary is not None and len(env.limit_summaries) < 20:
                 env.limit_summaries.append(summary)
+            elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
+            _debug_log(
+                "helper:end",
+                helper_name,
+                f"elapsed_ms={elapsed_ms}",
+                f"api_calls={env.call_count['n']}",
+            )
             return result
 
         return wrapped
@@ -117,16 +153,19 @@ async def _run_with_monty(
     }
 
     try:
+        _debug_log("run_monty:invoke")
         result = await pydantic_monty.run_monty_async(
             m,
-            inputs={"query": query, "max_calls": max_calls},
+            inputs={"query": query or "", "max_calls": max_calls},
             external_functions={
                 name: _collecting_wrapper(name, fn)
                 for name, fn in env.helper_functions.items()
             },
             limits=limits,
         )
+        _debug_log("run_monty:return", f"api_calls={env.call_count['n']}")
     except Exception as e:
+        _debug_log("run_monty:error", type(e).__name__, str(e))
         raise MontyExecutionError(str(e), env.call_count["n"], env.trace) from e
 
     if env.call_count["n"] == 0:
@@ -200,32 +239,32 @@ async def _run_with_monty(
 
 def _prepare_query_inputs(
     *,
-    query: str,
+    query: str | None,
     code: str,
     max_calls: int | None,
     timeout_sec: int | None,
 ) -> tuple[str, str, int, int]:
-    if not query or not query.strip():
-        raise ValueError("query is required")
     if not code or not code.strip():
         raise ValueError("code is required")
 
+    normalized_query = str(query or "").strip()
     resolved_max_calls = DEFAULT_MAX_CALLS if max_calls is None else max_calls
     resolved_timeout_sec = DEFAULT_TIMEOUT_SEC if timeout_sec is None else timeout_sec
     normalized_max_calls = max(1, min(int(resolved_max_calls), MAX_CALLS_LIMIT))
     normalized_timeout_sec = int(resolved_timeout_sec)
     normalized_code = _coerce_jsonish_python_literals(code.strip())
     _validate_generated_code(normalized_code)
-    return query, normalized_code, normalized_max_calls, normalized_timeout_sec
+    return normalized_query, normalized_code, normalized_max_calls, normalized_timeout_sec
 
 
 async def _execute_query(
     *,
-    query: str,
+    query: str | None,
     code: str,
     max_calls: int | None,
     timeout_sec: int | None,
 ) -> dict[str, Any]:
+    _debug_log("execute_query:start")
     prepared_query, prepared_code, prepared_max_calls, prepared_timeout = (
         _prepare_query_inputs(
             query=query,
@@ -234,6 +273,13 @@ async def _execute_query(
             timeout_sec=timeout_sec,
         )
     )
+    _debug_log(
+        "execute_query:prepared",
+        f"query_len={len(prepared_query)}",
+        f"code_len={len(prepared_code)}",
+        f"max_calls={prepared_max_calls}",
+        f"timeout_sec={prepared_timeout}",
+    )
     _log_generated_query(
         query=prepared_query,
         code=prepared_code,
@@ -250,8 +296,8 @@ async def _execute_query(
 
 
 async def hf_hub_query(
-    query: str,
     code: str,
+    query: str | None = None,
     max_calls: int | None = DEFAULT_MAX_CALLS,
     timeout_sec: int | None = DEFAULT_TIMEOUT_SEC,
 ) -> dict[str, Any]:
@@ -270,7 +316,7 @@ async def hf_hub_query(
         )
         return {
             "ok": True,
-            "data": run["output"],
+            "data": _compact_result_metadata(run["output"]),
             "error": None,
             "api_calls": run["api_calls"],
         }
@@ -291,8 +337,8 @@ async def hf_hub_query(
 
 
 async def hf_hub_query_raw(
-    query: str,
     code: str,
+    query: str | None = None,
     max_calls: int | None = DEFAULT_MAX_CALLS,
     timeout_sec: int | None = DEFAULT_TIMEOUT_SEC,
 ) -> Any:
@@ -300,7 +346,7 @@ async def hf_hub_query_raw(
 
     Best for read-only Hub discovery, lookup, ranking, and relationship
     questions when the caller wants a runtime-owned raw envelope:
-    ``result`` contains the direct ``solve(...)`` output and ``meta`` contains
+    ``result`` contains the generated script's final `result` value and ``meta`` contains
     execution details such as timing, call counts, and limit summaries.
     """
     started = time.perf_counter()
@@ -313,7 +359,7 @@ async def hf_hub_query_raw(
         )
         elapsed_ms = int((time.perf_counter() - started) * 1000)
         return _wrap_raw_result(
-            run["output"],
+            _compact_result_metadata(run["output"]),
             ok=True,
             api_calls=run["api_calls"],
             elapsed_ms=elapsed_ms,
@@ -341,7 +387,7 @@ async def hf_hub_query_raw(
 
 def _arg_parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser(description="Monty-backed API chaining tool (v3)")
-    p.add_argument("--query", required=True, help="Natural language query")
+    p.add_argument("--query", default=None, help="Optional natural language query/context")
     p.add_argument("--code", default=None, help="Inline Monty code to execute")
     p.add_argument(
         "--code-file", default=None, help="Path to .py file with Monty code to execute"
@@ -375,8 +421,8 @@ def main() -> int:
     try:
         out = asyncio.run(
             hf_hub_query(
-                query=args.query,
                 code=code,
+                query=args.query,
                 max_calls=args.max_calls,
                 timeout_sec=args.timeout,
             )

.prod/monty_api/registry.py

@@ -62,6 +62,7 @@ REPO_SEARCH_EXTRA_ARGS: dict[str, set[str]] = {
         "inference",
         "inference_provider",
         "model_name",
+        "num_parameters",
         "pipeline_tag",
         "trained_dataset",
     },
@@ -350,7 +351,7 @@ HELPER_CONFIGS: dict[str, HelperConfig] = {
             default_fields=REPO_SUMMARY_FIELDS,
             guaranteed_fields=["repo_id", "repo_type", "author", "repo_url"],
             optional_fields=REPO_SUMMARY_OPTIONAL_FIELDS,
-            default_limit=20,
+            default_limit=100,
             max_limit=5_000,
             notes=(
                 "Thin model-search wrapper around the Hub list_models path. Prefer this "
@@ -359,7 +360,7 @@ HELPER_CONFIGS: dict[str, HelperConfig] = {
                 "are not exact."
             ),
         ),
-        pagination={"default_limit": 20, "max_limit": 5_000},
+        pagination={"default_limit": 100, "max_limit": 5_000},
     ),
     "hf_datasets_search": _config(
         "hf_datasets_search",
@@ -368,7 +369,7 @@ HELPER_CONFIGS: dict[str, HelperConfig] = {
             default_fields=REPO_SUMMARY_FIELDS,
             guaranteed_fields=["repo_id", "repo_type", "author", "repo_url"],
             optional_fields=REPO_SUMMARY_OPTIONAL_FIELDS,
-            default_limit=20,
+            default_limit=100,
             max_limit=5_000,
             notes=(
                 "Thin dataset-search wrapper around the Hub list_datasets path. Prefer "
@@ -377,7 +378,7 @@ HELPER_CONFIGS: dict[str, HelperConfig] = {
                 "and counts are not exact."
             ),
         ),
-        pagination={"default_limit": 20, "max_limit": 5_000},
+        pagination={"default_limit": 100, "max_limit": 5_000},
     ),
     "hf_spaces_search": _config(
         "hf_spaces_search",
@@ -386,7 +387,7 @@ HELPER_CONFIGS: dict[str, HelperConfig] = {
             default_fields=REPO_SUMMARY_FIELDS,
             guaranteed_fields=["repo_id", "repo_type", "author", "repo_url"],
             optional_fields=REPO_SUMMARY_OPTIONAL_FIELDS,
-            default_limit=20,
+            default_limit=100,
             max_limit=5_000,
             notes=(
                 "Thin space-search wrapper around the Hub list_spaces path. Prefer this "
@@ -395,7 +396,7 @@ HELPER_CONFIGS: dict[str, HelperConfig] = {
                 "are not exact."
             ),
         ),
-        pagination={"default_limit": 20, "max_limit": 5_000},
+        pagination={"default_limit": 100, "max_limit": 5_000},
     ),
     "hf_repo_search": _config(
         "hf_repo_search",
@@ -404,7 +405,7 @@ HELPER_CONFIGS: dict[str, HelperConfig] = {
             default_fields=REPO_SUMMARY_FIELDS,
             guaranteed_fields=["repo_id", "repo_type", "author", "repo_url"],
             optional_fields=REPO_SUMMARY_OPTIONAL_FIELDS,
-            default_limit=20,
+            default_limit=100,
             max_limit=5_000,
             notes=(
                 "Small generic repo-search helper. Prefer hf_models_search, "
@@ -414,7 +415,7 @@ HELPER_CONFIGS: dict[str, HelperConfig] = {
                 "and counts are not exact."
             ),
         ),
-        pagination={"default_limit": 20, "max_limit": 5_000},
+        pagination={"default_limit": 100, "max_limit": 5_000},
     ),
     "hf_user_graph": _config(
         "hf_user_graph",

.prod/monty_api/runtime_context.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
 import os
+import sys
+import time
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable, NamedTuple, cast
 
+import httpx
+
 from .constants import MAX_CALLS_LIMIT
 from .helpers.activity import register_activity_helpers
 from .helpers.collections import register_collection_helpers
@@ -82,6 +86,48 @@ class RuntimeHelperEnvironment(NamedTuple):
     helper_functions: dict[str, Callable[..., Any]]
 
 
+def _execution_debug_enabled() -> bool:
+    for key in ("MONTY_DEBUG_EXECUTION", "MONTY_DEBUG_QUERY"):
+        value = os.environ.get(key, "")
+        if value.strip().lower() in {"1", "true", "yes", "on"}:
+            return True
+    return False
+
+
+def _debug_log(*parts: Any) -> None:
+    if not _execution_debug_enabled():
+        return
+    print("[monty-debug]", *parts, file=sys.stderr)
+    sys.stderr.flush()
+
+
+def _hf_call_timeout_default() -> int:
+    raw = os.environ.get("MONTY_HF_CALL_TIMEOUT_SEC", "20").strip()
+    try:
+        return max(1, int(raw))
+    except Exception:
+        return 20
+
+
+_HF_CLIENT_TIMEOUT_SEC: int | None = None
+
+
+def _configure_hf_client_factory(timeout_sec: int) -> None:
+    global _HF_CLIENT_TIMEOUT_SEC
+    if _HF_CLIENT_TIMEOUT_SEC == timeout_sec:
+        return
+    from huggingface_hub.utils._http import hf_request_event_hook, set_client_factory
+
+    set_client_factory(
+        lambda: httpx.Client(
+            event_hooks={"request": [hf_request_event_hook]},
+            follow_redirects=True,
+            timeout=float(timeout_sec),
+        )
+    )
+    _HF_CLIENT_TIMEOUT_SEC = timeout_sec
+
+
 @dataclass(slots=True)
 class RuntimeContext:
     max_calls: int
@@ -153,6 +199,8 @@ class RuntimeContext:
         json_body: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         idx = self._consume_call(endpoint, method)
+        started = time.perf_counter()
+        _debug_log("host_raw:start", f"call={idx}", method, endpoint)
         try:
             resp = call_api_host(
                 endpoint,
@@ -174,9 +222,29 @@ class RuntimeContext:
                     method=method,
                     status=int(resp.get("status") or 0),
                 )
+            elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
+            _debug_log(
+                "host_raw:end",
+                f"call={idx}",
+                method,
+                endpoint,
+                f"ok={bool(resp.get('ok'))}",
+                f"status={resp.get('status')}",
+                f"elapsed_ms={elapsed_ms}",
+            )
             return resp
         except Exception as exc:
             self._trace_err(idx, endpoint, exc, method=method, status=0)
+            elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
+            _debug_log(
+                "host_raw:error",
+                f"call={idx}",
+                method,
+                endpoint,
+                type(exc).__name__,
+                str(exc),
+                f"elapsed_ms={elapsed_ms}",
+            )
             raise
 
     def _get_hf_api_client(self) -> "HfApi":
@@ -184,24 +252,75 @@ class RuntimeContext:
             from huggingface_hub import HfApi
 
             endpoint = os.getenv("HF_ENDPOINT", "https://huggingface.co").rstrip("/")
+            _configure_hf_client_factory(
+                max(1, min(self.timeout_sec, _hf_call_timeout_default()))
+            )
             self._hf_api_client = HfApi(endpoint=endpoint, token=_load_token())
         return self._hf_api_client
 
     def _host_hf_call(self, endpoint: str, fn: Callable[[], Any]) -> Any:
         idx = self._consume_call(endpoint, "GET")
+        started = time.perf_counter()
+        timeout_sec = max(1, min(self.timeout_sec, _hf_call_timeout_default()))
+        _debug_log(
+            "host_hf:start",
+            f"call={idx}",
+            endpoint,
+            f"timeout_sec={timeout_sec}",
+        )
         try:
             out = fn()
             self._trace_ok(idx, endpoint, method="GET", status=200)
+            elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
+            _debug_log("host_hf:end", f"call={idx}", endpoint, f"elapsed_ms={elapsed_ms}")
             return out
         except Exception as exc:
             self._trace_err(idx, endpoint, exc, method="GET", status=0)
+            elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
+            _debug_log(
+                "host_hf:error",
+                f"call={idx}",
+                endpoint,
+                type(exc).__name__,
+                str(exc),
+                f"elapsed_ms={elapsed_ms}",
+            )
             raise
 
     async def call_helper(self, helper_name: str, /, *args: Any, **kwargs: Any) -> Any:
         fn = self.helper_registry.get(helper_name)
         if not callable(fn):
             raise RuntimeError(f"Helper '{helper_name}' is not registered")
-        return await cast(Callable[..., Any], fn)(*args, **kwargs)
+        started = time.perf_counter()
+        _debug_log(
+            "runtime_helper:start",
+            helper_name,
+            f"args={len(args)}",
+            f"kwargs={sorted(kwargs)}",
+            f"budget_remaining={self._budget_remaining()}",
+        )
+        try:
+            result = await cast(Callable[..., Any], fn)(*args, **kwargs)
+        except Exception as exc:
+            elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
+            _debug_log(
+                "runtime_helper:error",
+                helper_name,
+                type(exc).__name__,
+                str(exc),
+                f"elapsed_ms={elapsed_ms}",
+            )
+            raise
+        elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
+        ok = result.get("ok") if isinstance(result, dict) else None
+        _debug_log(
+            "runtime_helper:end",
+            helper_name,
+            f"ok={ok}",
+            f"elapsed_ms={elapsed_ms}",
+            f"budget_remaining={self._budget_remaining()}",
+        )
+        return result
 
 
 for name, value in {

.prod/monty_api/runtime_filtering.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import UTC, datetime
 from typing import Any
 
 from .constants import (
@@ -16,6 +17,23 @@ from .constants import (
 from .http_runtime import _as_int
 
 
+def _as_datetime(value: Any) -> datetime | None:
+    if not isinstance(value, str):
+        return None
+    text = value.strip()
+    if not text:
+        return None
+    if text.endswith("Z"):
+        text = f"{text[:-1]}+00:00"
+    try:
+        parsed = datetime.fromisoformat(text)
+    except Exception:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=UTC)
+    return parsed
+
+
 def _allowed_field_set(allowed_fields: tuple[str, ...] | list[str] | set[str]) -> set[str]:
     return {str(field).strip() for field in allowed_fields if str(field).strip()}
 
@@ -172,13 +190,25 @@ def _item_matches_where(
             if "gte" in cond:
                 left = _as_int(value)
                 right = _as_int(cond.get("gte"))
-                if left is None or right is None or left < right:
-                    return False
+                if left is not None and right is not None:
+                    if left < right:
+                        return False
+                else:
+                    left_dt = _as_datetime(value)
+                    right_dt = _as_datetime(cond.get("gte"))
+                    if left_dt is None or right_dt is None or left_dt < right_dt:
+                        return False
             if "lte" in cond:
                 left = _as_int(value)
                 right = _as_int(cond.get("lte"))
-                if left is None or right is None or left > right:
-                    return False
+                if left is not None and right is not None:
+                    if left > right:
+                        return False
+                else:
+                    left_dt = _as_datetime(value)
+                    right_dt = _as_datetime(cond.get("lte"))
+                    if left_dt is None or right_dt is None or left_dt > right_dt:
+                        return False
             continue
         if isinstance(cond, (list, tuple, set)):
             if value not in cond:

.prod/monty_api/tool_entrypoints.py

@@ -23,28 +23,28 @@ from monty_api import (  # noqa: E402
 
 
 async def hf_hub_query(
-    query: str,
     code: str,
+    query: str | None = None,
     max_calls: int | None = None,
     timeout_sec: int | None = None,
 ) -> dict[str, Any]:
     return await _hf_hub_query(
-        query=query,
         code=code,
+        query=query,
         max_calls=max_calls,
         timeout_sec=timeout_sec,
     )
 
 
 async def hf_hub_query_raw(
-    query: str,
     code: str,
+    query: str | None = None,
     max_calls: int | None = None,
     timeout_sec: int | None = None,
 ) -> Any:
     return await _hf_hub_query_raw(
-        query=query,
         code=code,
+        query=query,
         max_calls=max_calls,
         timeout_sec=timeout_sec,
     )

.prod/monty_api/validation.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+import os
 import re
 import tokenize
 from io import StringIO
@@ -119,6 +120,87 @@ def _truncate_result_payload(output: Any) -> Any:
     return trimmed
 
 
+def _verbose_result_meta_enabled() -> bool:
+    value = os.environ.get("MONTY_VERBOSE_RESULT_META", "")
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _is_helper_meta_dict(value: Any) -> bool:
+    return (
+        isinstance(value, dict)
+        and isinstance(value.get("source"), str)
+        and (
+            value.get("normalized") is True
+            or "budget_used" in value
+            or "budget_remaining" in value
+        )
+    )
+
+
+def _helper_meta_is_partial(value: dict[str, Any]) -> bool:
+    return any(
+        [
+            value.get("truncated") is True,
+            value.get("more_available") not in {False, None},
+            value.get("limit_boundary_hit") is True,
+            value.get("sample_complete") is False,
+            value.get("exact_count") is False,
+            value.get("ranking_complete") is False,
+            value.get("ranking_window_hit") is True,
+            value.get("hard_cap_applied") is True,
+        ]
+    )
+
+
+def _compact_helper_meta(value: dict[str, Any]) -> dict[str, Any]:
+    partial = _helper_meta_is_partial(value)
+    compact: dict[str, Any] = {
+        "partial": partial,
+    }
+    for key in (
+        "source",
+        "returned",
+        "total",
+        "matched",
+        "more_available",
+        "truncated",
+        "truncated_by",
+        "exact_count",
+        "sample_complete",
+        "hard_cap_applied",
+        "limit_boundary_hit",
+        "can_request_more",
+        "next_request_hint",
+        "ranking_window",
+        "ranking_window_hit",
+        "ranking_complete",
+        "ranking_next_request_hint",
+        "relation",
+        "username",
+        "organization",
+        "entity",
+        "entity_type",
+        "handle",
+    ):
+        if value.get(key) is not None:
+            compact[key] = value.get(key)
+    if compact.get("total") is None and value.get("total_available") is not None:
+        compact["total"] = value.get("total_available")
+    return compact
+
+
+def _compact_result_metadata(value: Any) -> Any:
+    if _verbose_result_meta_enabled():
+        return value
+    if _is_helper_meta_dict(value):
+        return _compact_helper_meta(value)
+    if isinstance(value, dict):
+        return {key: _compact_result_metadata(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_compact_result_metadata(item) for item in value]
+    return value
+
+
 def _is_helper_envelope(output: Any) -> bool:
     return (
         isinstance(output, dict)
@@ -139,8 +221,7 @@ def _summarize_limit_hit(helper_name: str, result: Any) -> dict[str, Any] | None
     truncated_by = str(meta.get("truncated_by") or "")
     limit_hit = any(
         [
-            meta.get("truncated") is True,
-            meta.get("hard_cap_applied") is True,
+            _helper_meta_is_partial(meta),
             truncated_by in {"scan_limit", "page_limit", "multiple"},
         ]
     )
@@ -233,54 +314,27 @@ def _validate_generated_code(code: str) -> None:
 
     if not isinstance(parsed, ast.Module):
         raise ValueError("Generated code must be a Python module")
-
-    solve_defs = [
-        node
-        for node in parsed.body
-        if isinstance(node, ast.AsyncFunctionDef) and node.name == "solve"
-    ]
-    if not solve_defs:
-        raise ValueError(
-            "Generated code must define `async def solve(query, max_calls): ...`."
-        )
-
-    def _valid_solve_signature(node: ast.AsyncFunctionDef) -> bool:
-        args = node.args
-        return (
-            not args.posonlyargs
-            and len(args.args) == 2
-            and [arg.arg for arg in args.args] == ["query", "max_calls"]
-            and args.vararg is None
-            and not args.kwonlyargs
-            and args.kwarg is None
-            and not args.defaults
-            and not args.kw_defaults
-        )
-
-    if not any(_valid_solve_signature(node) for node in solve_defs):
-        raise ValueError(
-            "`solve` must have signature `async def solve(query, max_calls): ...`."
-        )
-
     if not parsed.body:
         raise ValueError("Generated code is empty")
 
     final_stmt = parsed.body[-1]
-    valid_final_await = (
+    final_is_result = (
         isinstance(final_stmt, ast.Expr)
-        and isinstance(final_stmt.value, ast.Await)
-        and isinstance(final_stmt.value.value, ast.Call)
-        and isinstance(final_stmt.value.value.func, ast.Name)
-        and final_stmt.value.value.func.id == "solve"
-        and len(final_stmt.value.value.args) == 2
-        and not final_stmt.value.value.keywords
-        and all(isinstance(arg, ast.Name) for arg in final_stmt.value.value.args)
-        and [cast(ast.Name, arg).id for arg in final_stmt.value.value.args]
-        == ["query", "max_calls"]
+        and isinstance(final_stmt.value, ast.Name)
+        and final_stmt.value.id == "result"
+    )
+    if not final_is_result:
+        raise ValueError(
+            "Generated code must assign the final output to `result` and end with a final line containing only `result` (do not stop after `result = ...`)."
+        )
+
+    has_result_assignment = any(
+        isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store) and node.id == "result"
+        for node in ast.walk(parsed)
     )
-    if not valid_final_await:
+    if not has_result_assignment:
         raise ValueError(
-            "Generated code must end with `await solve(query, max_calls)`."
+            "Generated code must assign the final output to `result` before the final `result` line."
         )
 
     for node in ast.walk(parsed):

Dockerfile

@@ -17,7 +17,7 @@ RUN uv pip install --system --no-cache \
     "fast-agent-mcp==0.6.1" \
     /tmp/wheels/prefab_ui-0.13.2.dev5+a585463-py3-none-any.whl \
     huggingface_hub \
-    "pydantic-monty==0.0.8"
+    "pydantic-monty==0.0.17"
 
 COPY --link ./ /app
 RUN chown -R 1000:1000 /app

scripts/prefab_hub_ui.py

@@ -778,6 +778,55 @@ def _build_user_profile_card(title: str, values: dict[str, Any]) -> dict[str, An
     }
 
 
+def _looks_like_user_list(rows: list[dict[str, Any]]) -> bool:
+    return bool(rows) and all(_looks_like_user_profile(row) for row in rows)
+
+
+def _build_user_grid_card(
+    title: str,
+    rows: list[dict[str, Any]],
+    *,
+    description: str | None = None,
+) -> dict[str, Any] | None:
+    cards = [
+        card
+        for row in rows
+        if isinstance(row, dict)
+        for card in [_build_user_profile_card(title, row)]
+        if card is not None
+    ]
+    if not cards:
+        return None
+
+    return {
+        "type": "Card",
+        "children": [
+            {
+                "type": "CardHeader",
+                "children": [
+                    {"type": "CardTitle", "content": title},
+                    *(
+                        [{"type": "CardDescription", "content": description}]
+                        if description
+                        else []
+                    ),
+                ],
+            },
+            {
+                "type": "CardContent",
+                "children": [
+                    {
+                        "type": "Grid",
+                        "gap": 4,
+                        "minColumnWidth": "18rem",
+                        "children": cards,
+                    }
+                ],
+            },
+        ],
+    }
+
+
 def _prefers_wide_layout(value: Any) -> bool:
     if isinstance(value, list):
         return bool(value) and all(isinstance(item, dict) for item in value)
@@ -1053,6 +1102,10 @@ def _render_list(
 
     if all(isinstance(item, dict) for item in value):
         rows = [item for item in value if isinstance(item, dict)]
+        if _looks_like_user_list(rows):
+            user_grid = _build_user_grid_card(title, rows, description=description)
+            if user_grid is not None:
+                return [user_grid]
         table_card = _build_table_card(title, rows, description=description)
         distribution_fields = _select_distribution_fields(rows)
         if distribution_fields is None: