Deploy hf-hub-query with runtime capabilities helper and budget prompt fix

_monty_codegen_shared.md

@@ -18,6 +18,7 @@ await solve(query, max_calls)
   - no `await solve(query, max_calls if ... else ...)`
   - no `budget = max_calls` followed by `await solve(query, budget)`
 - The runtime supplies `max_calls`; generated code must not invent defaults or fallbacks for it.
+- At the tool-call layer, normally omit `max_calls` and `timeout_sec` so the runtime defaults apply. Do **not** invent small explicit tool-call budgets like `10` or `20` for ordinary requests.
 - Use helper functions first. Use raw `call_api('/api/...')` only if no helper fits.
 - `call_api` must receive a raw path starting with `/api/...`; never call helper names through `call_api`.
 - Raw `call_api(...)` endpoints must match the runtime allowlist exactly. Do **not** invent hyphen/underscore variants or guessed path shapes.
@@ -25,6 +26,7 @@ await solve(query, max_calls)
 - `call_api(...)` only accepts `endpoint`, `params`, `method`, and `json_body`. Do not guess extra kwargs.
 - Use `call_api(...)` only for endpoint families that do not already have a helper, such as `/api/daily_papers` or tag metadata endpoints.
 - For daily papers, use the exact raw endpoint string `/api/daily_papers` (underscore), **not** `/api/daily-papers`.
+- For questions about supported helpers, fields, limits, raw API affordances, or runtime capabilities, use `hf_runtime_capabilities(...)` instead of hand-authoring a static answer from memory.
 - Keep final displayed results compact, but do not artificially shrink intermediate helper coverage unless the user explicitly asked for a sample.
 - Prefer canonical snake_case keys in generated code and in JSON output.
 - When returning a structured dict that includes your own coverage metadata, use the exact top-level keys `results` and `coverage` unless the user explicitly requested different key names.
@@ -63,6 +65,9 @@ Rules:
 - For bounded list/sample helpers in raw mode, returning the helper envelope directly preserves helper-owned `meta` fields.
 
 ## Routing guide
+### Runtime self-description
+- Supported fields / helper signatures / limits / raw API affordances → `hf_runtime_capabilities(...)`
+
 ### Repo questions
 - Exact `owner/name` details → `hf_repo_details(repo_type="auto", ...)`
 - Search/discovery/list/top repos → `hf_repo_search(...)`
@@ -173,6 +178,8 @@ Common aliases tolerated in `fields=[...]`:
 
 ## Helper API
 ```py
+await hf_runtime_capabilities(section: str | None = None)
+
 await hf_org_overview(organization: str)
 
 await hf_org_members(
@@ -310,6 +317,13 @@ return {
     "repo_url": item.get("repo_url"),
 }
 
+# Runtime capability / supported-field introspection
+caps = await hf_runtime_capabilities(section="fields")
+if not caps["ok"]:
+    return caps
+item = caps["item"] or (caps["items"][0] if caps["items"] else None)
+return item["content"]
+
 # Compact user summary
 summary = await hf_user_summary(
     username="mishig",

hf-hub-query.md

@@ -25,6 +25,7 @@ The user must never see your generated Python unless they explicitly ask for deb
 - Only ask a brief clarification question if the request is genuinely ambiguous or missing required identity.
 - The generated program must define `async def solve(query, max_calls): ...` and end with `await solve(query, max_calls)`.
 - Use the original user request, or a tight restatement, as the tool `query`.
+- Do **not** pass explicit `max_calls` or `timeout_sec` tool arguments unless the user explicitly asked for a non-default budget/timeout. Let the runtime defaults apply for ordinary requests.
 - One user request = one `hf_hub_query_raw` call. Do **not** retry in the same turn.
 
 ## Raw return rules

monty_api_tool_v2.py

@@ -14,6 +14,7 @@ import argparse
 import asyncio
 import ast
 import contextvars
+import inspect
 import json
 import os
 import re
@@ -152,6 +153,68 @@ _COLLECTION_FIELD_ALIASES: dict[str, str] = {
     "author": "owner",
 }
 
+REPO_CANONICAL_FIELDS: tuple[str, ...] = (
+    "repo_id",
+    "repo_type",
+    "title",
+    "author",
+    "likes",
+    "downloads",
+    "created_at",
+    "last_modified",
+    "pipeline_tag",
+    "repo_url",
+    "tags",
+    "library_name",
+    "description",
+    "paperswithcode_id",
+    "sdk",
+    "models",
+    "datasets",
+    "subdomain",
+)
+
+USER_CANONICAL_FIELDS: tuple[str, ...] = (
+    "username",
+    "fullname",
+    "bio",
+    "websiteUrl",
+    "twitter",
+    "github",
+    "linkedin",
+    "bluesky",
+    "followers",
+    "following",
+    "likes",
+    "isPro",
+)
+
+ACTOR_CANONICAL_FIELDS: tuple[str, ...] = (
+    "username",
+    "fullname",
+    "isPro",
+    "role",
+    "type",
+)
+
+ACTIVITY_CANONICAL_FIELDS: tuple[str, ...] = (
+    "event_type",
+    "repo_id",
+    "repo_type",
+    "timestamp",
+)
+
+COLLECTION_CANONICAL_FIELDS: tuple[str, ...] = (
+    "collection_id",
+    "slug",
+    "title",
+    "owner",
+    "owner_type",
+    "description",
+    "last_updated",
+    "item_count",
+)
+
 # 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
@@ -278,6 +341,7 @@ PAGINATION_POLICY: dict[str, dict[str, Any]] = {
 # Single source of truth for the public helper surface exposed to generated
 # Monty code. Keep runtime helper resolution derived from this tuple.
 HELPER_EXTERNALS = (
+    "hf_runtime_capabilities",
     "hf_whoami",
     "hf_org_overview",
     "hf_org_members",
@@ -1070,6 +1134,7 @@ async def _run_with_monty(
     trace: list[dict[str, Any]] = []
     limit_summaries: list[dict[str, Any]] = []
     latest_helper_error: dict[str, Any] | None = None
+    internal_helper_used = {"used": False}
     def _budget_remaining() -> int:
         return max(0, max_calls - call_count["n"])
 
@@ -3500,6 +3565,146 @@ async def _run_with_monty(
             repo_types=sorted(allowed_repo_types) if allowed_repo_types is not None else None,
         )
 
+    async def hf_runtime_capabilities(section: str | None = None) -> dict[str, Any]:
+        start_calls = call_count["n"]
+        internal_helper_used["used"] = True
+
+        def _render_annotation(annotation: Any) -> str:
+            if annotation is inspect.Signature.empty:
+                return "Any"
+            return str(annotation)
+
+        def _render_default(default: Any) -> str | None:
+            if default is inspect.Signature.empty:
+                return None
+            return repr(default)
+
+        def _signature_payload(fn: Callable[..., Any]) -> dict[str, Any]:
+            signature = inspect.signature(fn)
+            parameters: list[dict[str, Any]] = []
+            for parameter in signature.parameters.values():
+                item: dict[str, Any] = {
+                    "name": parameter.name,
+                    "kind": str(parameter.kind).replace("Parameter.", "").lower(),
+                    "annotation": _render_annotation(parameter.annotation),
+                    "required": parameter.default is inspect.Signature.empty,
+                }
+                default = _render_default(parameter.default)
+                if default is not None:
+                    item["default"] = default
+                parameters.append(item)
+            return {
+                "parameters": parameters,
+                "returns": _render_annotation(signature.return_annotation),
+            }
+
+        helper_payload = {
+            name: _signature_payload(fn)
+            for name, fn in sorted(helper_functions.items())
+        }
+
+        manifest: dict[str, Any] = {
+            "overview": {
+                "helper_count": len(helper_functions),
+                "supports_current_user": True,
+                "supports_raw_api_fallback": True,
+                "helper_result_envelope": {
+                    "ok": "bool",
+                    "item": "dict | None",
+                    "items": "list[dict]",
+                    "meta": "dict",
+                    "error": "str | None",
+                },
+                "raw_result_envelope": {
+                    "result": "Any",
+                    "meta": {
+                        "ok": "bool",
+                        "api_calls": "int",
+                        "elapsed_ms": "int",
+                        "limits_reached": "bool",
+                        "limit_summary": "list[dict]",
+                    },
+                },
+            },
+            "helpers": helper_payload,
+            "fields": {
+                "repo": list(REPO_CANONICAL_FIELDS),
+                "user": list(USER_CANONICAL_FIELDS),
+                "actor": list(ACTOR_CANONICAL_FIELDS),
+                "activity": list(ACTIVITY_CANONICAL_FIELDS),
+                "collection": list(COLLECTION_CANONICAL_FIELDS),
+            },
+            "aliases": {
+                "repo": dict(sorted(_REPO_FIELD_ALIASES.items())),
+                "user": dict(sorted(_USER_FIELD_ALIASES.items())),
+                "actor": dict(sorted(_ACTOR_FIELD_ALIASES.items())),
+                "collection": dict(sorted(_COLLECTION_FIELD_ALIASES.items())),
+                "sort_keys": dict(sorted(_SORT_KEY_ALIASES.items())),
+            },
+            "limits": {
+                "default_timeout_sec": DEFAULT_TIMEOUT_SEC,
+                "default_max_calls": DEFAULT_MAX_CALLS,
+                "max_calls_limit": MAX_CALLS_LIMIT,
+                "output_items_truncation_limit": OUTPUT_ITEMS_TRUNCATION_LIMIT,
+                "graph_scan_limit_cap": GRAPH_SCAN_LIMIT_CAP,
+                "likes_scan_limit_cap": LIKES_SCAN_LIMIT_CAP,
+                "recent_activity_scan_max_pages": RECENT_ACTIVITY_SCAN_MAX_PAGES,
+                "trending_endpoint_max_limit": TRENDING_ENDPOINT_MAX_LIMIT,
+                "pagination_policy": {
+                    helper_name: dict(sorted(policy.items()))
+                    for helper_name, policy in sorted(PAGINATION_POLICY.items())
+                },
+            },
+            "raw_api": {
+                "call_api": _signature_payload(call_api),
+                "allowed_methods": ["GET", "POST"],
+                "allowed_endpoint_patterns": list(ALLOWLIST_PATTERNS),
+                "helper_covered_endpoint_patterns": [
+                    {"pattern": pattern, "helper": helper_name}
+                    for pattern, helper_name in HELPER_COVERED_ENDPOINT_PATTERNS
+                ],
+            },
+            "repo_search": {
+                "sort_keys": {
+                    repo_type: sorted(keys)
+                    for repo_type, keys in sorted(_REPO_SORT_KEYS.items())
+                },
+                "extra_args": {
+                    repo_type: sorted(args)
+                    for repo_type, args in sorted(_REPO_SEARCH_EXTRA_ARGS.items())
+                },
+            },
+        }
+
+        allowed_sections = sorted(manifest)
+        requested = str(section or "").strip().lower()
+        if requested:
+            if requested not in manifest:
+                return _helper_error(
+                    start_calls=start_calls,
+                    source="internal://runtime-capabilities",
+                    error=f"Unsupported section {section!r}. Allowed sections: {allowed_sections}",
+                    section=section,
+                    allowed_sections=allowed_sections,
+                )
+            payload = {
+                "section": requested,
+                "content": manifest[requested],
+                "allowed_sections": allowed_sections,
+            }
+        else:
+            payload = {
+                "allowed_sections": allowed_sections,
+                **manifest,
+            }
+
+        return _helper_success(
+            start_calls=start_calls,
+            source="internal://runtime-capabilities",
+            items=[payload],
+            section=requested or None,
+        )
+
     m = pydantic_monty.Monty(
         code,
         inputs=["query", "max_calls"],
@@ -3545,6 +3750,13 @@ async def _run_with_monty(
         # code either returns that explicit helper error envelope or flattens it
         # into an empty fallback shape, preserve the helper-owned error instead
         # of replacing it with a generic zero-call runtime failure.
+        if internal_helper_used["used"]:
+            return {"output": _truncate_result_payload(result), "api_calls": call_count["n"], "trace": trace, "limit_summaries": limit_summaries}
+        if isinstance(result, dict) and result.get("ok") is True:
+            meta = result.get("meta") if isinstance(result.get("meta"), dict) else {}
+            source = meta.get("source")
+            if isinstance(source, str) and source.startswith("internal://"):
+                return {"output": _truncate_result_payload(result), "api_calls": call_count["n"], "trace": trace, "limit_summaries": limit_summaries}
         if latest_helper_error is not None:
             return {"output": _truncate_result_payload(latest_helper_error), "api_calls": call_count["n"], "trace": trace, "limit_summaries": limit_summaries}
         if isinstance(result, dict) and result.get("ok") is False and isinstance(result.get("error"), str):