diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..5ccba29564ee9745507a71632db8a99f745f7680 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,56 @@ +# API-only Space image: same backend/agent as the main Space, but the static +# frontend is the self-documenting API landing page (api-docs/) instead of the +# React chat UI β€” no Node build stage needed. +FROM python:3.12-slim + +# Install uv directly from official image +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ + +# Create user with UID 1000 (required for HF Spaces) +RUN useradd -m -u 1000 user + +WORKDIR /app + +# Install system dependencies +RUN apt-get update && apt-get install -y --no-install-recommends \ + git \ + curl \ + && rm -rf /var/lib/apt/lists/* + +# Copy dependency files +COPY pyproject.toml uv.lock ./ + +# Install dependencies into /app/.venv +# Use --frozen to ensure exact versions from uv.lock +RUN uv sync --no-dev --frozen + +# Copy application code +COPY agent/ ./agent/ +COPY backend/ ./backend/ +COPY configs/ ./configs/ + +# Static self-documenting API landing page (served at /) +COPY api-docs/ ./static/ + +# Create directories and set ownership +RUN mkdir -p /app/session_logs && \ + chown -R user:user /app + +# Switch to non-root user +USER user + +# Set environment. REQUIRE_API_AUTH: this Space has no HF OAuth app, so force +# Bearer-token auth on β€” without it the backend would fall back to the +# dev-mode identity and act as the server's own HF_TOKEN for every caller. +ENV HOME=/home/user \ + PYTHONUNBUFFERED=1 \ + PYTHONPATH=/app \ + PATH="/app/.venv/bin:$PATH" \ + REQUIRE_API_AUTH=1 + +# Expose port +EXPOSE 7860 + +# Run the application from backend directory +WORKDIR /app/backend +CMD ["bash", "start.sh"] diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index 7c7a5d0c527cd1ec304a16bbc36676984e8ffee0..469564944eb522d77c0cf2218c4b1ea9e3edfd17 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,28 @@ --- -title: Ml Intern Api -emoji: 🐠 -colorFrom: red -colorTo: purple +title: ML Intern API +emoji: πŸ›°οΈ +colorFrom: yellow +colorTo: gray sdk: docker +app_port: 7860 pinned: false +license: apache-2.0 +short_description: OpenAI-compatible API for the ML Intern agent --- -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +# ML Intern API + +OpenAI Responses-API-compatible HTTP API for [ML Intern](https://huggingface.co/spaces/smolagents/ml-intern): +send a task with your Hugging Face token as a Bearer header, the agent +researches/codes/launches HF Jobs under **your** namespace, and streams +results + artifacts (trackio dashboards, jobs, models) over resumable SSE. + +The Space root serves the interactive API documentation. Endpoints live +under `/v1` β€” start at `POST /v1/responses`. + +Source: https://github.com/huggingface/ml-intern (see `docs/API.md`). + +Optional Space secrets: +- `MONGODB_URI` (+ `MONGODB_DB`) β€” durable event replay, reconnects, and + restart recovery. Without it, response tracking is in-memory only. +- `HF_TOKEN` β€” server-side fallbacks such as session trace uploads. diff --git a/agent/README.md b/agent/README.md new file mode 100644 index 0000000000000000000000000000000000000000..567ce033d000d9907f879ccaaf3ace2b8bd77993 --- /dev/null +++ b/agent/README.md @@ -0,0 +1,21 @@ +# Agent + +Async agent loop with LiteLLM. + +## Architecture + +**Queue-based async system:** +- Submissions in (user input) β†’ Agent Loop β†’ Events output for possible UI updates +- Session maintains state (context + tools) for possible future Context Engineering +- Handlers operations like (USER_INPUT, COMPACT, UNDO, SHUTDOWN) for possible UI control + +## Components + +| Component | Purpose | Long Term Goal | +|-----------|---------|----------------| +| **`agent_loop.py`** | Core agentic loop: processes user input, calls LLM via LiteLLM, executes tool calls iteratively until completion, emits events | Support parallel tool execution, streaming responses, and advanced reasoning patterns | +| **`session.py`** | Maintains session state and interaction with potential UI (context, config, event queue), handles interrupts, assigns unique session IDs for tracing | Enable plugging in different UIs (CLI, web, API, programmatic etc.) | +| **`tools.py`** | `ToolRouter` manages potential built-in tools (e.g. bash, read_file, write_file which are dummy implementations rn) + MCP tools, converts specs to OpenAI format | Be the place for tools that can be used by the agent. All crazy tool design happens here. | +| **`context_manager/`** | Manages conversation history, very rudimentary context engineering support | Implement intelligent context engineering to keep the agent on track | +| **`config.py`** | Loads JSON config for the agent | Support different configs etc. | +| **`main.py`** | Interactive CLI with async queue architecture (submissionβ†’agent, agentβ†’events) (simple way to interact with the agent now)| Serve as reference implementation for other UIs (web, API, programmatic) | diff --git a/agent/__init__.py b/agent/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0e4cf34cd240ebdb4bcefb7752cb8074a9f5244c --- /dev/null +++ b/agent/__init__.py @@ -0,0 +1,19 @@ +""" +HF Agent - Main agent module +""" + +import litellm + +# Global LiteLLM behavior β€” set once at package import so both CLI and +# backend entries share the same config. +# drop_params: quietly drop unsupported params rather than raising +# suppress_debug_info: hide the noisy "Give Feedback" banner on errors +# modify_params: let LiteLLM patch provider-specific schema requirements +# for router-compatible request bodies when possible. +litellm.drop_params = True +litellm.suppress_debug_info = True +litellm.modify_params = True + +from agent.core.agent_loop import submission_loop # noqa: E402 + +__all__ = ["submission_loop"] diff --git a/agent/config.py b/agent/config.py new file mode 100644 index 0000000000000000000000000000000000000000..c6784db92d0100f033cf497806e7803fcbac8109 --- /dev/null +++ b/agent/config.py @@ -0,0 +1,221 @@ +import json +import os +import re +from pathlib import Path +from typing import Any, Literal, Union + +from dotenv import load_dotenv +from fastmcp.mcp_config import ( + RemoteMCPServer, + StdioMCPServer, +) +from pydantic import BaseModel + +from agent.messaging.models import MessagingConfig + +# These two are the canonical server config types for MCP servers. +MCPServerConfig = Union[StdioMCPServer, RemoteMCPServer] + +# Project root: two levels up from this file (agent/config.py -> project root) +_PROJECT_ROOT = Path(__file__).resolve().parent.parent + + +class Config(BaseModel): + """Configuration manager""" + + model_name: str + mcpServers: dict[str, MCPServerConfig] = {} + save_sessions: bool = True + session_dataset_repo: str = "smolagents/ml-intern-sessions" + # Per-user private dataset that mirrors each session in Claude Code JSONL + # format so the HF Agent Trace Viewer auto-renders it + # (https://huggingface.co/changelog/agent-trace-viewer). Created private + # on first use; user flips it public via /share-traces. ``{hf_user}`` is + # substituted at upload time from the authenticated HF username. + share_traces: bool = True + personal_trace_repo_template: str = "{hf_user}/ml-intern-sessions" + auto_save_interval: int = 1 # Save every N user turns (0 = disabled) + # Mid-turn heartbeat: save + upload every N seconds while events are being + # emitted. Guards against losing trace data on long-running turns that + # crash before turn_complete (e.g. a multi-hour hf_jobs wait that OOMs). + # 0 = disabled. Consumed by agent.core.telemetry.HeartbeatSaver. + heartbeat_interval_s: int = 60 + yolo_mode: bool = False # Auto-approve all tool calls without confirmation + max_iterations: int = 300 # Max LLM calls per agent turn (-1 = unlimited) + + # Permission control parameters + confirm_cpu_jobs: bool = True + auto_file_upload: bool = False + tool_runtime: Literal["local", "sandbox"] = "local" + + # Reasoning effort *preference* β€” the ceiling the user wants. The probe + # on `/model` walks a cascade down from here (``max`` β†’ ``xhigh`` β†’ ``high`` + # β†’ …) and caches per-model what the provider actually accepted in + # ``Session.model_effective_effort``. Default ``high`` because HF Router + # accepts low/medium/high generically and provider-specific higher levels + # should be discovered through explicit probes. ``None`` = thinking off. + # Valid values: None | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" + reasoning_effort: str | None = "high" + messaging: MessagingConfig = MessagingConfig() + + +USER_CONFIG_ENV_VAR = "ML_INTERN_CLI_CONFIG" +DEFAULT_USER_CONFIG_PATH = ( + Path.home() / ".config" / "ml-intern" / "cli_agent_config.json" +) +SLACK_DEFAULT_DESTINATION = "slack.default" +SLACK_DEFAULT_AUTO_EVENT_TYPES = ["approval_required", "error", "turn_complete"] + + +def _deep_merge_config( + base: dict[str, Any], override: dict[str, Any] +) -> dict[str, Any]: + merged = dict(base) + for key, value in override.items(): + current = merged.get(key) + if isinstance(current, dict) and isinstance(value, dict): + merged[key] = _deep_merge_config(current, value) + else: + merged[key] = value + return merged + + +def _load_json_config(path: Path) -> dict[str, Any]: + with open(path, "r", encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"Config file {path} must contain a JSON object") + return data + + +def _load_user_config() -> dict[str, Any]: + raw_path = os.environ.get(USER_CONFIG_ENV_VAR) + if raw_path: + path = Path(raw_path).expanduser() + if not path.exists(): + raise FileNotFoundError( + f"{USER_CONFIG_ENV_VAR} points to missing config file: {path}" + ) + return _load_json_config(path) + + if DEFAULT_USER_CONFIG_PATH.exists(): + return _load_json_config(DEFAULT_USER_CONFIG_PATH) + return {} + + +def _env_bool(name: str, default: bool) -> bool: + value = os.environ.get(name) + if value is None: + return default + normalized = value.strip().lower() + if normalized in {"1", "true", "yes", "on"}: + return True + if normalized in {"0", "false", "no", "off"}: + return False + return default + + +def _env_list(name: str) -> list[str] | None: + value = os.environ.get(name) + if value is None: + return None + return [item.strip() for item in value.split(",") if item.strip()] + + +def apply_slack_user_defaults(raw_config: dict[str, Any]) -> dict[str, Any]: + """Enable a default Slack destination from user env vars, when present.""" + if not _env_bool("ML_INTERN_SLACK_NOTIFICATIONS", True): + return raw_config + + token = os.environ.get("SLACK_BOT_TOKEN") + channel = os.environ.get("SLACK_CHANNEL_ID") or os.environ.get("SLACK_CHANNEL") + if not token or not channel: + return raw_config + + config = dict(raw_config) + messaging = dict(config.get("messaging") or {}) + destinations = dict(messaging.get("destinations") or {}) + destination_name = ( + os.environ.get("ML_INTERN_SLACK_DESTINATION") or SLACK_DEFAULT_DESTINATION + ).strip() + + if destination_name not in destinations: + destinations[destination_name] = { + "provider": "slack", + "token": token, + "channel": channel, + "allow_agent_tool": _env_bool("ML_INTERN_SLACK_ALLOW_AGENT_TOOL", True), + "allow_auto_events": _env_bool("ML_INTERN_SLACK_ALLOW_AUTO_EVENTS", True), + } + + auto_events = _env_list("ML_INTERN_SLACK_AUTO_EVENTS") + if auto_events is not None: + messaging["auto_event_types"] = auto_events + elif "auto_event_types" not in messaging: + messaging["auto_event_types"] = SLACK_DEFAULT_AUTO_EVENT_TYPES + + messaging["enabled"] = True + messaging["destinations"] = destinations + config["messaging"] = messaging + return config + + +def substitute_env_vars(obj: Any) -> Any: + """ + Recursively substitute environment variables in any data structure. + + Supports ${VAR_NAME} syntax for required variables and ${VAR_NAME:-default} for optional. + """ + if isinstance(obj, str): + pattern = r"\$\{([^}:]+)(?::(-)?([^}]*))?\}" + + def replacer(match): + var_name = match.group(1) + has_default = match.group(2) is not None + default_value = match.group(3) if has_default else None + + env_value = os.environ.get(var_name) + + if env_value is not None: + return env_value + elif has_default: + return default_value or "" + else: + raise ValueError( + f"Environment variable '{var_name}' is not set. " + f"Add it to your .env file." + ) + + return re.sub(pattern, replacer, obj) + + elif isinstance(obj, dict): + return {key: substitute_env_vars(value) for key, value in obj.items()} + + elif isinstance(obj, list): + return [substitute_env_vars(item) for item in obj] + + return obj + + +def load_config( + config_path: str = "config.json", + include_user_defaults: bool = False, +) -> Config: + """ + Load configuration with environment variable substitution. + + Use ${VAR_NAME} in your JSON for any secret. + Automatically loads from .env file. + """ + # Load .env from project root first (so it works from any directory), + # then CWD .env can override if present + load_dotenv(_PROJECT_ROOT / ".env") + load_dotenv(override=False) + + raw_config = _load_json_config(Path(config_path)) + if include_user_defaults: + raw_config = _deep_merge_config(raw_config, _load_user_config()) + raw_config = apply_slack_user_defaults(raw_config) + + config_with_env = substitute_env_vars(raw_config) + return Config.model_validate(config_with_env) diff --git a/agent/context_manager/__init__.py b/agent/context_manager/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3cc692b6ba457c922a83f012fa4503a211737c3d --- /dev/null +++ b/agent/context_manager/__init__.py @@ -0,0 +1,7 @@ +""" +Context manager for handling conversation history +""" + +from agent.context_manager.manager import ContextManager + +__all__ = ["ContextManager"] diff --git a/agent/context_manager/manager.py b/agent/context_manager/manager.py new file mode 100644 index 0000000000000000000000000000000000000000..f0c909a0de4a70dda4fdb6cb21cf5d17d5dcc82a --- /dev/null +++ b/agent/context_manager/manager.py @@ -0,0 +1,643 @@ +""" +Context management for conversation history +""" + +import logging +import time +import zoneinfo +from datetime import datetime +from pathlib import Path +from typing import Any + +import yaml +from jinja2 import Template +from litellm import Message, acompletion + +from agent.core.prompt_caching import ( + router_session_id_for, + with_prompt_cache_params, + with_prompt_caching, +) + +logger = logging.getLogger(__name__) + +_HF_WHOAMI_URL = "https://huggingface.co/api/whoami-v2" +_HF_WHOAMI_TIMEOUT = 5 # seconds + + +def _get_hf_username(hf_token: str | None = None) -> str: + """Return the HF username for the given token. + + Uses subprocess + curl to avoid Python HTTP client IPv6 issues that + cause 40+ second hangs (httpx/urllib try IPv6 first which times out + at OS level before falling back to IPv4 β€” the "Happy Eyeballs" problem). + """ + import json + import subprocess + import time as _t + + if not hf_token: + logger.warning("No hf_token provided, using 'unknown' as username") + return "unknown" + + t0 = _t.monotonic() + try: + result = subprocess.run( + [ + "curl", + "-s", + "-4", # force IPv4 + "-m", + str(_HF_WHOAMI_TIMEOUT), # max time + "-H", + f"Authorization: Bearer {hf_token}", + _HF_WHOAMI_URL, + ], + capture_output=True, + text=True, + timeout=_HF_WHOAMI_TIMEOUT + 2, + ) + t1 = _t.monotonic() + if result.returncode == 0 and result.stdout: + data = json.loads(result.stdout) + username = data.get("name", "unknown") + logger.info(f"HF username resolved to '{username}' in {t1 - t0:.2f}s") + return username + else: + logger.warning( + f"curl whoami failed (rc={result.returncode}) in {t1 - t0:.2f}s" + ) + return "unknown" + except Exception as e: + t1 = _t.monotonic() + logger.warning(f"HF whoami failed in {t1 - t0:.2f}s: {e}") + return "unknown" + + +_COMPACT_PROMPT = ( + "Please provide a concise summary of the conversation above, focusing on " + "key decisions, the 'why' behind the decisions, problems solved, and " + "important context needed for developing further. Your summary will be " + "given to someone who has never worked on this project before and they " + "will be have to be filled in." +) + +# Per-message ceiling. If a single message in the "untouched" tail is larger +# than this, compaction can't recover even after summarizing the middle β€” +# producing the infinite compaction loop seen 2026-05-03 in pod logs (200k +# context shrinks to 200k+ because one tool output is 80k tokens). We replace +# such messages with a placeholder before compaction runs. +_MAX_TOKENS_PER_MESSAGE = 50_000 + + +class CompactionFailedError(Exception): + """Raised when compaction can't reduce context below the threshold. + + Typically means an individual preserved message (system, first user, or + untouched tail) exceeds what truncation can fix in one pass. The caller + must terminate the session; retrying produces an infinite loop that burns + hosted inference budget. + """ + + +# Used when seeding a brand-new session from prior browser-cached messages. +# Here we're writing a note to *ourselves* β€” so preserve the tool-call trail, +# files produced, and planned next steps in first person. Optimized for +# continuity, not brevity. +_RESTORE_PROMPT = ( + "You're about to be restored into a fresh session with no memory of the " + "conversation above. Write a first-person note to your future self so " + "you can continue right where you left off. Include:\n" + " β€’ What the user originally asked for and what progress you've made.\n" + " β€’ Every tool you called, with arguments and a one-line result summary.\n" + " β€’ Any code, files, scripts, or artifacts you produced (with paths).\n" + " β€’ Key decisions and the reasoning behind them.\n" + " β€’ What you were planning to do next.\n\n" + "Don't be cute. Be specific. This is the only context you'll have." +) + + +async def summarize_messages( + messages: list[Message], + model_name: str, + hf_token: str | None = None, + max_tokens: int = 2000, + tool_specs: list[dict] | None = None, + prompt: str = _COMPACT_PROMPT, + session: Any = None, + kind: str = "compaction", +) -> tuple[str, int]: + """Run a summarization prompt against a list of messages. + + ``prompt`` defaults to the compaction prompt (terse, decision-focused). + Callers seeding a new session after a restart should pass ``_RESTORE_PROMPT`` + instead β€” it preserves the tool-call trail so the agent can answer + follow-up questions about what it did. + + ``session`` is optional; when provided, the call is recorded via + ``telemetry.record_llm_call`` so its cost lands in the session's + ``total_cost_usd``. Without it, the call still happens but is + invisible in telemetry, which used to hide a significant share of hosted + inference spend. + + Returns ``(summary_text, completion_tokens)``. + """ + from agent.core.llm_params import _resolve_llm_params + + prompt_messages = list(messages) + [Message(role="user", content=prompt)] + llm_params = _resolve_llm_params( + model_name, + hf_token, + reasoning_effort="high", + ) + llm_params = with_prompt_cache_params( + llm_params, + session_id=router_session_id_for(session), + ) + llm_params = {**llm_params, "max_completion_tokens": max_tokens} + prompt_messages, tool_specs = with_prompt_caching( + prompt_messages, tool_specs, llm_params + ) + _t0 = time.monotonic() + response = await acompletion( + messages=prompt_messages, + tools=tool_specs, + **llm_params, + ) + if session is not None: + from agent.core import telemetry + from agent.core.yolo_budget import maybe_pause_yolo_after_spend + + usage = await telemetry.record_llm_call( + session, + model=model_name, + response=response, + latency_ms=int((time.monotonic() - _t0) * 1000), + finish_reason=response.choices[0].finish_reason + if response.choices + else None, + kind=kind, + ) + await maybe_pause_yolo_after_spend( + session, + spend_kind=kind, + observed_cost_usd=usage.get("cost_usd") + if isinstance(usage, dict) + else None, + ) + summary = response.choices[0].message.content or "" + completion_tokens = response.usage.completion_tokens if response.usage else 0 + return summary, completion_tokens + + +class ContextManager: + """Manages conversation context and message history for the agent""" + + def __init__( + self, + model_max_tokens: int = 180_000, + compact_size: float = 0.1, + untouched_messages: int = 5, + tool_specs: list[dict[str, Any]] | None = None, + prompt_file_suffix: str = "system_prompt_v3.yaml", + hf_token: str | None = None, + local_mode: bool = False, + ): + self.prompt_file_suffix = prompt_file_suffix + self.tool_specs = tool_specs or [] + self.hf_token = hf_token + self.local_mode = local_mode + self.system_prompt = self._load_system_prompt( + self.tool_specs, + prompt_file_suffix=self.prompt_file_suffix, + hf_token=hf_token, + local_mode=local_mode, + ) + # The model's real input-token ceiling (from litellm.get_model_info). + # Compaction triggers at _COMPACT_THRESHOLD_RATIO below it β€” see + # the compaction_threshold property. + self.model_max_tokens = model_max_tokens + self.compact_size = int(model_max_tokens * compact_size) + # Running count of tokens the last LLM call reported. Drives the + # compaction gate; updated in add_message() with each response's + # usage.total_tokens. + self.running_context_usage = 0 + self.untouched_messages = untouched_messages + self.items: list[Message] = [Message(role="system", content=self.system_prompt)] + self.on_message_added = None + + def refresh_system_prompt( + self, + *, + tool_specs: list[dict[str, Any]] | None = None, + hf_token: str | None = None, + local_mode: bool | None = None, + ) -> Message: + """Re-render the system prompt and return it as a system message.""" + if tool_specs is not None: + self.tool_specs = tool_specs + if hf_token is not None: + self.hf_token = hf_token + if local_mode is not None: + self.local_mode = local_mode + self.system_prompt = self._load_system_prompt( + self.tool_specs, + prompt_file_suffix=getattr( + self, "prompt_file_suffix", "system_prompt_v3.yaml" + ), + hf_token=getattr(self, "hf_token", None), + local_mode=getattr(self, "local_mode", False), + ) + return Message(role="system", content=self.system_prompt) + + def _load_system_prompt( + self, + tool_specs: list[dict[str, Any]], + prompt_file_suffix: str = "system_prompt.yaml", + hf_token: str | None = None, + local_mode: bool = False, + ): + """Load and render the system prompt from YAML file with Jinja2""" + prompt_file = Path(__file__).parent.parent / "prompts" / f"{prompt_file_suffix}" + + with open(prompt_file, "r") as f: + prompt_data = yaml.safe_load(f) + template_str = prompt_data.get("system_prompt", "") + + # Get current date and time + tz = zoneinfo.ZoneInfo("Europe/Paris") + now = datetime.now(tz) + current_date = now.strftime("%d-%m-%Y") + current_time = now.strftime("%H:%M:%S.%f")[:-3] + current_timezone = f"{now.strftime('%Z')} (UTC{now.strftime('%z')[:3]}:{now.strftime('%z')[3:]})" + + # Get HF user info from OAuth token + hf_user_info = _get_hf_username(hf_token) + + template = Template(template_str) + static_prompt = template.render( + tools=tool_specs, + num_tools=len(tool_specs), + ) + + # CLI-specific context for local mode + if local_mode: + import os + + cwd = os.getcwd() + local_context = ( + f"\n\n# CLI / Local mode\n\n" + f"You are running as a local CLI tool on the user's machine. " + f"There is NO sandbox β€” bash, read, write, and edit operate directly " + f"on the local filesystem.\n\n" + f"Working directory: {cwd}\n" + f"Use absolute paths or paths relative to the working directory. " + f"Do NOT use /app/ paths β€” that is a sandbox convention that does not apply here.\n" + f"The sandbox_create tool is NOT available. Run code directly with bash." + ) + static_prompt += local_context + + return ( + f"{static_prompt}\n\n" + f"[Session context: Date={current_date}, Time={current_time}, " + f"Timezone={current_timezone}, User={hf_user_info}, " + f"Tools={len(tool_specs)}]" + ) + + def add_message(self, message: Message, token_count: int = None) -> None: + """Add a message to the history""" + if token_count: + self.running_context_usage = token_count + self.items.append(message) + if self.on_message_added: + self.on_message_added(message) + + def get_messages(self) -> list[Message]: + """Get all messages for sending to LLM. + + Patches any dangling tool_calls (assistant messages with tool_calls + that have no matching tool-result message) so the LLM API doesn't + reject the request. + """ + self._patch_dangling_tool_calls() + return self.items + + @staticmethod + def _normalize_tool_calls(msg: Message) -> None: + """Ensure msg.tool_calls contains proper ToolCall objects, not dicts. + + litellm's Message has validate_assignment=False (Pydantic v2 default), + so direct attribute assignment (e.g. inside litellm's streaming handler) + can leave raw dicts. Re-assigning via the constructor fixes this. + """ + from litellm import ChatCompletionMessageToolCall as ToolCall + + tool_calls = getattr(msg, "tool_calls", None) + if not tool_calls: + return + needs_fix = any(isinstance(tc, dict) for tc in tool_calls) + if not needs_fix: + return + msg.tool_calls = [ + tc if not isinstance(tc, dict) else ToolCall(**tc) for tc in tool_calls + ] + + def _patch_dangling_tool_calls(self) -> None: + """Add stub tool results for any tool_calls that lack a matching result. + + Ensures each assistant message's tool_calls are followed immediately + by matching tool-result messages. This has to work across the whole + history, not just the most recent turn, because a cancelled tool use + in an earlier turn can still poison the next provider request. + """ + if not self.items: + return + + i = 0 + while i < len(self.items): + msg = self.items[i] + if getattr(msg, "role", None) != "assistant" or not getattr( + msg, "tool_calls", None + ): + i += 1 + continue + + self._normalize_tool_calls(msg) + + # Consume the contiguous tool-result block that immediately follows + # this assistant message. Any missing tool ids must be inserted + # before the next non-tool message to satisfy provider ordering. + j = i + 1 + immediate_ids: set[str | None] = set() + while ( + j < len(self.items) and getattr(self.items[j], "role", None) == "tool" + ): + immediate_ids.add(getattr(self.items[j], "tool_call_id", None)) + j += 1 + + missing: list[Message] = [] + for tc in msg.tool_calls: + if tc.id not in immediate_ids: + missing.append( + Message( + role="tool", + content="Tool was not executed (interrupted or error).", + tool_call_id=tc.id, + name=tc.function.name, + ) + ) + + if missing: + self.items[j:j] = missing + j += len(missing) + + i = j + + def undo_last_turn(self) -> bool: + """Remove the last complete turn (user msg + all assistant/tool msgs that follow). + + Pops from the end until the last user message is removed, keeping the + tool_use/tool_result pairing valid. Never removes the system message. + + Returns True if a user message was found and removed. + """ + if len(self.items) <= 1: + return False + + while len(self.items) > 1: + msg = self.items.pop() + if getattr(msg, "role", None) == "user": + return True + + return False + + def truncate_to_user_message(self, user_message_index: int) -> bool: + """Truncate history to just before the Nth user message (0-indexed). + + Removes that user message and everything after it. + System message (index 0) is never removed. + + Returns True if the target user message was found and removed. + """ + count = 0 + for i, msg in enumerate(self.items): + if i == 0: + continue # skip system message + if getattr(msg, "role", None) == "user": + if count == user_message_index: + self.items = self.items[:i] + return True + count += 1 + return False + + # Compaction fires at 90% of model_max_tokens so there's headroom for + # the next turn's prompt + response before we actually hit the ceiling. + _COMPACT_THRESHOLD_RATIO = 0.9 + + @property + def compaction_threshold(self) -> int: + """Token count at which `compact()` kicks in.""" + return int(self.model_max_tokens * self._COMPACT_THRESHOLD_RATIO) + + @property + def needs_compaction(self) -> bool: + return self.running_context_usage > self.compaction_threshold and bool( + self.items + ) + + def _truncate_oversized( + self, messages: list[Message], model_name: str + ) -> list[Message]: + """Replace any message > _MAX_TOKENS_PER_MESSAGE with a placeholder. + + These are typically tool outputs (CSV dumps, file contents) sitting in + the untouched tail or first-user position that compaction can't shrink + β€” they pass through verbatim, keeping context above threshold and + triggering an infinite compaction retry loop. + """ + from litellm import token_counter + + out: list[Message] = [] + for msg in messages: + # System messages are sacred β€” they're the agent's instructions. + # In edge cases (items < untouched_messages), the slice math in + # compact() can let items[0] (the system message) leak into the + # recent_messages list. Defense-in-depth: never truncate it. + if msg.role == "system": + out.append(msg) + continue + try: + n = token_counter(model=model_name, messages=[msg.model_dump()]) + except Exception: + # token_counter occasionally fails on edge-case content; + # don't drop the message, just keep it as-is. + out.append(msg) + continue + if n <= _MAX_TOKENS_PER_MESSAGE: + out.append(msg) + continue + placeholder = ( + f"[truncated for compaction β€” original was {n} tokens, " + f"removed to keep context under {self.compaction_threshold} tokens]" + ) + logger.warning( + "Truncating %s message: %d -> %d tokens for compaction", + msg.role, + n, + len(placeholder) // 4, + ) + # Preserve all known assistant-side fields (tool_calls, thinking_blocks, + # reasoning_content, provider_specific_fields) even when content is + # replaced. Historical traces may still contain provider reasoning + # metadata, and truncation should not silently discard it. + kept = { + k: getattr(msg, k, None) + for k in ( + "tool_call_id", + "tool_calls", + "name", + "thinking_blocks", + "reasoning_content", + "provider_specific_fields", + ) + if getattr(msg, k, None) is not None + } + out.append(Message(role=msg.role, content=placeholder, **kept)) + return out + + def _recompute_usage(self, model_name: str) -> None: + """Refresh ``running_context_usage`` from current items via real tokenizer.""" + from litellm import token_counter + + try: + self.running_context_usage = token_counter( + model=model_name, + messages=[m.model_dump() for m in self.items], + ) + except Exception as e: + logger.warning("token_counter failed (%s); rough estimate", e) + # Rough fallback: 4 chars per token. + self.running_context_usage = ( + sum(len(getattr(m, "content", "") or "") for m in self.items) // 4 + ) + + async def compact( + self, + model_name: str, + tool_specs: list[dict] | None = None, + hf_token: str | None = None, + session: Any = None, + ) -> None: + """Remove old messages to keep history under target size. + + ``session`` is optional β€” if passed, the underlying summarization + LLM call is recorded via ``telemetry.record_llm_call(kind= + "compaction")`` so its cost shows up in ``total_cost_usd``. + + Raises ``CompactionFailedError`` if the post-compact context is still + over the threshold. This happens when a preserved message (typically + a giant tool output stuck in the untouched tail) is too large for + truncation to fix. The caller must terminate the session β€” retrying + is what caused the 2026-05-03 infinite-compaction-loop pattern that + burned hosted inference budget invisibly. + """ + if not self.needs_compaction: + return + + system_msg = ( + self.items[0] if self.items and self.items[0].role == "system" else None + ) + + # Preserve the first user message (task prompt) β€” never summarize it + first_user_msg = None + first_user_idx = 1 + for i in range(1, len(self.items)): + if getattr(self.items[i], "role", None) == "user": + first_user_msg = self.items[i] + first_user_idx = i + break + + # Don't summarize a certain number of just-preceding messages + # Walk back to find a user message to make sure we keep an assistant -> user -> + # assistant general conversation structure + idx = len(self.items) - self.untouched_messages + while idx > 1 and self.items[idx].role != "user": + idx -= 1 + # The real invariant is "idx must be strictly after first_user_idx, + # otherwise recent_messages overlaps with the messages we put in + # head". The walk-back's `idx > 1` guard is necessary (no system in + # recent) but insufficient (first_user is also in head and would be + # duplicated). Chat providers can reject two consecutive user messages + # with a 400 β€” bot review on PR #213 caught this on the second clamp + # iteration. + if idx <= first_user_idx: + idx = first_user_idx + 1 + + recent_messages = self.items[idx:] + messages_to_summarize = self.items[first_user_idx + 1 : idx] + + # Truncate any message that's larger than _MAX_TOKENS_PER_MESSAGE in + # the parts we PRESERVE through compaction (first_user + recent_tail). + # These are the only places where individual messages can defeat + # compaction by being intrinsically too large. Messages in + # ``messages_to_summarize`` are folded into the summary, so their size + # doesn't matter on its own. + if first_user_msg is not None: + truncated = self._truncate_oversized([first_user_msg], model_name) + first_user_msg = truncated[0] + recent_messages = self._truncate_oversized(recent_messages, model_name) + + # If there's nothing to summarize but the preserved messages are now + # truncated and small, just rebuild and recompute. This is rare but + # avoids returning silently with the old (over-threshold) state. + if not messages_to_summarize: + head = [system_msg] if system_msg else [] + if first_user_msg: + head.append(first_user_msg) + self.items = head + recent_messages + self._recompute_usage(model_name) + if self.running_context_usage > self.compaction_threshold: + raise CompactionFailedError( + f"Nothing to summarize but context ({self.running_context_usage}) " + f"still over threshold ({self.compaction_threshold}) after truncation. " + f"System prompt or first user message likely exceeds the budget." + ) + return + + summary, completion_tokens = await summarize_messages( + messages_to_summarize, + model_name=model_name, + hf_token=hf_token, + max_tokens=self.compact_size, + tool_specs=tool_specs, + prompt=_COMPACT_PROMPT, + session=session, + kind="compaction", + ) + summarized_message = Message( + role="assistant", + content=summary, + ) + + # Reconstruct: system + first user msg + summary + recent messages + head = [system_msg] if system_msg else [] + if first_user_msg: + head.append(first_user_msg) + self.items = head + [summarized_message] + recent_messages + + self._recompute_usage(model_name) + + # Hard verify: if compaction didn't bring us below the threshold even + # after truncating oversized preserved messages, retrying just burns + # hosted inference budget on the same useless compaction call. Raise so the + # caller can terminate the session cleanly. Pre-2026-05-04, the + # caller looped indefinitely (~$3/Opus retry) until the pod was + # killed β€” invisible to the dataset because the session never + # finished cleanly. + if self.running_context_usage > self.compaction_threshold: + raise CompactionFailedError( + f"Compaction ineffective: {self.running_context_usage} tokens " + f"still over threshold {self.compaction_threshold} after summarize " + f"and truncation. Likely the system prompt + first user + summary " + f"+ truncated tail still exceeds budget." + ) diff --git a/agent/core/__init__.py b/agent/core/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6dc5781d631766c6b3fae6b3fa09d4dbcf3a3190 --- /dev/null +++ b/agent/core/__init__.py @@ -0,0 +1,12 @@ +""" +Core agent implementation +Contains the main agent logic, decision-making, and orchestration +""" + +from agent.core.tools import ToolRouter, ToolSpec, create_builtin_tools + +__all__ = [ + "ToolRouter", + "ToolSpec", + "create_builtin_tools", +] diff --git a/agent/core/agent_loop.py b/agent/core/agent_loop.py new file mode 100644 index 0000000000000000000000000000000000000000..6ed3a4e33d8b8097af222c7178e31ded74da9782 --- /dev/null +++ b/agent/core/agent_loop.py @@ -0,0 +1,2645 @@ +"""loop +Main agent implementation with integrated tool system and MCP support +""" + +import asyncio +import json +import logging +import time +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + +from litellm import ( + ChatCompletionMessageToolCall, + Message, + acompletion, +) +from litellm.exceptions import ContextWindowExceededError + +from agent.config import Config +from agent.core.approval_policy import ( + is_scheduled_operation, + normalize_tool_operation, +) +from agent.core.cost_estimation import CostEstimate, estimate_tool_cost +from agent.messaging.gateway import NotificationGateway +from agent.core import telemetry +from agent.core.doom_loop import check_for_doom_loop +from agent.core.hf_access import ( + HF_BILLING_URL, + HF_PRO_SUBSCRIBE_URL, + is_inference_billing_error, +) +from agent.core.llm_params import _resolve_llm_params +from agent.core.prompt_caching import ( + router_session_id_for, + with_prompt_cache_params, + with_prompt_caching, +) +from agent.core.session import DEFAULT_SESSION_LOG_DIR, Event, OpType, Session +from agent.core.tools import ToolRouter +from agent.core.usage_thresholds import ( + USAGE_THRESHOLD_TOOL_NAME, + is_usage_threshold_pending, + next_usage_warning_threshold, +) +from agent.core.yolo_budget import ( + BudgetDecision, + check_session_budget, + is_yolo_budget_pending, + maybe_pause_yolo_after_spend, + release_budget_reservation, + reserve_session_budget, + yolo_budget_can_resume, + yolo_budget_pending_to_tool, +) +from agent.tools.jobs_tool import CPU_FLAVORS +from agent.tools.sandbox_tool import ( + DEFAULT_CPU_SANDBOX_HARDWARE, + start_cpu_sandbox_preload, + teardown_session_sandbox, +) + +logger = logging.getLogger(__name__) + +ToolCall = ChatCompletionMessageToolCall + +_MALFORMED_TOOL_PREFIX = "ERROR: Tool call to '" +_MALFORMED_TOOL_SUFFIX = "' had malformed JSON arguments" +_NO_TOOL_INCOMPLETE_PLAN_RETRY_LIMIT = 2 + + +def _unfinished_plan_items(session: Session) -> list[dict[str, str]]: + plan = getattr(session, "current_plan", None) or [] + unfinished: list[dict[str, str]] = [] + for item in plan: + if not isinstance(item, dict): + continue + status = item.get("status") + if status in {"pending", "in_progress"}: + unfinished.append(item) + return unfinished + + +def _format_plan_items_for_guard(items: list[dict[str, str]], limit: int = 4) -> str: + formatted = [] + for item in items[:limit]: + item_id = item.get("id") or "?" + content = item.get("content") or "(unnamed task)" + status = item.get("status") or "unknown" + formatted.append(f"{item_id}. {content} [{status}]") + if len(items) > limit: + formatted.append(f"... and {len(items) - limit} more") + return "; ".join(formatted) + + +def _no_tool_incomplete_plan_prompt(items: list[dict[str, str]]) -> str: + summary = _format_plan_items_for_guard(items) + return ( + "[SYSTEM: CONTINUATION GUARD] Your previous response ended without any " + "tool calls, but the task is not complete. The current plan still has " + f"unfinished items: {summary}. Do not return control to the user yet. " + "Continue from the next unfinished item and make at least one tool call " + "now. If you genuinely cannot continue, first use tools to inspect the " + "state or verify the blocker." + ) + + +def _malformed_tool_name(message: Message) -> str | None: + """Return the tool name for malformed-json tool-result messages.""" + if getattr(message, "role", None) != "tool": + return None + content = getattr(message, "content", None) + if not isinstance(content, str): + return None + if not content.startswith(_MALFORMED_TOOL_PREFIX): + return None + end = content.find(_MALFORMED_TOOL_SUFFIX, len(_MALFORMED_TOOL_PREFIX)) + if end == -1: + return None + return content[len(_MALFORMED_TOOL_PREFIX) : end] + + +def _detect_repeated_malformed( + items: list[Message], + threshold: int = 2, +) -> str | None: + """Return the repeated malformed tool name if the tail contains a streak. + + Walk backward over the current conversation tail. A streak counts only + consecutive malformed tool-result messages for the same tool; any other + tool result breaks it. + """ + if threshold <= 0: + return None + + streak_tool: str | None = None + streak = 0 + + for item in reversed(items): + if getattr(item, "role", None) != "tool": + continue + + malformed_tool = _malformed_tool_name(item) + if malformed_tool is None: + break + + if streak_tool is None: + streak_tool = malformed_tool + streak = 1 + elif malformed_tool == streak_tool: + streak += 1 + else: + break + + if streak >= threshold: + return streak_tool + + return None + + +def _coerce_float(value: Any) -> float: + if isinstance(value, bool) or value is None: + return 0.0 + try: + return float(value) + except (TypeError, ValueError): + return 0.0 + + +def _usage_output_message(pending: dict[str, Any]) -> str: + current = _coerce_float(pending.get("current_spend_usd")) + next_threshold = _coerce_float(pending.get("next_threshold_usd")) + return ( + f"Current-session usage warning acknowledged at ${current:.2f}. " + f"The next warning is at ${next_threshold:.2f}." + ) + + +async def _maybe_pause_for_usage_threshold( + session: Session, + *, + continuation: str, + final_response: str | None = None, +) -> bool: + checker = getattr(session, "usage_threshold_checker", None) + if checker is None or session.pending_approval: + return False + payload: dict[str, Any] = { + "continuation": continuation, + "force_check": continuation == "complete_turn", + "history_size": len(session.context_manager.items), + } + if final_response is not None: + payload["final_response"] = final_response + try: + return bool(await checker(payload)) + except Exception as e: + logger.debug("Usage threshold check failed: %s", e) + return False + + +def _validate_tool_args(tool_args: dict) -> tuple[bool, str | None]: + """ + Validate tool arguments structure. + + Returns: + (is_valid, error_message) + """ + args = tool_args.get("args", {}) + # Sometimes LLM passes args as string instead of dict + if isinstance(args, str): + return ( + False, + f"Tool call error: 'args' must be a JSON object, not a string. You passed: {repr(args)}", + ) + if not isinstance(args, dict) and args is not None: + return ( + False, + f"Tool call error: 'args' must be a JSON object. You passed type: {type(args).__name__}", + ) + return True, None + + +_IMMEDIATE_HF_JOB_RUNS = {"run", "uv"} + + +@dataclass(frozen=True) +class ApprovalDecision: + requires_approval: bool + auto_approved: bool = False + auto_approval_blocked: bool = False + block_reason: str | None = None + estimated_cost_usd: float | None = None + remaining_cap_usd: float | None = None + billable: bool = False + + +def _operation(tool_args: dict) -> str: + return normalize_tool_operation(tool_args.get("operation")) + + +def _is_immediate_hf_job_run(tool_name: str, tool_args: dict) -> bool: + return tool_name == "hf_jobs" and _operation(tool_args) in _IMMEDIATE_HF_JOB_RUNS + + +def _is_scheduled_hf_job_run(tool_name: str, tool_args: dict) -> bool: + return tool_name == "hf_jobs" and is_scheduled_operation(_operation(tool_args)) + + +def _is_budgeted_auto_approval_target(tool_name: str, tool_args: dict) -> bool: + return tool_name == "sandbox_create" or _is_immediate_hf_job_run( + tool_name, tool_args + ) + + +def _base_needs_approval( + tool_name: str, tool_args: dict, config: Config | None = None +) -> bool: + """Check if a tool call requires approval before YOLO policy is applied.""" + + # If args are malformed, skip approval (validation error will be shown later) + args_valid, _ = _validate_tool_args(tool_args) + if not args_valid: + return False + + if tool_name == "sandbox_create": + hardware = tool_args.get("hardware") or DEFAULT_CPU_SANDBOX_HARDWARE + return hardware != DEFAULT_CPU_SANDBOX_HARDWARE + + if tool_name == "hf_jobs": + operation = _operation(tool_args) + if is_scheduled_operation(operation): + return True + if operation not in _IMMEDIATE_HF_JOB_RUNS: + return False + + # Check if this is a CPU-only job + # hardware_flavor is at top level of tool_args, not nested in args + hardware_flavor = ( + tool_args.get("hardware_flavor") + or tool_args.get("flavor") + or tool_args.get("hardware") + or "cpu-basic" + ) + is_cpu_job = hardware_flavor in CPU_FLAVORS + + if is_cpu_job: + if config and not config.confirm_cpu_jobs: + return False + return True + + return True + + # Check for file upload operations (hf_private_repos or other tools) + if tool_name == "hf_private_repos": + operation = tool_args.get("operation", "") + if operation == "upload_file": + if config and config.auto_file_upload: + return False + return True + # Other operations (create_repo, etc.) always require approval + if operation in ["create_repo"]: + return True + + # hf_repo_files: upload (can overwrite) and delete require approval + if tool_name == "hf_repo_files": + operation = tool_args.get("operation", "") + if operation in ["upload", "delete"]: + return True + + # hf_repo_git: destructive operations require approval + if tool_name == "hf_repo_git": + operation = tool_args.get("operation", "") + if operation in [ + "delete_branch", + "delete_tag", + "merge_pr", + "create_repo", + "update_repo", + ]: + return True + + return False + + +def _session_auto_approval_enabled(session: Session | None) -> bool: + return bool(session and getattr(session, "auto_approval_enabled", False)) + + +def _effective_yolo_enabled(session: Session | None, config: Config | None) -> bool: + return bool( + (config and config.yolo_mode) or _session_auto_approval_enabled(session) + ) + + +async def _approval_decision( + tool_name: str, + tool_args: dict, + session: Session, + *, + reserved_spend_usd: float = 0.0, +) -> ApprovalDecision: + """Return the approval decision for one parsed tool call.""" + config = session.config + base_requires_approval = _base_needs_approval(tool_name, tool_args, config) + + # Scheduled jobs are recurring/unbounded enough that YOLO never bypasses + # the human confirmation, including legacy config.yolo_mode. + if _is_scheduled_hf_job_run(tool_name, tool_args): + reason = "Scheduled HF jobs always require manual approval." + if _session_auto_approval_enabled(session): + reason = "Scheduled HF jobs require disabling YOLO because their recurring cost is unbounded." + return ApprovalDecision( + requires_approval=True, + auto_approval_blocked=_effective_yolo_enabled(session, config), + block_reason=reason, + ) + + yolo_enabled = _effective_yolo_enabled(session, config) + budgeted_target = _is_budgeted_auto_approval_target(tool_name, tool_args) + + # Cost caps are a session-scoped web policy. Legacy config.yolo_mode + # remains uncapped for CLI/headless, except for scheduled jobs above. + session_yolo_enabled = _session_auto_approval_enabled(session) + if yolo_enabled and budgeted_target and session_yolo_enabled: + estimate = await estimate_tool_cost(tool_name, tool_args, session=session) + budget = check_session_budget( + session, + estimate, + reserved_spend_usd=reserved_spend_usd, + ) + if not budget.allowed: + return ApprovalDecision( + requires_approval=True, + auto_approval_blocked=True, + block_reason=budget.block_reason, + estimated_cost_usd=budget.estimated_cost_usd, + remaining_cap_usd=budget.remaining_cap_usd, + billable=estimate.billable, + ) + if base_requires_approval: + return ApprovalDecision( + requires_approval=False, + auto_approved=True, + estimated_cost_usd=budget.estimated_cost_usd, + remaining_cap_usd=budget.remaining_cap_usd, + billable=estimate.billable, + ) + return ApprovalDecision( + requires_approval=False, + estimated_cost_usd=budget.estimated_cost_usd, + remaining_cap_usd=budget.remaining_cap_usd, + billable=estimate.billable, + ) + + if base_requires_approval and yolo_enabled: + return ApprovalDecision(requires_approval=False, auto_approved=True) + + return ApprovalDecision(requires_approval=base_requires_approval) + + +def _record_estimated_spend( + session: Session, + decision: ApprovalDecision, + *, + reservation_id: str | None = None, +) -> BudgetDecision: + if not decision.billable or decision.estimated_cost_usd is None: + return BudgetDecision(allowed=True, billable=False) + return reserve_session_budget( + session, + CostEstimate( + estimated_cost_usd=decision.estimated_cost_usd, + billable=True, + ), + spend_kind="tool", + reservation_id=reservation_id, + ) + + +async def _record_manual_approved_spend_if_needed( + session: Session, + tool_name: str, + tool_args: dict, + *, + tool_call_id: str | None = None, +) -> BudgetDecision: + if not _session_auto_approval_enabled(session): + return BudgetDecision(allowed=True) + if _is_scheduled_hf_job_run(tool_name, tool_args): + return BudgetDecision( + allowed=False, + billable=True, + block_reason=( + "Scheduled HF jobs require disabling YOLO because their recurring " + "cost is unbounded." + ), + ) + if not _is_budgeted_auto_approval_target(tool_name, tool_args): + return BudgetDecision(allowed=True) + estimate = await estimate_tool_cost(tool_name, tool_args, session=session) + return reserve_session_budget( + session, + estimate, + spend_kind=tool_name, + reservation_id=tool_call_id, + ) + + +async def _check_manual_approved_budget( + session: Session, + tool_name: str, + tool_args: dict, + *, + reserved_spend_usd: float = 0.0, +) -> BudgetDecision: + if not _session_auto_approval_enabled(session): + return BudgetDecision(allowed=True) + if _is_scheduled_hf_job_run(tool_name, tool_args): + return BudgetDecision( + allowed=False, + billable=True, + block_reason=( + "Scheduled HF jobs require disabling YOLO because their recurring " + "cost is unbounded." + ), + ) + if not _is_budgeted_auto_approval_target(tool_name, tool_args): + return BudgetDecision(allowed=True) + estimate = await estimate_tool_cost(tool_name, tool_args, session=session) + return check_session_budget( + session, + estimate, + reserved_spend_usd=reserved_spend_usd, + ) + + +# -- LLM retry constants -------------------------------------------------- +_MAX_LLM_RETRIES = 3 +_LLM_RETRY_DELAYS = [5, 15, 30] # seconds between retries +_LLM_RATE_LIMIT_RETRY_DELAYS = [30, 60] + + +def _is_rate_limit_error(error: Exception) -> bool: + """Return True for rate-limit / quota-bucket style provider errors.""" + err_str = str(error).lower() + rate_limit_patterns = [ + "429", + "rate limit", + "rate_limit", + "too many requests", + "too many tokens", + "request limit", + "throttl", + ] + return any(pattern in err_str for pattern in rate_limit_patterns) + + +def _is_context_overflow_error(error: Exception) -> bool: + """Return True when the prompt exceeded the model's context window.""" + if isinstance(error, ContextWindowExceededError): + return True + + err_str = str(error).lower() + overflow_patterns = [ + "context window exceeded", + "maximum context length", + "max context length", + "prompt is too long", + "context length exceeded", + "too many input tokens", + "input is too long", + ] + return any(pattern in err_str for pattern in overflow_patterns) + + +def _retry_delay_for(error: Exception, attempt_index: int) -> int | None: + """Return the delay for this retry attempt, or None if it should not retry.""" + if _is_rate_limit_error(error): + schedule = _LLM_RATE_LIMIT_RETRY_DELAYS + elif _is_transient_error(error): + schedule = _LLM_RETRY_DELAYS + else: + return None + + if attempt_index >= len(schedule): + return None + return schedule[attempt_index] + + +def _is_transient_error(error: Exception) -> bool: + """Return True for errors that are likely transient and worth retrying.""" + err_str = str(error).lower() + transient_patterns = [ + "timeout", + "timed out", + "503", + "service unavailable", + "502", + "bad gateway", + "500", + "internal server error", + "overloaded", + "capacity", + "connection reset", + "connection refused", + "connection error", + "eof", + "broken pipe", + ] + return _is_rate_limit_error(error) or any( + pattern in err_str for pattern in transient_patterns + ) + + +def _is_effort_config_error(error: Exception) -> bool: + """Catch the two 400s the effort probe also handles β€” thinking + unsupported for this model, or the specific effort level invalid. + + This is our safety net for the case where ``/effort`` was changed + mid-conversation (which clears the probe cache) and the new level + doesn't work for the current model. We heal the cache and retry once. + """ + from agent.core.effort_probe import _is_invalid_effort, _is_thinking_unsupported + + return _is_thinking_unsupported(error) or _is_invalid_effort(error) + + +async def _heal_effort_and_rebuild_params( + session: Session, + error: Exception, + llm_params: dict, +) -> dict: + """Update the session's effort cache based on ``error`` and return new + llm_params. Called only when ``_is_effort_config_error(error)`` is True. + + Two branches: + β€’ thinking-unsupported β†’ cache ``None`` for this model, next call + strips thinking entirely + β€’ invalid-effort β†’ re-run the full cascade probe; the result lands + in the cache + """ + from agent.core.effort_probe import ( + ProbeInconclusive, + _is_thinking_unsupported, + probe_effort, + ) + + model = session.config.model_name + if _is_thinking_unsupported(error): + session.model_effective_effort[model] = None + logger.info("healed: %s doesn't support thinking β€” stripped", model) + else: + try: + outcome = await probe_effort( + model, + session.config.reasoning_effort, + session.hf_token, + session=session, + ) + session.model_effective_effort[model] = outcome.effective_effort + logger.info( + "healed: %s effort cascade β†’ %s", + model, + outcome.effective_effort, + ) + except ProbeInconclusive: + # Transient during healing β€” strip thinking for safety, next + # call will either succeed or surface the real error. + session.model_effective_effort[model] = None + logger.info("healed: %s probe inconclusive β€” stripped", model) + + return _resolve_llm_params( + model, + session.hf_token, + reasoning_effort=session.effective_effort_for(model), + ) + + +def _inference_credit_error_message(user_plan: str | None = None) -> str: + plan = (user_plan or "unknown").lower() + if plan == "pro": + return ( + "Hugging Face Inference Providers credits are exhausted for this " + "account.\n\n" + f"Add credits to continue: {HF_BILLING_URL}" + ) + if plan == "free": + return ( + "Your monthly Hugging Face Inference Providers credits are exhausted.\n\n" + f"Subscribe to HF PRO for more monthly usage: {HF_PRO_SUBSCRIBE_URL}\n" + f"Or add pay-as-you-go credits: {HF_BILLING_URL}" + ) + return ( + "Hugging Face Inference Providers credits appear to be exhausted for " + "this account.\n\n" + f"Add pay-as-you-go credits: {HF_BILLING_URL}\n" + f"If this is a free account, HF PRO adds more monthly usage: {HF_PRO_SUBSCRIBE_URL}" + ) + + +def _friendly_error_message( + error: Exception, + *, + user_plan: str | None = None, +) -> str | None: + """Return a user-friendly message for known error types, or None to fall back to traceback.""" + err_str = str(error).lower() + + if ( + "authentication" in err_str + or "unauthorized" in err_str + or "invalid x-api-key" in err_str + ): + return ( + "Authentication failed - your Hugging Face token is missing or invalid.\n\n" + "To fix this, set HF_TOKEN=hf_... or run `hf auth login`.\n\n" + "You can also add it to a .env file in the project root.\n" + "To switch models, use the /model command." + ) + + if is_inference_billing_error(error): + return _inference_credit_error_message(user_plan) + + if "not supported by provider" in err_str or "no provider supports" in err_str: + return ( + "The model isn't served by the provider you pinned.\n\n" + "Drop the ':' suffix to let the HF router auto-pick a " + "provider, or use '/model' (no arg) to see which providers host " + "which models." + ) + + if "model_not_found" in err_str or ( + "model" in err_str and ("not found" in err_str or "does not exist" in err_str) + ): + return ( + "Model not found. Use '/model' to list suggestions, or paste an " + "HF model id like 'MiniMaxAI/MiniMax-M2.7'. Availability is shown " + "when you switch." + ) + + return None + + +async def _compact_and_notify(session: Session) -> None: + """Run compaction and send event if context was reduced. + + Catches ``CompactionFailedError`` and ends the session cleanly instead + of letting the caller retry. Pre-2026-05-04 the caller looped on + ContextWindowExceededError β†’ compact β†’ re-trigger, burning hosted + inference budget while the session never reached the upload path. + """ + from agent.context_manager.manager import CompactionFailedError + + cm = session.context_manager + old_usage = cm.running_context_usage + logger.debug( + "Compaction check: usage=%d, max=%d, threshold=%d, needs_compact=%s", + old_usage, + cm.model_max_tokens, + cm.compaction_threshold, + cm.needs_compaction, + ) + try: + await cm.compact( + model_name=session.config.model_name, + tool_specs=session.tool_router.get_tool_specs_for_llm(), + hf_token=session.hf_token, + session=session, + ) + except CompactionFailedError as e: + logger.error( + "Compaction failed for session %s: %s β€” terminating session", + session.session_id, + e, + ) + # Persist the failure event so the dataset has a record of WHY this + # session ended (and the cost it incurred up to that point) even if + # save_and_upload_detached has issues downstream. + await session.send_event( + Event( + event_type="session_terminated", + data={ + "reason": "compaction_failed", + "context_usage": cm.running_context_usage, + "context_threshold": cm.compaction_threshold, + "error": str(e)[:300], + "user_message": ( + "Your conversation has grown too large to continue. " + "The work you've done is saved β€” start a new session to keep going." + ), + }, + ) + ) + # Stop the agent loop; the finally in _run_session will fire + # cleanup_sandbox + save_trajectory so the dataset captures + # everything that did happen. + session.is_running = False + return + + new_usage = cm.running_context_usage + if new_usage != old_usage: + logger.warning( + "Context compacted: %d -> %d tokens (max=%d, %d messages)", + old_usage, + new_usage, + cm.model_max_tokens, + len(cm.items), + ) + await session.send_event( + Event( + event_type="compacted", + data={"old_tokens": old_usage, "new_tokens": new_usage}, + ) + ) + + +async def _cleanup_on_cancel(session: Session) -> None: + """Kill sandbox processes and cancel HF jobs when the user interrupts.""" + # Kill active sandbox processes + sandbox = getattr(session, "sandbox", None) + if sandbox: + try: + await asyncio.to_thread(sandbox.kill_all) + logger.info("Killed sandbox processes on cancel") + except Exception as e: + logger.warning("Failed to kill sandbox processes: %s", e) + + # Cancel running HF jobs + job_ids = list(session._running_job_ids) + if job_ids: + from huggingface_hub import HfApi + + api = HfApi(token=session.hf_token) + for job_id in job_ids: + try: + await asyncio.to_thread(api.cancel_job, job_id=job_id) + logger.info("Cancelled HF job %s on interrupt", job_id) + except Exception as e: + logger.warning("Failed to cancel HF job %s: %s", job_id, e) + session._running_job_ids.clear() + + +@dataclass +class LLMResult: + """Result from an LLM call (streaming or non-streaming).""" + + content: str | None + tool_calls_acc: dict[int, dict] + token_count: int + finish_reason: str | None + usage: dict = field(default_factory=dict) + + +def _is_invalid_thinking_signature_error(exc: Exception) -> bool: + """Return True when a provider rejected replayed thinking metadata.""" + text = str(exc) + return ( + "Invalid `signature` in `thinking` block" in text + or "Invalid signature in thinking block" in text + ) + + +def _strip_thinking_state_from_messages(messages: list[Any]) -> int: + """Remove replayed thinking metadata from assistant history messages.""" + stripped = 0 + + for message in messages: + role = ( + message.get("role") + if isinstance(message, dict) + else getattr(message, "role", None) + ) + if role != "assistant": + continue + + if isinstance(message, dict): + if message.pop("thinking_blocks", None) is not None: + stripped += 1 + if message.pop("reasoning_content", None) is not None: + stripped += 1 + provider_fields = message.get("provider_specific_fields") + content = message.get("content") + else: + if getattr(message, "thinking_blocks", None) is not None: + message.thinking_blocks = None + stripped += 1 + if getattr(message, "reasoning_content", None) is not None: + message.reasoning_content = None + stripped += 1 + provider_fields = getattr(message, "provider_specific_fields", None) + content = getattr(message, "content", None) + + if isinstance(provider_fields, dict): + cleaned_fields = dict(provider_fields) + if cleaned_fields.pop("thinking_blocks", None) is not None: + stripped += 1 + if cleaned_fields.pop("reasoning_content", None) is not None: + stripped += 1 + if cleaned_fields != provider_fields: + if isinstance(message, dict): + message["provider_specific_fields"] = cleaned_fields + else: + message.provider_specific_fields = cleaned_fields + + if isinstance(content, list): + cleaned_content = [ + block + for block in content + if not ( + isinstance(block, dict) + and block.get("type") in {"thinking", "redacted_thinking"} + ) + ] + if len(cleaned_content) != len(content): + stripped += len(content) - len(cleaned_content) + if isinstance(message, dict): + message["content"] = cleaned_content + else: + message.content = cleaned_content + + return stripped + + +async def _maybe_heal_invalid_thinking_signature( + session: Session, + messages: list[Any], + exc: Exception, + *, + already_healed: bool, +) -> bool: + if already_healed or not _is_invalid_thinking_signature_error(exc): + return False + + stripped = _strip_thinking_state_from_messages(messages) + if not stripped: + return False + + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "system", + "log": ( + "The inference provider rejected stale thinking signatures; retrying " + "without replayed thinking metadata." + ), + }, + ) + ) + return True + + +def _assistant_message_from_result( + llm_result: LLMResult, + *, + tool_calls: list[ToolCall] | None = None, +) -> Message: + """Build an assistant history message for HF Router-compatible replay.""" + kwargs: dict[str, Any] = { + "role": "assistant", + "content": llm_result.content, + } + if tool_calls is not None: + kwargs["tool_calls"] = tool_calls + return Message(**kwargs) + + +async def _call_llm_streaming( + session: Session, messages, tools, llm_params +) -> LLMResult: + """Call the LLM with streaming, emitting assistant_chunk events.""" + response = None + _healed_effort = False # one-shot safety net per call + _healed_thinking_signature = False + t_start = time.monotonic() + for _llm_attempt in range(_MAX_LLM_RETRIES): + try: + request_llm_params = with_prompt_cache_params( + llm_params, + session_id=router_session_id_for(session), + ) + cached_messages, cached_tools = with_prompt_caching( + messages, tools, request_llm_params + ) + response = await acompletion( + messages=cached_messages, + tools=cached_tools, + tool_choice="auto", + stream=True, + stream_options={"include_usage": True}, + timeout=600, + **request_llm_params, + ) + break + except ContextWindowExceededError: + raise + except Exception as e: + if _is_context_overflow_error(e): + raise ContextWindowExceededError(str(e)) from e + if not _healed_effort and _is_effort_config_error(e): + _healed_effort = True + llm_params = await _heal_effort_and_rebuild_params( + session, e, llm_params + ) + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "system", + "log": "Reasoning effort not supported for this model β€” adjusting and retrying.", + }, + ) + ) + continue + if await _maybe_heal_invalid_thinking_signature( + session, + messages, + e, + already_healed=_healed_thinking_signature, + ): + _healed_thinking_signature = True + continue + _delay = _retry_delay_for(e, _llm_attempt) + if _llm_attempt < _MAX_LLM_RETRIES - 1 and _delay is not None: + logger.warning( + "Transient LLM error (attempt %d/%d): %s β€” retrying in %ds", + _llm_attempt + 1, + _MAX_LLM_RETRIES, + e, + _delay, + ) + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "system", + "log": f"LLM connection error, retrying in {_delay}s...", + }, + ) + ) + await asyncio.sleep(_delay) + continue + raise + + full_content = "" + tool_calls_acc: dict[int, dict] = {} + token_count = 0 + finish_reason = None + final_usage_chunk = None + + async for chunk in response: + if session.is_cancelled: + tool_calls_acc.clear() + break + + choice = chunk.choices[0] if chunk.choices else None + if not choice: + if hasattr(chunk, "usage") and chunk.usage: + token_count = chunk.usage.total_tokens + final_usage_chunk = chunk + continue + + delta = choice.delta + if choice.finish_reason: + finish_reason = choice.finish_reason + + if delta.content: + full_content += delta.content + await session.send_event( + Event(event_type="assistant_chunk", data={"content": delta.content}) + ) + + if delta.tool_calls: + for tc_delta in delta.tool_calls: + idx = tc_delta.index + if idx not in tool_calls_acc: + tool_calls_acc[idx] = { + "id": "", + "type": "function", + "function": {"name": "", "arguments": ""}, + } + if tc_delta.id: + tool_calls_acc[idx]["id"] = tc_delta.id + if tc_delta.function: + if tc_delta.function.name: + tool_calls_acc[idx]["function"]["name"] += ( + tc_delta.function.name + ) + if tc_delta.function.arguments: + tool_calls_acc[idx]["function"]["arguments"] += ( + tc_delta.function.arguments + ) + + if hasattr(chunk, "usage") and chunk.usage: + token_count = chunk.usage.total_tokens + final_usage_chunk = chunk + + usage = await telemetry.record_llm_call( + session, + model=llm_params.get("model", session.config.model_name), + response=final_usage_chunk, + latency_ms=int((time.monotonic() - t_start) * 1000), + finish_reason=finish_reason, + ) + return LLMResult( + content=full_content or None, + tool_calls_acc=tool_calls_acc, + token_count=token_count, + finish_reason=finish_reason, + usage=usage, + ) + + +async def _call_llm_non_streaming( + session: Session, messages, tools, llm_params +) -> LLMResult: + """Call the LLM without streaming, emit assistant_message at the end.""" + response = None + _healed_effort = False + _healed_thinking_signature = False + t_start = time.monotonic() + for _llm_attempt in range(_MAX_LLM_RETRIES): + try: + request_llm_params = with_prompt_cache_params( + llm_params, + session_id=router_session_id_for(session), + ) + cached_messages, cached_tools = with_prompt_caching( + messages, tools, request_llm_params + ) + response = await acompletion( + messages=cached_messages, + tools=cached_tools, + tool_choice="auto", + stream=False, + timeout=600, + **request_llm_params, + ) + break + except ContextWindowExceededError: + raise + except Exception as e: + if _is_context_overflow_error(e): + raise ContextWindowExceededError(str(e)) from e + if not _healed_effort and _is_effort_config_error(e): + _healed_effort = True + llm_params = await _heal_effort_and_rebuild_params( + session, e, llm_params + ) + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "system", + "log": "Reasoning effort not supported for this model β€” adjusting and retrying.", + }, + ) + ) + continue + if await _maybe_heal_invalid_thinking_signature( + session, + messages, + e, + already_healed=_healed_thinking_signature, + ): + _healed_thinking_signature = True + continue + _delay = _retry_delay_for(e, _llm_attempt) + if _llm_attempt < _MAX_LLM_RETRIES - 1 and _delay is not None: + logger.warning( + "Transient LLM error (attempt %d/%d): %s β€” retrying in %ds", + _llm_attempt + 1, + _MAX_LLM_RETRIES, + e, + _delay, + ) + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "system", + "log": f"LLM connection error, retrying in {_delay}s...", + }, + ) + ) + await asyncio.sleep(_delay) + continue + raise + + choice = response.choices[0] + message = choice.message + content = message.content or None + finish_reason = choice.finish_reason + token_count = response.usage.total_tokens if response.usage else 0 + + # Build tool_calls_acc in the same format as streaming + tool_calls_acc: dict[int, dict] = {} + if message.tool_calls: + for idx, tc in enumerate(message.tool_calls): + tool_calls_acc[idx] = { + "id": tc.id, + "type": "function", + "function": { + "name": tc.function.name, + "arguments": tc.function.arguments, + }, + } + + # Emit the full message as a single event + if content: + await session.send_event( + Event(event_type="assistant_message", data={"content": content}) + ) + + usage = await telemetry.record_llm_call( + session, + model=llm_params.get("model", session.config.model_name), + response=response, + latency_ms=int((time.monotonic() - t_start) * 1000), + finish_reason=finish_reason, + ) + + return LLMResult( + content=content, + tool_calls_acc=tool_calls_acc, + token_count=token_count, + finish_reason=finish_reason, + usage=usage, + ) + + +class Handlers: + """Handler functions for each operation type""" + + @staticmethod + async def _abandon_pending_approval(session: Session) -> None: + """Cancel pending approval tools when the user continues the conversation. + + Injects rejection tool-result messages into the LLM context (so the + history stays valid) and notifies the frontend that those tools were + abandoned. + """ + if is_usage_threshold_pending( + session.pending_approval + ) or is_yolo_budget_pending(session.pending_approval): + pending = session.pending_approval + tool_call_id = str(pending.get("tool_call_id") or "") + tool_name = str(pending.get("kind") or USAGE_THRESHOLD_TOOL_NAME) + session.pending_approval = None + if tool_call_id: + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tool_call_id, + "tool": tool_name, + "state": "abandoned", + }, + ) + ) + if pending.get("continuation") == "complete_turn": + final_response = pending.get("final_response") + await session.send_event( + Event( + event_type="turn_complete", + data={ + "history_size": int( + pending.get("history_size") + or len(session.context_manager.items) + ), + "final_response": final_response + if isinstance(final_response, str) + else None, + }, + ) + ) + session.increment_turn() + await session.auto_save_if_needed() + return + + tool_calls = session.pending_approval.get("tool_calls", []) + for tc in tool_calls: + tool_name = tc.function.name + abandon_msg = ( + "Task abandoned β€” user continued the conversation without approving." + ) + + # Keep LLM context valid: every tool_call needs a tool result + tool_msg = Message( + role="tool", + content=abandon_msg, + tool_call_id=tc.id, + name=tool_name, + ) + session.context_manager.add_message(tool_msg) + + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tc.id, + "tool": tool_name, + "state": "abandoned", + }, + ) + ) + + session.pending_approval = None + logger.info("Abandoned %d pending approval tool(s)", len(tool_calls)) + + @staticmethod + async def run_agent( + session: Session, + text: str, + ) -> str | None: + """ + Handle user input (like user_input_or_turn in codex.rs:1291) + Returns the final assistant response content, if any. + """ + # Clear any stale cancellation flag from a previous run + session.reset_cancel() + + # If there's a pending approval and the user sent a new message, + # abandon the pending tools so the LLM context stays valid. + if text and session.pending_approval: + await Handlers._abandon_pending_approval(session) + + # Add user message to history only if there's actual content + if text: + user_msg = Message(role="user", content=text) + session.context_manager.add_message(user_msg) + + # Send event that we're processing + await session.send_event( + Event(event_type="processing", data={"message": "Processing user input"}) + ) + + # Agentic loop - continue until model doesn't call tools or max iterations is reached + iteration = 0 + final_response = None + errored = False + max_iterations = session.config.max_iterations + no_tool_incomplete_plan_retries = 0 + + while max_iterations == -1 or iteration < max_iterations: + # ── Cancellation check: before LLM call ── + if session.is_cancelled: + break + if session.pending_approval: + return final_response + + # Compact before calling the LLM if context is near the limit. + # When _compact_and_notify catches CompactionFailedError it sets + # session.is_running = False; we MUST exit the loop here, otherwise + # the LLM call below fires with an over-threshold context, hits + # ContextWindowExceededError, and we end up looping again on the + # except path β€” exactly the bug this PR is supposed to fix. + await _compact_and_notify(session) + if not session.is_running: + break + if session.pending_approval: + return final_response + + if await _maybe_pause_for_usage_threshold( + session, + continuation="continue_agent", + ): + return final_response + + # Doom-loop detection: break out of repeated tool call patterns + doom_prompt = check_for_doom_loop(session.context_manager.items) + if doom_prompt: + session.context_manager.add_message( + Message(role="user", content=doom_prompt) + ) + + malformed_tool = _detect_repeated_malformed(session.context_manager.items) + if malformed_tool: + recovery_prompt = ( + "[SYSTEM: Repeated malformed tool arguments detected for " + f"'{malformed_tool}'. Stop retrying the same tool call shape. " + "Use a different strategy that produces smaller, valid JSON. " + "For large file writes, prefer bash with a heredoc or split the " + "edit into multiple smaller tool calls.]" + ) + session.context_manager.add_message( + Message(role="user", content=recovery_prompt) + ) + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "system", + "log": ( + "Repeated malformed tool arguments detected β€” " + f"forcing a different strategy for {malformed_tool}" + ), + }, + ) + ) + + messages = session.context_manager.get_messages() + tools = session.tool_router.get_tool_specs_for_llm() + try: + # ── Call the LLM (streaming or non-streaming) ── + # Pull the per-model probed effort from the session cache when + # available; fall back to the raw preference for models we + # haven't probed yet (e.g. research sub-model). + llm_params = _resolve_llm_params( + session.config.model_name, + session.hf_token, + reasoning_effort=session.effective_effort_for( + session.config.model_name + ), + ) + if session.stream: + llm_result = await _call_llm_streaming( + session, messages, tools, llm_params + ) + else: + llm_result = await _call_llm_non_streaming( + session, messages, tools, llm_params + ) + llm_observed_cost_usd = llm_result.usage.get("cost_usd") + + content = llm_result.content + tool_calls_acc = llm_result.tool_calls_acc + token_count = llm_result.token_count + finish_reason = llm_result.finish_reason + + # If output was truncated, all tool call args are garbage. + # Inject a system hint so the LLM retries with smaller content. + if finish_reason == "length" and tool_calls_acc: + dropped_names = [ + tc["function"]["name"] + for tc in tool_calls_acc.values() + if tc["function"]["name"] + ] + logger.warning( + "Output truncated (finish_reason=length) β€” dropping tool calls: %s", + dropped_names, + ) + tool_calls_acc.clear() + + # Tell the agent what happened so it can retry differently + truncation_hint = ( + "Your previous response was truncated because the output hit the " + "token limit. The following tool calls were lost: " + f"{dropped_names}. " + "IMPORTANT: Do NOT retry with the same large content. Instead:\n" + " β€’ For 'write': use bash with cat<<'HEREDOC' to write the file, " + "or split into several smaller edit calls.\n" + " β€’ For other tools: reduce the size of your arguments or use bash." + ) + if content: + assistant_msg = _assistant_message_from_result(llm_result) + session.context_manager.add_message(assistant_msg, token_count) + session.context_manager.add_message( + Message(role="user", content=f"[SYSTEM: {truncation_hint}]") + ) + if session.stream: + await session.send_event( + Event(event_type="assistant_stream_end", data={}) + ) + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "system", + "log": f"Output truncated β€” retrying with smaller content ({dropped_names})", + }, + ) + ) + iteration += 1 + continue # retry this iteration + + # Build tool_calls list from accumulated deltas + tool_calls: list[ToolCall] = [] + for idx in sorted(tool_calls_acc.keys()): + tc_data = tool_calls_acc[idx] + tool_calls.append( + ToolCall( + id=tc_data["id"], + type="function", + function={ + "name": tc_data["function"]["name"], + "arguments": tc_data["function"]["arguments"], + }, + ) + ) + + # Signal end of streaming to the frontend + if session.stream: + await session.send_event( + Event(event_type="assistant_stream_end", data={}) + ) + + # If no tool calls, add assistant message and we're done + if not tool_calls: + unfinished_plan = _unfinished_plan_items(session) + if ( + unfinished_plan + and no_tool_incomplete_plan_retries + < _NO_TOOL_INCOMPLETE_PLAN_RETRY_LIMIT + ): + if await maybe_pause_yolo_after_spend( + session, + spend_kind="llm_call", + observed_cost_usd=llm_observed_cost_usd, + ): + return final_response + logger.info( + "No tool calls with unfinished plan; retrying agent turn " + "(attempt %d/%d)", + no_tool_incomplete_plan_retries + 1, + _NO_TOOL_INCOMPLETE_PLAN_RETRY_LIMIT, + ) + if content: + assistant_msg = _assistant_message_from_result(llm_result) + session.context_manager.add_message( + assistant_msg, token_count + ) + session.context_manager.add_message( + Message( + role="user", + content=_no_tool_incomplete_plan_prompt( + unfinished_plan + ), + ) + ) + no_tool_incomplete_plan_retries += 1 + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "system", + "log": ( + "Plan still has unfinished items after a " + "text-only response β€” retrying instead of " + "returning to the prompt." + ), + }, + ) + ) + iteration += 1 + continue + + logger.debug( + "Agent loop ending: no tool calls. " + "finish_reason=%s, token_count=%d, " + "usage=%d, model_max_tokens=%d, " + "iteration=%d/%d, " + "response_text=%s", + finish_reason, + token_count, + session.context_manager.running_context_usage, + session.context_manager.model_max_tokens, + iteration, + max_iterations, + (content or "")[:500], + ) + if content: + assistant_msg = _assistant_message_from_result(llm_result) + session.context_manager.add_message(assistant_msg, token_count) + final_response = content + if await maybe_pause_yolo_after_spend( + session, + spend_kind="llm_call", + observed_cost_usd=llm_observed_cost_usd, + continuation="complete_turn", + final_response=final_response + if isinstance(final_response, str) + else None, + ): + return final_response + break + + no_tool_incomplete_plan_retries = 0 + + if await maybe_pause_yolo_after_spend( + session, + spend_kind="llm_call", + observed_cost_usd=llm_observed_cost_usd, + ): + return final_response + + # Validate tool call args (one json.loads per call, once) + # and split into good vs bad + good_tools: list[tuple[ToolCall, str, dict]] = [] + bad_tools: list[ToolCall] = [] + for tc in tool_calls: + try: + args = json.loads(tc.function.arguments) + good_tools.append((tc, tc.function.name, args)) + except (json.JSONDecodeError, TypeError, ValueError): + logger.warning( + "Malformed arguments for tool_call %s (%s) β€” skipping", + tc.id, + tc.function.name, + ) + tc.function.arguments = "{}" + bad_tools.append(tc) + + # Add assistant message with all tool calls to context + assistant_msg = _assistant_message_from_result( + llm_result, + tool_calls=tool_calls, + ) + session.context_manager.add_message(assistant_msg, token_count) + + # Add error results for bad tool calls so the LLM + # knows what happened and can retry differently + for tc in bad_tools: + error_msg = ( + f"ERROR: Tool call to '{tc.function.name}' had malformed JSON " + f"arguments and was NOT executed. Retry with smaller content β€” " + f"for 'write', split into multiple smaller writes using 'edit'." + ) + session.context_manager.add_message( + Message( + role="tool", + content=error_msg, + tool_call_id=tc.id, + name=tc.function.name, + ) + ) + await session.send_event( + Event( + event_type="tool_call", + data={ + "tool": tc.function.name, + "arguments": {}, + "tool_call_id": tc.id, + }, + ) + ) + await session.send_event( + Event( + event_type="tool_output", + data={ + "tool": tc.function.name, + "tool_call_id": tc.id, + "output": error_msg, + "success": False, + }, + ) + ) + + # ── Cancellation check: before tool execution ── + if session.is_cancelled: + break + + # Separate good tools into approval-required vs auto-execute. + # Track reserved spend while classifying a batch so two + # auto-approved jobs in one model response cannot jointly + # exceed the remaining session cap. + approval_required_tools: list[ + tuple[ToolCall, str, dict, ApprovalDecision] + ] = [] + non_approval_tools: list[ + tuple[ToolCall, str, dict, ApprovalDecision] + ] = [] + reserved_auto_spend_usd = 0.0 + for tc, tool_name, tool_args in good_tools: + decision = await _approval_decision( + tool_name, + tool_args, + session, + reserved_spend_usd=reserved_auto_spend_usd, + ) + if decision.requires_approval: + approval_required_tools.append( + (tc, tool_name, tool_args, decision) + ) + else: + non_approval_tools.append((tc, tool_name, tool_args, decision)) + if ( + decision.auto_approved + and decision.billable + and decision.estimated_cost_usd is not None + ): + reserved_auto_spend_usd += decision.estimated_cost_usd + + # Execute non-approval tools (in parallel when possible) + if non_approval_tools: + # 1. Validate args upfront + parsed_tools: list[ + tuple[ToolCall, str, dict, ApprovalDecision, bool, str] + ] = [] + for tc, tool_name, tool_args, decision in non_approval_tools: + args_valid, error_msg = _validate_tool_args(tool_args) + parsed_tools.append( + (tc, tool_name, tool_args, decision, args_valid, error_msg) + ) + + # 2. Send all tool_call events upfront (so frontend shows them all) + for ( + tc, + tool_name, + tool_args, + _decision, + args_valid, + _, + ) in parsed_tools: + if args_valid: + await session.send_event( + Event( + event_type="tool_call", + data={ + "tool": tool_name, + "arguments": tool_args, + "tool_call_id": tc.id, + }, + ) + ) + + # 3. Execute all valid tools in parallel, cancellable + async def _exec_tool( + tc: ToolCall, + name: str, + args: dict, + decision: ApprovalDecision, + valid: bool, + err: str, + ) -> tuple[ToolCall, str, dict, str, bool]: + if not valid: + return (tc, name, args, err, False) + if decision.billable: + budget = _record_estimated_spend( + session, + decision, + reservation_id=tc.id, + ) + if not budget.allowed: + return ( + tc, + name, + args, + budget.block_reason + or "YOLO budget blocked this tool call.", + False, + ) + out, ok = await session.tool_router.call_tool( + name, args, session=session, tool_call_id=tc.id + ) + if not ok and decision.billable: + release_budget_reservation(session, tc.id) + return (tc, name, args, out, ok) + + gather_task = asyncio.ensure_future( + asyncio.gather( + *[ + _exec_tool(tc, name, args, decision, valid, err) + for tc, name, args, decision, valid, err in parsed_tools + ] + ) + ) + cancel_task = asyncio.ensure_future(session._cancelled.wait()) + + done, _ = await asyncio.wait( + [gather_task, cancel_task], + return_when=asyncio.FIRST_COMPLETED, + ) + + if cancel_task in done: + gather_task.cancel() + try: + await gather_task + except asyncio.CancelledError: + pass + # Notify frontend that in-flight tools were cancelled + for tc, name, _args, _decision, valid, _ in parsed_tools: + if valid: + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tc.id, + "tool": name, + "state": "cancelled", + }, + ) + ) + await _cleanup_on_cancel(session) + break + + cancel_task.cancel() + results = gather_task.result() + + # 4. Record results and send outputs (order preserved) + for tc, tool_name, tool_args, output, success in results: + tool_msg = Message( + role="tool", + content=output, + tool_call_id=tc.id, + name=tool_name, + ) + session.context_manager.add_message(tool_msg) + + await session.send_event( + Event( + event_type="tool_output", + data={ + "tool": tool_name, + "tool_call_id": tc.id, + "output": output, + "success": success, + }, + ) + ) + + # If there are tools requiring approval, ask for batch approval + if approval_required_tools: + # Prepare batch approval data + tools_data = [] + blocked_payloads = [] + for tc, tool_name, tool_args, decision in approval_required_tools: + # Resolve sandbox file paths for hf_jobs scripts so the + # frontend can display & edit the actual file content. + if tool_name == "hf_jobs" and isinstance( + tool_args.get("script"), str + ): + from agent.tools.sandbox_tool import resolve_sandbox_script + + sandbox = getattr(session, "sandbox", None) + resolved, _ = await resolve_sandbox_script( + sandbox, tool_args["script"] + ) + if resolved: + tool_args = {**tool_args, "script": resolved} + + tool_payload = { + "tool": tool_name, + "arguments": tool_args, + "tool_call_id": tc.id, + } + if decision.auto_approval_blocked: + tool_payload.update( + { + "auto_approval_blocked": True, + "block_reason": decision.block_reason, + "estimated_cost_usd": decision.estimated_cost_usd, + "remaining_cap_usd": decision.remaining_cap_usd, + } + ) + blocked_payloads.append(tool_payload) + tools_data.append(tool_payload) + + event_data = {"tools": tools_data, "count": len(tools_data)} + if blocked_payloads: + first = blocked_payloads[0] + event_data.update( + { + "auto_approval_blocked": True, + "block_reason": first.get("block_reason"), + "estimated_cost_usd": first.get("estimated_cost_usd"), + "remaining_cap_usd": first.get("remaining_cap_usd"), + } + ) + await session.send_event( + Event( + event_type="approval_required", + data=event_data, + ) + ) + + # Store all approval-requiring tools (ToolCall objects for execution) + session.pending_approval = { + "tool_calls": [tc for tc, _, _, _ in approval_required_tools], + } + + # Return early - wait for EXEC_APPROVAL operation + return None + + iteration += 1 + + except ContextWindowExceededError: + # Force compact and retry this iteration. + cm = session.context_manager + logger.warning( + "ContextWindowExceededError at iteration %d β€” forcing compaction " + "(usage=%d, model_max_tokens=%d, messages=%d)", + iteration, + cm.running_context_usage, + cm.model_max_tokens, + len(cm.items), + ) + cm.running_context_usage = cm.model_max_tokens + 1 + await _compact_and_notify(session) + # Same guard as the top of the loop: if compaction couldn't + # bring us under threshold, _compact_and_notify has already + # emitted session_terminated and set is_running=False. Continue + # would just re-call the LLM with the same too-big context. + if not session.is_running: + break + continue + + except Exception as e: + import traceback + + error_msg = _friendly_error_message( + e, + user_plan=getattr(session, "user_plan", None), + ) + if error_msg is None: + error_msg = str(e) + "\n" + traceback.format_exc() + + await session.send_event( + Event( + event_type="error", + data={"error": error_msg}, + ) + ) + errored = True + break + + if session.is_cancelled: + await _cleanup_on_cancel(session) + await session.send_event(Event(event_type="interrupted")) + elif not errored: + if await _maybe_pause_for_usage_threshold( + session, + continuation="complete_turn", + final_response=final_response + if isinstance(final_response, str) + else None, + ): + return final_response + await session.send_event( + Event( + event_type="turn_complete", + data={ + "history_size": len(session.context_manager.items), + "final_response": final_response + if isinstance(final_response, str) + else None, + }, + ) + ) + + # Increment turn counter and check for auto-save + session.increment_turn() + await session.auto_save_if_needed() + + return final_response + + @staticmethod + async def undo(session: Session) -> None: + """Remove the last complete turn and notify the frontend.""" + removed = session.context_manager.undo_last_turn() + if not removed: + logger.warning("Undo: no user message found to remove") + await session.send_event(Event(event_type="undo_complete")) + + @staticmethod + async def new_conversation(session: Session, *, clear_screen: bool = False) -> None: + """Start a fresh conversation inside the active runtime.""" + try: + result = session.start_new_conversation() + except Exception as e: + await session.send_event( + Event(event_type="error", data={"error": f"New chat failed: {e}"}) + ) + return + result["clear_screen"] = clear_screen + await session.send_event(Event(event_type="new_complete", data=result)) + + @staticmethod + async def resume(session: Session, path: str) -> None: + """Reload context from a saved session log into the active session.""" + from agent.core.session_resume import restore_session_from_log + + try: + result = restore_session_from_log(session, Path(path)) + except Exception as e: + await session.send_event( + Event(event_type="error", data={"error": f"Resume failed: {e}"}) + ) + return + await session.send_event(Event(event_type="resume_complete", data=result)) + + @staticmethod + async def _exec_usage_threshold_approval( + session: Session, approvals: list[dict] + ) -> None: + pending = ( + session.pending_approval + if isinstance(session.pending_approval, dict) + else {} + ) + tool_call_id = str(pending.get("tool_call_id") or "") + approval = next( + (item for item in approvals if item.get("tool_call_id") == tool_call_id), + {"approved": False}, + ) + approved = bool(approval.get("approved")) + + session.pending_approval = None + if not tool_call_id: + await session.send_event( + Event( + event_type="error", + data={"error": "Usage approval is missing its approval id"}, + ) + ) + return + + if not approved: + feedback = str(approval.get("feedback") or "Stopped by user").strip() + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tool_call_id, + "tool": USAGE_THRESHOLD_TOOL_NAME, + "state": "rejected", + }, + ) + ) + await session.send_event( + Event( + event_type="tool_output", + data={ + "tool": USAGE_THRESHOLD_TOOL_NAME, + "tool_call_id": tool_call_id, + "output": feedback, + "success": False, + }, + ) + ) + await session.send_event(Event(event_type="interrupted")) + session.increment_turn() + await session.auto_save_if_needed() + return + + current_spend = _coerce_float(pending.get("current_spend_usd")) + acknowledged_threshold = _coerce_float(pending.get("threshold_usd")) + next_threshold = next_usage_warning_threshold( + current_spend, + acknowledged_threshold, + ) + session.usage_warning_next_threshold_usd = next_threshold + pending["next_threshold_usd"] = next_threshold + + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tool_call_id, + "tool": USAGE_THRESHOLD_TOOL_NAME, + "state": "approved", + }, + ) + ) + await session.send_event( + Event( + event_type="tool_output", + data={ + "tool": USAGE_THRESHOLD_TOOL_NAME, + "tool_call_id": tool_call_id, + "output": _usage_output_message(pending), + "success": True, + }, + ) + ) + + if pending.get("continuation") == "complete_turn": + final_response = pending.get("final_response") + await session.send_event( + Event( + event_type="turn_complete", + data={ + "history_size": int( + pending.get("history_size") + or len(session.context_manager.items) + ), + "final_response": final_response + if isinstance(final_response, str) + else None, + }, + ) + ) + session.increment_turn() + await session.auto_save_if_needed() + return + + await Handlers.run_agent(session, "") + + @staticmethod + async def _exec_yolo_budget_approval( + session: Session, approvals: list[dict] + ) -> None: + pending = ( + session.pending_approval + if isinstance(session.pending_approval, dict) + else {} + ) + tool_call_id = str(pending.get("tool_call_id") or "") + approval = next( + (item for item in approvals if item.get("tool_call_id") == tool_call_id), + {"approved": False}, + ) + approved = bool(approval.get("approved")) + + if not tool_call_id: + session.pending_approval = None + await session.send_event( + Event( + event_type="error", + data={"error": "YOLO budget approval is missing its approval id"}, + ) + ) + return + + if not approved: + session.pending_approval = None + feedback = str(approval.get("feedback") or "Stopped by user").strip() + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tool_call_id, + "tool": "yolo_budget", + "state": "rejected", + }, + ) + ) + await session.send_event( + Event( + event_type="tool_output", + data={ + "tool": "yolo_budget", + "tool_call_id": tool_call_id, + "output": feedback, + "success": False, + }, + ) + ) + await session.send_event(Event(event_type="interrupted")) + session.increment_turn() + await session.auto_save_if_needed() + return + + can_resume, reason = yolo_budget_can_resume(session, pending) + if not can_resume: + pending["reason"] = reason + pending["current_spend_usd"] = round( + float( + getattr(session, "auto_approval_estimated_spend_usd", 0.0) or 0.0 + ), + 6, + ) + pending["remaining_cap_usd"] = ( + None + if getattr(session, "auto_approval_cost_cap_usd", None) is None + else session.auto_approval_remaining_usd + ) + tool = yolo_budget_pending_to_tool(pending) + await session.send_event( + Event( + event_type="approval_required", + data={ + "tools": [tool], + "count": 1, + "yolo_budget": True, + "auto_approval_blocked": True, + "block_reason": reason, + "estimated_cost_usd": pending.get("estimated_next_usd"), + "remaining_cap_usd": pending.get("remaining_cap_usd"), + }, + ) + ) + return + + session.pending_approval = None + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tool_call_id, + "tool": "yolo_budget", + "state": "approved", + }, + ) + ) + await session.send_event( + Event( + event_type="tool_output", + data={ + "tool": "yolo_budget", + "tool_call_id": tool_call_id, + "output": "YOLO budget check acknowledged.", + "success": True, + }, + ) + ) + + if pending.get("continuation") == "complete_turn": + final_response = pending.get("final_response") + await session.send_event( + Event( + event_type="turn_complete", + data={ + "history_size": int( + pending.get("history_size") + or len(session.context_manager.items) + ), + "final_response": final_response + if isinstance(final_response, str) + else None, + }, + ) + ) + session.increment_turn() + await session.auto_save_if_needed() + return + + await Handlers.run_agent(session, "") + + @staticmethod + async def exec_approval(session: Session, approvals: list[dict]) -> None: + """Handle batch job execution approval""" + if not session.pending_approval: + await session.send_event( + Event( + event_type="error", + data={"error": "No pending approval to process"}, + ) + ) + return + + if is_usage_threshold_pending(session.pending_approval): + await Handlers._exec_usage_threshold_approval(session, approvals) + return + if is_yolo_budget_pending(session.pending_approval): + await Handlers._exec_yolo_budget_approval(session, approvals) + return + + tool_calls = session.pending_approval.get("tool_calls", []) + if not tool_calls: + await session.send_event( + Event( + event_type="error", + data={"error": "No pending tool calls found"}, + ) + ) + return + + # Create a map of tool_call_id -> approval decision + approval_map = {a["tool_call_id"]: a for a in approvals} + for a in approvals: + if a.get("edited_script"): + logger.info( + f"Received edited script for tool_call {a['tool_call_id']} ({len(a['edited_script'])} chars)" + ) + + # Separate approved and rejected tool calls + approved_tasks = [] + rejected_tasks = [] + + for tc in tool_calls: + tool_name = tc.function.name + try: + tool_args = json.loads(tc.function.arguments) + except (json.JSONDecodeError, TypeError) as e: + # Malformed arguments β€” treat as failed, notify agent + logger.warning(f"Malformed tool arguments for {tool_name}: {e}") + tool_msg = Message( + role="tool", + content=f"Malformed arguments: {e}", + tool_call_id=tc.id, + name=tool_name, + ) + session.context_manager.add_message(tool_msg) + await session.send_event( + Event( + event_type="tool_output", + data={ + "tool": tool_name, + "tool_call_id": tc.id, + "output": f"Malformed arguments: {e}", + "success": False, + }, + ) + ) + continue + + approval_decision = approval_map.get(tc.id, {"approved": False}) + + if approval_decision.get("approved", False): + edited_script = approval_decision.get("edited_script") + was_edited = False + if edited_script and "script" in tool_args: + tool_args["script"] = edited_script + was_edited = True + logger.info(f"Using user-edited script for {tool_name} ({tc.id})") + selected_namespace = approval_decision.get("namespace") + if selected_namespace and tool_name == "hf_jobs": + tool_args["namespace"] = selected_namespace + approved_tasks.append((tc, tool_name, tool_args, was_edited)) + else: + rejected_tasks.append((tc, tool_name, approval_decision)) + + reserved_manual_spend_usd = 0.0 + blocked_manual_budget: tuple[ToolCall, str, BudgetDecision] | None = None + for tc, tool_name, tool_args, _was_edited in approved_tasks: + budget = await _check_manual_approved_budget( + session, + tool_name, + tool_args, + reserved_spend_usd=reserved_manual_spend_usd, + ) + if not budget.allowed: + blocked_manual_budget = (tc, tool_name, budget) + break + if budget.billable and budget.estimated_cost_usd is not None: + reserved_manual_spend_usd += budget.estimated_cost_usd + + if blocked_manual_budget is not None: + blocked_tc, _blocked_tool, blocked_budget = blocked_manual_budget + tools_data = [] + for tc in tool_calls: + try: + args = json.loads(tc.function.arguments) + except (json.JSONDecodeError, AttributeError, TypeError): + args = {} + payload = { + "tool": getattr(tc.function, "name", None), + "arguments": args, + "tool_call_id": tc.id, + } + if tc.id == blocked_tc.id: + payload.update( + { + "auto_approval_blocked": True, + "block_reason": blocked_budget.block_reason, + "estimated_cost_usd": blocked_budget.estimated_cost_usd, + "remaining_cap_usd": blocked_budget.remaining_cap_usd, + } + ) + tools_data.append(payload) + await session.send_event( + Event( + event_type="approval_required", + data={ + "tools": tools_data, + "count": len(tools_data), + "auto_approval_blocked": True, + "block_reason": blocked_budget.block_reason, + "estimated_cost_usd": blocked_budget.estimated_cost_usd, + "remaining_cap_usd": blocked_budget.remaining_cap_usd, + }, + ) + ) + return + + # Clear pending approval immediately so a page refresh during + # execution won't re-show the approval dialog. + session.pending_approval = None + + # Notify frontend of approval decisions immediately (before execution) + for tc, tool_name, tool_args, _was_edited in approved_tasks: + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tc.id, + "tool": tool_name, + "state": "approved", + }, + ) + ) + for tc, tool_name, approval_decision in rejected_tasks: + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tc.id, + "tool": tool_name, + "state": "rejected", + }, + ) + ) + + # Execute all approved tools concurrently + async def execute_tool(tc, tool_name, tool_args, was_edited): + """Execute a single tool and return its result. + + The TraceLog already exists on the frontend (created by + approval_required), so we send tool_state_change instead of + tool_call to avoid creating a duplicate. + """ + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tc.id, + "tool": tool_name, + "state": "running", + }, + ) + ) + + budget = await _record_manual_approved_spend_if_needed( + session, + tool_name, + tool_args, + tool_call_id=tc.id, + ) + if not budget.allowed: + return ( + tc, + tool_name, + budget.block_reason or "YOLO budget blocked this tool call.", + False, + was_edited, + ) + + output, success = await session.tool_router.call_tool( + tool_name, tool_args, session=session, tool_call_id=tc.id + ) + if not success and budget.reservation: + release_budget_reservation(session, budget.reservation.reservation_id) + + return (tc, tool_name, output, success, was_edited) + + # Execute all approved tools concurrently (cancellable) + if approved_tasks: + gather_task = asyncio.ensure_future( + asyncio.gather( + *[ + execute_tool(tc, tool_name, tool_args, was_edited) + for tc, tool_name, tool_args, was_edited in approved_tasks + ], + return_exceptions=True, + ) + ) + cancel_task = asyncio.ensure_future(session._cancelled.wait()) + + done, _ = await asyncio.wait( + [gather_task, cancel_task], + return_when=asyncio.FIRST_COMPLETED, + ) + + if cancel_task in done: + gather_task.cancel() + try: + await gather_task + except asyncio.CancelledError: + pass + # Notify frontend that approved tools were cancelled + for tc, tool_name, _args, _was_edited in approved_tasks: + await session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": tc.id, + "tool": tool_name, + "state": "cancelled", + }, + ) + ) + await _cleanup_on_cancel(session) + await session.send_event(Event(event_type="interrupted")) + session.increment_turn() + await session.auto_save_if_needed() + return + + cancel_task.cancel() + results = gather_task.result() + + # Process results and add to context + for result in results: + if isinstance(result, Exception): + # Handle execution error + logger.error(f"Tool execution error: {result}") + continue + + tc, tool_name, output, success, was_edited = result + + if was_edited: + output = f"[Note: The user edited the script before execution. The output below reflects the user-modified version, not your original script.]\n\n{output}" + + # Add tool result to context + tool_msg = Message( + role="tool", + content=output, + tool_call_id=tc.id, + name=tool_name, + ) + session.context_manager.add_message(tool_msg) + + await session.send_event( + Event( + event_type="tool_output", + data={ + "tool": tool_name, + "tool_call_id": tc.id, + "output": output, + "success": success, + }, + ) + ) + + # Process rejected tools + for tc, tool_name, approval_decision in rejected_tasks: + rejection_msg = "Job execution cancelled by user" + user_feedback = approval_decision.get("feedback") + if user_feedback: + # Ensure feedback is a string and sanitize any problematic characters + feedback_str = str(user_feedback).strip() + # Remove any control characters that might break JSON parsing + feedback_str = "".join( + char for char in feedback_str if ord(char) >= 32 or char in "\n\t" + ) + rejection_msg += f". User feedback: {feedback_str}" + + # Ensure rejection_msg is a clean string + rejection_msg = str(rejection_msg).strip() + + tool_msg = Message( + role="tool", + content=rejection_msg, + tool_call_id=tc.id, + name=tool_name, + ) + session.context_manager.add_message(tool_msg) + + await session.send_event( + Event( + event_type="tool_output", + data={ + "tool": tool_name, + "tool_call_id": tc.id, + "output": rejection_msg, + "success": False, + }, + ) + ) + + # Continue agent loop with empty input to process the tool results + await Handlers.run_agent(session, "") + + @staticmethod + async def shutdown(session: Session) -> bool: + """Handle shutdown (like shutdown in codex.rs:1329)""" + # Save session trajectory if enabled (fire-and-forget, returns immediately) + if session.config.save_sessions: + logger.info("Saving session...") + repo_id = session.config.session_dataset_repo + _ = session.save_and_upload_detached(repo_id) + + session.is_running = False + if not getattr(session, "local_mode", False): + await teardown_session_sandbox(session) + await session.send_event(Event(event_type="shutdown")) + return True + + +async def process_submission(session: Session, submission) -> bool: + """ + Process a single submission and return whether to continue running. + + Returns: + bool: True to continue, False to shutdown + """ + op = submission.operation + logger.debug("Received operation: %s", op.op_type.value) + + if op.op_type == OpType.USER_INPUT: + text = op.data.get("text", "") if op.data else "" + await Handlers.run_agent(session, text) + return True + + if op.op_type == OpType.COMPACT: + await _compact_and_notify(session) + return True + + if op.op_type == OpType.UNDO: + await Handlers.undo(session) + return True + + if op.op_type == OpType.NEW: + clear_screen = bool((op.data or {}).get("clear_screen")) + await Handlers.new_conversation(session, clear_screen=clear_screen) + return True + + if op.op_type == OpType.RESUME: + path = op.data.get("path") if op.data else None + if path: + await Handlers.resume(session, path) + else: + await session.send_event( + Event(event_type="error", data={"error": "Resume requires a path"}) + ) + return True + + if op.op_type == OpType.EXEC_APPROVAL: + approvals = op.data.get("approvals", []) if op.data else [] + await Handlers.exec_approval(session, approvals) + return True + + if op.op_type == OpType.SHUTDOWN: + return not await Handlers.shutdown(session) + + logger.warning(f"Unknown operation: {op.op_type}") + return True + + +async def submission_loop( + submission_queue: asyncio.Queue, + event_queue: asyncio.Queue, + config: Config, + tool_router: ToolRouter | None = None, + session_holder: list | None = None, + hf_token: str | None = None, + user_id: str | None = None, + local_mode: bool = False, + stream: bool = True, + notification_gateway: NotificationGateway | None = None, + notification_destinations: list[str] | None = None, + defer_turn_complete_notification: bool = False, + user_plan: str | None = None, +) -> None: + """ + Main agent loop - processes submissions and dispatches to handlers. + This is the core of the agent (like submission_loop in codex.rs:1259-1340) + """ + + # Create session with tool router + session = Session( + event_queue, + config=config, + tool_router=tool_router, + hf_token=hf_token, + user_id=user_id, + user_plan=user_plan, + local_mode=local_mode, + stream=stream, + notification_gateway=notification_gateway, + notification_destinations=notification_destinations, + defer_turn_complete_notification=defer_turn_complete_notification, + ) + if session_holder is not None: + session_holder[0] = session + if not local_mode: + start_cpu_sandbox_preload(session) + logger.info("Agent loop started") + + # Retry any failed uploads from previous sessions (fire-and-forget). + # Includes the personal trace repo when enabled so a session that failed + # to publish to the user's HF dataset gets a fresh attempt on next run. + if config and config.save_sessions: + Session.retry_failed_uploads_detached( + directory=str(DEFAULT_SESSION_LOG_DIR), + repo_id=config.session_dataset_repo, + personal_repo_id=session._personal_trace_repo_id(), + ) + + try: + # Main processing loop + async with tool_router: + # Emit ready event after initialization + await session.send_event( + Event( + event_type="ready", + data={ + "message": "Agent initialized", + "tool_count": len(tool_router.tools), + }, + ) + ) + + while session.is_running: + submission = await submission_queue.get() + + try: + should_continue = await process_submission(session, submission) + if not should_continue: + break + except asyncio.CancelledError: + logger.warning("Agent loop cancelled") + break + except Exception as e: + logger.error(f"Error in agent loop: {e}") + await session.send_event( + Event(event_type="error", data={"error": str(e)}) + ) + + logger.info("Agent loop exited") + + finally: + # Emergency save if session saving is enabled and shutdown wasn't called properly + if session.config.save_sessions and session.is_running: + logger.info("Emergency save: preserving session before exit...") + try: + local_path = session.save_and_upload_detached( + session.config.session_dataset_repo + ) + if local_path: + logger.info("Emergency save successful, upload in progress") + except Exception as e: + logger.error(f"Emergency save failed: {e}") diff --git a/agent/core/approval_policy.py b/agent/core/approval_policy.py new file mode 100644 index 0000000000000000000000000000000000000000..73098ca61dffca66929984bd5b5c34e532106f18 --- /dev/null +++ b/agent/core/approval_policy.py @@ -0,0 +1,11 @@ +"""Shared predicates for approval-gated tool operations.""" + +from typing import Any + + +def normalize_tool_operation(operation: Any) -> str: + return str(operation or "").strip().lower() + + +def is_scheduled_operation(operation: Any) -> bool: + return normalize_tool_operation(operation).startswith("scheduled ") diff --git a/agent/core/cost_estimation.py b/agent/core/cost_estimation.py new file mode 100644 index 0000000000000000000000000000000000000000..a41ad196efec7495c7ca9141d2f7f3a4f38e6dbd --- /dev/null +++ b/agent/core/cost_estimation.py @@ -0,0 +1,282 @@ +"""Conservative cost estimates for auto-approved infrastructure actions.""" + +import os +import re +import time +from dataclasses import dataclass +from typing import Any + +import httpx + +OPENID_PROVIDER_URL = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface.co") +JOBS_HARDWARE_URL = f"{OPENID_PROVIDER_URL}/api/jobs/hardware" +JOBS_PRICE_CACHE_TTL_S = 6 * 60 * 60 + +DEFAULT_JOB_TIMEOUT_HOURS = 0.5 +DEFAULT_SANDBOX_RESERVATION_HOURS = 1.0 + +# Static fallback prices are intentionally conservative enough for a budget +# guard. The live /api/jobs/hardware catalog wins whenever it is reachable. +HF_JOBS_PRICE_USD_PER_HOUR: dict[str, float] = { + "cpu-basic": 0.05, + "cpu-upgrade": 0.25, + "cpu-performance": 0.50, + "cpu-xl": 1.00, + "t4-small": 0.60, + "t4-medium": 0.90, + "l4x1": 1.00, + "l4x4": 4.00, + "l40sx1": 2.00, + "l40sx4": 8.00, + "l40sx8": 16.00, + "a10g-small": 1.00, + "a10g-large": 2.00, + "a10g-largex2": 4.00, + "a10g-largex4": 8.00, + "a100-large": 4.00, + "a100x4": 16.00, + "a100x8": 32.00, + "h200": 10.00, + "h200x2": 20.00, + "h200x4": 40.00, + "h200x8": 80.00, + "inf2x6": 6.00, +} + +SPACE_PRICE_USD_PER_HOUR: dict[str, float] = { + "cpu-basic": 0.0, + "cpu-upgrade": 0.05, + "cpu-performance": 0.50, + "cpu-xl": 1.00, + "t4-small": 0.60, + "t4-medium": 0.90, + "l4x1": 1.00, + "l4x4": 4.00, + "l40sx1": 2.00, + "l40sx4": 8.00, + "l40sx8": 16.00, + "a10g-small": 1.00, + "a10g-large": 2.00, + "a10g-largex2": 4.00, + "a10g-largex4": 8.00, + "a100-large": 4.00, + "a100x4": 16.00, + "a100x8": 32.00, + "h200": 10.00, + "h200x2": 20.00, + "h200x4": 40.00, + "h200x8": 80.00, + "inf2x6": 6.00, +} + +_DURATION_RE = re.compile(r"^\s*(\d+(?:\.\d+)?)\s*([smhd]?)\s*$", re.IGNORECASE) +_PRICE_RE = re.compile(r"(\d+(?:\.\d+)?)") +_jobs_price_cache: tuple[float, dict[str, float]] | None = None + + +@dataclass(frozen=True) +class CostEstimate: + """Estimated cost for a tool call. + + ``estimated_cost_usd=None`` means the call may be billable but we could not + estimate it safely, so auto-approval should fall back to a human decision. + """ + + estimated_cost_usd: float | None + billable: bool + block_reason: str | None = None + label: str | None = None + + +def parse_timeout_hours( + value: Any, *, default_hours: float = DEFAULT_JOB_TIMEOUT_HOURS +) -> float | None: + """Parse HF timeout values into hours. + + Strings accept ``s``, ``m``, ``h``, or ``d`` suffixes. Numeric values are + treated as seconds, matching the Hub client's typed timeout parameter. + """ + if value is None or value == "": + return default_hours + if isinstance(value, bool): + return None + if isinstance(value, int | float): + seconds = float(value) + return seconds / 3600 if seconds > 0 else None + if not isinstance(value, str): + return None + + match = _DURATION_RE.match(value) + if not match: + return None + amount = float(match.group(1)) + unit = match.group(2).lower() or "s" + if amount <= 0: + return None + if unit == "s": + return amount / 3600 + if unit == "m": + return amount / 60 + if unit == "h": + return amount + if unit == "d": + return amount * 24 + return None + + +def _extract_flavor(item: dict[str, Any]) -> str | None: + for key in ("flavor", "name", "id", "value", "hardware", "hardware_flavor"): + value = item.get(key) + if isinstance(value, str) and value: + return value + return None + + +def _coerce_price(value: Any) -> float | None: + if isinstance(value, bool) or value is None: + return None + if isinstance(value, int | float): + return float(value) if value >= 0 else None + if isinstance(value, str): + match = _PRICE_RE.search(value.replace(",", "")) + if match: + return float(match.group(1)) + return None + + +def _extract_hourly_price(item: dict[str, Any]) -> float | None: + for key in ( + "price", + "price_usd", + "priceUsd", + "price_per_hour", + "pricePerHour", + "hourly_price", + "hourlyPrice", + "usd_per_hour", + "usdPerHour", + ): + price = _coerce_price(item.get(key)) + if price is not None: + return price + for key in ("pricing", "billing", "cost"): + nested = item.get(key) + if isinstance(nested, dict): + price = _extract_hourly_price(nested) + if price is not None: + return price + return None + + +def _iter_hardware_items(payload: Any): + if isinstance(payload, list): + for item in payload: + yield from _iter_hardware_items(item) + elif isinstance(payload, dict): + if _extract_flavor(payload): + yield payload + for key in ("hardware", "flavors", "items", "data", "jobs"): + child = payload.get(key) + if child is not None: + yield from _iter_hardware_items(child) + + +def _parse_jobs_price_catalog(payload: Any) -> dict[str, float]: + prices: dict[str, float] = {} + for item in _iter_hardware_items(payload): + flavor = _extract_flavor(item) + price = _extract_hourly_price(item) + if flavor and price is not None: + prices[flavor] = price + return prices + + +async def hf_jobs_price_catalog() -> dict[str, float]: + """Return live HF Jobs hourly prices, falling back to static prices.""" + global _jobs_price_cache + now = time.monotonic() + if _jobs_price_cache and now - _jobs_price_cache[0] < JOBS_PRICE_CACHE_TTL_S: + return dict(_jobs_price_cache[1]) + + prices: dict[str, float] = {} + try: + async with httpx.AsyncClient(timeout=3.0) as client: + response = await client.get(JOBS_HARDWARE_URL) + if response.status_code == 200: + prices = _parse_jobs_price_catalog(response.json()) + except (httpx.HTTPError, ValueError): + prices = {} + + if not prices: + prices = dict(HF_JOBS_PRICE_USD_PER_HOUR) + else: + prices = {**HF_JOBS_PRICE_USD_PER_HOUR, **prices} + + _jobs_price_cache = (now, prices) + return dict(prices) + + +async def estimate_hf_job_cost(args: dict[str, Any]) -> CostEstimate: + flavor = str( + args.get("hardware_flavor") + or args.get("flavor") + or args.get("hardware") + or "cpu-basic" + ) + timeout_hours = parse_timeout_hours(args.get("timeout")) + if timeout_hours is None: + return CostEstimate( + estimated_cost_usd=None, + billable=True, + block_reason=f"Could not parse HF job timeout: {args.get('timeout')!r}.", + label=flavor, + ) + + prices = await hf_jobs_price_catalog() + price = prices.get(flavor) + if price is None: + return CostEstimate( + estimated_cost_usd=None, + billable=True, + block_reason=f"No price is available for HF job hardware '{flavor}'.", + label=flavor, + ) + + return CostEstimate( + estimated_cost_usd=round(price * timeout_hours, 4), + billable=price > 0, + label=flavor, + ) + + +async def estimate_sandbox_cost( + args: dict[str, Any], *, session: Any = None +) -> CostEstimate: + if session is not None and getattr(session, "sandbox", None): + return CostEstimate(estimated_cost_usd=0.0, billable=False, label="existing") + + hardware = str(args.get("hardware") or "cpu-basic") + price = SPACE_PRICE_USD_PER_HOUR.get(hardware) + if price is None: + return CostEstimate( + estimated_cost_usd=None, + billable=True, + block_reason=f"No price is available for sandbox hardware '{hardware}'.", + label=hardware, + ) + + return CostEstimate( + estimated_cost_usd=round(price * DEFAULT_SANDBOX_RESERVATION_HOURS, 4), + billable=price > 0, + label=hardware, + ) + + +async def estimate_tool_cost( + tool_name: str, args: dict[str, Any], *, session: Any = None +) -> CostEstimate: + if tool_name == "sandbox_create": + return await estimate_sandbox_cost(args, session=session) + if tool_name == "hf_jobs": + return await estimate_hf_job_cost(args) + return CostEstimate(estimated_cost_usd=0.0, billable=False) diff --git a/agent/core/doom_loop.py b/agent/core/doom_loop.py new file mode 100644 index 0000000000000000000000000000000000000000..3b57fe2cc3cffd07b466db9ac98cc0d0b665de79 --- /dev/null +++ b/agent/core/doom_loop.py @@ -0,0 +1,190 @@ +""" +Doom-loop detection for repeated tool call patterns. + +Detects when the agent is stuck calling the same tools repeatedly +and injects a corrective prompt to break the cycle. +""" + +import hashlib +import json +import logging +from dataclasses import dataclass + +from litellm import Message + +logger = logging.getLogger(__name__) + + +@dataclass(frozen=True) +class ToolCallSignature: + """Hashable signature for a single tool call plus its observed result.""" + + name: str + args_hash: str + result_hash: str | None = None + + +def _normalize_args(args_str: str) -> str: + """Canonicalise a tool-call arguments string before hashing. + + LLMs can emit semantically-identical JSON for the same call with different + key orderings (``{"a": 1, "b": 2}`` vs ``{"b": 2, "a": 1}``) or whitespace + (``{"a":1}`` vs ``{"a": 1}``). Hashing the raw bytes makes the doom-loop + detector miss those repeats. We parse-and-redump with ``sort_keys=True`` + plus the most compact separators so trivially-different spellings collapse + to the same canonical form. + + Falls back to the original string if the input isn't valid JSON (e.g. a + handful of providers occasionally pass a bare string for ``arguments``); + that path keeps the legacy behaviour and never raises. + """ + if not args_str: + return "" + try: + return json.dumps(json.loads(args_str), sort_keys=True, separators=(",", ":")) + except (json.JSONDecodeError, TypeError, ValueError): + return args_str + + +def _hash_args(args_str: str) -> str: + """Return a short hash of the JSON arguments string. + + The input is normalised via :func:`_normalize_args` first so that + semantically-identical tool calls produce the same hash regardless of key + order or whitespace. + """ + return hashlib.md5(_normalize_args(args_str).encode()).hexdigest()[:12] + + +def extract_recent_tool_signatures( + messages: list[Message], lookback: int = 30 +) -> list[ToolCallSignature]: + """Extract tool call signatures from recent assistant messages. + + Includes the immediate tool result hash when present. This prevents + legitimate polling from being classified as a doom loop when the poll + arguments stay constant but the observed result keeps changing. + """ + signatures: list[ToolCallSignature] = [] + recent = messages[-lookback:] if len(messages) > lookback else messages + + for idx, msg in enumerate(recent): + if getattr(msg, "role", None) != "assistant": + continue + tool_calls = getattr(msg, "tool_calls", None) + if not tool_calls: + continue + for tc in tool_calls: + fn = getattr(tc, "function", None) + if not fn: + continue + name = getattr(fn, "name", "") or "" + args_str = getattr(fn, "arguments", "") or "" + result_hash = None + for follow in recent[idx + 1 :]: + role = getattr(follow, "role", None) + if role == "tool" and getattr(follow, "tool_call_id", None) == getattr( + tc, "id", None + ): + result_hash = _hash_args(str(getattr(follow, "content", "") or "")) + break + if role in {"assistant", "user"}: + break + signatures.append( + ToolCallSignature( + name=name, + args_hash=_hash_args(args_str), + result_hash=result_hash, + ) + ) + + return signatures + + +def detect_identical_consecutive( + signatures: list[ToolCallSignature], threshold: int = 3 +) -> str | None: + """Return the tool name if threshold+ identical consecutive calls are found.""" + if len(signatures) < threshold: + return None + + count = 1 + for i in range(1, len(signatures)): + if signatures[i] == signatures[i - 1]: + count += 1 + if count >= threshold: + return signatures[i].name + else: + count = 1 + + return None + + +def detect_repeating_sequence( + signatures: list[ToolCallSignature], +) -> list[ToolCallSignature] | None: + """Detect repeating patterns like [A,B,A,B] for sequences of length 2-5 with 2+ reps.""" + n = len(signatures) + for seq_len in range(2, 6): + min_required = seq_len * 2 + if n < min_required: + continue + + # Check the tail of the signatures list + tail = signatures[-min_required:] + pattern = tail[:seq_len] + + # Count how many full repetitions from the end + reps = 0 + for start in range(n - seq_len, -1, -seq_len): + chunk = signatures[start : start + seq_len] + if chunk == pattern: + reps += 1 + else: + break + + if reps >= 2: + return pattern + + return None + + +def check_for_doom_loop(messages: list[Message]) -> str | None: + """Check for doom loop patterns. Returns a corrective prompt or None.""" + signatures = extract_recent_tool_signatures(messages, lookback=30) + if len(signatures) < 3: + return None + + # Check for identical consecutive calls + tool_name = detect_identical_consecutive(signatures, threshold=3) + if tool_name: + logger.warning( + "Repetition guard activated: %d+ identical consecutive calls to '%s'", + 3, + tool_name, + ) + return ( + f"[SYSTEM: REPETITION GUARD] You have called '{tool_name}' with the same " + f"arguments multiple times in a row, getting the same result each time. " + f"STOP repeating this approach β€” it is not working. " + f"Step back and try a fundamentally different strategy. " + f"Consider: using a different tool, changing your arguments significantly, " + f"or explaining to the user what you're stuck on and asking for guidance." + ) + + # Check for repeating sequences + pattern = detect_repeating_sequence(signatures) + if pattern: + pattern_desc = " β†’ ".join(s.name for s in pattern) + logger.warning( + "Repetition guard activated: repeating sequence [%s]", pattern_desc + ) + return ( + f"[SYSTEM: REPETITION GUARD] You are stuck in a repeating cycle of tool calls: " + f"[{pattern_desc}]. This pattern has repeated multiple times without progress. " + f"STOP this cycle and try a fundamentally different approach. " + f"Consider: breaking down the problem differently, using alternative tools, " + f"or explaining to the user what you're stuck on and asking for guidance." + ) + + return None diff --git a/agent/core/effort_probe.py b/agent/core/effort_probe.py new file mode 100644 index 0000000000000000000000000000000000000000..583fdd5a996da5c3169ea5bcc6eb6e9b020a03ca --- /dev/null +++ b/agent/core/effort_probe.py @@ -0,0 +1,297 @@ +"""Probe-and-cascade for reasoning effort on /model switch. + +We don't maintain a per-model capability table. Instead, the first time a +user picks a model we fire a 1-token ping with the same params we'd use +for real and walk down a cascade (``max`` β†’ ``xhigh`` β†’ ``high`` β†’ …) +until the provider stops rejecting us. The result is cached per-model on +the session, so real messages don't pay the probe cost again. + +Three outcomes, classified from the 400 error text: + +* success β†’ cache the effort that worked +* ``"thinking ... not supported"`` β†’ model doesn't do thinking at all; + cache ``None`` so we stop sending thinking params +* ``"effort ... invalid"`` / synonyms β†’ cascade walks down and retries + +Transient errors (5xx, timeout, connection reset) bubble out as +``ProbeInconclusive`` so the caller can complete the switch with a +warning instead of blocking on a flaky provider. +""" + +from __future__ import annotations + +import asyncio +import logging +import time +from dataclasses import dataclass +from typing import Any + +from litellm import acompletion + +from agent.core.llm_params import UnsupportedEffortError, _resolve_llm_params +from agent.core.prompt_caching import router_session_id_for, with_prompt_cache_params +from agent.core.yolo_budget import maybe_pause_yolo_after_spend + +logger = logging.getLogger(__name__) + + +# Cascade: for each user-stated preference, the ordered list of levels to +# try. First success wins. HF Router accepts low/medium/high generically; +# higher preferences are kept in the cascade for future/provider-specific +# support and are skipped synchronously when unsupported. +_EFFORT_CASCADE: dict[str, list[str]] = { + "max": ["max", "xhigh", "high", "medium", "low"], + "xhigh": ["xhigh", "high", "medium", "low"], + "high": ["high", "medium", "low"], + "medium": ["medium", "low"], + "minimal": ["minimal", "low"], + "low": ["low"], +} + +_PROBE_TIMEOUT = 15.0 +# Keep the probe cheap, but high enough that frontier reasoning models can +# finish a trivial reply instead of tripping a false "output limit reached" +# error during capability detection. +_PROBE_MAX_TOKENS = 64 + + +class ProbeInconclusive(Exception): + """The probe couldn't reach a verdict (transient network / provider error). + + Caller should complete the switch with a warning β€” the next real call + will re-surface the error if it's persistent. + """ + + +@dataclass +class ProbeOutcome: + """What the probe learned. ``effective_effort`` semantics match the cache: + + * str β†’ send this level + * None β†’ model doesn't support thinking; strip it + """ + + effective_effort: str | None + attempts: int + elapsed_ms: int + note: str | None = None # e.g. "max not supported, falling back" + + +def _is_thinking_unsupported(e: Exception) -> bool: + """Model rejected any thinking config. + + Substring-match because exact wording shifts across models and providers. + """ + s = str(e).lower() + return "thinking" in s and "not supported" in s + + +def _is_invalid_effort(e: Exception) -> bool: + """The requested effort level isn't accepted for this model. + + Covers API responses with "invalid", "must be one of", etc. and local + validation that fires *before* the request. The cascade walks down on + either. + + Explicitly returns False when the message is really about thinking + itself. That case is caught by ``_is_thinking_unsupported``. + """ + if _is_thinking_unsupported(e): + return False + s = str(e).lower() + if "effort" not in s and "output_config" not in s: + return False + return any( + phrase in s + for phrase in ( + "invalid", + "not supported", + "must be one of", + "not a valid", + "unrecognized", + "unknown", + # LiteLLM's own pre-flight validation phrasing. + "only supported by", + "is only supported", + ) + ) + + +def _is_transient(e: Exception) -> bool: + """Network / provider-side flake. Keep in sync with agent_loop's list. + + Also matches by type for ``asyncio.TimeoutError`` β€” its ``str(e)`` is + empty, so substring matching alone misses it. + """ + if isinstance(e, (asyncio.TimeoutError, TimeoutError)): + return True + s = str(e).lower() + return any( + p in s + for p in ( + "timeout", + "timed out", + "429", + "rate limit", + "503", + "service unavailable", + "502", + "bad gateway", + "500", + "internal server error", + "overloaded", + "capacity", + "connection reset", + "connection refused", + "connection error", + "eof", + "broken pipe", + ) + ) + + +async def probe_effort( + model_name: str, + preference: str | None, + hf_token: str | None, + session: Any = None, +) -> ProbeOutcome: + """Walk the cascade for ``preference`` on ``model_name``. + + Returns the first effort the provider accepts, or ``None`` if it + rejects thinking altogether. Raises ``ProbeInconclusive`` only for + transient errors (5xx, timeout) β€” persistent 4xx that aren't thinking/ + effort related bubble as the original exception so callers can surface + them (auth, model-not-found, quota, etc.). + + ``session`` is optional; when provided, each successful probe attempt + is recorded via ``telemetry.record_llm_call(kind="effort_probe")`` so + the cost shows up in the session's ``total_cost_usd``. Failed probes + (rejected by the provider) typically aren't billed, so we only record + on success. + """ + loop = asyncio.get_event_loop() + start = loop.time() + attempts = 0 + + if not preference: + # User explicitly turned effort off β€” nothing to probe. A bare + # ping with no thinking params is pointless; just report "off". + return ProbeOutcome(effective_effort=None, attempts=0, elapsed_ms=0) + + cascade = _EFFORT_CASCADE.get(preference, [preference]) + skipped: list[str] = [] # levels the provider rejected synchronously + + last_error: Exception | None = None + for effort in cascade: + try: + params = _resolve_llm_params( + model_name, + hf_token, + reasoning_effort=effort, + strict=True, + ) + params = with_prompt_cache_params( + params, + session_id=router_session_id_for(session), + ) + except UnsupportedEffortError: + # Provider can't even accept this effort name (e.g. "max" on + # HF router). Skip without a network call. + skipped.append(effort) + continue + + attempts += 1 + probe_messages = [{"role": "user", "content": "ping"}] + params = {**params, "max_tokens": _PROBE_MAX_TOKENS} + try: + _t0 = time.monotonic() + response = await asyncio.wait_for( + acompletion( + messages=probe_messages, + stream=False, + **params, + ), + timeout=_PROBE_TIMEOUT, + ) + if session is not None: + # Best-effort telemetry β€” never let a logging blip propagate + # out of the probe and break model switching. + try: + from agent.core import telemetry + + usage = await telemetry.record_llm_call( + session, + model=model_name, + response=response, + latency_ms=int((time.monotonic() - _t0) * 1000), + finish_reason=response.choices[0].finish_reason + if response.choices + else None, + kind="effort_probe", + ) + if await maybe_pause_yolo_after_spend( + session, + spend_kind="effort_probe", + observed_cost_usd=usage.get("cost_usd") + if isinstance(usage, dict) + else None, + ): + return ProbeOutcome( + effective_effort=effort, + attempts=attempts, + elapsed_ms=int((loop.time() - start) * 1000), + note="YOLO budget paused effort probe", + ) + except Exception as _telem_err: + logger.debug("effort_probe telemetry failed: %s", _telem_err) + except Exception as e: + last_error = e + if _is_thinking_unsupported(e): + elapsed = int((loop.time() - start) * 1000) + return ProbeOutcome( + effective_effort=None, + attempts=attempts, + elapsed_ms=elapsed, + note="model doesn't support reasoning, dropped", + ) + if _is_invalid_effort(e): + logger.debug( + "probe: %s rejected effort=%s, trying next", model_name, effort + ) + continue + if _is_transient(e): + raise ProbeInconclusive(str(e)) from e + # Persistent non-thinking 4xx (auth, quota, model-not-found) β€” + # let the caller classify & surface. + raise + else: + elapsed = int((loop.time() - start) * 1000) + note = None + if effort != preference: + note = f"{preference} not supported, using {effort}" + return ProbeOutcome( + effective_effort=effort, + attempts=attempts, + elapsed_ms=elapsed, + note=note, + ) + + # Cascade exhausted without a success. This only happens when every + # level was either rejected synchronously (``UnsupportedEffortError``, + # e.g. preference=max on HF and we also somehow filtered all others) + # or the provider 400'd ``invalid effort`` on every level. + elapsed = int((loop.time() - start) * 1000) + if last_error is not None and not _is_invalid_effort(last_error): + raise last_error + note = ( + "no effort level accepted β€” proceeding without thinking" + if not skipped + else f"provider rejected all efforts ({', '.join(skipped)})" + ) + return ProbeOutcome( + effective_effort=None, + attempts=attempts, + elapsed_ms=elapsed, + note=note, + ) diff --git a/agent/core/hf_access.py b/agent/core/hf_access.py new file mode 100644 index 0000000000000000000000000000000000000000..cdfaaf41cf51a8410ca17456f60031d01a7e6594 --- /dev/null +++ b/agent/core/hf_access.py @@ -0,0 +1,201 @@ +"""Helpers for Hugging Face account / org access decisions. + +HF Jobs are gated by *credits*, not by HF Pro subscriptions. Any user who +has credits β€” on their personal account or on an org they belong to β€” can +launch jobs under that namespace. The picker UI lets the caller choose +which wallet to bill. +""" + +from __future__ import annotations + +import asyncio +import os +import re +from dataclasses import dataclass +from typing import Any, Literal + +import httpx + +OPENID_PROVIDER_URL = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface.co") +HF_BILLING_URL = "https://huggingface.co/settings/billing" +HF_PRO_SUBSCRIBE_URL = "https://huggingface.co/subscribe/pro" + +HfUserPlan = Literal["free", "pro"] + + +@dataclass(frozen=True) +class JobsAccess: + """Namespaces the caller may bill HF Jobs to.""" + + username: str | None + org_names: list[str] + eligible_namespaces: list[str] + default_namespace: str | None + + +class JobsAccessError(Exception): + """Structured jobs-namespace error. + + ``namespace_required`` fires when the caller belongs to more than one + eligible namespace and the UI must prompt them to pick one. There is no + longer an ``upgrade_required`` state β€” Pro is irrelevant; HF Jobs are + gated on per-wallet credits, surfaced separately when the API returns + a billing error at job-creation time. + """ + + def __init__( + self, + message: str, + *, + access: JobsAccess | None = None, + namespace_required: bool = False, + ) -> None: + super().__init__(message) + self.access = access + self.namespace_required = namespace_required + + +def _extract_username(whoami: dict[str, Any]) -> str | None: + for key in ("name", "user", "preferred_username"): + value = whoami.get(key) + if isinstance(value, str) and value: + return value + return None + + +def _org_names(whoami: dict[str, Any]) -> list[str]: + """All orgs the caller belongs to. + + Plan/tier is ignored β€” credits live on the namespace itself, so any + org the user belongs to can host a job as long as it has credits. + """ + names: list[str] = [] + orgs = whoami.get("orgs") or [] + if not isinstance(orgs, list): + return names + for org in orgs: + if not isinstance(org, dict): + continue + name = org.get("name") + if isinstance(name, str) and name: + names.append(name) + return sorted(set(names)) + + +def jobs_access_from_whoami(whoami: dict[str, Any]) -> JobsAccess: + username = _extract_username(whoami) + org_names = _org_names(whoami) + eligible: list[str] = [] + if username: + eligible.append(username) + eligible.extend(org_names) + default = username if username else (org_names[0] if org_names else None) + return JobsAccess( + username=username, + org_names=org_names, + eligible_namespaces=eligible, + default_namespace=default, + ) + + +def normalize_hf_user_plan(whoami: Any) -> HfUserPlan | None: + """Normalize a whoami-v2 payload to the supported HF account plan tiers.""" + if not isinstance(whoami, dict): + return None + if whoami.get("isPro") is True: + return "pro" + return "free" + + +async def fetch_whoami_v2(token: str, timeout: float = 5.0) -> dict[str, Any] | None: + if not token: + return None + async with httpx.AsyncClient(timeout=timeout) as client: + try: + response = await client.get( + f"{OPENID_PROVIDER_URL}/api/whoami-v2", + headers={"Authorization": f"Bearer {token}"}, + ) + if response.status_code != 200: + return None + payload = response.json() + return payload if isinstance(payload, dict) else None + except (httpx.HTTPError, ValueError): + return None + + +async def get_jobs_access(token: str) -> JobsAccess | None: + whoami = await fetch_whoami_v2(token) + if whoami is None: + return None + return jobs_access_from_whoami(whoami) + + +async def resolve_jobs_namespace( + token: str, + requested_namespace: str | None = None, +) -> tuple[str, JobsAccess | None]: + """Return the namespace to use for jobs. + + If whoami-v2 is unavailable, fall back to the token owner's username. + """ + access = await get_jobs_access(token) + if access: + if requested_namespace: + if requested_namespace in access.eligible_namespaces: + return requested_namespace, access + raise JobsAccessError( + f"You can only run jobs under your own account or an org you belong to. " + f"Allowed namespaces: {', '.join(access.eligible_namespaces) or '(none)'}", + access=access, + ) + if access.default_namespace: + return access.default_namespace, access + raise JobsAccessError( + "Couldn't resolve a Hugging Face namespace for this token.", + access=access, + ) + + # Fallback: whoami-v2 unavailable. Don't block the call pre-emptively. + from huggingface_hub import HfApi + + username = None + if token: + whoami = await asyncio.to_thread(HfApi(token=token).whoami) + username = whoami.get("name") + if not username: + raise JobsAccessError("No HF token available to resolve a jobs namespace.") + return requested_namespace or username, None + + +_BILLING_PATTERNS = re.compile( + r"\b(insufficient[_\s-]?credits?|out\s+of\s+credits?|" + r"payment\s+required|billing|no\s+credits?|add\s+credits?|requires?\s+credits?|" + r"credits?\s+(?:exhausted|used\s+up|limit))\b", + re.IGNORECASE, +) + +_INFERENCE_BILLING_PATTERNS = re.compile( + r"\b(insufficient[_\s-]?quota|out\s+of\s+monthly\s+credits?|" + r"exhausted\s+monthly\s+credits?|" + r"quota[_\s-]?(?:exceeded|exhausted|limit|insufficient)|" + r"monthly\s+credits?\s+(?:exhausted|used\s+up|limit))\b", + re.IGNORECASE, +) + + +def is_billing_error(message: str) -> bool: + """True if an HF API error message looks like an out-of-credits / billing error.""" + if not message: + return False + if "402" in message: + return True + return bool(_BILLING_PATTERNS.search(message)) + + +def is_inference_billing_error(error: Exception | str) -> bool: + """True if an Inference Providers error looks like exhausted credits.""" + message = str(error) + return is_billing_error(message) or bool( + _INFERENCE_BILLING_PATTERNS.search(message) + ) diff --git a/agent/core/hf_router_catalog.py b/agent/core/hf_router_catalog.py new file mode 100644 index 0000000000000000000000000000000000000000..1efabb5ed26d65fc44a5dd6c1075259dae5578ac --- /dev/null +++ b/agent/core/hf_router_catalog.py @@ -0,0 +1,126 @@ +"""Fetch and cache the HF Inference Router model catalog. + +The router exposes an OpenAI-compatible listing at +``https://router.huggingface.co/v1/models`` with per-provider availability, +pricing, context length, and tool-use support. We use it to: + + β€’ Validate ``/model`` switches with live data instead of a hard-coded allowlist. + β€’ Show the user which providers serve a model, at what price, and whether they + support tool calls. + +The listing is cached in-memory for a few minutes so repeated lookups during a +session are free. On fetch failure we return stale data if we have it, or an +empty catalog otherwise. +""" + +import logging +import time +from dataclasses import dataclass +from difflib import get_close_matches +from typing import Optional + +import httpx + +logger = logging.getLogger(__name__) + +_CATALOG_URL = "https://router.huggingface.co/v1/models" +_CACHE_TTL_SECONDS = 300 +_CACHE_FAILURE_TTL_SECONDS = 15 +_HTTP_TIMEOUT_SECONDS = 5.0 + +_cache: Optional[dict] = None +_cache_time: float = 0.0 +_last_fetch_error: Optional[str] = None + + +@dataclass +class ProviderInfo: + provider: str + status: str + context_length: Optional[int] + input_price: Optional[float] + output_price: Optional[float] + supports_tools: bool + + +@dataclass +class ModelInfo: + id: str + providers: list[ProviderInfo] + + @property + def live_providers(self) -> list[ProviderInfo]: + return [p for p in self.providers if p.status == "live"] + + @property + def any_supports_tools(self) -> bool: + return any(p.supports_tools for p in self.live_providers) + + +def _fetch_catalog(force: bool = False) -> dict: + global _cache, _cache_time, _last_fetch_error + now = time.time() + ttl = _CACHE_FAILURE_TTL_SECONDS if _last_fetch_error else _CACHE_TTL_SECONDS + if not force and _cache is not None and now - _cache_time < ttl: + return _cache + try: + resp = httpx.get(_CATALOG_URL, timeout=_HTTP_TIMEOUT_SECONDS) + resp.raise_for_status() + _cache = resp.json() + _cache_time = now + _last_fetch_error = None + except Exception as e: + logger.warning("Failed to fetch HF router catalog: %s", e) + _last_fetch_error = str(e) + if _cache is None: + _cache = {"data": []} + _cache_time = now + return _cache + + +def _parse_entry(entry: dict) -> ModelInfo: + providers = [] + for p in entry.get("providers", []) or []: + pricing = p.get("pricing") or {} + providers.append( + ProviderInfo( + provider=p.get("provider", ""), + status=p.get("status", ""), + context_length=p.get("context_length"), + input_price=pricing.get("input"), + output_price=pricing.get("output"), + supports_tools=bool(p.get("supports_tools", False)), + ) + ) + return ModelInfo(id=entry.get("id", ""), providers=providers) + + +def lookup(model_id: str) -> Optional[ModelInfo]: + """Find a model in the router catalog. + + Accepts ``/`` or ``/:`` β€” the tag is stripped + for lookup. Returns ``None`` if the model isn't listed. + """ + bare = model_id.split(":", 1)[0] + catalog = _fetch_catalog() + for entry in catalog.get("data", []): + if entry.get("id") == bare: + return _parse_entry(entry) + return None + + +def fuzzy_suggest(model_id: str, limit: int = 3) -> list[str]: + """Return the closest model ids from the catalog.""" + bare = model_id.split(":", 1)[0] + catalog = _fetch_catalog() + ids = [e.get("id", "") for e in catalog.get("data", []) if e.get("id")] + return get_close_matches(bare, ids, n=limit, cutoff=0.4) + + +def prewarm() -> None: + """Fetch the catalog so subsequent lookups are instant. Safe to call from + a background task β€” swallows failures.""" + try: + _fetch_catalog(force=False) + except Exception: + pass diff --git a/agent/core/hf_tokens.py b/agent/core/hf_tokens.py new file mode 100644 index 0000000000000000000000000000000000000000..a7e3df341e8dd69f23486f9aafca234f60aa54a9 --- /dev/null +++ b/agent/core/hf_tokens.py @@ -0,0 +1,77 @@ +"""Hugging Face token resolution helpers.""" + +from __future__ import annotations + +import os +from typing import Any + + +def clean_hf_token(token: str | None) -> str | None: + """Normalize token strings the same way huggingface_hub does.""" + if token is None: + return None + return token.replace("\r", "").replace("\n", "").strip() or None + + +def get_cached_hf_token() -> str | None: + """Return the token from huggingface_hub's normal env/cache lookup.""" + try: + from huggingface_hub import get_token + + return get_token() + except Exception: + return None + + +def resolve_hf_token( + *candidates: str | None, + include_cached: bool = True, +) -> str | None: + """Return the first non-empty explicit token, then optionally HF cache.""" + for token in candidates: + cleaned = clean_hf_token(token) + if cleaned: + return cleaned + if include_cached: + return get_cached_hf_token() + return None + + +def resolve_hf_router_token(session_hf_token: str | None = None) -> str | None: + """Resolve the token used for Hugging Face Router LLM calls. + + App-specific precedence: + 1. session_hf_token: the active user/session token. + 2. huggingface_hub.get_token(): HF_TOKEN/HUGGING_FACE_HUB_TOKEN or + local ``hf auth login`` cache. + """ + return resolve_hf_token(session_hf_token) + + +def bearer_token_from_header(auth_header: str | None) -> str | None: + """Extract a cleaned bearer token from an Authorization header.""" + if not auth_header or not auth_header.startswith("Bearer "): + return None + return clean_hf_token(auth_header[7:]) + + +def resolve_hf_request_token( + request: Any, + *, + include_env_fallback: bool = True, +) -> str | None: + """Resolve a user token from a FastAPI request. + + This intentionally does not use the local ``hf auth login`` cache. Backend + request paths should act as the browser user from Authorization/cookie, or + fall back only to an explicit server ``HF_TOKEN`` in dev/server contexts. + """ + token = bearer_token_from_header(request.headers.get("Authorization", "")) + if token: + return token + token = clean_hf_token(request.cookies.get("hf_access_token")) + if token: + return token + if include_env_fallback: + return clean_hf_token(os.environ.get("HF_TOKEN")) + return None diff --git a/agent/core/hub_artifacts.py b/agent/core/hub_artifacts.py new file mode 100644 index 0000000000000000000000000000000000000000..17634ef780f7d2708ba81eaf5dae5f6e098b494d --- /dev/null +++ b/agent/core/hub_artifacts.py @@ -0,0 +1,794 @@ +"""Best-effort Hub metadata for artifacts generated by ML Intern sessions.""" + +import asyncio +import base64 +import logging +import re +import shlex +import tempfile +import textwrap +from datetime import datetime +from pathlib import Path +from typing import Any + +from huggingface_hub import hf_hub_download +from huggingface_hub.repocard import metadata_load, metadata_save +from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError + +logger = logging.getLogger(__name__) + +ML_INTERN_TAG = "ml-intern" +SUPPORTED_REPO_TYPES = {"model", "dataset", "space"} +PROVENANCE_MARKER = "" +_COLLECTION_TITLE_PREFIX = "ml-intern-artifacts" +_COLLECTION_TITLE_MAX_LENGTH = 59 +_UUID_SESSION_ID_RE = re.compile( + r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-" + r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$" +) +_KNOWN_ARTIFACTS_ATTR = "_ml_intern_known_hub_artifacts" +_REGISTERED_ARTIFACTS_ATTR = "_ml_intern_registered_hub_artifacts" +_COLLECTION_SLUG_ATTR = "_ml_intern_artifact_collection_slug" +_SESSION_ARTIFACT_SET_FALLBACK: dict[tuple[int, str], set[str]] = {} +_USAGE_HEADING_RE = re.compile( + r"^#{2,6}\s+(usage|how to use|using this (model|dataset)|use this (model|dataset))\b", + re.IGNORECASE | re.MULTILINE, +) +_FRONT_MATTER_RE = re.compile(r"\A---\s*\n.*?\n---\s*\n?", re.DOTALL) + + +def _safe_session_id(session: Any) -> str: + raw = str(getattr(session, "session_id", "") or "unknown-session") + safe = re.sub(r"[^A-Za-z0-9._-]+", "-", raw).strip("-") + return safe or "unknown-session" + + +def session_artifact_date(session: Any) -> str: + """Return the YYYY-MM-DD partition date for a session.""" + raw = getattr(session, "session_start_time", None) + if raw: + try: + return datetime.fromisoformat(str(raw).replace("Z", "+00:00")).strftime( + "%Y-%m-%d" + ) + except ValueError: + logger.debug("Could not parse session_start_time=%r", raw) + return datetime.utcnow().strftime("%Y-%m-%d") + + +def _collection_session_id_fragment(session: Any) -> str: + safe_id = _safe_session_id(session) + if _UUID_SESSION_ID_RE.match(safe_id): + return safe_id[:8] + stem = f"{_COLLECTION_TITLE_PREFIX}-{session_artifact_date(session)}-" + max_id_length = max(1, _COLLECTION_TITLE_MAX_LENGTH - len(stem)) + if len(safe_id) <= max_id_length: + return safe_id + return safe_id[:max_id_length].rstrip("-._") or safe_id[:max_id_length] + + +def artifact_collection_title(session: Any) -> str: + return ( + f"{_COLLECTION_TITLE_PREFIX}-{session_artifact_date(session)}-" + f"{_collection_session_id_fragment(session)}" + ) + + +def _artifact_key(repo_id: str, repo_type: str | None) -> str: + return f"{repo_type or 'model'}:{repo_id}" + + +def _sandbox_space_name_pattern() -> str: + from agent.tools.sandbox_tool import SANDBOX_SPACE_NAME_RE + + return SANDBOX_SPACE_NAME_RE.pattern + + +def is_sandbox_hub_repo(repo_id: str | None, repo_type: str | None) -> bool: + """Return True for ML Intern's ephemeral sandbox Space repos.""" + if (repo_type or "model") != "space" or not repo_id: + return False + repo_name = str(repo_id).rsplit("/", 1)[-1] + return bool(re.fullmatch(_sandbox_space_name_pattern(), repo_name)) + + +def _session_artifact_set(session: Any, attr: str) -> set[str]: + current = getattr(session, attr, None) + if isinstance(current, set): + return current + current = set() + try: + setattr(session, attr, current) + except Exception: + logger.warning( + "Could not attach %s to session; using process-local fallback state", + attr, + ) + return _SESSION_ARTIFACT_SET_FALLBACK.setdefault((id(session), attr), set()) + return current + + +def _emit_hub_artifact_event(session: Any, repo_id: str, repo_type: str) -> None: + """Best-effort `hub_artifact` session event for streaming/persistence. + + Lets API/web consumers see created repos as they happen. Tool code runs + both on the agent's event loop and in worker threads (asyncio.to_thread), + so schedule onto the loop stashed by Session.send_event when there is no + running loop here. Failures are swallowed β€” the session's Hub artifact + collection remains the durable backstop. + """ + if is_sandbox_hub_repo(repo_id, repo_type): + return + send_event = getattr(session, "send_event", None) + if send_event is None: + return + try: + from agent.core.session import Event + + event = Event( + event_type="hub_artifact", + data={"repo_id": repo_id, "repo_type": repo_type}, + ) + try: + asyncio.get_running_loop().create_task(send_event(event)) + except RuntimeError: + loop = getattr(session, "_main_event_loop", None) + if loop is None or loop.is_closed(): + return + asyncio.run_coroutine_threadsafe(send_event(event), loop) + except Exception as e: + logger.debug("hub_artifact event emission failed for %s: %s", repo_id, e) + + +def remember_hub_artifact(session: Any, repo_id: str, repo_type: str | None) -> None: + if session is None or not repo_id: + return + known = _session_artifact_set(session, _KNOWN_ARTIFACTS_ATTR) + key = _artifact_key(repo_id, repo_type) + if key in known: + return + known.add(key) + _emit_hub_artifact_event(session, repo_id, repo_type or "model") + + +def is_known_hub_artifact(session: Any, repo_id: str, repo_type: str | None) -> bool: + if session is None or not repo_id: + return False + return _artifact_key(repo_id, repo_type) in _session_artifact_set( + session, _KNOWN_ARTIFACTS_ATTR + ) + + +def _merge_tags(metadata: dict[str, Any], tag: str = ML_INTERN_TAG) -> dict[str, Any]: + merged = dict(metadata) + raw_tags = merged.get("tags") + if raw_tags is None: + tags: list[str] = [] + elif isinstance(raw_tags, str): + tags = [raw_tags] + elif isinstance(raw_tags, list): + tags = [str(item) for item in raw_tags] + else: + tags = [str(raw_tags)] + + if tag not in tags: + tags.append(tag) + merged["tags"] = tags + return merged + + +def _metadata_from_content(content: str) -> dict[str, Any]: + with tempfile.TemporaryDirectory() as tmp_dir: + path = Path(tmp_dir) / "README.md" + path.write_text(content, encoding="utf-8") + return metadata_load(path) or {} + + +def _content_with_metadata(content: str, metadata: dict[str, Any]) -> str: + with tempfile.TemporaryDirectory() as tmp_dir: + path = Path(tmp_dir) / "README.md" + path.write_text(content, encoding="utf-8") + metadata_save(path, metadata) + return path.read_text(encoding="utf-8") + + +def _body_without_metadata(content: str) -> str: + return _FRONT_MATTER_RE.sub("", content, count=1).strip() + + +def _append_section(content: str, section: str) -> str: + base = content.rstrip() + if base: + return f"{base}\n\n{section.strip()}\n" + return f"{section.strip()}\n" + + +def _provenance_section(repo_type: str) -> str: + label = {"model": "model", "dataset": "dataset"}.get(repo_type, "Hub") + return f"""{PROVENANCE_MARKER} +## Generated by ML Intern + +This {label} repository was generated by [ML Intern](https://github.com/huggingface/ml-intern), an agent for machine learning research and development on the Hugging Face Hub. + +- Try ML Intern: https://smolagents-ml-intern.hf.space +- Source code: https://github.com/huggingface/ml-intern +""" + + +def _usage_section(repo_id: str, repo_type: str) -> str: + if repo_type == "dataset": + return f"""## Usage + +```python +from datasets import load_dataset + +dataset = load_dataset("{repo_id}") +``` +""" + + return f"""## Usage + +```python +from transformers import AutoModelForCausalLM, AutoTokenizer + +model_id = "{repo_id}" +tokenizer = AutoTokenizer.from_pretrained(model_id) +model = AutoModelForCausalLM.from_pretrained(model_id) +``` + +For non-causal architectures, replace `AutoModelForCausalLM` with the appropriate `AutoModel` class. +""" + + +def augment_repo_card_content( + content: str | None, + repo_id: str, + repo_type: str = "model", + *, + extra_metadata: dict[str, Any] | None = None, +) -> str: + """Return README content with ML Intern metadata and provenance added.""" + repo_type = repo_type or "model" + content = content or "" + metadata = _metadata_from_content(content) + if extra_metadata: + metadata = {**extra_metadata, **metadata} + metadata = _merge_tags(metadata) + updated = _content_with_metadata(content, metadata) + + if not _body_without_metadata(updated): + updated = _append_section(updated, f"# {repo_id}") + + if repo_type in {"model", "dataset"} and PROVENANCE_MARKER not in updated: + updated = _append_section(updated, _provenance_section(repo_type)) + if not _USAGE_HEADING_RE.search(content): + updated = _append_section(updated, _usage_section(repo_id, repo_type)) + + return updated + + +def _read_remote_readme( + api: Any, + repo_id: str, + repo_type: str, + *, + token: str | bool | None = None, +) -> str: + token_value = token if token is not None else getattr(api, "token", None) + try: + readme_path = hf_hub_download( + repo_id=repo_id, + filename="README.md", + repo_type=repo_type, + token=token_value, + ) + except (EntryNotFoundError, RepositoryNotFoundError): + return "" + return Path(readme_path).read_text(encoding="utf-8") + + +def _update_repo_card( + api: Any, + repo_id: str, + repo_type: str, + *, + token: str | bool | None = None, + extra_metadata: dict[str, Any] | None = None, +) -> None: + current = _read_remote_readme(api, repo_id, repo_type, token=token) + updated = augment_repo_card_content( + current, + repo_id, + repo_type, + extra_metadata=extra_metadata, + ) + if updated == current: + return + api.upload_file( + path_or_fileobj=updated.encode("utf-8"), + path_in_repo="README.md", + repo_id=repo_id, + repo_type=repo_type, + token=token, + commit_message="Update ML Intern artifact metadata", + ) + + +def _ensure_collection_slug( + api: Any, + session: Any, + *, + token: str | bool | None = None, +) -> str | None: + slug = getattr(session, _COLLECTION_SLUG_ATTR, None) + if slug: + return slug + + title = artifact_collection_title(session) + collection = api.create_collection( + title=title, + description=( + f"Artifacts generated by ML Intern session {_safe_session_id(session)} " + f"on {session_artifact_date(session)}." + ), + private=True, + exists_ok=True, + token=token, + ) + slug = getattr(collection, "slug", None) + if slug: + setattr(session, _COLLECTION_SLUG_ATTR, slug) + return slug + + +def _add_to_collection( + api: Any, + session: Any, + repo_id: str, + repo_type: str, + *, + token: str | bool | None = None, +) -> bool: + slug = _ensure_collection_slug(api, session, token=token) + if not slug: + return False + api.add_collection_item( + collection_slug=slug, + item_id=repo_id, + item_type=repo_type, + note=( + f"Generated by ML Intern session {_safe_session_id(session)} " + f"on {session_artifact_date(session)}." + ), + exists_ok=True, + token=token, + ) + return True + + +def register_hub_artifact( + api: Any, + repo_id: str, + repo_type: str = "model", + *, + session: Any = None, + token: str | bool | None = None, + extra_metadata: dict[str, Any] | None = None, + force: bool = False, +) -> bool: + """Tag, card, and collection-register a Hub artifact without raising.""" + if session is None or not repo_id: + return False + repo_type = repo_type or "model" + if repo_type not in SUPPORTED_REPO_TYPES: + return False + if is_sandbox_hub_repo(repo_id, repo_type): + return False + + key = _artifact_key(repo_id, repo_type) + remember_hub_artifact(session, repo_id, repo_type) + registered = _session_artifact_set(session, _REGISTERED_ARTIFACTS_ATTR) + if key in registered and not force: + return True + + token_value = token if token is not None else getattr(api, "token", None) + card_updated = False + collection_updated = False + try: + _update_repo_card( + api, + repo_id, + repo_type, + token=token_value, + extra_metadata=extra_metadata, + ) + card_updated = True + except Exception as e: + logger.debug("ML Intern repo-card update failed for %s: %s", repo_id, e) + + try: + collection_updated = _add_to_collection( + api, + session, + repo_id, + repo_type, + token=token_value, + ) + except Exception as e: + logger.debug("ML Intern collection update failed for %s: %s", repo_id, e) + + if card_updated and collection_updated: + registered.add(key) + return True + return False + + +def build_hub_artifact_sitecustomize(session: Any) -> str: + """Build standalone sitecustomize.py code for HF Jobs Python processes.""" + if session is None or not getattr(session, "session_id", None): + return "" + + session_id = _safe_session_id(session) + session_date = session_artifact_date(session) + collection_title = artifact_collection_title(session) + collection_slug = getattr(session, _COLLECTION_SLUG_ATTR, None) + + return ( + textwrap.dedent( + f""" + # Auto-generated by ML Intern. Best-effort Hub artifact metadata only. + def _install_ml_intern_artifact_hooks(): + import os + import re + import tempfile + from pathlib import Path + + try: + import huggingface_hub as _hub + from huggingface_hub import HfApi, hf_hub_download + from huggingface_hub.repocard import metadata_load, metadata_save + from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError + except Exception: + return + + session_id = {session_id!r} + session_date = {session_date!r} + collection_title = {collection_title!r} + tag = {ML_INTERN_TAG!r} + marker = {PROVENANCE_MARKER!r} + supported = {sorted(SUPPORTED_REPO_TYPES)!r} + sandbox_space_re = re.compile({_sandbox_space_name_pattern()!r}) + registering = False + collection_slug = {collection_slug!r} + registered = set() + usage_re = re.compile( + r"^#{{2,6}}\\s+(usage|how to use|using this (model|dataset)|use this (model|dataset))\\b", + re.IGNORECASE | re.MULTILINE, + ) + front_matter_re = re.compile(r"\\A---\\s*\\n.*?\\n---\\s*\\n?", re.DOTALL) + collection_cache_path = ( + os.environ.get("ML_INTERN_ARTIFACT_COLLECTION_CACHE") + or str( + Path(tempfile.gettempdir()) + / f"ml-intern-artifacts-{{session_id}}.collection" + ) + ) + + def _token(value=None, api=None): + if isinstance(value, str) and value: + return value + api_token = getattr(api, "token", None) + if isinstance(api_token, str) and api_token: + return api_token + return ( + os.environ.get("HF_TOKEN") + or os.environ.get("HUGGINGFACE_HUB_TOKEN") + or None + ) + + def _merge_tags(metadata): + metadata = dict(metadata or {{}}) + raw_tags = metadata.get("tags") + if raw_tags is None: + tags = [] + elif isinstance(raw_tags, str): + tags = [raw_tags] + elif isinstance(raw_tags, list): + tags = [str(item) for item in raw_tags] + else: + tags = [str(raw_tags)] + if tag not in tags: + tags.append(tag) + metadata["tags"] = tags + return metadata + + def _metadata_from_content(content): + with tempfile.TemporaryDirectory() as tmp_dir: + path = Path(tmp_dir) / "README.md" + path.write_text(content or "", encoding="utf-8") + return metadata_load(path) or {{}} + + def _content_with_metadata(content, metadata): + with tempfile.TemporaryDirectory() as tmp_dir: + path = Path(tmp_dir) / "README.md" + path.write_text(content or "", encoding="utf-8") + metadata_save(path, metadata) + return path.read_text(encoding="utf-8") + + def _body_without_metadata(content): + return front_matter_re.sub("", content or "", count=1).strip() + + def _append_section(content, section): + base = (content or "").rstrip() + if base: + return base + "\\n\\n" + section.strip() + "\\n" + return section.strip() + "\\n" + + def _provenance(repo_type): + label = {{"model": "model", "dataset": "dataset"}}.get( + repo_type, "Hub" + ) + return ( + marker + + "\\n## Generated by ML Intern\\n\\n" + + f"This {{label}} repository was generated by [ML Intern](https://github.com/huggingface/ml-intern), an agent for machine learning research and development on the Hugging Face Hub.\\n\\n" + + "- Try ML Intern: https://smolagents-ml-intern.hf.space\\n" + + "- Source code: https://github.com/huggingface/ml-intern\\n" + ) + + def _usage(repo_id, repo_type): + if repo_type == "dataset": + return ( + "## Usage\\n\\n" + "```python\\n" + "from datasets import load_dataset\\n\\n" + f"dataset = load_dataset({{repo_id!r}})\\n" + "```\\n" + ) + return ( + "## Usage\\n\\n" + "```python\\n" + "from transformers import AutoModelForCausalLM, AutoTokenizer\\n\\n" + f"model_id = {{repo_id!r}}\\n" + "tokenizer = AutoTokenizer.from_pretrained(model_id)\\n" + "model = AutoModelForCausalLM.from_pretrained(model_id)\\n" + "```\\n\\n" + "For non-causal architectures, replace `AutoModelForCausalLM` with the appropriate `AutoModel` class.\\n" + ) + + def _augment(content, repo_id, repo_type, extra_metadata=None): + metadata = _metadata_from_content(content or "") + if extra_metadata: + metadata = {{**extra_metadata, **metadata}} + updated = _content_with_metadata(content or "", _merge_tags(metadata)) + if not _body_without_metadata(updated): + updated = _append_section(updated, f"# {{repo_id}}") + if repo_type in {{"model", "dataset"}} and marker not in updated: + updated = _append_section(updated, _provenance(repo_type)) + if not usage_re.search(content or ""): + updated = _append_section(updated, _usage(repo_id, repo_type)) + return updated + + def _readme(api, repo_id, repo_type, token_value): + try: + path = hf_hub_download( + repo_id=repo_id, + filename="README.md", + repo_type=repo_type, + token=token_value, + ) + except (EntryNotFoundError, RepositoryNotFoundError): + return "" + return Path(path).read_text(encoding="utf-8") + + def _ensure_collection(api, token_value): + nonlocal collection_slug + if collection_slug: + return collection_slug + try: + cached_slug = Path(collection_cache_path).read_text( + encoding="utf-8" + ).strip() + if cached_slug: + collection_slug = cached_slug + return collection_slug + except Exception: + pass + collection = api.create_collection( + title=collection_title, + description=( + f"Artifacts generated by ML Intern session {{session_id}} " + f"on {{session_date}}." + ), + private=True, + exists_ok=True, + token=token_value, + ) + collection_slug = getattr(collection, "slug", None) + if collection_slug: + try: + cache_path = Path(collection_cache_path) + cache_path.parent.mkdir(parents=True, exist_ok=True) + cache_path.write_text(collection_slug, encoding="utf-8") + except Exception: + pass + return collection_slug + + def _register( + repo_id, + repo_type="model", + token_value=None, + extra_metadata=None, + force=False, + ): + nonlocal registering + if registering or not repo_id: + return + repo_type = repo_type or "model" + if repo_type not in supported: + return + if _is_sandbox_repo(repo_id, repo_type): + return + key = f"{{repo_type}}:{{repo_id}}" + if key in registered and not force: + return + registering = True + try: + token_value = _token(token_value) + api = HfApi(token=token_value) + card_updated = False + try: + current = _readme(api, repo_id, repo_type, token_value) + updated = _augment( + current, repo_id, repo_type, extra_metadata=extra_metadata + ) + if updated != current: + _original_upload_file( + api, + path_or_fileobj=updated.encode("utf-8"), + path_in_repo="README.md", + repo_id=repo_id, + repo_type=repo_type, + token=token_value, + commit_message="Update ML Intern artifact metadata", + ) + card_updated = True + except Exception: + pass + collection_updated = False + try: + slug = _ensure_collection(api, token_value) + if slug: + api.add_collection_item( + collection_slug=slug, + item_id=repo_id, + item_type=repo_type, + note=( + f"Generated by ML Intern session {{session_id}} " + f"on {{session_date}}." + ), + exists_ok=True, + token=token_value, + ) + collection_updated = True + except Exception: + pass + if card_updated and collection_updated: + registered.add(key) + finally: + registering = False + + _original_create_repo = HfApi.create_repo + _original_upload_file = HfApi.upload_file + _original_upload_folder = getattr(HfApi, "upload_folder", None) + _original_create_commit = getattr(HfApi, "create_commit", None) + + def _repo_id(args, kwargs): + return kwargs.get("repo_id") or (args[0] if args else None) + + def _repo_type(kwargs): + return kwargs.get("repo_type") or "model" + + def _is_sandbox_repo(repo_id, repo_type): + if (repo_type or "model") != "space" or not repo_id: + return False + repo_name = str(repo_id).rsplit("/", 1)[-1] + return bool(sandbox_space_re.fullmatch(repo_name)) + + def _patched_create_repo(self, *args, **kwargs): + result = _original_create_repo(self, *args, **kwargs) + repo_id = _repo_id(args, kwargs) + repo_type = _repo_type(kwargs) + extra = None + if repo_type == "space" and kwargs.get("space_sdk"): + extra = {{"sdk": kwargs.get("space_sdk")}} + _register(repo_id, repo_type, _token(kwargs.get("token"), self), extra) + return result + + def _patched_upload_file(self, *args, **kwargs): + result = _original_upload_file(self, *args, **kwargs) + if not kwargs.get("create_pr"): + force = kwargs.get("path_in_repo") == "README.md" + _register( + kwargs.get("repo_id"), + _repo_type(kwargs), + _token(kwargs.get("token"), self), + force=force, + ) + return result + + def _patched_upload_folder(self, *args, **kwargs): + result = _original_upload_folder(self, *args, **kwargs) + if not kwargs.get("create_pr"): + _register( + kwargs.get("repo_id"), + _repo_type(kwargs), + _token(kwargs.get("token"), self), + force=True, + ) + return result + + def _patched_create_commit(self, *args, **kwargs): + result = _original_create_commit(self, *args, **kwargs) + if not kwargs.get("create_pr"): + _register( + _repo_id(args, kwargs), + _repo_type(kwargs), + _token(kwargs.get("token"), self), + force=True, + ) + return result + + HfApi.create_repo = _patched_create_repo + HfApi.upload_file = _patched_upload_file + if _original_upload_folder is not None: + HfApi.upload_folder = _patched_upload_folder + if _original_create_commit is not None: + HfApi.create_commit = _patched_create_commit + + def _patch_module_func(name, method_name): + original = getattr(_hub, name, None) + if original is None: + return + method = getattr(HfApi, method_name) + + def _patched(*args, **kwargs): + api = HfApi(token=_token(kwargs.get("token"))) + return method(api, *args, **kwargs) + + setattr(_hub, name, _patched) + + _patch_module_func("create_repo", "create_repo") + _patch_module_func("upload_file", "upload_file") + if _original_upload_folder is not None: + _patch_module_func("upload_folder", "upload_folder") + if _original_create_commit is not None: + _patch_module_func("create_commit", "create_commit") + + try: + _install_ml_intern_artifact_hooks() + except Exception: + pass + """ + ).strip() + + "\n" + ) + + +def wrap_shell_command_with_hub_artifact_bootstrap( + command: str, + session: Any, +) -> str: + """Prefix a shell command so child Python processes load Hub hooks.""" + sitecustomize = build_hub_artifact_sitecustomize(session) + if not sitecustomize or not command: + return command + + encoded = base64.b64encode(sitecustomize.encode("utf-8")).decode("ascii") + bootstrap = ( + '_ml_intern_artifacts_dir="$(mktemp -d 2>/dev/null)" ' + f"&& printf %s {shlex.quote(encoded)} | base64 -d " + '> "$_ml_intern_artifacts_dir/sitecustomize.py" ' + '&& export PYTHONPATH="$_ml_intern_artifacts_dir${PYTHONPATH:+:$PYTHONPATH}"' + ) + return f"{bootstrap}; {command}" diff --git a/agent/core/llm_params.py b/agent/core/llm_params.py new file mode 100644 index 0000000000000000000000000000000000000000..d2f821c2b7e0e4c985faf6230d26404b72ffd6cb --- /dev/null +++ b/agent/core/llm_params.py @@ -0,0 +1,148 @@ +"""LiteLLM kwargs resolution for the model ids this agent accepts. + +Kept separate from ``agent_loop`` so tools (research, context compaction, etc.) +can import it without pulling in the whole agent loop / tool router and +creating circular imports. +""" + +import os + +from agent.core.hf_tokens import resolve_hf_router_token +from agent.core.local_models import ( + LOCAL_MODEL_API_KEY_DEFAULT, + LOCAL_MODEL_API_KEY_ENV, + LOCAL_MODEL_BASE_URL_ENV, + is_reserved_local_model_id, + local_model_name, + local_model_provider, +) +from agent.core.model_ids import ( + HF_ROUTER_BASE_URL, + strip_huggingface_model_prefix, +) + + +def _resolve_hf_router_token(session_hf_token: str | None = None) -> str | None: + """Backward-compatible private wrapper used by tests and older imports.""" + return resolve_hf_router_token(session_hf_token) + + +# Effort levels accepted on the wire. +# HF Router exposes reasoning controls through the OpenAI-compatible +# ``extra_body`` field. The probe cascade walks down when a provider rejects +# an accepted-looking value, so this stays intentionally small and generic. +_HF_EFFORTS = {"low", "medium", "high"} + + +def _hf_router_effort_level(reasoning_effort: str) -> str: + level = "low" if reasoning_effort == "minimal" else reasoning_effort + return level + + +class UnsupportedEffortError(ValueError): + """The requested effort isn't valid for this provider's API surface. + + Raised synchronously before any network call so the probe cascade can + skip levels the provider can't accept (e.g. ``max`` on HF router). + """ + + +def _local_api_base(base_url: str) -> str: + base = base_url.strip().rstrip("/") + if base.endswith("/v1"): + return base + return f"{base}/v1" + + +def _resolve_local_model_params( + model_name: str, + reasoning_effort: str | None = None, + strict: bool = False, +) -> dict: + if reasoning_effort and strict: + raise UnsupportedEffortError( + "Local OpenAI-compatible endpoints don't accept reasoning_effort" + ) + + local_name = local_model_name(model_name) + if local_name is None: + raise ValueError(f"Unsupported local model id: {model_name}") + + provider = local_model_provider(model_name) + assert provider is not None + raw_base = ( + os.environ.get(provider["base_url_env"]) + or os.environ.get(LOCAL_MODEL_BASE_URL_ENV) + or provider["base_url_default"] + ) + api_key = ( + os.environ.get(provider["api_key_env"]) + or os.environ.get(LOCAL_MODEL_API_KEY_ENV) + or LOCAL_MODEL_API_KEY_DEFAULT + ) + return { + "model": f"openai/{local_name}", + "api_base": _local_api_base(raw_base), + "api_key": api_key, + } + + +def _resolve_llm_params( + model_name: str, + session_hf_token: str | None = None, + reasoning_effort: str | None = None, + strict: bool = False, +) -> dict: + """ + Build LiteLLM kwargs for a given model id. + + β€’ ``ollama/``, ``vllm/``, ``lm_studio/``, and + ``llamacpp/`` β€” local OpenAI-compatible endpoints. The id prefix + selects a configurable localhost base URL, and the model suffix is sent + to LiteLLM as ``openai/``. These endpoints don't receive + ``reasoning_effort``. + + β€’ Anything else is treated as an HF Router id. We hit the auto-routing + OpenAI-compatible endpoint at ``https://router.huggingface.co/v1``. + The id can be bare or carry an HF routing suffix (``:fastest`` / + ``:cheapest`` / ``:``). A leading ``huggingface/`` is + stripped. ``reasoning_effort`` is forwarded via ``extra_body``. + "minimal" normalizes to "low". + + ``strict=True`` raises ``UnsupportedEffortError`` when the requested + effort isn't in the provider's accepted set, instead of silently + dropping it. The probe cascade uses strict mode so it can walk down + (``max`` β†’ ``xhigh`` β†’ ``high`` …) without making an API call. Regular + runtime callers leave ``strict=False``, so a stale cached effort + can't crash a turn β€” it just doesn't get sent. + + Token precedence for HF-router calls (first non-empty wins): + 1. session.hf_token β€” the user's own token (CLI / OAuth / cache file). + 2. huggingface_hub cache β€” ``HF_TOKEN`` / ``HUGGING_FACE_HUB_TOKEN`` / + local ``hf auth login`` cache. + """ + normalized_model = strip_huggingface_model_prefix(model_name) or model_name + + if is_reserved_local_model_id(normalized_model): + raise ValueError(f"Unsupported local model id: {normalized_model}") + + if local_model_provider(normalized_model) is not None: + return _resolve_local_model_params(normalized_model, reasoning_effort, strict) + + hf_model = normalized_model + api_key = _resolve_hf_router_token(session_hf_token) + params = { + "model": f"openai/{hf_model}", + "api_base": HF_ROUTER_BASE_URL, + "api_key": api_key, + } + if reasoning_effort: + hf_level = _hf_router_effort_level(reasoning_effort) + if hf_level not in _HF_EFFORTS: + if strict: + raise UnsupportedEffortError( + f"HF Router doesn't accept effort={hf_level!r}" + ) + else: + params["extra_body"] = {"reasoning_effort": hf_level} + return params diff --git a/agent/core/local_models.py b/agent/core/local_models.py new file mode 100644 index 0000000000000000000000000000000000000000..9f8a9491d635dd3892388ebfdd0f8384ac78144f --- /dev/null +++ b/agent/core/local_models.py @@ -0,0 +1,59 @@ +"""Helpers for CLI local OpenAI-compatible model ids.""" + +LOCAL_MODEL_PROVIDERS: dict[str, dict[str, str]] = { + "ollama/": { + "base_url_env": "OLLAMA_BASE_URL", + "base_url_default": "http://localhost:11434", + "api_key_env": "OLLAMA_API_KEY", + }, + "vllm/": { + "base_url_env": "VLLM_BASE_URL", + "base_url_default": "http://localhost:8000", + "api_key_env": "VLLM_API_KEY", + }, + "lm_studio/": { + "base_url_env": "LMSTUDIO_BASE_URL", + "base_url_default": "http://127.0.0.1:1234", + "api_key_env": "LMSTUDIO_API_KEY", + }, + "llamacpp/": { + "base_url_env": "LLAMACPP_BASE_URL", + "base_url_default": "http://localhost:8080", + "api_key_env": "LLAMACPP_API_KEY", + }, +} + +LOCAL_MODEL_PREFIXES = tuple(LOCAL_MODEL_PROVIDERS) +RESERVED_LOCAL_MODEL_PREFIXES = ("openai-compat/",) +LOCAL_MODEL_BASE_URL_ENV = "LOCAL_LLM_BASE_URL" +LOCAL_MODEL_API_KEY_ENV = "LOCAL_LLM_API_KEY" +LOCAL_MODEL_API_KEY_DEFAULT = "sk-local-no-key-required" + + +def local_model_provider(model_id: str) -> dict[str, str] | None: + """Return provider config for a local model id, if it uses a local prefix.""" + for prefix, config in LOCAL_MODEL_PROVIDERS.items(): + if model_id.startswith(prefix): + return config + return None + + +def local_model_name(model_id: str) -> str | None: + """Return the backend model name with the local provider prefix removed.""" + for prefix in LOCAL_MODEL_PREFIXES: + if model_id.startswith(prefix): + name = model_id[len(prefix) :] + return name or None + return None + + +def is_local_model_id(model_id: str) -> bool: + """Return True for non-empty, whitespace-free local model ids.""" + if not model_id or any(char.isspace() for char in model_id): + return False + return local_model_name(model_id) is not None + + +def is_reserved_local_model_id(model_id: str) -> bool: + """Return True for local-style prefixes intentionally not supported.""" + return model_id.startswith(RESERVED_LOCAL_MODEL_PREFIXES) diff --git a/agent/core/model_ids.py b/agent/core/model_ids.py new file mode 100644 index 0000000000000000000000000000000000000000..f1b6c4456149562b04b93df760f079983babb34d --- /dev/null +++ b/agent/core/model_ids.py @@ -0,0 +1,32 @@ +"""Canonical model ids for HF Router inference.""" + +HF_ROUTER_BASE_URL = "https://router.huggingface.co/v1" + +# Keep these as verbatim HF Router ids; version punctuation differs by model. +CLAUDE_OPUS_48_MODEL_ID = "anthropic/claude-opus-4.8:fal-ai" +GPT_55_MODEL_ID = "openai/gpt-5.5:fal-ai" +KIMI_K26_MODEL_ID = "moonshotai/Kimi-K2.6:novita" +MINIMAX_M27_MODEL_ID = "MiniMaxAI/MiniMax-M2.7:novita" +GLM_51_MODEL_ID = "zai-org/GLM-5.1:novita" +DEEPSEEK_V4_PRO_MODEL_ID = "deepseek-ai/DeepSeek-V4-Pro:novita" + +HOSTED_MODEL_IDS = { + CLAUDE_OPUS_48_MODEL_ID, + GPT_55_MODEL_ID, + KIMI_K26_MODEL_ID, + MINIMAX_M27_MODEL_ID, + GLM_51_MODEL_ID, + DEEPSEEK_V4_PRO_MODEL_ID, +} + + +def strip_huggingface_model_prefix(model_id: str | None) -> str | None: + """Return model ids without LiteLLM's optional ``huggingface/`` prefix.""" + if not model_id: + return model_id + return model_id.removeprefix("huggingface/") + + +def is_known_router_model_id(model_id: str | None) -> bool: + normalized = strip_huggingface_model_prefix(model_id) + return bool(normalized and normalized in HOSTED_MODEL_IDS) diff --git a/agent/core/model_switcher.py b/agent/core/model_switcher.py new file mode 100644 index 0000000000000000000000000000000000000000..b47b5d496361212604d06a7ceab689ebe5bd12a6 --- /dev/null +++ b/agent/core/model_switcher.py @@ -0,0 +1,290 @@ +"""Model-switching logic for the interactive CLI's ``/model`` command. + +Split out of ``agent.main`` so the REPL dispatcher stays focused on input +parsing. Exposes: + +* ``SUGGESTED_MODELS`` β€” the short list shown by ``/model`` with no arg. +* ``is_valid_model_id`` β€” loose format check on user input. +* ``probe_and_switch_model`` β€” async: checks routing, fires a 1-token + probe to resolve the effort cascade, then commits the switch (or + rejects it on hard error). + +The probe's cascade lives in ``agent.core.effort_probe``; this module +glues it to CLI output + session state. +""" + +from __future__ import annotations + +import asyncio + +from litellm import acompletion + +from agent.core.effort_probe import ProbeInconclusive, probe_effort +from agent.core.llm_params import _resolve_llm_params +from agent.core.local_models import ( + LOCAL_MODEL_PREFIXES, + is_local_model_id, + is_reserved_local_model_id, +) +from agent.core.model_ids import ( + CLAUDE_OPUS_48_MODEL_ID, + DEEPSEEK_V4_PRO_MODEL_ID, + GLM_51_MODEL_ID, + GPT_55_MODEL_ID, + KIMI_K26_MODEL_ID, + MINIMAX_M27_MODEL_ID, + strip_huggingface_model_prefix, +) + + +# Suggested models shown by `/model` (not a gate). Users can paste any HF +# Router model id (e.g. "MiniMaxAI/MiniMax-M2.7"). Append ":fastest", +# ":cheapest", ":preferred", or ":" to override the default routing +# policy (auto = fastest with failover). +SUGGESTED_MODELS = [ + {"id": CLAUDE_OPUS_48_MODEL_ID, "label": "Claude Opus 4.8"}, + {"id": GPT_55_MODEL_ID, "label": "GPT-5.5"}, + {"id": MINIMAX_M27_MODEL_ID, "label": "MiniMax M2.7"}, + {"id": KIMI_K26_MODEL_ID, "label": "Kimi K2.6"}, + {"id": GLM_51_MODEL_ID, "label": "GLM 5.1"}, + {"id": DEEPSEEK_V4_PRO_MODEL_ID, "label": "DeepSeek V4 Pro"}, +] + + +_ROUTING_POLICIES = {"fastest", "cheapest", "preferred"} +_LOCAL_PROBE_TIMEOUT = 15.0 + + +def is_valid_model_id(model_id: str) -> bool: + """Loose format check β€” lets users pick any model id. + + Accepts: + β€’ ollama/, vllm/, lm_studio/, llamacpp/ + β€’ /[:] (HF router; tag = provider or policy) + β€’ huggingface//[:] (same, optional LiteLLM prefix) + + Actual availability is verified against the HF router catalog on + switch, and by the provider on the probe's ping call. + """ + if not model_id: + return False + normalized_model_id = strip_huggingface_model_prefix(model_id) or model_id + if is_local_model_id(normalized_model_id): + return True + if is_reserved_local_model_id(normalized_model_id): + return False + if any(normalized_model_id.startswith(prefix) for prefix in LOCAL_MODEL_PREFIXES): + return False + if "/" not in normalized_model_id: + return False + head = normalized_model_id.split(":", 1)[0] + parts = head.split("/") + return len(parts) >= 2 and all(parts) + + +def _print_hf_routing_info(model_id: str, console) -> bool: + """Show HF router catalog info (providers, price, context, tool support) + for an HF-router model id. Returns ``True`` to signal the caller can + proceed with the switch, ``False`` to indicate a hard problem the user + should notice before we fire the effort probe. + + Local ids return ``True`` without printing anything. Router ids are checked + against the router catalog when possible; the probe below covers provider + availability for uncataloged ids. + """ + if is_local_model_id(model_id): + return True + + from agent.core import hf_router_catalog as cat + + bare, _, tag = model_id.partition(":") + info = cat.lookup(bare) + if info is None: + console.print( + f"[bold red]Warning:[/bold red] '{bare}' isn't in the HF router " + "catalog. Checking anyway β€” first call may fail." + ) + suggestions = cat.fuzzy_suggest(bare) + if suggestions: + console.print(f"[dim]Did you mean: {', '.join(suggestions)}[/dim]") + return True + + live = info.live_providers + if not live: + console.print( + f"[bold red]Warning:[/bold red] '{bare}' has no live providers " + "right now. First call will likely fail." + ) + return True + + if tag and tag not in _ROUTING_POLICIES: + matched = [p for p in live if p.provider == tag] + if not matched: + names = ", ".join(p.provider for p in live) + console.print( + f"[bold red]Warning:[/bold red] provider '{tag}' doesn't serve " + f"'{bare}'. Live providers: {names}. Checking anyway." + ) + + if not info.any_supports_tools: + console.print( + f"[bold red]Warning:[/bold red] no provider for '{bare}' advertises " + "tool-call support. This agent relies on tool calls β€” expect errors." + ) + + if tag in _ROUTING_POLICIES: + policy = tag + elif tag: + policy = f"pinned to {tag}" + else: + policy = "auto (fastest)" + console.print(f" [dim]routing: {policy}[/dim]") + for p in live: + price = ( + f"${p.input_price:g}/${p.output_price:g} per M tok" + if p.input_price is not None and p.output_price is not None + else "price n/a" + ) + ctx = f"{p.context_length:,} ctx" if p.context_length else "ctx n/a" + tools = "tools" if p.supports_tools else "no tools" + console.print(f" [dim]{p.provider}: {price}, {ctx}, {tools}[/dim]") + return True + + +def print_model_listing(config, console) -> None: + """Render the default ``/model`` (no-arg) view: current + suggested.""" + current = config.model_name if config else "" + console.print("[bold]Current model:[/bold]") + console.print(f" {current}") + console.print("\n[bold]Suggested:[/bold]") + for m in SUGGESTED_MODELS: + marker = " [dim]<-- current[/dim]" if m["id"] == current else "" + console.print(f" {m['id']} [dim]({m['label']})[/dim]{marker}") + console.print( + "\n[dim]Paste any HF model id (e.g. 'MiniMaxAI/MiniMax-M2.7').\n" + "Add ':fastest', ':cheapest', ':preferred', or ':' to override routing.\n" + "Use 'ollama/', 'vllm/', 'lm_studio/', or " + "'llamacpp/' for local OpenAI-compatible endpoints.[/dim]" + ) + + +def print_invalid_id(arg: str, console) -> None: + console.print(f"[bold red]Invalid model id format:[/bold red] {arg}") + console.print( + "[dim]Expected:\n" + " β€’ /[:tag] (HF router β€” paste from huggingface.co)\n" + " β€’ ollama/ | vllm/ | lm_studio/ | llamacpp/[/dim]" + ) + + +async def _probe_local_model(model_id: str) -> None: + params = _resolve_llm_params(model_id) + await asyncio.wait_for( + acompletion( + messages=[{"role": "user", "content": "ping"}], + max_tokens=1, + stream=False, + **params, + ), + timeout=_LOCAL_PROBE_TIMEOUT, + ) + + +async def probe_and_switch_model( + model_id: str, + config, + session, + console, + hf_token: str | None, +) -> None: + """Validate model+effort with a 1-token ping, cache the effective effort, + then commit the switch. + + Three visible outcomes: + + * βœ“ ``effort: `` β€” model accepted the preferred effort (or a + fallback from the cascade; the note explains if so) + * βœ“ ``effort: off`` β€” model doesn't support thinking; we'll strip it + * βœ— hard error (auth, model-not-found, quota) β€” we reject the switch + and keep the current model so the user isn't stranded + + For non-local models, transient errors (5xx, timeout) complete the switch + with a yellow warning; the next real call re-surfaces the error if it's + persistent. Local models reject every probe error, including timeouts, and + keep the current model. + """ + if is_local_model_id(model_id): + console.print(f"[dim]checking local model {model_id}...[/dim]") + try: + await _probe_local_model(model_id) + except Exception as e: + console.print(f"[bold red]Switch failed:[/bold red] {e}") + console.print(f"[dim]Keeping current model: {config.model_name}[/dim]") + return + + _commit_switch(model_id, config, session, effective=None, cache=True) + console.print( + f"[green]Model switched to {model_id}[/green] [dim](effort: off)[/dim]" + ) + return + + preference = config.reasoning_effort + if not _print_hf_routing_info(model_id, console): + return + + if not preference: + # Nothing to validate with a ping that we couldn't validate on the + # first real call just as cheaply. Skip the probe entirely. + _commit_switch(model_id, config, session, effective=None, cache=False) + console.print( + f"[green]Model switched to {model_id}[/green] [dim](effort: off)[/dim]" + ) + return + + console.print(f"[dim]checking {model_id} (effort: {preference})...[/dim]") + try: + outcome = await probe_effort(model_id, preference, hf_token, session=session) + except ProbeInconclusive as e: + _commit_switch(model_id, config, session, effective=None, cache=False) + console.print( + f"[yellow]Model switched to {model_id}[/yellow] " + f"[dim](couldn't validate: {e}; will verify on first message)[/dim]" + ) + return + except Exception as e: + # Hard persistent error β€” auth, unknown model, quota. Don't switch. + console.print(f"[bold red]Switch failed:[/bold red] {e}") + console.print(f"[dim]Keeping current model: {config.model_name}[/dim]") + return + + _commit_switch( + model_id, + config, + session, + effective=outcome.effective_effort, + cache=True, + ) + effort_label = outcome.effective_effort or "off" + suffix = f" β€” {outcome.note}" if outcome.note else "" + console.print( + f"[green]Model switched to {model_id}[/green] " + f"[dim](effort: {effort_label}{suffix}, {outcome.elapsed_ms}ms)[/dim]" + ) + + +def _commit_switch(model_id, config, session, effective, cache: bool) -> None: + """Apply the switch to the session (or bare config if no session yet). + + ``effective`` is the probe's resolved effort; ``cache=True`` stores it + in the session's per-model cache so real calls use the resolved level + instead of re-probing. ``cache=False`` (inconclusive probe / effort + off) leaves the cache untouched β€” next call falls back to preference. + """ + if session is not None: + session.update_model(model_id) + if cache: + session.model_effective_effort[model_id] = effective + else: + session.model_effective_effort.pop(model_id, None) + else: + config.model_name = model_id diff --git a/agent/core/prompt_caching.py b/agent/core/prompt_caching.py new file mode 100644 index 0000000000000000000000000000000000000000..f445a2d371ef95e64d18ee288ee22704d79ef42a --- /dev/null +++ b/agent/core/prompt_caching.py @@ -0,0 +1,219 @@ +"""Prompt-cache helpers for HF Router FAL requests. + +The HF Router/OpenRouter path uses provider-native prompt caching. Anthropic +models keep explicit JSON ``cache_control`` content blocks for compatibility, +and also need the top-level ``cache_control`` hint on the OpenAI-compatible HF +Router path; the explicit markers alone are accepted there but do not produce +cache writes. OpenAI models cache eligible prefixes automatically and accept +routing/retention hints in the body. +Headers like ``X-OpenRouter-Cache`` control response caching, not prompt +caching through this route. +""" + +from typing import Any + +from agent.core.model_ids import HF_ROUTER_BASE_URL + +_CACHE_CONTROL = {"type": "ephemeral"} +_CACHEABLE_ROLES = {"system", "user"} +_HF_ROUTER_SESSION_ID_MAX_LENGTH = 256 +HF_ROUTER_SESSION_ID_HEADER = "X-HF-Session-id" + + +def router_session_id_for(session: Any) -> str | None: + """Return the usage-window-scoped Router session ID for a runtime session.""" + billing_session_id = getattr(session, "inference_billing_session_id", None) + if isinstance(billing_session_id, str) and billing_session_id: + return billing_session_id + session_id = getattr(session, "session_id", None) + if isinstance(session_id, str) and session_id: + return session_id + return None + + +def _is_hf_router_request(llm_params: dict[str, Any]) -> bool: + api_base = str(llm_params.get("api_base") or "").rstrip("/") + return api_base == HF_ROUTER_BASE_URL + + +def _is_fal_router_request(llm_params: dict[str, Any]) -> bool: + return _is_hf_router_request(llm_params) and ":fal" in _router_model(llm_params) + + +def _router_model(llm_params: dict[str, Any]) -> str: + model = str(llm_params.get("model") or "") + return model.removeprefix("openai/") + + +def _uses_explicit_cache_control(llm_params: dict[str, Any]) -> bool: + if not _is_fal_router_request(llm_params): + return False + return _router_model(llm_params).startswith("anthropic/") + + +def _is_openai_gpt55(llm_params: dict[str, Any]) -> bool: + if not _is_fal_router_request(llm_params): + return False + return _router_model(llm_params).startswith("openai/gpt-5.5") + + +def _merge_extra_body( + llm_params: dict[str, Any], updates: dict[str, Any] +) -> dict[str, Any]: + if not updates: + return llm_params + + cached_params = dict(llm_params) + extra_body = dict(cached_params.get("extra_body") or {}) + extra_body.update(updates) + cached_params["extra_body"] = extra_body + return cached_params + + +def _merge_extra_headers( + llm_params: dict[str, Any], updates: dict[str, str] +) -> dict[str, Any]: + if not updates: + return llm_params + + cached_params = dict(llm_params) + extra_headers = dict(cached_params.get("extra_headers") or {}) + extra_headers.update(updates) + cached_params["extra_headers"] = extra_headers + return cached_params + + +def with_prompt_cache_params( + llm_params: dict[str, Any], + *, + session_id: str | None = None, +) -> dict[str, Any]: + """Return LiteLLM params with provider-native prompt-cache body hints.""" + updates: dict[str, Any] = {} + headers: dict[str, str] = {} + if session_id and _is_hf_router_request(llm_params): + stable_session_id = session_id[:_HF_ROUTER_SESSION_ID_MAX_LENGTH] + headers[HF_ROUTER_SESSION_ID_HEADER] = stable_session_id + if _is_openai_gpt55(llm_params): + updates["prompt_cache_key"] = stable_session_id + + if _uses_explicit_cache_control(llm_params): + updates["cache_control"] = dict(_CACHE_CONTROL) + + if _is_openai_gpt55(llm_params): + updates["prompt_cache_retention"] = "24h" + + return _merge_extra_headers(_merge_extra_body(llm_params, updates), headers) + + +def _message_role(message: Any) -> str | None: + if isinstance(message, dict): + role = message.get("role") + else: + role = getattr(message, "role", None) + return role if isinstance(role, str) else None + + +def _message_content(message: Any) -> Any: + if isinstance(message, dict): + return message.get("content") + return getattr(message, "content", None) + + +def _message_to_dict(message: Any) -> dict[str, Any]: + if isinstance(message, dict): + return dict(message) + if hasattr(message, "model_dump"): + return message.model_dump(exclude_none=True) + raise TypeError(f"Unsupported message type for prompt caching: {type(message)!r}") + + +def _has_cacheable_text(content: Any) -> bool: + if isinstance(content, str): + return bool(content) + if not isinstance(content, list): + return False + return any( + isinstance(block, dict) + and block.get("type") == "text" + and isinstance(block.get("text"), str) + and bool(block.get("text")) + for block in content + ) + + +def _cache_target_index(messages: list[Any]) -> int | None: + if len(messages) < 2: + return None + + for idx in range(len(messages) - 2, -1, -1): + message = messages[idx] + if _message_role(message) not in _CACHEABLE_ROLES: + continue + if _has_cacheable_text(_message_content(message)): + return idx + return None + + +def _content_with_cache_control(content: Any) -> list[dict[str, Any]]: + if isinstance(content, str): + return [ + {"type": "text", "text": content, "cache_control": dict(_CACHE_CONTROL)} + ] + + blocks = [dict(block) if isinstance(block, dict) else block for block in content] + for idx in range(len(blocks) - 1, -1, -1): + block = blocks[idx] + if ( + isinstance(block, dict) + and block.get("type") == "text" + and isinstance(block.get("text"), str) + and bool(block.get("text")) + ): + cached = dict(block) + cached["cache_control"] = dict(_CACHE_CONTROL) + blocks[idx] = cached + break + return blocks + + +def _tools_with_cache_control(tools: list[dict] | None) -> list[dict] | None: + if not tools: + return tools + + cached_tools = list(tools) + last_tool = dict(cached_tools[-1]) + last_tool["cache_control"] = dict(_CACHE_CONTROL) + cached_tools[-1] = last_tool + return cached_tools + + +def with_prompt_caching( + messages: list[Any], + tools: list[dict] | None, + llm_params: dict[str, Any], +) -> tuple[list[Any], list[dict] | None]: + """Return outgoing messages with explicit cache breakpoints when needed. + + The newest message is treated as dynamic. For Anthropic FAL models, the + cache breakpoint is placed on the closest earlier system/user text block so + provider-side caching covers the stable prefix without changing persisted + conversation history. The final tool spec is also marked so stable tool + definitions are cached. + """ + if not _uses_explicit_cache_control(llm_params): + return messages, tools + + cached_tools = _tools_with_cache_control(tools) + idx = _cache_target_index(messages) + if idx is None: + return messages, cached_tools + + cached_message = _message_to_dict(messages[idx]) + cached_message["content"] = _content_with_cache_control( + cached_message.get("content") + ) + + cached_messages = list(messages) + cached_messages[idx] = cached_message + return cached_messages, cached_tools diff --git a/agent/core/redact.py b/agent/core/redact.py new file mode 100644 index 0000000000000000000000000000000000000000..a91bcb280deec2a1dc69d68be4a218af147b4f73 --- /dev/null +++ b/agent/core/redact.py @@ -0,0 +1,66 @@ +"""Secret scrubbing for session trajectories before upload. + +Users frequently paste HF / API / GitHub tokens into the chat, or scripts echo +them via env dumps. This module applies regex-based redaction to any string +value found recursively in a trajectory payload. The goal is best-effort β€” +strict formats are matched; we won't catch free-form leaks like "my password +is hunter2". +""" + +from __future__ import annotations + +import re +from typing import Any + +# Each entry: (compiled regex, replacement placeholder). +# Patterns are conservative: they only match tokens with the canonical prefix +# and a minimum body length so we don't paint over normal text. +_PATTERNS: list[tuple[re.Pattern, str]] = [ + # Hugging Face tokens: hf_[A-Za-z0-9]{30,} + (re.compile(r"hf_[A-Za-z0-9]{30,}"), "[REDACTED_HF_TOKEN]"), + # Provider API keys with common sk-* prefixes. + (re.compile(r"sk-ant-[A-Za-z0-9_\-]{20,}"), "[REDACTED_PROVIDER_API_KEY]"), + (re.compile(r"sk-(?!ant-)[A-Za-z0-9_\-]{40,}"), "[REDACTED_PROVIDER_API_KEY]"), + # GitHub classic PATs: ghp_, gho_, ghu_, ghs_, ghr_ followed by 36+ chars + (re.compile(r"gh[pousr]_[A-Za-z0-9]{36,}"), "[REDACTED_GITHUB_TOKEN]"), + # GitHub fine-grained PATs: github_pat_ + (re.compile(r"github_pat_[A-Za-z0-9_]{36,}"), "[REDACTED_GITHUB_TOKEN]"), + # AWS access key IDs: AKIA / ASIA + 16 uppercase alnum + (re.compile(r"\b(?:AKIA|ASIA)[A-Z0-9]{16}\b"), "[REDACTED_AWS_KEY_ID]"), + # Generic 'Bearer ' header values + (re.compile(r"(?i)bearer\s+[A-Za-z0-9_\-\.=]{20,}"), "Bearer [REDACTED]"), +] + +# Env-var-like exports: we scrub the value but keep the name so callers can +# still see which secret was referenced. Covers `KEY=value` and `KEY: value` +# when the key looks secret-y. +_SECRETY_NAMES = re.compile( + r"(?i)\b([A-Z0-9_]*(?:TOKEN|API_KEY|SECRET|PASSWORD|ACCESS_KEY_ID))" + r"\s*[:=]\s*([^\s\"']+)" +) + + +def scrub_string(s: str) -> str: + """Apply all redaction patterns to a single string. Safe on non-strings.""" + if not isinstance(s, str) or not s: + return s + out = s + for pat, repl in _PATTERNS: + out = pat.sub(repl, out) + out = _SECRETY_NAMES.sub(lambda m: f"{m.group(1)}=[REDACTED]", out) + return out + + +def scrub(obj: Any) -> Any: + """Recursively scrub every string value in a nested dict/list structure. + + Returns a new object β€” inputs are not mutated.""" + if isinstance(obj, str): + return scrub_string(obj) + if isinstance(obj, dict): + return {k: scrub(v) for k, v in obj.items()} + if isinstance(obj, list): + return [scrub(v) for v in obj] + if isinstance(obj, tuple): + return tuple(scrub(v) for v in obj) + return obj diff --git a/agent/core/session.py b/agent/core/session.py new file mode 100644 index 0000000000000000000000000000000000000000..4e173479c68234bf51b68014b970b369815cbc38 --- /dev/null +++ b/agent/core/session.py @@ -0,0 +1,806 @@ +import asyncio +import json +import logging +import os +import subprocess +import sys +import uuid +from dataclasses import dataclass +from datetime import datetime +from enum import Enum +from pathlib import Path +from typing import Any, Optional + +from litellm import Message + +from agent.config import Config +from agent.context_manager.manager import ContextManager +from agent.messaging.gateway import NotificationGateway +from agent.messaging.models import NotificationRequest +from agent.core.usage_thresholds import ( + USAGE_THRESHOLD_TOOL_NAME, + USAGE_WARNING_FIRST_THRESHOLD_USD, +) + +logger = logging.getLogger(__name__) + +_DEFAULT_MAX_TOKENS = 200_000 +_TURN_COMPLETE_NOTIFICATION_CHARS = 39000 + +DEFAULT_SESSION_LOG_DIR = Path("session_logs") + + +def _format_usd(value: Any) -> str: + if isinstance(value, bool): + return "$0.00" + try: + amount = float(value) + except (TypeError, ValueError): + amount = 0.0 + return f"${amount:.2f}" + + +def _approval_tools_are_usage_thresholds(tools: Any) -> bool: + if not isinstance(tools, list) or len(tools) != 1: + return False + tool = tools[0] + return isinstance(tool, dict) and tool.get("tool") == USAGE_THRESHOLD_TOOL_NAME + + +def _get_max_tokens_safe(model_name: str) -> int: + """Return the max input-context tokens for a model. + + Primary source: ``litellm.get_model_info(model)['max_input_tokens']``. + Strips any HF routing suffix / huggingface/ prefix so tagged ids + ('moonshotai/Kimi-K2.6:cheapest') look up the bare model. Falls back to a + conservative 200k default for models not in the catalog. + """ + from litellm import get_model_info + + candidates = [model_name] + stripped = model_name.removeprefix("huggingface/").split(":", 1)[0] + if stripped != model_name: + candidates.append(stripped) + for candidate in candidates: + try: + info = get_model_info(candidate) + max_input = info.get("max_input_tokens") if info else None + if isinstance(max_input, int) and max_input > 0: + return max_input + except Exception: + continue + logger.info( + "No litellm.get_model_info entry for %s, falling back to %d", + model_name, + _DEFAULT_MAX_TOKENS, + ) + return _DEFAULT_MAX_TOKENS + + +class OpType(Enum): + USER_INPUT = "user_input" + EXEC_APPROVAL = "exec_approval" + UNDO = "undo" + COMPACT = "compact" + NEW = "new" + RESUME = "resume" + SHUTDOWN = "shutdown" + + +@dataclass +class Event: + event_type: str + data: Optional[dict[str, Any]] = None + seq: Optional[int] = None + + +class Session: + """ + Maintains agent session state + Similar to Session in codex-rs/core/src/codex.rs + """ + + def __init__( + self, + event_queue: asyncio.Queue, + config: Config, + tool_router=None, + context_manager: ContextManager | None = None, + hf_token: str | None = None, + local_mode: bool = False, + stream: bool = True, + notification_gateway: NotificationGateway | None = None, + notification_destinations: list[str] | None = None, + defer_turn_complete_notification: bool = False, + session_id: str | None = None, + user_id: str | None = None, + hf_username: str | None = None, + user_plan: str | None = None, + persistence_store: Any | None = None, + ): + self.hf_token: Optional[str] = hf_token + self.user_id: Optional[str] = user_id + self.hf_username: Optional[str] = hf_username + self.user_plan: str | None = user_plan + self.local_mode = local_mode + self.persistence_store = persistence_store + self.tool_router = tool_router + self.stream = stream + if config is None: + raise ValueError("Session requires a Config") + tool_specs = tool_router.get_tool_specs_for_llm() if tool_router else [] + self.context_manager = context_manager or ContextManager( + model_max_tokens=_get_max_tokens_safe(config.model_name), + compact_size=0.1, + untouched_messages=5, + tool_specs=tool_specs, + hf_token=hf_token, + local_mode=local_mode, + ) + self.event_queue = event_queue + self.session_id = session_id or str(uuid.uuid4()) + self.inference_billing_session_id: str | None = None + self.config = config + self.is_running = True + self.current_plan: list[dict[str, str]] = [] + self._cancelled = asyncio.Event() + self.pending_approval: Optional[dict[str, Any]] = None + self.sandbox = None + self.sandbox_hardware: Optional[str] = None + self.sandbox_preload_task: Optional[asyncio.Task] = None + self.sandbox_preload_error: Optional[str] = None + self.sandbox_preload_cancel_event: Any | None = None + self._running_job_ids: set[str] = set() # HF job IDs currently executing + self.notification_gateway = notification_gateway + self.notification_destinations = list(notification_destinations or []) + self.defer_turn_complete_notification = defer_turn_complete_notification + self.auto_approval_enabled: bool = False + self.auto_approval_cost_cap_usd: float | None = None + self.auto_approval_estimated_spend_usd: float = 0.0 + self._yolo_budget_reservations: dict[str, Any] = {} + self.usage_warning_next_threshold_usd: float = USAGE_WARNING_FIRST_THRESHOLD_USD + self.usage_threshold_checker: Any | None = None + self.yolo_budget_checker: Any | None = None + self.usage_hf_billing_snapshot: dict[str, Any] | None = None + self.usage_metrics: dict[str, Any] | None = None + + # Session trajectory logging + self.logged_events: list[dict] = [] + self.session_start_time = datetime.now().astimezone().isoformat() + self.turn_count: int = 0 + self.last_auto_save_turn: int = 0 + # Stable local save path so heartbeat saves overwrite one file instead + # of spamming session_logs/. ``_last_heartbeat_ts`` is owned by + # ``agent.core.telemetry.HeartbeatSaver`` and lazily initialised there. + self._local_save_path: Optional[str] = None + self._last_heartbeat_ts: Optional[float] = None + + # Per-model probed reasoning-effort cache. Populated by the probe + # on /model switch, read by ``effective_effort_for`` below. Keys are + # raw model ids (including any ``:tag``). Values: + # str β†’ the effort level to send (may be a downgrade from the + # preference, e.g. "high" when user asked for "max") + # None β†’ model rejected all efforts in the cascade; send no + # thinking params at all + # Key absent β†’ not probed yet; fall back to the raw preference. + self.model_effective_effort: dict[str, str | None] = {} + self.context_manager.on_message_added = self._schedule_trace_message + + async def send_event(self, event: Event) -> None: + """Send event back to client and log to trajectory""" + # Loop reference for sync/threaded callers (e.g. hub_artifacts) that + # need to schedule an event emission from outside the agent loop. + self._main_event_loop = asyncio.get_running_loop() + # Log event to trajectory + self.logged_events.append( + { + "timestamp": datetime.now().astimezone().isoformat(), + "event_type": event.event_type, + "data": event.data, + } + ) + if self.persistence_store is not None: + try: + event.seq = await self.persistence_store.append_event( + self.session_id, event.event_type, event.data + ) + except Exception as e: + logger.debug("Event persistence failed for %s: %s", self.session_id, e) + + await self.event_queue.put(event) + await self._enqueue_auto_notification_requests(event) + + # Mid-turn heartbeat flush (owned by telemetry module). + from agent.core.telemetry import HeartbeatSaver + + HeartbeatSaver.maybe_fire(self) + + def _schedule_trace_message(self, message: Any) -> None: + """Best-effort append-only trace save for SFT/KPI export.""" + if self.persistence_store is None: + return + try: + payload = message.model_dump(mode="json") + except Exception: + return + try: + loop = asyncio.get_running_loop() + except RuntimeError: + return + source = str(payload.get("role") or "message") + loop.create_task( + self.persistence_store.append_trace_message( + self.session_id, payload, source=source + ) + ) + + def set_notification_destinations(self, destinations: list[str]) -> None: + """Replace the session's opted-in auto-notification destinations.""" + deduped: list[str] = [] + seen: set[str] = set() + for destination in destinations: + if destination not in seen: + deduped.append(destination) + seen.add(destination) + self.notification_destinations = deduped + + async def send_deferred_turn_complete_notification(self, event: Event) -> None: + if event.event_type != "turn_complete": + return + await self._enqueue_auto_notification_requests( + event, + include_deferred_turn_complete=True, + ) + + async def _enqueue_auto_notification_requests( + self, + event: Event, + include_deferred_turn_complete: bool = False, + ) -> None: + if self.notification_gateway is None: + return + if not self.notification_destinations: + return + auto_events = set(self.config.messaging.auto_event_types) + if event.event_type not in auto_events: + return + if ( + self.defer_turn_complete_notification + and event.event_type == "turn_complete" + and not include_deferred_turn_complete + ): + return + + requests = self._build_auto_notification_requests(event) + for request in requests: + await self.notification_gateway.enqueue(request) + + def _build_auto_notification_requests( + self, event: Event + ) -> list[NotificationRequest]: + metadata = { + "session_id": self.session_id, + "model": self.config.model_name, + "event_type": event.event_type, + } + + title: str | None = None + message: str | None = None + severity = "info" + data = event.data or {} + if event.event_type == "approval_required": + tools = data.get("tools", []) + if _approval_tools_are_usage_thresholds(tools): + tool = tools[0] + args = tool.get("arguments") if isinstance(tool, dict) else {} + args = args if isinstance(args, dict) else {} + current = _format_usd(args.get("current_spend_usd")) + threshold = _format_usd(args.get("threshold_usd")) + next_threshold = _format_usd(args.get("next_threshold_usd")) + title = "Usage approval required" + message = ( + f"Session {self.session_id} reached {current} in current-session " + f"usage, crossing the {threshold} warning threshold." + ) + if next_threshold: + message += f" The next warning is at {next_threshold}." + severity = "warning" + else: + tools = data.get("tools", []) + tool_names = [] + for tool in tools if isinstance(tools, list) else []: + if isinstance(tool, dict): + tool_name = str(tool.get("tool") or "").strip() + if tool_name and tool_name not in tool_names: + tool_names.append(tool_name) + count = len(tools) if isinstance(tools, list) else 0 + title = "Agent approval required" + message = ( + f"Session {self.session_id} is waiting for approval " + f"for {count} tool call(s)." + ) + if tool_names: + message += " Tools: " + ", ".join(tool_names) + severity = "warning" + elif event.event_type == "error": + title = "Agent error" + error = str(data.get("error") or "Unknown error") + message = f"Session {self.session_id} hit an error.\n{error[:500]}" + severity = "error" + elif event.event_type == "turn_complete": + title = "Agent task complete" + summary = str(data.get("final_response") or "").strip() + if summary: + summary = summary[:_TURN_COMPLETE_NOTIFICATION_CHARS] + message = ( + f"Session {self.session_id} completed successfully.\n{summary}" + ) + else: + message = f"Session {self.session_id} completed successfully." + severity = "success" + + if message is None: + return [] + + requests: list[NotificationRequest] = [] + for destination in self.notification_destinations: + if not self.config.messaging.can_auto_send(destination): + continue + requests.append( + NotificationRequest( + destination=destination, + title=title, + message=message, + severity=severity, + metadata=metadata, + event_type=event.event_type, + ) + ) + return requests + + def cancel(self) -> None: + """Signal cancellation to the running agent loop.""" + self._cancelled.set() + + def reset_cancel(self) -> None: + """Clear the cancellation flag before a new run.""" + self._cancelled.clear() + + @property + def is_cancelled(self) -> bool: + return self._cancelled.is_set() + + def update_model(self, model_name: str) -> None: + """Switch the active model and update the context window limit.""" + from agent.core.model_ids import strip_huggingface_model_prefix + + normalized = strip_huggingface_model_prefix(model_name) or model_name + self.config.model_name = normalized + self.context_manager.model_max_tokens = _get_max_tokens_safe(normalized) + + def set_auto_approval_policy( + self, *, enabled: bool, cost_cap_usd: float | None + ) -> None: + self.auto_approval_enabled = bool(enabled) + self.auto_approval_cost_cap_usd = cost_cap_usd + + def add_auto_approval_estimated_spend(self, amount_usd: float | None) -> None: + if amount_usd is None or amount_usd <= 0: + return + self.auto_approval_estimated_spend_usd = round( + self.auto_approval_estimated_spend_usd + float(amount_usd), 4 + ) + + @property + def auto_approval_remaining_usd(self) -> float | None: + if self.auto_approval_cost_cap_usd is None: + return None + return round( + max( + 0.0, + self.auto_approval_cost_cap_usd + - self.auto_approval_estimated_spend_usd, + ), + 4, + ) + + def auto_approval_policy_summary(self) -> dict[str, Any]: + return { + "enabled": self.auto_approval_enabled, + "cost_cap_usd": self.auto_approval_cost_cap_usd, + "estimated_spend_usd": round(self.auto_approval_estimated_spend_usd, 4), + "remaining_usd": self.auto_approval_remaining_usd, + } + + def effective_effort_for(self, model_name: str) -> str | None: + """Resolve the effort level to actually send for ``model_name``. + + Returns the probed result when we have one (may be ``None`` meaning + "model doesn't do thinking, strip it"), else the raw preference. + Unknown-model case falls back to the preference so a stale cache + from a prior ``/model`` can't poison research sub-calls that use a + different model id. + """ + if model_name in self.model_effective_effort: + return self.model_effective_effort[model_name] + return self.config.reasoning_effort + + def increment_turn(self) -> None: + """Increment turn counter (called after each user interaction)""" + self.turn_count += 1 + + def start_new_conversation(self) -> dict[str, Any]: + """Rotate this runtime into a fresh conversation. + + The tool router, model/config choices, user identity, and external + resources stay attached to the CLI process. Conversation-specific state + gets reset so later saves do not merge with the prior chat. Warm runtime + resources such as the sandbox, in-flight job tracking, and probed + model-effort cache are deliberately preserved. + """ + previous_session_id = self.session_id + previous_turn_count = self.turn_count + previous_message_count = len(self.context_manager.items) + previous_non_system_count = sum( + 1 + for item in self.context_manager.items + if getattr(item, "role", None) != "system" + ) + + saved_path: str | None = None + if self.config.save_sessions and previous_non_system_count: + saved_path = self.save_and_upload_detached(self.config.session_dataset_repo) + + from agent.tools.plan_tool import reset_current_plan + + self.current_plan = [] + reset_current_plan() + + system_msg = self._fresh_system_message() + self.context_manager.items = [system_msg] if system_msg is not None else [] + self.context_manager.running_context_usage = 0 + + self.session_id = str(uuid.uuid4()) + self.inference_billing_session_id = None + self.session_start_time = datetime.now().astimezone().isoformat() + self.turn_count = 0 + self.last_auto_save_turn = 0 + self.logged_events = [] + self._local_save_path = None + self._last_heartbeat_ts = None + self.pending_approval = None + self.auto_approval_estimated_spend_usd = 0.0 + self._yolo_budget_reservations = {} + self.usage_hf_billing_snapshot = None + self.usage_metrics = None + self.reset_cancel() + + # Previous-session metadata is intentionally included for event + # consumers and telemetry, even though the CLI currently prints only + # the optional save path. + return { + "session_id": self.session_id, + "previous_session_id": previous_session_id, + "previous_turn_count": previous_turn_count, + "previous_message_count": previous_message_count, + "saved_path": saved_path, + } + + def _fresh_system_message(self) -> Message | None: + existing = ( + self.context_manager.items[0] + if self.context_manager.items + and getattr(self.context_manager.items[0], "role", None) == "system" + else None + ) + refresh = getattr(self.context_manager, "refresh_system_prompt", None) + if refresh is None: + return existing + try: + tool_specs = ( + self.tool_router.get_tool_specs_for_llm() if self.tool_router else [] + ) + return refresh( + tool_specs=tool_specs, + hf_token=self.hf_token, + local_mode=self.local_mode, + ) + except Exception as e: + logger.warning("Failed to refresh system prompt for new chat: %s", e) + return existing + + async def auto_save_if_needed(self) -> None: + """Check if auto-save should trigger and save if so (completely non-blocking)""" + if not self.config.save_sessions: + return + + interval = self.config.auto_save_interval + if interval <= 0: + return + + turns_since_last_save = self.turn_count - self.last_auto_save_turn + if turns_since_last_save >= interval: + logger.info(f"Auto-saving session (turn {self.turn_count})...") + # Fire-and-forget save - returns immediately + self.save_and_upload_detached(self.config.session_dataset_repo) + self.last_auto_save_turn = self.turn_count + + def get_trajectory(self) -> dict: + """Serialize complete session trajectory for logging""" + tools: list = [] + if self.tool_router is not None: + try: + tools = self.tool_router.get_tool_specs_for_llm() or [] + except Exception: + tools = [] + # Sum per-call cost from llm_call events so analyzers don't have to + # walk the events array themselves. Each `llm_call` event already + # carries cost_usd from `agent.core.telemetry.record_llm_call`. + total_cost_usd = sum( + float((e.get("data") or {}).get("cost_usd") or 0.0) + for e in self.logged_events + if e.get("event_type") == "llm_call" + ) + try: + from agent.core.usage_metrics import summarize_usage_events + + usage_metrics = summarize_usage_events( + self.logged_events, + session_id=self.session_id, + hf_billing_snapshot=self.usage_hf_billing_snapshot, + ) + self.usage_metrics = usage_metrics + except Exception as e: + logger.debug("Usage metrics summary failed for %s: %s", self.session_id, e) + usage_metrics = self.usage_metrics or {} + return { + "session_id": self.session_id, + "user_id": self.user_id, + "hf_username": self.hf_username, + "session_start_time": self.session_start_time, + "session_end_time": datetime.now().isoformat(), + "model_name": self.config.model_name, + "total_cost_usd": total_cost_usd, + "usage_metrics": usage_metrics, + "messages": [msg.model_dump() for msg in self.context_manager.items], + "events": self.logged_events, + "tools": tools, + } + + def save_trajectory_local( + self, + directory: str = str(DEFAULT_SESSION_LOG_DIR), + upload_status: str = "pending", + dataset_url: Optional[str] = None, + ) -> Optional[str]: + """ + Save trajectory to local JSON file as backup with upload status + + Args: + directory: Directory to save logs (default: "session_logs") + upload_status: Status of upload attempt ("pending", "success", "failed") + dataset_url: URL of dataset if upload succeeded + + Returns: + Path to saved file if successful, None otherwise + """ + try: + log_dir = Path(directory) + log_dir.mkdir(parents=True, exist_ok=True) + + trajectory = self.get_trajectory() + + # Scrub secrets at save time so session_logs/ never holds raw + # tokens on disk β€” a log aggregator, crash dump, or filesystem + # snapshot between heartbeats would otherwise leak them. + try: + from agent.core.redact import scrub + + for key in ("messages", "events", "tools"): + if key in trajectory: + trajectory[key] = scrub(trajectory[key]) + except Exception as _e: + logger.debug("Redact-on-save failed (non-fatal): %s", _e) + + # Add upload metadata + trajectory["upload_status"] = upload_status + trajectory["upload_url"] = dataset_url + trajectory["last_save_time"] = datetime.now().isoformat() + + # Reuse one stable path per session so heartbeat saves overwrite + # the same file instead of creating a new timestamped file every + # minute. The timestamp in the filename is kept for first-save + # ordering; subsequent saves just rewrite that file. + if self._local_save_path and Path(self._local_save_path).parent == log_dir: + filepath = Path(self._local_save_path) + else: + filename = ( + f"session_{self.session_id}_" + f"{datetime.now().strftime('%Y%m%d_%H%M%S')}.json" + ) + filepath = log_dir / filename + self._local_save_path = str(filepath) + + # Atomic-ish write: stage to .tmp then rename so a crash mid-write + # doesn't leave a truncated JSON that breaks the retry scanner. + tmp_path = filepath.with_suffix(filepath.suffix + ".tmp") + with open(tmp_path, "w") as f: + json.dump(trajectory, f, indent=2) + tmp_path.replace(filepath) + + return str(filepath) + except Exception as e: + logger.error(f"Failed to save session locally: {e}") + return None + + def _personal_trace_repo_id(self) -> Optional[str]: + """Resolve the per-user trace repo id from config + HF username. + + Returns ``None`` when sharing is disabled, the user is anonymous, + or the template is missing β€” caller skips the personal upload in + those cases. + """ + if not getattr(self.config, "share_traces", False): + return None + hf_user = self.hf_username or self.user_id + if not hf_user: + return None + template = getattr(self.config, "personal_trace_repo_template", None) + if not template: + return None + try: + return template.format(hf_user=hf_user) + except (KeyError, IndexError): + logger.debug("personal_trace_repo_template format failed: %r", template) + return None + + def _spawn_uploader( + self, + action: str, + target: str, + repo_id: str, + *, + format: str, + token_env: Optional[str], + private: bool, + token_value: Optional[str] = None, + ) -> None: + """Fire-and-forget spawn of ``session_uploader.py`` with the given args.""" + try: + uploader_script = Path(__file__).parent / "session_uploader.py" + cmd = [ + sys.executable, + str(uploader_script), + action, + target, + repo_id, + "--format", + format, + "--private", + "true" if private else "false", + ] + if token_env: + cmd.extend(["--token-env", token_env]) + + env = os.environ.copy() + if token_value: + env["_ML_INTERN_PERSONAL_TOKEN"] = token_value + + subprocess.Popen( + cmd, + stdin=subprocess.DEVNULL, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + env=env, + start_new_session=True, # Detach from parent + ) + except Exception as e: + logger.warning(f"Failed to spawn upload subprocess: {e}") + + def save_and_upload_detached(self, repo_id: str) -> Optional[str]: + """ + Save session locally and spawn detached subprocess(es) for upload + (fire-and-forget). + + Always uploads to the shared org dataset (``repo_id``) in the + single-row format used by the KPI scheduler. When + ``config.share_traces`` is enabled and a username is known, also + uploads to the user's personal private dataset in Claude Code JSONL + format so the HF Agent Trace Viewer auto-renders it. + + Args: + repo_id: HuggingFace dataset repo ID for the org/KPI upload. + + Returns: + Path to local save file + """ + local_path = self.save_trajectory_local(upload_status="pending") + if not local_path: + return None + + self._spawn_uploader( + "upload", + local_path, + repo_id, + format="row", + token_env=None, # default org token chain + private=False, + ) + + personal_repo = self._personal_trace_repo_id() + if personal_repo: + # User's own HF_TOKEN write-scoped to their namespace. + self._spawn_uploader( + "upload", + local_path, + personal_repo, + format="claude_code", + token_env="HF_TOKEN", + token_value=self.hf_token, + private=True, + ) + + return local_path + + @staticmethod + def retry_failed_uploads_detached( + directory: str = str(DEFAULT_SESSION_LOG_DIR), + repo_id: Optional[str] = None, + *, + personal_repo_id: Optional[str] = None, + ) -> None: + """ + Spawn detached subprocess(es) to retry failed/pending uploads + (fire-and-forget). + + Args: + directory: Directory containing session logs + repo_id: Target dataset repo ID for the shared org/KPI upload. + personal_repo_id: Per-user dataset for Claude-Code-format + retries. ``None`` skips the personal retry pass. + """ + if not repo_id and not personal_repo_id: + return + + try: + uploader_script = Path(__file__).parent / "session_uploader.py" + + if repo_id: + subprocess.Popen( + [ + sys.executable, + str(uploader_script), + "retry", + directory, + repo_id, + "--format", + "row", + ], + stdin=subprocess.DEVNULL, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + start_new_session=True, + ) + + if personal_repo_id: + subprocess.Popen( + [ + sys.executable, + str(uploader_script), + "retry", + directory, + personal_repo_id, + "--format", + "claude_code", + "--token-env", + "HF_TOKEN", + "--private", + "true", + ], + stdin=subprocess.DEVNULL, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + start_new_session=True, + ) + except Exception as e: + logger.warning(f"Failed to spawn retry subprocess: {e}") diff --git a/agent/core/session_persistence.py b/agent/core/session_persistence.py new file mode 100644 index 0000000000000000000000000000000000000000..ed8a5221ed2bdd3414e1fb678953260eea6b6483 --- /dev/null +++ b/agent/core/session_persistence.py @@ -0,0 +1,618 @@ +"""Optional durable session persistence for the hosted backend. + +The public CLI must keep working without MongoDB. This module therefore +exposes one small async store interface and returns a no-op implementation +unless ``MONGODB_URI`` is configured and reachable. +""" + +from __future__ import annotations + +import logging +import os +from datetime import UTC, datetime +from typing import Any + +from bson import BSON +from pymongo import AsyncMongoClient, DeleteMany, ReturnDocument, UpdateOne +from pymongo.errors import InvalidDocument, PyMongoError + +logger = logging.getLogger(__name__) + +SCHEMA_VERSION = 1 +MAX_BSON_BYTES = 15 * 1024 * 1024 +USAGE_EVENT_TYPES = ( + "llm_call", + "hf_job_complete", + "sandbox_create", + "sandbox_destroy", +) + + +def _now() -> datetime: + return datetime.now(UTC) + + +def _doc_id(session_id: str, idx: int) -> str: + return f"{session_id}:{idx}" + + +def _safe_message_doc(message: dict[str, Any]) -> dict[str, Any]: + """Return a Mongo-safe message document payload. + + Mongo's hard document limit is 16 MB. We stay below that and store an + explicit marker rather than failing the whole snapshot for one huge tool log. + """ + try: + if len(BSON.encode({"message": message})) <= MAX_BSON_BYTES: + return message + except (InvalidDocument, OverflowError): + pass + return { + "role": "tool", + "content": ( + "[SYSTEM: A single persisted message exceeded MongoDB's document " + "size/encoding limit and was replaced by this marker.]" + ), + "ml_intern_persistence_error": "message_too_large_or_invalid", + } + + +class NoopSessionStore: + """Async no-op store used when Mongo is not configured. + + API response documents are kept in a process-local dict so the `/v1` + developer API still works in dev mode for the lifetime of the process + (no durable replay without Mongo). + """ + + enabled = False + + def __init__(self) -> None: + self._api_responses: dict[str, dict[str, Any]] = {} + + async def init(self) -> None: + return None + + async def close(self) -> None: + return None + + async def upsert_session(self, **_: Any) -> None: + return None + + async def save_snapshot(self, **_: Any) -> None: + return None + + async def load_session(self, *_: Any, **__: Any) -> dict[str, Any] | None: + return None + + async def list_sessions(self, *_: Any, **__: Any) -> list[dict[str, Any]]: + return [] + + async def soft_delete_session(self, *_: Any, **__: Any) -> None: + return None + + async def update_session_fields(self, *_: Any, **__: Any) -> None: + return None + + async def append_event(self, *_: Any, **__: Any) -> int | None: + return None + + async def load_events_after(self, *_: Any, **__: Any) -> list[dict[str, Any]]: + return [] + + async def load_usage_events(self, *_: Any, **__: Any) -> list[dict[str, Any]]: + return [] + + async def append_trace_message(self, *_: Any, **__: Any) -> int | None: + return None + + async def mark_pro_seen(self, *_: Any, **__: Any) -> dict[str, Any] | None: + return None + + # ── API response documents (the /v1 developer API) ────────────── + + async def upsert_api_response(self, doc: dict[str, Any]) -> None: + response_id = str(doc.get("_id") or "") + if not response_id: + return + stored = dict(doc) + stored.setdefault("created_at", _now()) + stored["updated_at"] = _now() + self._api_responses[response_id] = stored + + async def load_api_response(self, response_id: str) -> dict[str, Any] | None: + doc = self._api_responses.get(response_id) + return dict(doc) if doc else None + + async def update_api_response_fields(self, response_id: str, **fields: Any) -> None: + doc = self._api_responses.get(response_id) + if doc is None: + return + doc.update(fields) + doc["updated_at"] = _now() + + async def current_event_seq(self, session_id: str) -> int: + return 0 + + +class MongoSessionStore(NoopSessionStore): + """MongoDB-backed session store.""" + + enabled = True + + def __init__(self, uri: str, db_name: str) -> None: + super().__init__() + self.uri = uri + self.db_name = db_name + self.enabled = False + self.client: AsyncMongoClient | None = None + self.db = None + + async def init(self) -> None: + try: + self.client = AsyncMongoClient(self.uri, serverSelectionTimeoutMS=3000) + self.db = self.client[self.db_name] + await self.client.admin.command("ping") + await self._create_indexes() + self.enabled = True + logger.info("Mongo session persistence enabled (db=%s)", self.db_name) + except Exception as e: + logger.warning("Mongo session persistence disabled: %s", e) + self.enabled = False + if self.client is not None: + await self.client.close() + self.client = None + self.db = None + + async def close(self) -> None: + if self.client is not None: + await self.client.close() + self.client = None + self.db = None + + async def _create_indexes(self) -> None: + if self.db is None: + return + await self.db.sessions.create_index( + [("user_id", 1), ("visibility", 1), ("updated_at", -1)] + ) + await self.db.sessions.create_index( + [("visibility", 1), ("status", 1), ("last_active_at", -1)] + ) + await self.db.session_messages.create_index( + [("session_id", 1), ("idx", 1)], unique=True + ) + await self.db.session_events.create_index( + [("session_id", 1), ("seq", 1)], unique=True + ) + await self.db.session_events.create_index( + [("session_id", 1), ("created_at", 1), ("event_type", 1)] + ) + await self.db.session_trace_messages.create_index( + [("session_id", 1), ("seq", 1)], unique=True + ) + await self.db.session_trace_messages.create_index([("created_at", -1)]) + await self.db.pro_users.create_index([("first_seen_pro_at", -1)]) + await self.db.api_responses.create_index([("user_id", 1), ("created_at", -1)]) + await self.db.api_responses.create_index([("session_id", 1)]) + + def _ready(self) -> bool: + return bool(self.enabled and self.db is not None) + + async def upsert_session( + self, + *, + session_id: str, + user_id: str, + model: str, + title: str | None = None, + surface: str = "frontend", + created_at: datetime | None = None, + usage_window_started_at: datetime | None = None, + inference_billing_session_id: str | None = None, + runtime_state: str = "idle", + status: str = "active", + message_count: int = 0, + turn_count: int = 0, + pending_approval: list[dict[str, Any]] | None = None, + notification_destinations: list[str] | None = None, + auto_approval_enabled: bool = False, + auto_approval_cost_cap_usd: float | None = None, + auto_approval_estimated_spend_usd: float = 0.0, + usage_warning_next_threshold_usd: float = 5.0, + ) -> None: + if not self._ready(): + return + now = _now() + await self.db.sessions.update_one( + {"_id": session_id}, + { + "$setOnInsert": { + "_id": session_id, + "session_id": session_id, + "user_id": user_id, + "surface": surface, + "created_at": created_at or now, + "schema_version": SCHEMA_VERSION, + "visibility": "live", + }, + "$set": { + "title": title, + "model": model, + "usage_window_started_at": ( + usage_window_started_at or created_at or now + ), + "inference_billing_session_id": inference_billing_session_id, + "status": status, + "runtime_state": runtime_state, + "updated_at": now, + "last_active_at": now, + "message_count": message_count, + "turn_count": turn_count, + "pending_approval": pending_approval or [], + "notification_destinations": notification_destinations or [], + "auto_approval_enabled": auto_approval_enabled, + "auto_approval_cost_cap_usd": auto_approval_cost_cap_usd, + "auto_approval_estimated_spend_usd": auto_approval_estimated_spend_usd, + "usage_warning_next_threshold_usd": usage_warning_next_threshold_usd, + }, + }, + upsert=True, + ) + + async def save_snapshot( + self, + *, + session_id: str, + user_id: str, + model: str, + messages: list[dict[str, Any]], + title: str | None = None, + surface: str = "frontend", + runtime_state: str = "idle", + status: str = "active", + turn_count: int = 0, + pending_approval: list[dict[str, Any]] | None = None, + created_at: datetime | None = None, + usage_window_started_at: datetime | None = None, + inference_billing_session_id: str | None = None, + notification_destinations: list[str] | None = None, + auto_approval_enabled: bool = False, + auto_approval_cost_cap_usd: float | None = None, + auto_approval_estimated_spend_usd: float = 0.0, + usage_warning_next_threshold_usd: float = 5.0, + raise_on_error: bool = False, + ) -> None: + if not self._ready(): + if raise_on_error: + raise RuntimeError("session store not ready") + return + now = _now() + await self.upsert_session( + session_id=session_id, + user_id=user_id, + model=model, + title=title, + surface=surface, + created_at=created_at, + runtime_state=runtime_state, + status=status, + message_count=len(messages), + turn_count=turn_count, + pending_approval=pending_approval, + notification_destinations=notification_destinations, + usage_window_started_at=usage_window_started_at, + inference_billing_session_id=inference_billing_session_id, + auto_approval_enabled=auto_approval_enabled, + auto_approval_cost_cap_usd=auto_approval_cost_cap_usd, + auto_approval_estimated_spend_usd=auto_approval_estimated_spend_usd, + usage_warning_next_threshold_usd=usage_warning_next_threshold_usd, + ) + ops: list[Any] = [] + for idx, raw in enumerate(messages): + ops.append( + UpdateOne( + {"_id": _doc_id(session_id, idx)}, + { + "$set": { + "session_id": session_id, + "idx": idx, + "message": _safe_message_doc(raw), + "updated_at": now, + }, + "$setOnInsert": {"created_at": now}, + }, + upsert=True, + ) + ) + ops.append( + DeleteMany({"session_id": session_id, "idx": {"$gte": len(messages)}}) + ) + try: + if ops: + await self.db.session_messages.bulk_write(ops, ordered=False) + except PyMongoError as e: + # Best-effort by default, but the reaper passes raise_on_error so a + # silent message-write failure doesn't let it evict a session whose + # latest messages never made it to Mongo. + if raise_on_error: + raise + logger.warning("Failed to persist session %s snapshot: %s", session_id, e) + + async def load_session( + self, session_id: str, *, include_deleted: bool = False + ) -> dict[str, Any] | None: + if not self._ready(): + return None + meta = await self.db.sessions.find_one({"_id": session_id}) + if not meta: + return None + if meta.get("visibility") == "deleted" and not include_deleted: + return None + cursor = self.db.session_messages.find({"session_id": session_id}).sort( + "idx", 1 + ) + messages = [row.get("message") async for row in cursor] + return {"metadata": meta, "messages": messages} + + async def list_sessions( + self, user_id: str, *, include_deleted: bool = False + ) -> list[dict[str, Any]]: + if not self._ready(): + return [] + query: dict[str, Any] = {"user_id": user_id} + if user_id == "dev": + query = {} + if not include_deleted: + query["visibility"] = {"$ne": "deleted"} + cursor = self.db.sessions.find(query).sort("updated_at", -1) + return [row async for row in cursor] + + async def soft_delete_session(self, session_id: str) -> None: + if not self._ready(): + return + await self.db.sessions.update_one( + {"_id": session_id}, + { + "$set": { + "visibility": "deleted", + "runtime_state": "idle", + "updated_at": _now(), + } + }, + ) + + async def update_session_fields(self, session_id: str, **fields: Any) -> None: + if not self._ready() or not fields: + return + fields["updated_at"] = _now() + await self.db.sessions.update_one({"_id": session_id}, {"$set": fields}) + + async def _next_seq(self, counter_id: str) -> int: + doc = await self.db.counters.find_one_and_update( + {"_id": counter_id}, + {"$inc": {"seq": 1}}, + upsert=True, + return_document=ReturnDocument.AFTER, + ) + return int(doc["seq"]) + + async def append_event( + self, session_id: str, event_type: str, data: dict[str, Any] | None + ) -> int | None: + if not self._ready(): + return None + try: + seq = await self._next_seq(f"event:{session_id}") + await self.db.session_events.insert_one( + { + "_id": _doc_id(session_id, seq), + "session_id": session_id, + "seq": seq, + "event_type": event_type, + "data": data or {}, + "created_at": _now(), + } + ) + return seq + except PyMongoError as e: + logger.debug("Failed to append event for %s: %s", session_id, e) + return None + + async def load_events_after( + self, session_id: str, after_seq: int = 0 + ) -> list[dict[str, Any]]: + if not self._ready(): + return [] + cursor = self.db.session_events.find( + {"session_id": session_id, "seq": {"$gt": int(after_seq or 0)}} + ).sort("seq", 1) + return [row async for row in cursor] + + async def load_usage_events( + self, + user_id: str, + *, + session_id: str | None = None, + start: datetime | None = None, + end: datetime | None = None, + ) -> list[dict[str, Any]]: + if not self._ready(): + return [] + session_query: dict[str, Any] = {"visibility": {"$ne": "deleted"}} + if user_id != "dev": + session_query["user_id"] = user_id + if session_id is not None: + session_query["_id"] = session_id + + session_cursor = self.db.sessions.find(session_query, {"_id": 1}) + session_ids = [str(row.get("_id")) async for row in session_cursor] + if not session_ids: + return [] + + event_query: dict[str, Any] = { + "session_id": {"$in": session_ids}, + "event_type": {"$in": list(USAGE_EVENT_TYPES)}, + } + if start is not None or end is not None: + created_at: dict[str, datetime] = {} + if start is not None: + created_at["$gte"] = start + if end is not None: + created_at["$lt"] = end + event_query["created_at"] = created_at + + event_cursor = self.db.session_events.find(event_query).sort("created_at", 1) + return [row async for row in event_cursor] + + async def append_trace_message( + self, session_id: str, message: dict[str, Any], source: str = "message" + ) -> int | None: + if not self._ready(): + return None + try: + seq = await self._next_seq(f"trace:{session_id}") + await self.db.session_trace_messages.insert_one( + { + "_id": _doc_id(session_id, seq), + "session_id": session_id, + "seq": seq, + "role": message.get("role"), + "message": _safe_message_doc(message), + "source": source, + "created_at": _now(), + } + ) + return seq + except PyMongoError as e: + logger.debug("Failed to append trace message for %s: %s", session_id, e) + return None + + async def mark_pro_seen( + self, user_id: str, *, is_pro: bool + ) -> dict[str, Any] | None: + """Track per-user Pro state and detect freeβ†’Pro conversions. + + Returns ``{"converted": True, "first_seen_at": ..."}`` exactly once + per user β€” the first time we see them as Pro after having recorded + them as non-Pro at least once. Otherwise returns ``None``. + + Storing ``ever_non_pro`` lets us distinguish "user joined as Pro" + (no conversion) from "user upgraded" (conversion). The atomic + ``find_one_and_update`` on a guarded filter makes the conversion + emit at-most-once even under concurrent requests. + """ + if not self._ready() or not user_id: + return None + now = _now() + set_fields: dict[str, Any] = {"last_seen_at": now, "is_pro": bool(is_pro)} + if not is_pro: + set_fields["ever_non_pro"] = True + try: + await self.db.pro_users.update_one( + {"_id": user_id}, + { + "$setOnInsert": {"_id": user_id, "first_seen_at": now}, + "$set": set_fields, + }, + upsert=True, + ) + except PyMongoError as e: + logger.debug("mark_pro_seen upsert failed for %s: %s", user_id, e) + return None + + if not is_pro: + return None + + try: + doc = await self.db.pro_users.find_one_and_update( + { + "_id": user_id, + "ever_non_pro": True, + "first_seen_pro_at": {"$exists": False}, + }, + {"$set": {"first_seen_pro_at": now}}, + return_document=ReturnDocument.AFTER, + ) + except PyMongoError as e: + logger.debug("mark_pro_seen conversion check failed for %s: %s", user_id, e) + return None + + if not doc: + return None + return { + "converted": True, + "first_seen_at": (doc.get("first_seen_at") or now).isoformat(), + } + + # ── API response documents (the /v1 developer API) ────────────── + + async def upsert_api_response(self, doc: dict[str, Any]) -> None: + if not self._ready(): + return await super().upsert_api_response(doc) + response_id = str(doc.get("_id") or "") + if not response_id: + return + now = _now() + fields = {k: v for k, v in doc.items() if k != "_id"} + fields["updated_at"] = now + try: + await self.db.api_responses.update_one( + {"_id": response_id}, + { + "$setOnInsert": {"_id": response_id, "created_at": now}, + "$set": fields, + }, + upsert=True, + ) + except PyMongoError as e: + logger.warning("Failed to upsert api response %s: %s", response_id, e) + + async def load_api_response(self, response_id: str) -> dict[str, Any] | None: + if not self._ready(): + return await super().load_api_response(response_id) + try: + return await self.db.api_responses.find_one({"_id": response_id}) + except PyMongoError as e: + logger.warning("Failed to load api response %s: %s", response_id, e) + return None + + async def update_api_response_fields(self, response_id: str, **fields: Any) -> None: + if not self._ready(): + return await super().update_api_response_fields(response_id, **fields) + if not fields: + return + fields["updated_at"] = _now() + try: + await self.db.api_responses.update_one( + {"_id": response_id}, {"$set": fields} + ) + except PyMongoError as e: + logger.warning("Failed to update api response %s: %s", response_id, e) + + async def current_event_seq(self, session_id: str) -> int: + """Current value of the session's event counter (0 if none yet). + + Read-only β€” does NOT increment. Used to bracket an API response's + event range before submitting a turn. + """ + if not self._ready(): + return 0 + try: + doc = await self.db.counters.find_one({"_id": f"event:{session_id}"}) + except PyMongoError as e: + logger.debug("Failed to read event counter for %s: %s", session_id, e) + return 0 + return int(doc["seq"]) if doc and doc.get("seq") is not None else 0 + + +_store: NoopSessionStore | MongoSessionStore | None = None + + +def get_session_store() -> NoopSessionStore | MongoSessionStore: + global _store + if _store is None: + uri = os.environ.get("MONGODB_URI") + db_name = os.environ.get("MONGODB_DB", "ml-intern") + _store = MongoSessionStore(uri, db_name) if uri else NoopSessionStore() + return _store diff --git a/agent/core/session_resume.py b/agent/core/session_resume.py new file mode 100644 index 0000000000000000000000000000000000000000..ac7d335f6c69b63c99f06519afb536ce4f4455b5 --- /dev/null +++ b/agent/core/session_resume.py @@ -0,0 +1,289 @@ +"""Reload a previously saved session log into the active CLI session.""" + +from __future__ import annotations + +import json +import logging +import re +from dataclasses import dataclass +from datetime import datetime +from pathlib import Path +from typing import Any + +from litellm import Message + +from agent.core.model_ids import strip_huggingface_model_prefix +from agent.core.model_switcher import is_valid_model_id +from agent.core.session import DEFAULT_SESSION_LOG_DIR + +logger = logging.getLogger(__name__) + +_REDACTED_MARKER = re.compile(r"\[REDACTED_[A-Z_]+\]") + + +@dataclass +class SessionLogEntry: + """Metadata for a locally saved session log.""" + + path: Path + session_id: str + session_start_time: str | None + session_end_time: str | None + model_name: str | None + message_count: int + preview: str + mtime: float + + +def _message_preview(content: Any, max_chars: int = 72) -> str: + """Return a one-line preview for string or OpenAI-style block content.""" + if isinstance(content, str): + text = content + elif isinstance(content, list): + parts: list[str] = [] + for block in content: + if isinstance(block, dict): + value = block.get("text") or block.get("content") + if isinstance(value, str): + parts.append(value) + elif isinstance(block, str): + parts.append(block) + text = " ".join(parts) + else: + text = "" + text = " ".join(text.split()) + if len(text) > max_chars: + return text[: max_chars - 1].rstrip() + "…" + return text + + +def _first_user_preview(messages: list[Any]) -> str: + for raw in messages: + if isinstance(raw, dict) and raw.get("role") == "user": + preview = _message_preview(raw.get("content")) + if preview: + return preview + return "(no user prompt preview)" + + +def list_session_logs( + directory: Path = DEFAULT_SESSION_LOG_DIR, +) -> list[SessionLogEntry]: + """Return readable session logs under ``directory``, newest first.""" + if not directory.exists(): + return [] + + entries: list[SessionLogEntry] = [] + for path in directory.glob("*.json"): + try: + with open(path) as f: + data = json.load(f) + except Exception: + continue + + messages = data.get("messages") or [] + if not isinstance(messages, list): + continue + + session_id = data.get("session_id") + if not isinstance(session_id, str) or not session_id: + session_id = path.stem + + stat = path.stat() + entries.append( + SessionLogEntry( + path=path, + session_id=session_id, + session_start_time=data.get("session_start_time"), + session_end_time=data.get("session_end_time"), + model_name=data.get("model_name"), + message_count=len(messages), + preview=_first_user_preview(messages), + mtime=stat.st_mtime, + ) + ) + + entries.sort(key=lambda item: item.mtime, reverse=True) + return entries + + +def format_session_log_entry(index: int, entry: SessionLogEntry) -> str: + timestamp = entry.session_end_time or entry.session_start_time + label = "unknown time" + if isinstance(timestamp, str) and timestamp: + try: + label = datetime.fromisoformat(timestamp).strftime("%Y-%m-%d %H:%M") + except ValueError: + label = timestamp[:16] + short_id = entry.session_id[:8] + model = entry.model_name or "unknown model" + return ( + f"{index:>2}. {label} {short_id} " + f"{entry.message_count} msgs {model}\n" + f" {entry.preview}" + ) + + +def resolve_session_log_arg( + arg: str, + entries: list[SessionLogEntry], + directory: Path = DEFAULT_SESSION_LOG_DIR, +) -> Path | None: + """Resolve ``/resume `` as index, path, filename, or session id prefix.""" + value = arg.strip() + if not value: + return None + + if value.isdigit(): + idx = int(value) + if 1 <= idx <= len(entries): + return entries[idx - 1].path + + candidate = Path(value).expanduser() + candidates = [candidate] + if not candidate.is_absolute(): + candidates.append(directory / candidate) + if candidate.suffix != ".json": + candidates.append(directory / f"{value}.json") + + for path in candidates: + if path.exists() and path.is_file(): + return path + + matches = [ + entry.path + for entry in entries + if entry.session_id.startswith(value) or entry.path.name.startswith(value) + ] + if len(matches) == 1: + return matches[0] + return None + + +def _turn_count_from_messages(messages: list[Any]) -> int: + return sum( + 1 for raw in messages if isinstance(raw, dict) and raw.get("role") == "user" + ) + + +def _has_redacted_content(messages: list[Any]) -> bool: + """Whether any message body contains a ``[REDACTED_*]`` marker.""" + for raw in messages: + if not isinstance(raw, dict): + continue + content = raw.get("content") + if isinstance(content, str) and _REDACTED_MARKER.search(content): + return True + if isinstance(content, list): + for block in content: + if isinstance(block, dict): + text = block.get("text") or block.get("content") + if isinstance(text, str) and _REDACTED_MARKER.search(text): + return True + return False + + +def restore_session_from_log(session: Any, path: Path) -> dict[str, Any]: + """Replace the active session context with messages from ``path``. + + Continues the saved session (reusing its id and on-disk save path) when + the log's ``user_id`` matches the current session, and forks otherwise: + the caller's session id stays put and future heartbeat saves go to a + fresh file rather than overwriting the source log. + + Returns metadata for the ``resume_complete`` event. + """ + with open(path) as f: + data = json.load(f) + + raw_messages = data.get("messages") + if not isinstance(raw_messages, list): + raise ValueError("Selected log does not contain a messages array") + + restored_messages: list[Message] = [] + dropped_count = 0 + for raw in raw_messages: + if not isinstance(raw, dict) or raw.get("role") == "system": + continue + try: + restored_messages.append(Message.model_validate(raw)) + except Exception as e: + dropped_count += 1 + logger.warning("Dropping malformed message from %s: %s", path, e) + + if not restored_messages: + raise ValueError("Selected log has no restorable non-system messages") + + cm = session.context_manager + system_msg = cm.items[0] if cm.items and cm.items[0].role == "system" else None + cm.items = ([system_msg] if system_msg else []) + restored_messages + + # Validate the saved model id before switching. ``update_model`` doesn't + # check availability; an unrecognised id silently sticks and the next LLM + # call fails with a cryptic routing error. Logs from a different + # deployment, an older catalog, or a removed model land here. + saved_model = data.get("model_name") + invalid_saved_model: str | None = None + if isinstance(saved_model, str) and saved_model: + normalized_model = strip_huggingface_model_prefix(saved_model) + if normalized_model and is_valid_model_id(normalized_model): + session.update_model(normalized_model) + else: + invalid_saved_model = saved_model + logger.warning( + "Saved log model %r failed format validation; keeping %r", + saved_model, + session.config.model_name, + ) + + cm._recompute_usage(session.config.model_name) + + saved_session_id = data.get("session_id") + saved_user_id = data.get("user_id") + is_continuation = saved_user_id == session.user_id + + if is_continuation: + if isinstance(saved_session_id, str) and saved_session_id: + session.session_id = saved_session_id + session.session_start_time = ( + data.get("session_start_time") or session.session_start_time + ) + + # Always fork the on-disk save path. The source log is treated as an + # immutable snapshot: ``logged_events`` is reset to a single + # ``resumed_from`` marker below for cost accounting, so reusing the + # source path would let the next heartbeat save destroy the original + # ``llm_call``/event history on disk. The next save will pick a fresh + # filename instead. + session._local_save_path = None + + saved_event_count = ( + len(data.get("events", [])) if isinstance(data.get("events"), list) else 0 + ) + session.logged_events = [ + { + "timestamp": datetime.now().isoformat(), + "event_type": "resumed_from", + "data": { + "path": str(path), + "original_session_id": ( + saved_session_id if isinstance(saved_session_id, str) else None + ), + "original_event_count": saved_event_count, + "forked": not is_continuation, + }, + } + ] + session.turn_count = _turn_count_from_messages(raw_messages) + session.last_auto_save_turn = session.turn_count + session.pending_approval = None + + return { + "path": str(path), + "restored_count": len(restored_messages), + "dropped_count": dropped_count, + "model_name": session.config.model_name, + "invalid_saved_model": invalid_saved_model, + "forked": not is_continuation, + "had_redacted_content": _has_redacted_content(raw_messages), + } diff --git a/agent/core/session_uploader.py b/agent/core/session_uploader.py new file mode 100644 index 0000000000000000000000000000000000000000..268c8459688de705fdb255553ecd121fb2bf83fb --- /dev/null +++ b/agent/core/session_uploader.py @@ -0,0 +1,682 @@ +#!/usr/bin/env python3 +""" +Standalone script for uploading session trajectories to HuggingFace. +This runs as a separate process to avoid blocking the main agent. +Uses individual file uploads to avoid race conditions. + +Two formats are supported: + +* ``row`` β€” single-line JSONL row used by the existing org telemetry/KPI + pipeline (``smolagents/ml-intern-sessions``). Compatible with + ``backend/kpis_scheduler.py``. +* ``claude_code`` β€” one event per line in the Claude Code JSONL schema, + auto-detected by the HF Agent Trace Viewer + (https://huggingface.co/changelog/agent-trace-viewer). Used for the + per-user private dataset (default ``{hf_user}/ml-intern-sessions``). +""" + +import argparse +import hashlib +import json +import os +import sys +from datetime import datetime +from pathlib import Path +from typing import Any + +from dotenv import load_dotenv + +from agent.core.usage_metrics import ( + summarize_usage_events, + usage_metric_scalar_fields, +) + +load_dotenv() + +# Token resolution for the org KPI dataset. Fallback chain (least-privilege +# first) β€” matches backend/kpis_scheduler.py so one write-scoped token on the +# Space covers every telemetry dataset. Never hardcode tokens in source. +_ORG_TOKEN_FALLBACK_CHAIN = ( + "HF_SESSION_UPLOAD_TOKEN", + "HF_TOKEN", + "HF_ADMIN_TOKEN", +) +_PERSONAL_TOKEN_ENV = "_ML_INTERN_PERSONAL_TOKEN" + + +def _resolve_token(token_env: str | None) -> str: + """Resolve an HF token from env. ``token_env`` overrides the fallback chain.""" + if token_env == "HF_TOKEN": + try: + from agent.core.hf_tokens import resolve_hf_token + + return ( + resolve_hf_token( + os.environ.get(_PERSONAL_TOKEN_ENV), + os.environ.get("HF_TOKEN"), + ) + or "" + ) + except Exception: + token = os.environ.get(_PERSONAL_TOKEN_ENV) or os.environ.get("HF_TOKEN") + return token or "" + + if token_env: + return os.environ.get(token_env, "") or "" + for var in _ORG_TOKEN_FALLBACK_CHAIN: + val = os.environ.get(var) + if val: + return val + return "" + + +def _scrub(obj: Any) -> Any: + """Best-effort regex scrub for HF tokens / API keys before upload.""" + try: + from agent.core.redact import scrub # type: ignore + except Exception: + # Fallback for environments where the agent package isn't importable + # (shouldn't happen in our subprocess, but be defensive). + import importlib.util + + _spec = importlib.util.spec_from_file_location( + "_redact", + Path(__file__).parent / "redact.py", + ) + _mod = importlib.util.module_from_spec(_spec) + _spec.loader.exec_module(_mod) # type: ignore + scrub = _mod.scrub + return scrub(obj) + + +def _msg_uuid(session_id: str, role: str, idx: int) -> str: + """Deterministic UUID-shaped id for a Claude Code message. + + Uses sha1 of ``session_id::role::idx`` so re-uploads/heartbeats keep the + parent/child chain stable. Same convention as the example dataset + https://huggingface.co/datasets/clem/hf-coding-tools-traces. + """ + digest = hashlib.sha1(f"{session_id}::{role}::{idx}".encode("utf-8")).hexdigest() + # Format like a UUID for visual familiarity (32 hex chars w/ dashes). + return ( + f"{digest[0:8]}-{digest[8:12]}-{digest[12:16]}-{digest[16:20]}-{digest[20:32]}" + ) + + +def _content_to_text(content: Any) -> str: + """Best-effort flatten of a litellm/openai content field to plain text.""" + if content is None: + return "" + if isinstance(content, str): + return content + if isinstance(content, list): + parts: list[str] = [] + for block in content: + if isinstance(block, dict): + text = block.get("text") + if isinstance(text, str): + parts.append(text) + else: + # Unknown content block β€” keep round-trippable representation. + parts.append(json.dumps(block, default=str)) + else: + parts.append(str(block)) + return "\n".join(parts) + return str(content) + + +def _parse_tool_args(raw: Any) -> Any: + """Tool call arguments arrive as a JSON-encoded string from LLMs.""" + if isinstance(raw, dict): + return raw + if isinstance(raw, str): + try: + return json.loads(raw) + except (json.JSONDecodeError, TypeError): + return {"_raw": raw} + return raw + + +def to_claude_code_jsonl(trajectory: dict) -> list[dict]: + """Convert an internal trajectory dict to Claude Code JSONL events. + + Schema reference (per the HF Agent Trace Viewer auto-detector): + + {"type":"user","message":{"role":"user","content":"..."}, + "uuid":"...","parentUuid":null,"sessionId":"...","timestamp":"..."} + {"type":"assistant", + "message":{"role":"assistant","model":"...", + "content":[{"type":"text","text":"..."}, + {"type":"tool_use","id":"...","name":"...","input":{...}}]}, + "uuid":"...","parentUuid":"","sessionId":"...","timestamp":"..."} + {"type":"user","message":{"role":"user", + "content":[{"type":"tool_result", + "tool_use_id":"...","content":"..."}]}, + "uuid":"...","parentUuid":"","sessionId":"...","timestamp":"..."} + + System messages are skipped (they're not part of the viewer schema and + contain large prompts that pollute the trace viewer UI). + """ + session_id = trajectory["session_id"] + model_name = trajectory.get("model_name") or "" + fallback_timestamp = ( + trajectory.get("session_start_time") or datetime.now().isoformat() + ) + messages: list[dict] = trajectory.get("messages") or [] + + out: list[dict] = [] + parent_uuid: str | None = None + + for idx, msg in enumerate(messages): + if not isinstance(msg, dict): + continue + role = msg.get("role") + if role == "system": + continue + timestamp = msg.get("timestamp") or fallback_timestamp + + if role == "user": + content = _content_to_text(msg.get("content")) + event_uuid = _msg_uuid(session_id, "user", idx) + out.append( + { + "type": "user", + "message": {"role": "user", "content": content}, + "uuid": event_uuid, + "parentUuid": parent_uuid, + "sessionId": session_id, + "timestamp": timestamp, + } + ) + parent_uuid = event_uuid + + elif role == "assistant": + content_text = _content_to_text(msg.get("content")) + content_blocks: list[dict] = [] + if content_text: + content_blocks.append({"type": "text", "text": content_text}) + for tc in msg.get("tool_calls") or []: + if not isinstance(tc, dict): + continue + fn = tc.get("function") or {} + content_blocks.append( + { + "type": "tool_use", + "id": tc.get("id") or "", + "name": fn.get("name") or "", + "input": _parse_tool_args(fn.get("arguments")), + } + ) + if not content_blocks: + # Edge case: empty assistant turn (shouldn't normally happen, + # but skip rather than emit an empty content array which + # confuses the viewer). + continue + event_uuid = _msg_uuid(session_id, "assistant", idx) + out.append( + { + "type": "assistant", + "message": { + "role": "assistant", + "model": model_name, + "content": content_blocks, + }, + "uuid": event_uuid, + "parentUuid": parent_uuid, + "sessionId": session_id, + "timestamp": timestamp, + } + ) + parent_uuid = event_uuid + + elif role == "tool": + tool_call_id = msg.get("tool_call_id") or "" + content_text = _content_to_text(msg.get("content")) + event_uuid = _msg_uuid(session_id, "tool", idx) + out.append( + { + "type": "user", + "message": { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": tool_call_id, + "content": content_text, + } + ], + }, + "uuid": event_uuid, + "parentUuid": parent_uuid, + "sessionId": session_id, + "timestamp": timestamp, + } + ) + parent_uuid = event_uuid + + return out + + +def _scrub_session_for_upload(data: dict) -> dict: + """Best-effort scrub of transcript fields before any upload temp file.""" + scrubbed = dict(data) + scrubbed["messages"] = _scrub(data.get("messages") or []) + scrubbed["events"] = _scrub(data.get("events") or []) + scrubbed["tools"] = _scrub(data.get("tools") or []) + return scrubbed + + +def _usage_metrics_for_row(data: dict) -> dict: + metrics = data.get("usage_metrics") + if isinstance(metrics, str): + try: + parsed = json.loads(metrics) + metrics = parsed if isinstance(parsed, dict) else None + except (json.JSONDecodeError, TypeError): + metrics = None + if isinstance(metrics, dict): + return metrics + events = data.get("events") + return summarize_usage_events( + events if isinstance(events, list) else [], + session_id=data.get("session_id"), + ) + + +def _write_row_payload(data: dict, tmp_path: str) -> None: + """Single-row JSONL (existing format) β€” used by KPI scheduler.""" + scrubbed = _scrub_session_for_upload(data) + usage_metrics = _usage_metrics_for_row(data) + session_row = { + "session_id": data["session_id"], + "user_id": data.get("user_id"), + "session_start_time": data["session_start_time"], + "session_end_time": data["session_end_time"], + "model_name": data["model_name"], + "total_cost_usd": data.get("total_cost_usd"), + "messages": json.dumps(scrubbed["messages"]), + "events": json.dumps(scrubbed["events"]), + "tools": json.dumps(scrubbed["tools"]), + "usage_metrics": json.dumps(_scrub(usage_metrics)), + } + session_row.update(usage_metric_scalar_fields(usage_metrics)) + + with open(tmp_path, "w") as tmp: + json.dump(session_row, tmp) + + +def _write_claude_code_payload(data: dict, tmp_path: str) -> None: + """Multi-line JSONL in Claude Code schema for the HF trace viewer.""" + # Scrub before conversion so secrets never reach the upload temp file. + scrubbed = _scrub_session_for_upload(data) + events = to_claude_code_jsonl(scrubbed) + with open(tmp_path, "w") as tmp: + for event in events: + tmp.write(json.dumps(event)) + tmp.write("\n") + + +def _status_field(format: str) -> str: + """Per-format upload status field on the local trajectory file.""" + return "personal_upload_status" if format == "claude_code" else "upload_status" + + +def _url_field(format: str) -> str: + return "personal_upload_url" if format == "claude_code" else "upload_url" + + +def _read_session_file(session_file: str) -> dict: + """Read a local session file while respecting uploader file locks.""" + import fcntl + + with open(session_file, "r") as f: + fcntl.flock(f, fcntl.LOCK_SH) + try: + return json.load(f) + finally: + fcntl.flock(f, fcntl.LOCK_UN) + + +def _update_upload_status( + session_file: str, + status_key: str, + url_key: str, + status: str, + dataset_url: str | None = None, +) -> None: + """Atomically update only this uploader's status fields. + + The org and personal uploaders run as separate processes against the same + local session JSON file. Re-read under an exclusive lock so one uploader + cannot clobber fields written by the other. + """ + import fcntl + + with open(session_file, "r+") as f: + fcntl.flock(f, fcntl.LOCK_EX) + try: + data = json.load(f) + data[status_key] = status + if dataset_url is not None: + data[url_key] = dataset_url + data["last_save_time"] = datetime.now().isoformat() + f.seek(0) + json.dump(data, f, indent=2) + f.truncate() + f.flush() + os.fsync(f.fileno()) + finally: + fcntl.flock(f, fcntl.LOCK_UN) + + +def dataset_card_readme(repo_id: str) -> str: + """Dataset card for personal ML Intern session trace repos.""" + return """--- +pretty_name: "ML Intern Session Traces" +language: +- en +license: other +task_categories: +- text-generation +tags: +- agent-traces +- coding-agent +- ml-intern +- session-traces +- claude-code +- hf-agent-trace-viewer +configs: +- config_name: default + data_files: + - split: train + path: "sessions/**/*.jsonl" +--- + +# ML Intern session traces + +This dataset contains ML Intern coding agent session traces uploaded from local +ML Intern runs. The traces are stored as JSON Lines files under `sessions/`, +with one file per session. + +## Links + +- ML Intern demo: https://smolagents-ml-intern.hf.space +- ML Intern CLI: https://github.com/huggingface/ml-intern + +## Data description + +Each `*.jsonl` file contains a single ML Intern session converted to a +Claude-Code-style event stream for the Hugging Face Agent Trace Viewer. Entries +can include user messages, assistant messages, tool calls, tool results, model +metadata, and timestamps. + +Session files are written to paths of the form: + +```text +sessions/YYYY-MM-DD/.jsonl +``` + +## Redaction and review + +**WARNING: no comprehensive redaction or human review has been performed for this dataset.** + +ML Intern applies automated best-effort scrubbing for common secret patterns +such as Hugging Face, GitHub, AWS, and provider API tokens before upload. +This is not a privacy guarantee. + +These traces may contain sensitive information, including prompts, code, +terminal output, file paths, repository names, private task context, tool +outputs, or other data from the local development environment. Treat every +session as potentially sensitive. + +Do not make this dataset public unless you have manually inspected the uploaded +sessions and are comfortable sharing their full contents. + +## Limitations + +Coding agent transcripts can include private or off-topic content, failed +experiments, credentials accidentally pasted by a user, and outputs copied from +local files or services. Use with appropriate caution, especially before +changing repository visibility. +""" + + +def _upload_dataset_card(api: Any, repo_id: str, token: str, format: str) -> None: + """Create/update a README for personal trace datasets.""" + if format != "claude_code": + return + + api.upload_file( + path_or_fileobj=dataset_card_readme(repo_id).encode("utf-8"), + path_in_repo="README.md", + repo_id=repo_id, + repo_type="dataset", + token=token, + commit_message="Update dataset card", + ) + + +def upload_session_as_file( + session_file: str, + repo_id: str, + max_retries: int = 3, + format: str = "row", + token_env: str | None = None, + private: bool = False, +) -> bool: + """Upload a single session as an individual JSONL file (no race conditions). + + Args: + session_file: Path to local session JSON file + repo_id: HuggingFace dataset repo ID + max_retries: Number of retry attempts + format: ``row`` (default, KPI-compatible) or ``claude_code`` (HF + Agent Trace Viewer compatible). + token_env: Name of the env var holding the HF token. ``None`` falls + back to the org-token chain (``HF_SESSION_UPLOAD_TOKEN`` β†’ + ``HF_TOKEN`` β†’ ``HF_ADMIN_TOKEN``). + private: When creating the repo for the first time, mark it private. + + Returns: + True if successful, False otherwise + """ + try: + from huggingface_hub import HfApi + except ImportError: + print("Error: huggingface_hub library not available", file=sys.stderr) + return False + + status_key = _status_field(format) + url_key = _url_field(format) + + try: + data = _read_session_file(session_file) + + # Skip if already uploaded for this format. + if data.get(status_key) == "success": + return True + + hf_token = _resolve_token(token_env) + if not hf_token: + _update_upload_status(session_file, status_key, url_key, "failed") + return False + + # Build temp upload payload in the requested format. + import tempfile + + with tempfile.NamedTemporaryFile( + mode="w", suffix=".jsonl", delete=False + ) as tmp: + tmp_path = tmp.name + + try: + if format == "claude_code": + _write_claude_code_payload(data, tmp_path) + else: + _write_row_payload(data, tmp_path) + + session_id = data["session_id"] + date_str = datetime.fromisoformat(data["session_start_time"]).strftime( + "%Y-%m-%d" + ) + repo_path = f"sessions/{date_str}/{session_id}.jsonl" + + api = HfApi() + for attempt in range(max_retries): + try: + # Idempotent create β€” visibility is set on first creation + # only. Existing repos keep whatever the user picked via + # /share-traces. + try: + api.create_repo( + repo_id=repo_id, + repo_type="dataset", + private=private, + token=hf_token, + exist_ok=True, + ) + except Exception: + pass + + _upload_dataset_card(api, repo_id, hf_token, format) + + api.upload_file( + path_or_fileobj=tmp_path, + path_in_repo=repo_path, + repo_id=repo_id, + repo_type="dataset", + token=hf_token, + commit_message=f"Add session {session_id}", + ) + + _update_upload_status( + session_file, + status_key, + url_key, + "success", + f"https://huggingface.co/datasets/{repo_id}", + ) + return True + + except Exception: + if attempt < max_retries - 1: + import time + + wait_time = 2**attempt + time.sleep(wait_time) + else: + _update_upload_status( + session_file, status_key, url_key, "failed" + ) + return False + + finally: + try: + os.unlink(tmp_path) + except Exception: + pass + + except Exception as e: + print(f"Error uploading session: {e}", file=sys.stderr) + return False + + +def retry_failed_uploads( + directory: str, + repo_id: str, + format: str = "row", + token_env: str | None = None, + private: bool = False, +): + """Retry all failed/pending uploads in a directory for the given format.""" + log_dir = Path(directory) + if not log_dir.exists(): + return + + status_key = _status_field(format) + session_files = list(log_dir.glob("session_*.json")) + + for filepath in session_files: + try: + data = _read_session_file(str(filepath)) + + # Only retry pending or failed uploads. Files predating this + # field don't have it; treat unknown as "not yet attempted" for + # the row format (legacy behavior) and "skip" for claude_code + # so we don't suddenly re-upload pre-existing sessions to a + # newly-introduced personal repo. + status = data.get(status_key, "unknown") + if format == "claude_code" and status_key not in data: + continue + + if status in ("pending", "failed", "unknown"): + upload_session_as_file( + str(filepath), + repo_id, + format=format, + token_env=token_env, + private=private, + ) + + except Exception: + pass + + +def _str2bool(v: str) -> bool: + return str(v).strip().lower() in {"1", "true", "yes", "on"} + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(prog="session_uploader.py") + sub = parser.add_subparsers(dest="command", required=True) + + p_upload = sub.add_parser("upload") + p_upload.add_argument("session_file") + p_upload.add_argument("repo_id") + p_upload.add_argument( + "--format", + choices=["row", "claude_code"], + default="row", + ) + p_upload.add_argument( + "--token-env", + default=None, + help="Env var name holding the HF token (default: org fallback chain).", + ) + p_upload.add_argument("--private", default="false") + + p_retry = sub.add_parser("retry") + p_retry.add_argument("directory") + p_retry.add_argument("repo_id") + p_retry.add_argument( + "--format", + choices=["row", "claude_code"], + default="row", + ) + p_retry.add_argument("--token-env", default=None) + p_retry.add_argument("--private", default="false") + + args = parser.parse_args() + + if args.command == "upload": + ok = upload_session_as_file( + args.session_file, + args.repo_id, + format=args.format, + token_env=args.token_env, + private=_str2bool(args.private), + ) + sys.exit(0 if ok else 1) + + if args.command == "retry": + retry_failed_uploads( + args.directory, + args.repo_id, + format=args.format, + token_env=args.token_env, + private=_str2bool(args.private), + ) + sys.exit(0) + + parser.print_help() + sys.exit(1) diff --git a/agent/core/telemetry.py b/agent/core/telemetry.py new file mode 100644 index 0000000000000000000000000000000000000000..ef6623dd908616cbbb774dd7cffe1d4ee2038def --- /dev/null +++ b/agent/core/telemetry.py @@ -0,0 +1,439 @@ +"""All agent observability in one module. + +Every telemetry signal the agent emits β€” LLM-call usage / cost, hf_jobs +lifecycle, sandbox lifecycle, user feedback, mid-turn heartbeat saves β€” is +defined here so business-logic files stay free of instrumentation noise. + +Callsites are one-liners:: + + await telemetry.record_llm_call(session, model=..., response=r, ...) + await telemetry.record_hf_job_submit(session, job, args, image=..., job_type="Python") + HeartbeatSaver.maybe_fire(session) + +All ``record_*`` functions emit a single ``Event`` via ``session.send_event`` +and never raise β€” telemetry is best-effort and must not break the agent. +""" + +from __future__ import annotations + +import asyncio +import logging +import time +from typing import Any + +from agent.core.cost_estimation import hf_jobs_price_catalog + +logger = logging.getLogger(__name__) + + +# ── usage extraction ──────────────────────────────────────────────────────── + + +def extract_usage(response_or_chunk: Any) -> dict: + """Flat usage dict from a litellm response or final-chunk usage object. + + Normalizes cache-token details across provider response shapes. Exposed + under the stable keys ``cache_read_tokens`` / ``cache_creation_tokens``. + """ + u = getattr(response_or_chunk, "usage", None) + if u is None and isinstance(response_or_chunk, dict): + u = response_or_chunk.get("usage") + if u is None: + return {} + + def _g(name, default=0): + if isinstance(u, dict): + return u.get(name, default) or default + return getattr(u, name, default) or default + + prompt = _g("prompt_tokens") + completion = _g("completion_tokens") + total = _g("total_tokens") or (prompt + completion) + + cache_read = _g("cache_read_input_tokens") + cache_creation = _g("cache_creation_input_tokens") + details = _g("prompt_tokens_details", None) + + if not cache_read and details is not None: + if isinstance(details, dict): + cache_read = details.get("cached_tokens", 0) or 0 + else: + cache_read = getattr(details, "cached_tokens", 0) or 0 + if not cache_creation and details is not None: + if isinstance(details, dict): + cache_creation = details.get("cache_write_tokens", 0) or 0 + else: + cache_creation = getattr(details, "cache_write_tokens", 0) or 0 + + return { + "prompt_tokens": int(prompt), + "completion_tokens": int(completion), + "total_tokens": int(total), + "cache_read_tokens": int(cache_read), + "cache_creation_tokens": int(cache_creation), + } + + +# ── llm_call ──────────────────────────────────────────────────────────────── + + +async def record_llm_call( + session: Any, + *, + model: str, + response: Any = None, + latency_ms: int, + finish_reason: str | None, + kind: str = "main", +) -> dict: + """Emit an ``llm_call`` event and return the extracted usage dict so + callers can stash it on their result object if they want. + + ``kind`` tags the call site so downstream analytics can break spend + down by category. Values currently emitted by the codebase: + + * ``main`` β€” agent loop turn (user-facing reply or tool follow-up) + * ``research`` β€” research sub-agent inner loop (3 call sites) + * ``compaction`` β€” context-window summary on overflow + * ``effort_probe``β€” effort cascade walk on rejection / model switch + * ``restore`` β€” session re-seed summary after a Space restart + + Pre-2026-04-29 only ``main`` calls were instrumented; observed gap on + Cost Explorer was ~67%, with the other 5 call sites accounting for + the rest. Tagging lets us split the dataset's ``total_cost_usd`` by + category and validate against billing data. + + The ``/title`` and ``/health/llm`` diagnostic call sites are intentionally + not instrumented because they have no session context and are tiny. + """ + usage = extract_usage(response) if response is not None else {} + cost_usd = 0.0 + if response is not None: + try: + from litellm import completion_cost + + cost_usd = float(completion_cost(completion_response=response) or 0.0) + except Exception: + cost_usd = 0.0 + from agent.core.session import Event # local import to avoid cycle + + try: + payload = { + "model": model, + "latency_ms": latency_ms, + "finish_reason": finish_reason, + "cost_usd": cost_usd, + "kind": kind, + **usage, + } + await session.send_event( + Event( + event_type="llm_call", + data=payload, + ) + ) + except Exception as e: + logger.debug("record_llm_call failed (non-fatal): %s", e) + return {"cost_usd": cost_usd, **usage} + + +# ── hf_jobs ──────────────────────────────────────────────────────────────── + + +def _infer_push_to_hub(script_or_cmd: Any) -> bool: + if not isinstance(script_or_cmd, str): + return False + return ( + "push_to_hub=True" in script_or_cmd + or "push_to_hub=true" in script_or_cmd + or "hub_model_id" in script_or_cmd + ) + + +async def record_hf_job_submit( + session: Any, + job: Any, + args: dict, + *, + image: str, + job_type: str, +) -> float: + """Emit ``hf_job_submit``. Returns the monotonic start timestamp so the + caller can pass it back into :func:`record_hf_job_complete`.""" + from agent.core.session import Event + + t_start = time.monotonic() + try: + script_text = args.get("script") or args.get("command") or "" + await session.send_event( + Event( + event_type="hf_job_submit", + data={ + "job_id": getattr(job, "id", None), + "job_url": getattr(job, "url", None), + "flavor": args.get("hardware_flavor", "cpu-basic"), + "timeout": args.get("timeout", "30m"), + "job_type": job_type, + "image": image, + "namespace": args.get("namespace"), + "push_to_hub": _infer_push_to_hub(script_text), + }, + ) + ) + except Exception as e: + logger.debug("record_hf_job_submit failed (non-fatal): %s", e) + return t_start + + +async def record_hf_job_complete( + session: Any, + job: Any, + *, + flavor: str, + final_status: str, + submit_ts: float, +) -> dict: + from agent.core.session import Event + + try: + wall_time_s = int(time.monotonic() - submit_ts) + billable_seconds = max(0, wall_time_s) + price_usd_per_hour = None + estimated_cost_usd = None + cost_estimate_source = "unknown_price" + prices = await hf_jobs_price_catalog() + if flavor in prices: + price_usd_per_hour = float(prices[flavor]) + estimated_cost_usd = round( + price_usd_per_hour * (billable_seconds / 3600), + 4, + ) + cost_estimate_source = "runtime_price_catalog" + payload = { + "job_id": getattr(job, "id", None), + "flavor": flavor, + "final_status": final_status, + "wall_time_s": wall_time_s, + "billable_seconds_estimate": billable_seconds, + "price_usd_per_hour": price_usd_per_hour, + "estimated_cost_usd": estimated_cost_usd, + "cost_estimate_source": cost_estimate_source, + } + await session.send_event( + Event( + event_type="hf_job_complete", + data=payload, + ) + ) + return payload + except Exception as e: + logger.debug("record_hf_job_complete failed (non-fatal): %s", e) + return {} + + +# ── sandbox ───────────────────────────────────────────────────────────────── + + +async def record_sandbox_create( + session: Any, + sandbox: Any, + *, + hardware: str, + create_latency_s: int, +) -> None: + from agent.core.session import Event + + try: + # Pin created-at on the session so record_sandbox_destroy can diff. + session._sandbox_created_at = time.monotonic() - create_latency_s + await session.send_event( + Event( + event_type="sandbox_create", + data={ + "sandbox_id": getattr(sandbox, "space_id", None), + "hardware": hardware, + "create_latency_s": int(create_latency_s), + }, + ) + ) + except Exception as e: + logger.debug("record_sandbox_create failed (non-fatal): %s", e) + + +async def record_sandbox_destroy(session: Any, sandbox: Any) -> dict: + from agent.core.session import Event + + try: + created = getattr(session, "_sandbox_created_at", None) + lifetime_s = int(time.monotonic() - created) if created else None + hardware = getattr(session, "sandbox_hardware", None) or "cpu-basic" + estimated_cost_usd = None + try: + from agent.core.cost_estimation import SPACE_PRICE_USD_PER_HOUR + + price_usd_per_hour = SPACE_PRICE_USD_PER_HOUR.get(str(hardware)) + if price_usd_per_hour is not None and lifetime_s is not None: + estimated_cost_usd = round( + float(price_usd_per_hour) * (max(0, lifetime_s) / 3600), + 4, + ) + except Exception: + estimated_cost_usd = None + payload = { + "sandbox_id": getattr(sandbox, "space_id", None), + "hardware": hardware, + "lifetime_s": lifetime_s, + "estimated_cost_usd": estimated_cost_usd, + } + await session.send_event( + Event( + event_type="sandbox_destroy", + data=payload, + ) + ) + return payload + except Exception as e: + logger.debug("record_sandbox_destroy failed (non-fatal): %s", e) + return {} + + +# ── feedback ─────────────────────────────────────────────────────────────── + + +async def record_feedback( + session: Any, + *, + rating: str, + turn_index: int | None = None, + message_id: str | None = None, + comment: str | None = None, +) -> None: + from agent.core.session import Event + + try: + await session.send_event( + Event( + event_type="feedback", + data={ + "rating": rating, + "turn_index": turn_index, + "message_id": message_id, + "comment": (comment or "")[:500], + }, + ) + ) + except Exception as e: + logger.debug("record_feedback failed (non-fatal): %s", e) + + +async def record_pro_cta_click( + session: Any, + *, + source: str, + target: str = "pro_pricing", +) -> None: + from agent.core.session import Event + + try: + await session.send_event( + Event( + event_type="pro_cta_click", + data={"source": source, "target": target}, + ) + ) + except Exception as e: + logger.debug("record_pro_cta_click failed (non-fatal): %s", e) + + +async def record_pro_conversion( + session: Any, + *, + first_seen_at: str | None = None, +) -> None: + """Emit a ``pro_conversion`` event for a user we've previously observed + as non-Pro and now see as Pro for the first time. Detected upstream in + ``MongoSessionStore.mark_pro_seen``; fired into the user's first Pro + session so the rollup picks it up alongside other event-driven KPIs.""" + from agent.core.session import Event + + try: + await session.send_event( + Event( + event_type="pro_conversion", + data={"first_seen_at": first_seen_at}, + ) + ) + except Exception as e: + logger.debug("record_pro_conversion failed (non-fatal): %s", e) + + +async def record_credits_topped_up( + session: Any, + *, + namespace: str | None = None, +) -> None: + """Emit a ``credits_topped_up`` event when an hf_job submits successfully + in a session that previously hit ``jobs_access_blocked`` β€” i.e. the user + came back from the HF billing top-up flow and unblocked themselves. + Caller is responsible for firing this at most once per session.""" + from agent.core.session import Event + + try: + await session.send_event( + Event( + event_type="credits_topped_up", + data={"namespace": namespace}, + ) + ) + except Exception as e: + logger.debug("record_credits_topped_up failed (non-fatal): %s", e) + + +# ── heartbeat ────────────────────────────────────────────────────────────── + +# Module-level reference set for fire-and-forget heartbeat tasks. asyncio only +# keeps *weak* references to tasks, so the returned Task would otherwise be +# eligible for GC before running β€” the task gets discarded and the upload +# silently never happens. Hold strong refs until the task completes. +_heartbeat_tasks: set[asyncio.Task] = set() + + +class HeartbeatSaver: + """Time-gated mid-turn flush. + + Called from ``Session.send_event`` after every event. Fires + ``save_and_upload_detached`` in a worker thread at most once per + ``heartbeat_interval_s`` (default 60s). Guards against losing trace data + on long-running turns that crash before ``turn_complete``. + """ + + @staticmethod + def maybe_fire(session: Any) -> None: + if not getattr(session.config, "save_sessions", False): + return + interval = getattr(session.config, "heartbeat_interval_s", 0) or 0 + if interval <= 0: + return + now = time.monotonic() + last = getattr(session, "_last_heartbeat_ts", None) + if last is None: + # Initialise on first event; no save yet. + session._last_heartbeat_ts = now + return + if now - last < interval: + return + session._last_heartbeat_ts = now + repo_id = session.config.session_dataset_repo + try: + task = asyncio.get_running_loop().create_task( + asyncio.to_thread(session.save_and_upload_detached, repo_id) + ) + # Hold a strong reference until the task finishes so asyncio can't + # GC it. ``set.discard`` is a no-op on missing keys β†’ safe callback. + _heartbeat_tasks.add(task) + task.add_done_callback(_heartbeat_tasks.discard) + except RuntimeError: + try: + session.save_and_upload_detached(repo_id) + except Exception as e: + logger.debug("Heartbeat save failed (non-fatal): %s", e) diff --git a/agent/core/tools.py b/agent/core/tools.py new file mode 100644 index 0000000000000000000000000000000000000000..0ac100fae770bd444332332d67140f6664630694 --- /dev/null +++ b/agent/core/tools.py @@ -0,0 +1,394 @@ +""" +Tool system for the agent +Provides ToolSpec and ToolRouter for managing both built-in and MCP tools +""" + +import logging +import warnings +from dataclasses import dataclass +from typing import Any, Awaitable, Callable, Optional + +from fastmcp import Client +from fastmcp.exceptions import ToolError +from mcp.types import EmbeddedResource, ImageContent, TextContent + +from agent.config import MCPServerConfig +from agent.tools.dataset_tools import ( + HF_INSPECT_DATASET_TOOL_SPEC, + hf_inspect_dataset_handler, +) +from agent.tools.docs_tools import ( + EXPLORE_HF_DOCS_TOOL_SPEC, + HF_DOCS_FETCH_TOOL_SPEC, + explore_hf_docs_handler, + hf_docs_fetch_handler, +) +from agent.tools.github_find_examples import ( + GITHUB_FIND_EXAMPLES_TOOL_SPEC, + github_find_examples_handler, +) +from agent.tools.github_list_repos import ( + GITHUB_LIST_REPOS_TOOL_SPEC, + github_list_repos_handler, +) +from agent.tools.github_read_file import ( + GITHUB_READ_FILE_TOOL_SPEC, + github_read_file_handler, +) +from agent.tools.hf_repo_files_tool import ( + HF_REPO_FILES_TOOL_SPEC, + hf_repo_files_handler, +) +from agent.tools.hf_repo_git_tool import ( + HF_REPO_GIT_TOOL_SPEC, + hf_repo_git_handler, +) +from agent.tools.jobs_tool import HF_JOBS_TOOL_SPEC, hf_jobs_handler +from agent.tools.notify_tool import NOTIFY_TOOL_SPEC, notify_handler +from agent.tools.papers_tool import HF_PAPERS_TOOL_SPEC, hf_papers_handler +from agent.tools.plan_tool import PLAN_TOOL_SPEC, plan_tool_handler +from agent.tools.research_tool import RESEARCH_TOOL_SPEC, research_handler +from agent.tools.sandbox_tool import get_sandbox_tools +from agent.tools.web_search_tool import WEB_SEARCH_TOOL_SPEC, web_search_handler + +# Suppress aiohttp deprecation warning +warnings.filterwarnings( + "ignore", category=DeprecationWarning, module="aiohttp.connector" +) + +logger = logging.getLogger(__name__) + +NOT_ALLOWED_TOOL_NAMES = ["hf_jobs", "hf_doc_search", "hf_doc_fetch", "hf_whoami"] + + +def convert_mcp_content_to_string(content: list) -> str: + """ + Convert MCP content blocks to a string format compatible with LLM messages. + + Based on FastMCP documentation, content can be: + - TextContent: has .text field + - ImageContent: has .data and .mimeType fields + - EmbeddedResource: has .resource field with .text or .blob + + Args: + content: List of MCP content blocks + + Returns: + String representation of the content suitable for LLM consumption + """ + if not content: + return "" + + parts = [] + for item in content: + if isinstance(item, TextContent): + # Extract text from TextContent blocks + parts.append(item.text) + elif isinstance(item, ImageContent): + # TODO: Handle images + # For images, include a description with MIME type + parts.append(f"[Image: {item.mimeType}]") + elif isinstance(item, EmbeddedResource): + # TODO: Handle embedded resources + # For embedded resources, try to extract text + resource = item.resource + if hasattr(resource, "text") and resource.text: + parts.append(resource.text) + elif hasattr(resource, "blob") and resource.blob: + parts.append( + f"[Binary data: {resource.mimeType if hasattr(resource, 'mimeType') else 'unknown'}]" + ) + else: + parts.append( + f"[Resource: {resource.uri if hasattr(resource, 'uri') else 'unknown'}]" + ) + else: + # Fallback: try to convert to string + parts.append(str(item)) + + return "\n".join(parts) + + +@dataclass +class ToolSpec: + """Tool specification for LLM""" + + name: str + description: str + parameters: dict[str, Any] + handler: Optional[Callable[[dict[str, Any]], Awaitable[tuple[str, bool]]]] = None + + +class ToolRouter: + """ + Routes tool calls to appropriate handlers. + Based on codex-rs/core/src/tools/router.rs + """ + + def __init__( + self, + mcp_servers: dict[str, MCPServerConfig], + hf_token: str | None = None, + local_mode: bool = False, + ): + self.tools: dict[str, ToolSpec] = {} + self.mcp_servers: dict[str, dict[str, Any]] = {} + + for tool in create_builtin_tools(local_mode=local_mode): + self.register_tool(tool) + + self.mcp_client: Client | None = None + if mcp_servers: + mcp_servers_payload = {} + for name, server in mcp_servers.items(): + data = server.model_dump() + if hf_token: + data.setdefault("headers", {})["Authorization"] = ( + f"Bearer {hf_token}" + ) + mcp_servers_payload[name] = data + self.mcp_client = Client({"mcpServers": mcp_servers_payload}) + self._mcp_initialized = False + + def register_tool(self, tool: ToolSpec) -> None: + self.tools[tool.name] = tool + + async def register_mcp_tools(self) -> None: + tools = await self.mcp_client.list_tools() + registered_names = [] + skipped_count = 0 + for tool in tools: + if tool.name in NOT_ALLOWED_TOOL_NAMES: + skipped_count += 1 + continue + registered_names.append(tool.name) + self.register_tool( + ToolSpec( + name=tool.name, + description=tool.description, + parameters=tool.inputSchema, + handler=None, + ) + ) + logger.info( + f"Loaded {len(registered_names)} MCP tools: {', '.join(registered_names)} ({skipped_count} disabled)" + ) + + async def register_openapi_tool(self) -> None: + """Register the OpenAPI search tool (requires async initialization)""" + from agent.tools.docs_tools import ( + _get_api_search_tool_spec, + search_openapi_handler, + ) + + try: + openapi_spec = await _get_api_search_tool_spec() + self.register_tool( + ToolSpec( + name=openapi_spec["name"], + description=openapi_spec["description"], + parameters=openapi_spec["parameters"], + handler=search_openapi_handler, + ) + ) + logger.info(f"Loaded OpenAPI search tool: {openapi_spec['name']}") + except Exception as e: + logger.warning("Failed to load OpenAPI search tool: %s", e) + + def get_tool_specs_for_llm(self) -> list[dict[str, Any]]: + """Get tool specifications in OpenAI format""" + specs = [] + for tool in self.tools.values(): + specs.append( + { + "type": "function", + "function": { + "name": tool.name, + "description": tool.description, + "parameters": tool.parameters, + }, + } + ) + return specs + + async def __aenter__(self) -> "ToolRouter": + if self.mcp_client is not None: + try: + await self.mcp_client.__aenter__() + await self.mcp_client.initialize() + await self.register_mcp_tools() + self._mcp_initialized = True + except Exception as e: + logger.warning( + "MCP connection failed, continuing without MCP tools: %s", e + ) + self.mcp_client = None + + await self.register_openapi_tool() + + total_tools = len(self.tools) + logger.info(f"Agent ready with {total_tools} tools total") + + return self + + async def __aexit__(self, exc_type, exc, tb) -> None: + if self.mcp_client is not None: + await self.mcp_client.__aexit__(exc_type, exc, tb) + self._mcp_initialized = False + + async def call_tool( + self, + tool_name: str, + arguments: dict[str, Any], + session: Any = None, + tool_call_id: str | None = None, + ) -> tuple[str, bool]: + """ + Call a tool and return (output_string, success_bool). + + For MCP tools, converts the CallToolResult content blocks to a string. + For built-in tools, calls their handler directly. + """ + # Check if this is a built-in tool with a handler + tool = self.tools.get(tool_name) + if tool and tool.handler: + import inspect + + # Check if handler accepts session argument + sig = inspect.signature(tool.handler) + if "session" in sig.parameters: + # Check if handler also accepts tool_call_id parameter + if "tool_call_id" in sig.parameters: + return await tool.handler( + arguments, session=session, tool_call_id=tool_call_id + ) + return await tool.handler(arguments, session=session) + return await tool.handler(arguments) + + # Otherwise, use MCP client + if self._mcp_initialized: + try: + result = await self.mcp_client.call_tool(tool_name, arguments) + output = convert_mcp_content_to_string(result.content) + return output, not result.is_error + except ToolError as e: + # Catch MCP tool errors and return them to the agent + error_msg = f"Tool error: {str(e)}" + return error_msg, False + + return "MCP client not initialized", False + + +# ============================================================================ +# BUILT-IN TOOL HANDLERS +# ============================================================================ + + +def create_builtin_tools(local_mode: bool = False) -> list[ToolSpec]: + """Create built-in tool specifications""" + # in order of importance + tools = [ + # Research sub-agent (delegates to read-only tools in independent context) + ToolSpec( + name=RESEARCH_TOOL_SPEC["name"], + description=RESEARCH_TOOL_SPEC["description"], + parameters=RESEARCH_TOOL_SPEC["parameters"], + handler=research_handler, + ), + # Documentation search tools + ToolSpec( + name=EXPLORE_HF_DOCS_TOOL_SPEC["name"], + description=EXPLORE_HF_DOCS_TOOL_SPEC["description"], + parameters=EXPLORE_HF_DOCS_TOOL_SPEC["parameters"], + handler=explore_hf_docs_handler, + ), + ToolSpec( + name=HF_DOCS_FETCH_TOOL_SPEC["name"], + description=HF_DOCS_FETCH_TOOL_SPEC["description"], + parameters=HF_DOCS_FETCH_TOOL_SPEC["parameters"], + handler=hf_docs_fetch_handler, + ), + # Paper discovery and reading + ToolSpec( + name=HF_PAPERS_TOOL_SPEC["name"], + description=HF_PAPERS_TOOL_SPEC["description"], + parameters=HF_PAPERS_TOOL_SPEC["parameters"], + handler=hf_papers_handler, + ), + ToolSpec( + name=WEB_SEARCH_TOOL_SPEC["name"], + description=WEB_SEARCH_TOOL_SPEC["description"], + parameters=WEB_SEARCH_TOOL_SPEC["parameters"], + handler=web_search_handler, + ), + # Dataset inspection tool (unified) + ToolSpec( + name=HF_INSPECT_DATASET_TOOL_SPEC["name"], + description=HF_INSPECT_DATASET_TOOL_SPEC["description"], + parameters=HF_INSPECT_DATASET_TOOL_SPEC["parameters"], + handler=hf_inspect_dataset_handler, + ), + # Planning and job management tools + ToolSpec( + name=PLAN_TOOL_SPEC["name"], + description=PLAN_TOOL_SPEC["description"], + parameters=PLAN_TOOL_SPEC["parameters"], + handler=plan_tool_handler, + ), + ToolSpec( + name=NOTIFY_TOOL_SPEC["name"], + description=NOTIFY_TOOL_SPEC["description"], + parameters=NOTIFY_TOOL_SPEC["parameters"], + handler=notify_handler, + ), + ToolSpec( + name=HF_JOBS_TOOL_SPEC["name"], + description=HF_JOBS_TOOL_SPEC["description"], + parameters=HF_JOBS_TOOL_SPEC["parameters"], + handler=hf_jobs_handler, + ), + # HF Repo management tools + ToolSpec( + name=HF_REPO_FILES_TOOL_SPEC["name"], + description=HF_REPO_FILES_TOOL_SPEC["description"], + parameters=HF_REPO_FILES_TOOL_SPEC["parameters"], + handler=hf_repo_files_handler, + ), + ToolSpec( + name=HF_REPO_GIT_TOOL_SPEC["name"], + description=HF_REPO_GIT_TOOL_SPEC["description"], + parameters=HF_REPO_GIT_TOOL_SPEC["parameters"], + handler=hf_repo_git_handler, + ), + ToolSpec( + name=GITHUB_FIND_EXAMPLES_TOOL_SPEC["name"], + description=GITHUB_FIND_EXAMPLES_TOOL_SPEC["description"], + parameters=GITHUB_FIND_EXAMPLES_TOOL_SPEC["parameters"], + handler=github_find_examples_handler, + ), + ToolSpec( + name=GITHUB_LIST_REPOS_TOOL_SPEC["name"], + description=GITHUB_LIST_REPOS_TOOL_SPEC["description"], + parameters=GITHUB_LIST_REPOS_TOOL_SPEC["parameters"], + handler=github_list_repos_handler, + ), + ToolSpec( + name=GITHUB_READ_FILE_TOOL_SPEC["name"], + description=GITHUB_READ_FILE_TOOL_SPEC["description"], + parameters=GITHUB_READ_FILE_TOOL_SPEC["parameters"], + handler=github_read_file_handler, + ), + ] + + # Sandbox or local tools (highest priority) + if local_mode: + from agent.tools.local_tools import get_local_tools + + tools = get_local_tools() + tools + else: + tools = get_sandbox_tools() + tools + + tool_names = ", ".join([t.name for t in tools]) + logger.info(f"Loaded {len(tools)} built-in tools: {tool_names}") + + return tools diff --git a/agent/core/usage_metrics.py b/agent/core/usage_metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..f93c0a42d9593ec3089767ff26a0a680f93c010d --- /dev/null +++ b/agent/core/usage_metrics.py @@ -0,0 +1,448 @@ +"""Pure usage/billing summaries for session trajectory analytics.""" + +from collections import Counter, defaultdict +from datetime import UTC, datetime, timedelta +from math import isfinite +from typing import Any + +from agent.core.cost_estimation import SPACE_PRICE_USD_PER_HOUR + +USAGE_METRICS_VERSION = 1 +BILLING_SCOPE_ACCOUNT_WINDOW_DELTA = "account_window_delta" + +_USAGE_SCALAR_KEYS = ( + "usage_total_usd", + "usage_total_usd_source", + "usage_app_total_usd", + "usage_hf_billing_total_usd", + "usage_llm_calls", + "usage_total_tokens", + "usage_hf_job_submits", + "usage_hf_job_status_snapshots", + "usage_sandbox_creates", + "usage_sandbox_pairs", +) + + +def _coerce_float(value: Any) -> float: + if isinstance(value, bool) or value is None: + return 0.0 + try: + parsed = float(value) + except (TypeError, ValueError): + return 0.0 + return parsed if isfinite(parsed) else 0.0 + + +def _coerce_optional_float(value: Any) -> float | None: + if isinstance(value, bool) or value is None: + return None + try: + parsed = float(value) + except (TypeError, ValueError): + return None + return parsed if isfinite(parsed) else None + + +def _coerce_int(value: Any) -> int: + if isinstance(value, bool) or value is None: + return 0 + try: + return int(value) + except (TypeError, ValueError): + return 0 + + +def _round_usd(value: Any) -> float: + return round(_coerce_float(value), 6) + + +def _parse_timestamp(value: Any) -> datetime | None: + if isinstance(value, datetime): + dt = value + elif isinstance(value, str) and value: + try: + dt = datetime.fromisoformat(value.replace("Z", "+00:00")) + except ValueError: + return None + else: + return None + if dt.tzinfo is None: + return dt.replace(tzinfo=UTC) + return dt.astimezone(UTC) + + +def event_created_at(event: dict[str, Any]) -> datetime | None: + return _parse_timestamp(event.get("created_at") or event.get("timestamp")) + + +def _event_data(event: dict[str, Any]) -> dict[str, Any]: + data = event.get("data") or {} + return data if isinstance(data, dict) else {} + + +def _has_number(value: Any) -> bool: + return _coerce_optional_float(value) is not None + + +def _counter_dict(counter: Counter[str]) -> dict[str, int]: + return dict(sorted(counter.items())) + + +def _empty_app_bucket(session_id: str | None) -> dict[str, Any]: + return { + "session_id": session_id, + "total_usd": 0.0, + "inference_usd": 0.0, + "hf_jobs_estimated_usd": 0.0, + "sandbox_estimated_usd": 0.0, + "llm_calls": 0, + "hf_jobs_count": 0, + "sandbox_count": 0, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0, + "hf_jobs_billable_seconds_estimate": 0, + "sandbox_billable_seconds_estimate": 0, + } + + +def _sandbox_id(event: dict[str, Any]) -> str | None: + sandbox_id = _event_data(event).get("sandbox_id") + return sandbox_id if isinstance(sandbox_id, str) and sandbox_id else None + + +def _sandbox_duration_seconds( + create_event: dict[str, Any], + destroy_event: dict[str, Any], +) -> int: + create_data = _event_data(create_event) + destroy_data = _event_data(destroy_event) + lifetime_s = _coerce_int(destroy_data.get("lifetime_s")) + if lifetime_s > 0: + return lifetime_s + + create_at = event_created_at(create_event) + destroy_at = event_created_at(destroy_event) + if create_at is None or destroy_at is None: + return 0 + create_latency_s = max(0, _coerce_int(create_data.get("create_latency_s"))) + interval_start = create_at - timedelta(seconds=create_latency_s) + if destroy_at <= interval_start: + return 0 + return int((destroy_at - interval_start).total_seconds()) + + +def summarize_sandbox_lifecycle( + lifecycle_events: list[tuple[int, dict[str, Any]]], +) -> dict[str, Any]: + """Pair sandbox lifecycle events and estimate billed usage. + + Shared by dataset usage metrics and backend usage responses so sandbox + pricing and create/destroy pairing semantics cannot drift. + """ + ordered_events = [ + event + for _, event in sorted( + lifecycle_events, + key=lambda indexed: ( + event_created_at(indexed[1]) is None, + event_created_at(indexed[1]) or datetime.min.replace(tzinfo=UTC), + indexed[0], + ), + ) + ] + active_creates: dict[str, list[dict[str, Any]]] = defaultdict(list) + matched_pairs = 0 + unpaired_destroys = 0 + estimated_usd = 0.0 + billable_seconds = 0 + + for event in ordered_events: + event_type = event.get("event_type") + sandbox_id = _sandbox_id(event) + if sandbox_id is None: + continue + if event_type == "sandbox_create": + active_creates[sandbox_id].append(event) + continue + if event_type != "sandbox_destroy": + continue + + creates = active_creates.get(sandbox_id) + if not creates: + unpaired_destroys += 1 + continue + + create_event = creates.pop() + if not creates: + active_creates.pop(sandbox_id, None) + + hardware = str(_event_data(create_event).get("hardware") or "cpu-basic") + seconds = _sandbox_duration_seconds(create_event, event) + price_usd_per_hour = _coerce_float(SPACE_PRICE_USD_PER_HOUR.get(hardware)) + matched_pairs += 1 + if price_usd_per_hour > 0: + billable_seconds += seconds + estimated_usd += price_usd_per_hour * (seconds / 3600) + + return { + "matched_pairs": matched_pairs, + "unpaired_creates": sum(len(events) for events in active_creates.values()), + "unpaired_destroys": unpaired_destroys, + "estimated_usd": _round_usd(estimated_usd), + "billable_seconds_estimate": billable_seconds, + } + + +def normalize_hf_billing_snapshot(snapshot: dict[str, Any] | None) -> dict[str, Any]: + """Return a dataset-safe HF billing snapshot. + + Only current-session window rollups are retained. Monthly account totals, + credit limits, and any caller-provided extra fields are intentionally + dropped before the snapshot can be serialized into session artifacts. + """ + hf_billing = snapshot.get("hf_billing") if isinstance(snapshot, dict) else None + hf_billing = hf_billing if isinstance(hf_billing, dict) else {} + current_session = hf_billing.get("current_session") + current_session = current_session if isinstance(current_session, dict) else None + + sanitized_current = None + if current_session is not None: + sanitized_current = { + "window_start": current_session.get("window_start"), + "window_end": current_session.get("window_end"), + "timezone": current_session.get("timezone"), + "total_usd": _round_usd(current_session.get("total_usd")), + "inference_providers_usd": _round_usd( + current_session.get("inference_providers_usd") + ), + "hf_jobs_usd": _round_usd(current_session.get("hf_jobs_usd")), + "inference_provider_requests": _coerce_int( + current_session.get("inference_provider_requests") + ), + "hf_jobs_minutes": round( + _coerce_float(current_session.get("hf_jobs_minutes")), 3 + ), + } + + available = bool(hf_billing.get("available") and sanitized_current is not None) + return { + "billing_scope": BILLING_SCOPE_ACCOUNT_WINDOW_DELTA, + "hf_billing": { + "source": str(hf_billing.get("source") or "hf_billing_usage_v2"), + "available": available, + "error": None if available else hf_billing.get("error"), + "current_session": sanitized_current if available else None, + }, + } + + +def summarize_usage_events( + events: list[dict[str, Any]], + *, + session_id: str | None = None, + hf_billing_snapshot: dict[str, Any] | None = None, +) -> dict[str, Any]: + app = _empty_app_bucket(session_id) + llm_by_kind: Counter[str] = Counter() + llm_by_model: Counter[str] = Counter() + job_statuses: Counter[str] = Counter() + job_submit_flavors: Counter[str] = Counter() + job_status_flavors: Counter[str] = Counter() + sandbox_hardware: Counter[str] = Counter() + lifecycle_events: list[tuple[int, dict[str, Any]]] = [] + + event_count = 0 + events_without_timestamp = 0 + llm_calls_with_cost_usd = 0 + llm_calls_with_nonzero_cost_usd = 0 + job_submits = 0 + job_status_snapshots = 0 + job_snapshots_with_estimated_cost = 0 + job_snapshots_with_nonzero_estimated_cost = 0 + sandbox_creates = 0 + sandbox_destroys = 0 + turn_complete_count = 0 + assistant_stream_end_count = 0 + + for index, event in enumerate(events or []): + if not isinstance(event, dict): + continue + event_count += 1 + if event_created_at(event) is None: + events_without_timestamp += 1 + + event_type = event.get("event_type") + data = _event_data(event) + if event_type == "llm_call": + app["llm_calls"] += 1 + if "cost_usd" in data: + llm_calls_with_cost_usd += 1 + cost_usd = _coerce_float(data.get("cost_usd")) + if cost_usd > 0: + llm_calls_with_nonzero_cost_usd += 1 + app["inference_usd"] += cost_usd + + prompt_tokens = _coerce_int(data.get("prompt_tokens")) + completion_tokens = _coerce_int(data.get("completion_tokens")) + cache_read_tokens = _coerce_int(data.get("cache_read_tokens")) + cache_creation_tokens = _coerce_int(data.get("cache_creation_tokens")) + total_tokens = _coerce_int(data.get("total_tokens")) or ( + prompt_tokens + + completion_tokens + + cache_read_tokens + + cache_creation_tokens + ) + app["prompt_tokens"] += prompt_tokens + app["completion_tokens"] += completion_tokens + app["cache_read_tokens"] += cache_read_tokens + app["cache_creation_tokens"] += cache_creation_tokens + app["total_tokens"] += total_tokens + llm_by_kind[str(data.get("kind") or "unknown")] += 1 + llm_by_model[str(data.get("model") or "unknown")] += 1 + elif event_type == "hf_job_submit": + job_submits += 1 + job_submit_flavors[str(data.get("flavor") or "unknown")] += 1 + elif event_type == "hf_job_complete": + job_status_snapshots += 1 + app["hf_jobs_count"] += 1 + estimated_cost = _coerce_float(data.get("estimated_cost_usd")) + app["hf_jobs_estimated_usd"] += estimated_cost + app["hf_jobs_billable_seconds_estimate"] += _coerce_int( + data.get("billable_seconds_estimate") or data.get("wall_time_s") + ) + if _has_number(data.get("estimated_cost_usd")): + job_snapshots_with_estimated_cost += 1 + if estimated_cost > 0: + job_snapshots_with_nonzero_estimated_cost += 1 + job_statuses[str(data.get("final_status") or "unknown")] += 1 + job_status_flavors[str(data.get("flavor") or "unknown")] += 1 + elif event_type == "sandbox_create": + sandbox_creates += 1 + sandbox_hardware[str(data.get("hardware") or "cpu-basic")] += 1 + lifecycle_events.append((index, event)) + elif event_type == "sandbox_destroy": + sandbox_destroys += 1 + lifecycle_events.append((index, event)) + elif event_type == "turn_complete": + turn_complete_count += 1 + elif event_type == "assistant_stream_end": + assistant_stream_end_count += 1 + + sandbox = summarize_sandbox_lifecycle(lifecycle_events) + app["sandbox_count"] = sandbox["matched_pairs"] + app["sandbox_estimated_usd"] = sandbox["estimated_usd"] + app["sandbox_billable_seconds_estimate"] = sandbox["billable_seconds_estimate"] + app["inference_usd"] = _round_usd(app["inference_usd"]) + app["hf_jobs_estimated_usd"] = _round_usd(app["hf_jobs_estimated_usd"]) + app["total_usd"] = _round_usd( + app["inference_usd"] + + app["hf_jobs_estimated_usd"] + + app["sandbox_estimated_usd"] + ) + + billing = normalize_hf_billing_snapshot(hf_billing_snapshot) + current_billing = billing["hf_billing"]["current_session"] + hf_billing_total = None + if billing["hf_billing"]["available"] and current_billing is not None: + hf_billing_total = _round_usd(current_billing.get("total_usd")) + usage_total = _round_usd(hf_billing_total + app["sandbox_estimated_usd"]) + usage_total_source = "hf_billing_plus_sandbox_estimate" + else: + usage_total = app["total_usd"] + usage_total_source = "app_telemetry_fallback" + + job_flavors = job_submit_flavors + job_status_flavors + + return { + "version": USAGE_METRICS_VERSION, + "session_id": session_id, + "billing_scope": BILLING_SCOPE_ACCOUNT_WINDOW_DELTA, + "total_usd": usage_total, + "total_usd_source": usage_total_source, + "app_total_usd": app["total_usd"], + "hf_billing_total_usd": hf_billing_total, + "app_telemetry": app, + "hf_billing": billing["hf_billing"], + "llm": { + "calls": app["llm_calls"], + "calls_by_kind": _counter_dict(llm_by_kind), + "calls_by_model": _counter_dict(llm_by_model), + "prompt_tokens": app["prompt_tokens"], + "completion_tokens": app["completion_tokens"], + "cache_read_tokens": app["cache_read_tokens"], + "cache_creation_tokens": app["cache_creation_tokens"], + "total_tokens": app["total_tokens"], + }, + "turns": { + "turn_complete_count": turn_complete_count, + "assistant_stream_end_count": assistant_stream_end_count, + }, + "hf_jobs": { + "submits": job_submits, + "status_snapshots": job_status_snapshots, + "statuses": _counter_dict(job_statuses), + "flavors": _counter_dict(job_flavors), + "submit_flavors": _counter_dict(job_submit_flavors), + "status_snapshot_flavors": _counter_dict(job_status_flavors), + "estimated_usd": app["hf_jobs_estimated_usd"], + "billable_seconds_estimate": app["hf_jobs_billable_seconds_estimate"], + "snapshots_with_estimated_cost": job_snapshots_with_estimated_cost, + "snapshots_with_nonzero_estimated_cost": ( + job_snapshots_with_nonzero_estimated_cost + ), + }, + "sandboxes": { + "creates": sandbox_creates, + "destroys": sandbox_destroys, + "matched_pairs": sandbox["matched_pairs"], + "unpaired_creates": sandbox["unpaired_creates"], + "unpaired_destroys": sandbox["unpaired_destroys"], + "hardware": _counter_dict(sandbox_hardware), + "estimated_usd": app["sandbox_estimated_usd"], + "billable_seconds_estimate": app["sandbox_billable_seconds_estimate"], + }, + "data_quality": { + "event_count": event_count, + "events_without_timestamp": events_without_timestamp, + "llm_calls_with_cost_usd": llm_calls_with_cost_usd, + "llm_calls_with_nonzero_cost_usd": llm_calls_with_nonzero_cost_usd, + "job_snapshots_with_estimated_cost": job_snapshots_with_estimated_cost, + "job_snapshots_missing_estimated_cost": ( + job_status_snapshots - job_snapshots_with_estimated_cost + ), + }, + } + + +def usage_metric_scalar_fields(metrics: dict[str, Any]) -> dict[str, Any]: + app = metrics.get("app_telemetry") if isinstance(metrics, dict) else {} + llm = metrics.get("llm") if isinstance(metrics, dict) else {} + jobs = metrics.get("hf_jobs") if isinstance(metrics, dict) else {} + sandboxes = metrics.get("sandboxes") if isinstance(metrics, dict) else {} + values = { + "usage_total_usd": metrics.get("total_usd"), + "usage_total_usd_source": metrics.get("total_usd_source"), + "usage_app_total_usd": metrics.get("app_total_usd"), + "usage_hf_billing_total_usd": metrics.get("hf_billing_total_usd"), + "usage_llm_calls": app.get("llm_calls") if isinstance(app, dict) else None, + "usage_total_tokens": llm.get("total_tokens") + if isinstance(llm, dict) + else None, + "usage_hf_job_submits": ( + jobs.get("submits") if isinstance(jobs, dict) else None + ), + "usage_hf_job_status_snapshots": ( + jobs.get("status_snapshots") if isinstance(jobs, dict) else None + ), + "usage_sandbox_creates": ( + sandboxes.get("creates") if isinstance(sandboxes, dict) else None + ), + "usage_sandbox_pairs": ( + sandboxes.get("matched_pairs") if isinstance(sandboxes, dict) else None + ), + } + return {key: values.get(key) for key in _USAGE_SCALAR_KEYS} diff --git a/agent/core/usage_thresholds.py b/agent/core/usage_thresholds.py new file mode 100644 index 0000000000000000000000000000000000000000..effba12bafa75e28b2c0bd89de85c8dfddfd722f --- /dev/null +++ b/agent/core/usage_thresholds.py @@ -0,0 +1,55 @@ +"""Helpers for session usage-threshold approval warnings.""" + +from typing import Any + +USAGE_THRESHOLD_TOOL_NAME = "usage_threshold" +USAGE_WARNING_FIRST_THRESHOLD_USD = 5.0 +USAGE_WARNING_MULTIPLIER = 2.0 + + +def normalize_usage_threshold(value: Any) -> float: + """Return a usable positive threshold, defaulting to the first warning.""" + if isinstance(value, bool): + return USAGE_WARNING_FIRST_THRESHOLD_USD + try: + threshold = float(value) + except (TypeError, ValueError): + return USAGE_WARNING_FIRST_THRESHOLD_USD + if threshold <= 0: + return USAGE_WARNING_FIRST_THRESHOLD_USD + return threshold + + +def next_usage_warning_threshold( + current_spend_usd: float, + acknowledged_threshold_usd: float, +) -> float: + """Advance the next threshold until it is above the current spend.""" + threshold = normalize_usage_threshold(acknowledged_threshold_usd) + current = max(0.0, float(current_spend_usd or 0.0)) + while threshold <= current: + threshold *= USAGE_WARNING_MULTIPLIER + return round(threshold, 4) + + +def is_usage_threshold_pending(pending_approval: Any) -> bool: + return ( + isinstance(pending_approval, dict) + and pending_approval.get("kind") == USAGE_THRESHOLD_TOOL_NAME + ) + + +def usage_threshold_pending_to_tool(pending_approval: dict[str, Any]) -> dict[str, Any]: + """Represent a synthetic usage approval as the existing pending-tool shape.""" + tool_call_id = str(pending_approval.get("tool_call_id") or "") + arguments = { + "threshold_usd": pending_approval.get("threshold_usd"), + "current_spend_usd": pending_approval.get("current_spend_usd"), + "next_threshold_usd": pending_approval.get("next_threshold_usd"), + "billing_source": pending_approval.get("billing_source"), + } + return { + "tool": USAGE_THRESHOLD_TOOL_NAME, + "tool_call_id": tool_call_id, + "arguments": arguments, + } diff --git a/agent/core/yolo_budget.py b/agent/core/yolo_budget.py new file mode 100644 index 0000000000000000000000000000000000000000..c8ed1684e19e3a4d5f5de268bb23f2fe63b8a889 --- /dev/null +++ b/agent/core/yolo_budget.py @@ -0,0 +1,403 @@ +"""Session-scoped YOLO budget guardrails.""" + +import uuid +from dataclasses import dataclass +from typing import Any + +from agent.core.cost_estimation import CostEstimate + +YOLO_BUDGET_TOOL_NAME = "yolo_budget" + + +@dataclass(frozen=True) +class BudgetReservation: + reservation_id: str + amount_usd: float + spend_kind: str + + +@dataclass(frozen=True) +class BudgetDecision: + allowed: bool + estimated_cost_usd: float | None = None + remaining_cap_usd: float | None = None + block_reason: str | None = None + billable: bool = False + reservation: BudgetReservation | None = None + + +def session_yolo_enabled(session: Any | None) -> bool: + return bool(session and getattr(session, "auto_approval_enabled", False)) + + +def session_spend_usd(session: Any | None) -> float: + if not session: + return 0.0 + return max( + 0.0, + float(getattr(session, "auto_approval_estimated_spend_usd", 0.0) or 0.0), + ) + + +def session_remaining_usd( + session: Any | None, reserved_spend_usd: float = 0.0 +) -> float | None: + if not session or getattr(session, "auto_approval_cost_cap_usd", None) is None: + return None + cap = float(getattr(session, "auto_approval_cost_cap_usd") or 0.0) + return round(max(0.0, cap - session_spend_usd(session) - reserved_spend_usd), 4) + + +def _set_session_spend(session: Any, amount_usd: float) -> None: + session.auto_approval_estimated_spend_usd = round(max(0.0, amount_usd), 4) + + +def add_session_spend(session: Any, amount_usd: float | None) -> None: + if amount_usd is None or amount_usd <= 0: + return + if hasattr(session, "add_auto_approval_estimated_spend"): + session.add_auto_approval_estimated_spend(amount_usd) + else: + _set_session_spend(session, session_spend_usd(session) + float(amount_usd)) + + +def adjust_session_spend(session: Any, delta_usd: float | None) -> None: + if delta_usd is None or delta_usd == 0: + return + _set_session_spend(session, session_spend_usd(session) + float(delta_usd)) + + +def seed_session_spend(session: Any, amount_usd: float | None) -> None: + if amount_usd is None: + return + _set_session_spend(session, max(session_spend_usd(session), float(amount_usd))) + + +def _cap_usd(session: Any | None) -> float | None: + if not session or getattr(session, "auto_approval_cost_cap_usd", None) is None: + return None + return max(0.0, float(getattr(session, "auto_approval_cost_cap_usd") or 0.0)) + + +def _reservation_store(session: Any) -> dict[str, BudgetReservation]: + store = getattr(session, "_yolo_budget_reservations", None) + if not isinstance(store, dict): + store = {} + setattr(session, "_yolo_budget_reservations", store) + return store + + +def _coerce_cost(value: Any) -> float | None: + if isinstance(value, bool) or value is None: + return None + try: + return max(0.0, float(value)) + except (TypeError, ValueError): + return None + + +def check_session_budget( + session: Any | None, + estimate: CostEstimate, + *, + reserved_spend_usd: float = 0.0, +) -> BudgetDecision: + if not session_yolo_enabled(session) or not estimate.billable: + return BudgetDecision( + allowed=True, + estimated_cost_usd=estimate.estimated_cost_usd, + billable=estimate.billable, + ) + + remaining = session_remaining_usd(session, reserved_spend_usd=reserved_spend_usd) + amount = _coerce_cost(estimate.estimated_cost_usd) + if amount is None: + return BudgetDecision( + allowed=False, + estimated_cost_usd=None, + remaining_cap_usd=remaining, + block_reason=estimate.block_reason + or "Could not estimate this session spend safely.", + billable=True, + ) + if remaining is not None and amount > remaining: + return BudgetDecision( + allowed=False, + estimated_cost_usd=round(amount, 4), + remaining_cap_usd=remaining, + block_reason=( + f"Estimated cost ${amount:.2f} exceeds remaining YOLO cap " + f"${remaining:.2f}." + ), + billable=True, + ) + return BudgetDecision( + allowed=True, + estimated_cost_usd=round(amount, 4), + remaining_cap_usd=remaining, + billable=True, + ) + + +def reserve_session_budget( + session: Any | None, + estimate: CostEstimate, + *, + spend_kind: str, + reservation_id: str | None = None, +) -> BudgetDecision: + decision = check_session_budget(session, estimate) + if not session or not session_yolo_enabled(session) or not decision.billable: + return decision + if not decision.allowed: + return decision + amount = _coerce_cost(decision.estimated_cost_usd) + if amount is None or amount <= 0: + return decision + + add_session_spend(session, amount) + rid = reservation_id or f"{spend_kind}-{uuid.uuid4().hex[:10]}" + reservation = BudgetReservation( + reservation_id=rid, + amount_usd=round(amount, 4), + spend_kind=spend_kind, + ) + _reservation_store(session)[rid] = reservation + return BudgetDecision( + allowed=True, + estimated_cost_usd=round(amount, 4), + remaining_cap_usd=session_remaining_usd(session), + billable=True, + reservation=reservation, + ) + + +def release_budget_reservation(session: Any | None, reservation_id: str | None) -> None: + if not session or not reservation_id: + return + reservation = _reservation_store(session).pop(reservation_id, None) + if reservation is None: + return + adjust_session_spend(session, -reservation.amount_usd) + + +def reconcile_budget_reservation( + session: Any | None, + reservation_id: str | None, + actual_cost_usd: Any, + *, + allow_zero_actual: bool = False, +) -> None: + if not session or not reservation_id: + return + reservation = _reservation_store(session).pop(reservation_id, None) + if reservation is None: + return + actual = _coerce_cost(actual_cost_usd) + if actual is None or (actual == 0 and not allow_zero_actual): + return + adjust_session_spend(session, actual - reservation.amount_usd) + + +def is_yolo_budget_pending(pending_approval: Any) -> bool: + return ( + isinstance(pending_approval, dict) + and pending_approval.get("kind") == YOLO_BUDGET_TOOL_NAME + ) + + +def yolo_budget_pending_to_tool(pending_approval: dict[str, Any]) -> dict[str, Any]: + tool_call_id = str(pending_approval.get("tool_call_id") or "") + arguments = { + "cap_usd": pending_approval.get("cap_usd"), + "current_spend_usd": pending_approval.get("current_spend_usd"), + "remaining_cap_usd": pending_approval.get("remaining_cap_usd"), + "estimated_next_usd": pending_approval.get("estimated_next_usd"), + "spend_kind": pending_approval.get("spend_kind"), + "reason": pending_approval.get("reason"), + } + return { + "tool": YOLO_BUDGET_TOOL_NAME, + "tool_call_id": tool_call_id, + "arguments": arguments, + "auto_approval_blocked": True, + "block_reason": pending_approval.get("reason"), + "estimated_cost_usd": pending_approval.get("estimated_next_usd"), + "remaining_cap_usd": pending_approval.get("remaining_cap_usd"), + } + + +async def request_yolo_budget_approval( + session: Any, + decision: BudgetDecision, + *, + spend_kind: str, + current_spend_usd: float | None = None, + cap_usd: float | None = None, + billing_source: str | None = None, + continuation: str | None = None, + final_response: str | None = None, + history_size: int | None = None, +) -> bool: + if session.pending_approval: + return False + from agent.core.session import Event + + current_spend = ( + session_spend_usd(session) + if current_spend_usd is None + else max(0.0, float(current_spend_usd)) + ) + cap = getattr(session, "auto_approval_cost_cap_usd", None) + if cap_usd is not None: + cap = max(0.0, float(cap_usd)) + pending = { + "kind": YOLO_BUDGET_TOOL_NAME, + "tool_call_id": f"yolo-budget-{uuid.uuid4().hex[:10]}", + "cap_usd": cap, + "current_spend_usd": round(current_spend, 6), + "remaining_cap_usd": decision.remaining_cap_usd, + "estimated_next_usd": decision.estimated_cost_usd, + "spend_kind": spend_kind, + "reason": decision.block_reason or "YOLO budget requires confirmation.", + "history_size": history_size + if history_size is not None + else len(session.context_manager.items), + } + if billing_source: + pending["billing_source"] = billing_source + if continuation: + pending["continuation"] = continuation + if isinstance(final_response, str): + pending["final_response"] = final_response + session.pending_approval = pending + tool = yolo_budget_pending_to_tool(pending) + await session.send_event( + Event( + event_type="approval_required", + data={ + "tools": [tool], + "count": 1, + "yolo_budget": True, + "auto_approval_blocked": True, + "block_reason": pending["reason"], + "estimated_cost_usd": pending["estimated_next_usd"], + "remaining_cap_usd": pending["remaining_cap_usd"], + }, + ) + ) + return True + + +async def request_yolo_budget_exceeded_approval( + session: Any, + *, + spend_kind: str, + current_spend_usd: float, + cap_usd: float, + billing_source: str | None = None, + reason: str | None = None, + continuation: str | None = None, + final_response: str | None = None, + history_size: int | None = None, +) -> bool: + current_spend = max(0.0, float(current_spend_usd)) + cap = max(0.0, float(cap_usd)) + seed_session_spend(session, current_spend) + if not session_yolo_enabled(session) or current_spend < cap: + return False + decision = BudgetDecision( + allowed=False, + estimated_cost_usd=None, + remaining_cap_usd=round(max(0.0, cap - current_spend), 4), + block_reason=reason + or ( + "YOLO cap paused session usage after " + f"{spend_kind}: current session spend ${current_spend:.2f} " + f"has reached the ${cap:.2f} cap." + ), + billable=True, + ) + return await request_yolo_budget_approval( + session, + decision, + spend_kind=spend_kind, + current_spend_usd=current_spend, + cap_usd=cap, + billing_source=billing_source, + continuation=continuation, + final_response=final_response, + history_size=history_size, + ) + + +async def maybe_pause_yolo_after_spend( + session: Any | None, + *, + spend_kind: str, + observed_cost_usd: Any = None, + continuation: str | None = None, + final_response: str | None = None, +) -> bool: + if not session or not session_yolo_enabled(session) or session.pending_approval: + return False + + observed = _coerce_cost(observed_cost_usd) + if observed is not None and observed > 0: + add_session_spend(session, observed) + + checker = getattr(session, "yolo_budget_checker", None) + if checker is not None: + try: + return bool( + await checker( + { + "spend_kind": spend_kind, + "observed_cost_usd": observed, + "continuation": continuation, + "final_response": final_response, + "history_size": len(session.context_manager.items), + } + ) + ) + except Exception: + pass + + cap = _cap_usd(session) + current_spend = session_spend_usd(session) + if cap is None or current_spend < cap: + return False + return await request_yolo_budget_exceeded_approval( + session, + spend_kind=spend_kind, + current_spend_usd=current_spend, + cap_usd=cap, + continuation=continuation, + final_response=final_response, + history_size=len(session.context_manager.items), + ) + + +def yolo_budget_can_resume( + session: Any, pending: dict[str, Any] +) -> tuple[bool, str | None]: + if not session_yolo_enabled(session): + return True, None + estimated_next = _coerce_cost(pending.get("estimated_next_usd")) + remaining = session_remaining_usd(session) + if estimated_next is None: + if remaining is None or remaining > 0: + return True, None + return ( + False, + str( + pending.get("reason") + or "YOLO cap is reached. Raise or disable the cap to continue." + ), + ) + if remaining is not None and estimated_next > remaining: + return ( + False, + f"Estimated cost ${estimated_next:.2f} exceeds remaining YOLO cap ${remaining:.2f}.", + ) + return True, None diff --git a/agent/main.py b/agent/main.py new file mode 100644 index 0000000000000000000000000000000000000000..86a6de25ea12be9ae0980ebf2ea62c8fbc2062ac --- /dev/null +++ b/agent/main.py @@ -0,0 +1,1712 @@ +""" +Interactive CLI chat with the agent + +Supports two modes: + Interactive: python -m agent.main + Headless: python -m agent.main "find me bird datasets" +""" + +import argparse +import asyncio +import json +import logging +import os +import signal +import subprocess +import sys +import time +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Optional + +import litellm +from prompt_toolkit import PromptSession + +from agent.config import load_config +from agent.core.approval_policy import is_scheduled_operation +from agent.core.agent_loop import submission_loop +from agent.core import model_switcher +from agent.core.hf_access import fetch_whoami_v2, normalize_hf_user_plan +from agent.core.hf_tokens import resolve_hf_token +from agent.core.local_models import is_local_model_id +from agent.core.model_ids import strip_huggingface_model_prefix +from agent.core.session import OpType +from agent.core.tools import ToolRouter +from agent.messaging.gateway import NotificationGateway +from agent.utils.reliability_checks import check_training_script_save_pattern +from agent.utils.terminal_display import ( + get_console, + print_approval_header, + print_approval_item, + print_banner, + print_compacted, + print_error, + print_help, + print_init_done, + print_interrupted, + print_markdown, + print_plan, + print_tool_call, + print_tool_log, + print_tool_output, + print_turn_complete, + print_yolo_approve, +) + +litellm.drop_params = True +# Suppress the "Give Feedback / Get Help" banner LiteLLM prints to stderr +# on every error β€” users don't need it, and our friendly errors cover the case. +litellm.suppress_debug_info = True + +CLI_CONFIG_PATH = Path(__file__).parent.parent / "configs" / "cli_agent_config.json" +logger = logging.getLogger(__name__) + + +def _apply_tool_runtime_override(config: Any, *, sandbox_tools: bool) -> str: + if sandbox_tools: + config.tool_runtime = "sandbox" + return getattr(config, "tool_runtime", "local") + + +def _is_local_tool_runtime(config: Any) -> bool: + return getattr(config, "tool_runtime", "local") == "local" + + +def _tool_runtime_label(local_mode: bool) -> str: + return "local filesystem" if local_mode else "HF sandbox" + + +def _normalize_config_model(config: Any) -> None: + normalized = strip_huggingface_model_prefix(getattr(config, "model_name", None)) + if normalized: + config.model_name = normalized + + +def _validate_cli_model_override(model: str) -> str: + if not model_switcher.is_valid_model_id(model): + raise ValueError( + "Invalid model id. Use an HF Router id like " + "'anthropic/claude-opus-4.8:fal-ai' or a supported local prefix." + ) + return model.removeprefix("huggingface/") + + +async def _wait_for_initial_sandbox_preload(session_holder: list | None) -> None: + session = session_holder[0] if session_holder else None + task = getattr(session, "sandbox_preload_task", None) + if not task: + return + try: + await asyncio.shield(task) + except asyncio.CancelledError: + raise + except Exception: + # The sandbox tool will surface the stored preload error on first use. + return + + +def _is_scheduled_hf_job_tool(tool_info: dict[str, Any]) -> bool: + if tool_info.get("tool") != "hf_jobs": + return False + arguments = tool_info.get("arguments") or {} + if isinstance(arguments, str): + try: + arguments = json.loads(arguments) + except json.JSONDecodeError: + return False + if not isinstance(arguments, dict): + return False + return is_scheduled_operation(arguments.get("operation")) + + +def _configure_runtime_logging() -> None: + """Keep third-party warning spam from punching through the interactive UI.""" + import logging + + logging.getLogger("LiteLLM").setLevel(logging.ERROR) + logging.getLogger("litellm").setLevel(logging.ERROR) + + +def _safe_get_args(arguments: dict) -> dict: + """Safely extract args dict from arguments, handling cases where LLM passes string.""" + args = arguments.get("args", {}) + # Sometimes LLM passes args as string instead of dict + if isinstance(args, str): + return {} + return args if isinstance(args, dict) else {} + + +def _get_hf_user(token: str | None) -> str | None: + """Resolve the HF username for a token, if available.""" + if not token: + return None + try: + from huggingface_hub import HfApi + + return HfApi(token=token).whoami().get("name") + except Exception: + return None + + +def _get_hf_user_from_whoami(whoami: dict[str, Any] | None) -> str | None: + if not isinstance(whoami, dict): + return None + for key in ("name", "user", "preferred_username"): + value = whoami.get(key) + if isinstance(value, str) and value: + return value + return None + + +async def _get_hf_identity(token: str | None) -> tuple[str | None, str]: + if not token: + return None, "unknown" + whoami = await fetch_whoami_v2(token) + if whoami is None: + return _get_hf_user(token), "unknown" + return _get_hf_user_from_whoami(whoami), normalize_hf_user_plan(whoami) or "unknown" + + +async def _prompt_and_save_hf_token(prompt_session: PromptSession) -> str: + """Prompt user for HF token, validate it, save via huggingface_hub.login(). Loops until valid.""" + from prompt_toolkit.formatted_text import HTML + from huggingface_hub import HfApi, login + + print("\nA Hugging Face token is required.") + print("Get one at: https://huggingface.co/settings/tokens\n") + + while True: + try: + token = await prompt_session.prompt_async( + HTML("Paste your HF token: ") + ) + except (EOFError, KeyboardInterrupt): + print("\nToken is required to continue.") + continue + + token = token.strip() + if not token: + print("Token cannot be empty.") + continue + + # Validate token against the API + try: + api = HfApi(token=token) + user_info = api.whoami() + username = user_info.get("name", "unknown") + print(f"Token valid (user: {username})") + except Exception: + print("Invalid token. Please try again.") + continue + + # Save for future sessions + try: + login(token=token, add_to_git_credential=False) + print("Token saved to ~/.cache/huggingface/token") + except Exception as e: + print( + f"Warning: could not persist token ({e}), using for this session only." + ) + + return token + + +@dataclass +class Operation: + """Operation to be executed by the agent""" + + op_type: OpType + data: Optional[dict[str, Any]] = None + + +@dataclass +class Submission: + """Submission to the agent loop""" + + id: str + operation: Operation + + +def _create_rich_console(): + """Get the shared rich Console.""" + return get_console() + + +def _clear_terminal() -> None: + command = ["cmd", "/c", "cls"] if os.name == "nt" else ["clear"] + try: + subprocess.run(command, check=False) + except OSError: + pass + + +class _ThinkingShimmer: + """Animated shiny/shimmer thinking indicator β€” a bright gradient sweeps across the text.""" + + _BASE = (90, 90, 110) # dim base color + _HIGHLIGHT = (255, 200, 80) # bright shimmer highlight (warm gold) + _WIDTH = 5 # shimmer width in characters + _FPS = 24 + + def __init__(self, console): + self._console = console + self._task = None + self._running = False + + def start(self): + if self._running: + return + self._running = True + self._task = asyncio.ensure_future(self._animate()) + + def stop(self): + if not self._running: + return # no-op when never started (e.g. headless mode) + self._running = False + if self._task: + self._task.cancel() + self._task = None + # Clear the shimmer line + self._console.file.write("\r\033[K") + self._console.file.flush() + + def _render_frame(self, text: str, offset: float) -> str: + """Render one frame: a bright spot sweeps left-to-right across `text`.""" + out = [] + n = len(text) + for i, ch in enumerate(text): + # Distance from the shimmer center (wraps around) + dist = abs(i - offset) + wrap_dist = abs(i - offset + n + self._WIDTH) + dist = min(dist, wrap_dist, abs(i - offset - n - self._WIDTH)) + # Blend factor: 1.0 at center, 0.0 beyond _WIDTH + t = max(0.0, 1.0 - dist / self._WIDTH) + t = t * t * (3 - 2 * t) # smoothstep + r = int(self._BASE[0] + (self._HIGHLIGHT[0] - self._BASE[0]) * t) + g = int(self._BASE[1] + (self._HIGHLIGHT[1] - self._BASE[1]) * t) + b = int(self._BASE[2] + (self._HIGHLIGHT[2] - self._BASE[2]) * t) + out.append(f"\033[38;2;{r};{g};{b}m{ch}") + out.append("\033[0m") + return "".join(out) + + async def _animate(self): + text = "Thinking..." + n = len(text) + speed = 0.45 # characters per frame + pos = 0.0 + try: + while self._running: + frame = self._render_frame(text, pos) + self._console.file.write(f"\r {frame}") + self._console.file.flush() + pos = (pos + speed) % (n + self._WIDTH) + await asyncio.sleep(1.0 / self._FPS) + except asyncio.CancelledError: + pass + + +class _StreamBuffer: + """Accumulates streamed tokens, renders markdown block-by-block as complete + blocks appear. A "block" is everything up to a paragraph break (\\n\\n). + Unclosed code fences (odd count of ```) hold back flushing until closed so + a code block is always rendered as one unit.""" + + def __init__(self, console): + self._console = console + self._buffer = "" + + def add_chunk(self, text: str): + self._buffer += text + + def _pop_block(self) -> str | None: + """Extract the next complete block, or return None if nothing complete.""" + if self._buffer.count("```") % 2 == 1: + return None # inside an open code fence β€” wait for close + idx = self._buffer.find("\n\n") + if idx == -1: + return None + block = self._buffer[:idx] + self._buffer = self._buffer[idx + 2 :] + return block + + async def flush_ready( + self, + cancel_event: "asyncio.Event | None" = None, + instant: bool = False, + ): + """Render any complete blocks that have accumulated; leave the tail.""" + while True: + if cancel_event is not None and cancel_event.is_set(): + return + block = self._pop_block() + if block is None: + return + if block.strip(): + await print_markdown(block, cancel_event=cancel_event, instant=instant) + + async def finish( + self, + cancel_event: "asyncio.Event | None" = None, + instant: bool = False, + ): + """Flush complete blocks, then render whatever incomplete tail remains.""" + await self.flush_ready(cancel_event=cancel_event, instant=instant) + if self._buffer.strip(): + await print_markdown( + self._buffer, cancel_event=cancel_event, instant=instant + ) + self._buffer = "" + + def discard(self): + self._buffer = "" + + +async def event_listener( + event_queue: asyncio.Queue, + submission_queue: asyncio.Queue, + turn_complete_event: asyncio.Event, + ready_event: asyncio.Event, + prompt_session: PromptSession, + config=None, + session_holder=None, +) -> None: + """Background task that listens for events and displays them""" + submission_id = [1000] + last_tool_name = [None] + console = _create_rich_console() + shimmer = _ThinkingShimmer(console) + stream_buf = _StreamBuffer(console) + + def _cancel_event(): + """Return the session's cancellation Event so print_markdown can abort + its typewriter loop mid-stream when Ctrl+C fires.""" + s = session_holder[0] if session_holder else None + return s._cancelled if s is not None else None + + while True: + try: + event = await event_queue.get() + + if event.event_type == "ready": + tool_count = event.data.get("tool_count", 0) if event.data else 0 + print_init_done(tool_count=tool_count) + ready_event.set() + elif event.event_type == "assistant_message": + shimmer.stop() + content = event.data.get("content", "") if event.data else "" + if content: + await print_markdown(content, cancel_event=_cancel_event()) + elif event.event_type == "assistant_chunk": + content = event.data.get("content", "") if event.data else "" + if content: + stream_buf.add_chunk(content) + # Flush any complete markdown blocks progressively so the + # user sees paragraphs appear as they're produced, not just + # at the end of the whole response. + shimmer.stop() + await stream_buf.flush_ready(cancel_event=_cancel_event()) + elif event.event_type == "assistant_stream_end": + shimmer.stop() + await stream_buf.finish(cancel_event=_cancel_event()) + elif event.event_type == "tool_call": + shimmer.stop() + stream_buf.discard() + tool_name = event.data.get("tool", "") if event.data else "" + arguments = event.data.get("arguments", {}) if event.data else {} + if tool_name: + last_tool_name[0] = tool_name + # Skip printing research tool_call β€” the tool_log handler shows it + if tool_name != "research": + args_str = json.dumps(arguments)[:80] + print_tool_call(tool_name, args_str) + elif event.event_type == "tool_output": + output = event.data.get("output", "") if event.data else "" + success = event.data.get("success", False) if event.data else False + # Only show output for plan_tool β€” everything else is noise + if last_tool_name[0] == "plan_tool" and output: + print_tool_output(output, success, truncate=False) + shimmer.start() + elif event.event_type == "turn_complete": + shimmer.stop() + stream_buf.discard() + print_turn_complete() + print_plan() + session = session_holder[0] if session_holder else None + if session is not None: + await session.send_deferred_turn_complete_notification(event) + turn_complete_event.set() + elif event.event_type == "interrupted": + shimmer.stop() + stream_buf.discard() + print_interrupted() + turn_complete_event.set() + elif event.event_type == "undo_complete": + console.print("[dim]Undone.[/dim]") + turn_complete_event.set() + elif event.event_type == "new_complete": + data = event.data or {} + if data.get("clear_screen"): + _clear_terminal() + saved_path = data.get("saved_path") + if saved_path: + console.print( + f"[dim]Started new chat. Prior chat saved to {saved_path}.[/dim]" + ) + else: + console.print("[dim]Started new chat.[/dim]") + turn_complete_event.set() + elif event.event_type == "resume_complete": + data = event.data or {} + path = data.get("path", "?") + count = data.get("restored_count", 0) + dropped = int(data.get("dropped_count", 0) or 0) + model = data.get("model_name", "?") + invalid_model = data.get("invalid_saved_model") + forked = bool(data.get("forked", False)) + redacted = bool(data.get("had_redacted_content", False)) + verb = "Forked from" if forked else "Resumed" + console.print( + f"[green]{verb}[/green] {path} " + f"([cyan]{count}[/cyan] messages, " + f"model [cyan]{model}[/cyan])." + ) + if dropped: + console.print( + f"[yellow]Warning:[/yellow] dropped {dropped} " + "malformed message(s) while restoring β€” surrounding " + "tool-call alignment may be off." + ) + if invalid_model: + console.print( + f"[yellow]Warning:[/yellow] saved model id " + f"[cyan]{invalid_model}[/cyan] failed validation; " + f"kept current model [cyan]{model}[/cyan]." + ) + if forked: + console.print( + "[dim]Saved log belongs to a different user β€” kept " + "current session id; future saves go to a fresh file.[/dim]" + ) + if redacted: + console.print( + "[yellow]Note:[/yellow] tokens/secrets in restored " + "messages were scrubbed at save time. Your live tokens " + "are used for this session; [REDACTED_*] markers in " + "past messages are not re-injected." + ) + turn_complete_event.set() + elif event.event_type == "tool_log": + tool = event.data.get("tool", "") if event.data else "" + log = event.data.get("log", "") if event.data else "" + if log: + agent_id = event.data.get("agent_id", "") if event.data else "" + label = event.data.get("label", "") if event.data else "" + print_tool_log(tool, log, agent_id=agent_id, label=label) + elif event.event_type == "tool_state_change": + pass # visual noise β€” approval flow handles this + elif event.event_type == "error": + shimmer.stop() + stream_buf.discard() + error = ( + event.data.get("error", "Unknown error") + if event.data + else "Unknown error" + ) + print_error(error) + turn_complete_event.set() + elif event.event_type == "shutdown": + shimmer.stop() + stream_buf.discard() + break + elif event.event_type == "processing": + shimmer.start() + elif event.event_type == "compacted": + old_tokens = event.data.get("old_tokens", 0) if event.data else 0 + new_tokens = event.data.get("new_tokens", 0) if event.data else 0 + print_compacted(old_tokens, new_tokens) + elif event.event_type == "approval_required": + # Handle batch approval format + tools_data = event.data.get("tools", []) if event.data else [] + count = event.data.get("count", 0) if event.data else 0 + + # If yolo mode is active, auto-approve everything except + # scheduled HF jobs, whose recurring cost stays manual. + if ( + config + and config.yolo_mode + and not any(_is_scheduled_hf_job_tool(t) for t in tools_data) + ): + approvals = [ + { + "tool_call_id": t.get("tool_call_id", ""), + "approved": True, + "feedback": None, + } + for t in tools_data + ] + print_yolo_approve(count) + submission_id[0] += 1 + approval_submission = Submission( + id=f"approval_{submission_id[0]}", + operation=Operation( + op_type=OpType.EXEC_APPROVAL, + data={"approvals": approvals}, + ), + ) + await submission_queue.put(approval_submission) + continue + + print_approval_header(count) + approvals = [] + + # Ask for approval for each tool + for i, tool_info in enumerate(tools_data, 1): + tool_name = tool_info.get("tool", "") + arguments = tool_info.get("arguments", {}) + tool_call_id = tool_info.get("tool_call_id", "") + + # Handle case where arguments might be a JSON string + if isinstance(arguments, str): + try: + arguments = json.loads(arguments) + except json.JSONDecodeError: + print(f"Warning: Failed to parse arguments for {tool_name}") + arguments = {} + + operation = arguments.get("operation", "") + + print_approval_item(i, count, tool_name, operation) + + # Handle different tool types + if tool_name == "hf_jobs": + # Check if this is Python mode (script) or Docker mode (command) + script = arguments.get("script") + command = arguments.get("command") + + if script: + # Python mode + dependencies = arguments.get("dependencies", []) + python_version = arguments.get("python") + script_args = arguments.get("script_args", []) + + # Show full script + print(f"Script:\n{script}") + if dependencies: + print(f"Dependencies: {', '.join(dependencies)}") + if python_version: + print(f"Python version: {python_version}") + if script_args: + print(f"Script args: {' '.join(script_args)}") + + # Run reliability checks on the full script (not truncated) + check_message = check_training_script_save_pattern(script) + if check_message: + print(check_message) + elif command: + # Docker mode + image = arguments.get("image", "python:3.12") + command_str = ( + " ".join(command) + if isinstance(command, list) + else str(command) + ) + print(f"Docker image: {image}") + print(f"Command: {command_str}") + + # Common parameters for jobs + hardware_flavor = arguments.get("hardware_flavor", "cpu-basic") + timeout = arguments.get("timeout", "30m") + env = arguments.get("env", {}) + schedule = arguments.get("schedule") + + print(f"Hardware: {hardware_flavor}") + print(f"Timeout: {timeout}") + + if env: + env_keys = ", ".join(env.keys()) + print(f"Environment variables: {env_keys}") + + if schedule: + print(f"Schedule: {schedule}") + + elif tool_name == "hf_private_repos": + # Handle private repo operations + args = _safe_get_args(arguments) + + if operation in ["create_repo", "upload_file"]: + repo_id = args.get("repo_id", "") + repo_type = args.get("repo_type", "dataset") + + # Build repo URL + type_path = "" if repo_type == "model" else f"{repo_type}s" + repo_url = ( + f"https://huggingface.co/{type_path}/{repo_id}".replace( + "//", "/" + ) + ) + + print(f"Repository: {repo_id}") + print(f"Type: {repo_type}") + print("Private: Yes") + print(f"URL: {repo_url}") + + # Show file preview for upload_file operation + if operation == "upload_file": + path_in_repo = args.get("path_in_repo", "") + file_content = args.get("file_content", "") + print(f"File: {path_in_repo}") + + if isinstance(file_content, str): + # Calculate metrics + all_lines = file_content.split("\n") + line_count = len(all_lines) + size_bytes = len(file_content.encode("utf-8")) + size_kb = size_bytes / 1024 + size_mb = size_kb / 1024 + + print(f"Line count: {line_count}") + if size_kb < 1024: + print(f"Size: {size_kb:.2f} KB") + else: + print(f"Size: {size_mb:.2f} MB") + + # Show preview + preview_lines = all_lines[:5] + preview = "\n".join(preview_lines) + print( + f"Content preview (first 5 lines):\n{preview}" + ) + if len(all_lines) > 5: + print("...") + + elif tool_name == "hf_repo_files": + # Handle repo files operations (upload, delete) + repo_id = arguments.get("repo_id", "") + repo_type = arguments.get("repo_type", "model") + revision = arguments.get("revision", "main") + + # Build repo URL + if repo_type == "model": + repo_url = f"https://huggingface.co/{repo_id}" + else: + repo_url = f"https://huggingface.co/{repo_type}s/{repo_id}" + + print(f"Repository: {repo_id}") + print(f"Type: {repo_type}") + print(f"Branch: {revision}") + print(f"URL: {repo_url}") + + if operation == "upload": + path = arguments.get("path", "") + content = arguments.get("content", "") + create_pr = arguments.get("create_pr", False) + + print(f"File: {path}") + if create_pr: + print("Mode: Create PR") + + if isinstance(content, str): + all_lines = content.split("\n") + line_count = len(all_lines) + size_bytes = len(content.encode("utf-8")) + size_kb = size_bytes / 1024 + + print(f"Lines: {line_count}") + if size_kb < 1024: + print(f"Size: {size_kb:.2f} KB") + else: + print(f"Size: {size_kb / 1024:.2f} MB") + + # Show full content + print(f"Content:\n{content}") + + elif operation == "delete": + patterns = arguments.get("patterns", []) + if isinstance(patterns, str): + patterns = [patterns] + print(f"Patterns to delete: {', '.join(patterns)}") + + elif tool_name == "hf_repo_git": + # Handle git operations (branches, tags, PRs, repo management) + repo_id = arguments.get("repo_id", "") + repo_type = arguments.get("repo_type", "model") + + # Build repo URL + if repo_type == "model": + repo_url = f"https://huggingface.co/{repo_id}" + else: + repo_url = f"https://huggingface.co/{repo_type}s/{repo_id}" + + print(f"Repository: {repo_id}") + print(f"Type: {repo_type}") + print(f"URL: {repo_url}") + + if operation == "delete_branch": + branch = arguments.get("branch", "") + print(f"Branch to delete: {branch}") + + elif operation == "delete_tag": + tag = arguments.get("tag", "") + print(f"Tag to delete: {tag}") + + elif operation == "merge_pr": + pr_num = arguments.get("pr_num", "") + print(f"PR to merge: #{pr_num}") + + elif operation == "create_repo": + private = arguments.get("private", False) + space_sdk = arguments.get("space_sdk") + print(f"Private: {private}") + if space_sdk: + print(f"Space SDK: {space_sdk}") + + elif operation == "update_repo": + private = arguments.get("private") + gated = arguments.get("gated") + if private is not None: + print(f"Private: {private}") + if gated is not None: + print(f"Gated: {gated}") + + # Get user decision for this item. Ctrl+C / EOF here is + # treated as "reject remaining" (matches Codex's modal + # priority and Forgecode's approval-cancel path). Without + # this, KeyboardInterrupt kills the event listener and + # the main loop deadlocks waiting for turn_complete. + try: + response = await prompt_session.prompt_async( + f"Approve item {i}? (y=yes, yolo=approve all, n=no, or provide feedback): " + ) + except (KeyboardInterrupt, EOFError): + get_console().print( + "[dim]Approval cancelled β€” rejecting remaining items[/dim]" + ) + approvals.append( + { + "tool_call_id": tool_call_id, + "approved": False, + "feedback": "User cancelled approval", + } + ) + for remaining in tools_data[i:]: + approvals.append( + { + "tool_call_id": remaining.get("tool_call_id", ""), + "approved": False, + "feedback": None, + } + ) + break + + response = response.strip().lower() + + # Handle yolo mode activation + if response == "yolo": + config.yolo_mode = True + print( + "YOLO MODE ACTIVATED - Auto-approving all future tool calls" + ) + # Auto-approve this item and all remaining + approvals.append( + { + "tool_call_id": tool_call_id, + "approved": True, + "feedback": None, + } + ) + for remaining in tools_data[i:]: + approvals.append( + { + "tool_call_id": remaining.get("tool_call_id", ""), + "approved": True, + "feedback": None, + } + ) + break + + approved = response in ["y", "yes"] + feedback = None if approved or response in ["n", "no"] else response + + approvals.append( + { + "tool_call_id": tool_call_id, + "approved": approved, + "feedback": feedback, + } + ) + + # Submit batch approval + submission_id[0] += 1 + approval_submission = Submission( + id=f"approval_{submission_id[0]}", + operation=Operation( + op_type=OpType.EXEC_APPROVAL, + data={"approvals": approvals}, + ), + ) + await submission_queue.put(approval_submission) + console.print() # spacing after approval + # Silently ignore other events + + except asyncio.CancelledError: + break + except Exception as e: + print(f"Event listener error: {e}") + + +async def get_user_input(prompt_session: PromptSession) -> str: + """Get user input asynchronously""" + from prompt_toolkit.formatted_text import HTML + + return await prompt_session.prompt_async(HTML("\n> ")) + + +# ── Slash command helpers ──────────────────────────────────────────────── + +# Slash commands are defined in terminal_display + + +async def _resume_picker( + arg: str, + prompt_session: PromptSession | None, +) -> Path | None: + """Resolve a session log path via ``arg`` or interactive selection. + + Returns ``None`` if the user cancels, no logs exist, or the argument + matches nothing β€” already prints the explanation in those cases. + """ + from agent.core.session_resume import ( + format_session_log_entry, + list_session_logs, + resolve_session_log_arg, + ) + from agent.core.session import DEFAULT_SESSION_LOG_DIR + + console = get_console() + directory = DEFAULT_SESSION_LOG_DIR + entries = list_session_logs(directory) + if not entries: + console.print(f"[yellow]No session logs found in ./{directory}.[/yellow]") + return None + + if arg: + selected = resolve_session_log_arg(arg, entries, directory) + if selected is None: + console.print(f"[bold red]No matching session log:[/bold red] {arg}") + return selected + + console.print() + console.print("[bold]Saved sessions[/bold]") + for index, entry in enumerate(entries, start=1): + console.print(format_session_log_entry(index, entry)) + console.print() + + if prompt_session is None: + console.print("[yellow]Cannot prompt for a selection here.[/yellow]") + return None + + try: + choice = await prompt_session.prompt_async( + "Select session number (blank to cancel): " + ) + except (EOFError, KeyboardInterrupt): + console.print("[dim]Resume cancelled.[/dim]") + return None + choice = choice.strip() + if not choice: + console.print("[dim]Resume cancelled.[/dim]") + return None + selected = resolve_session_log_arg(choice, entries, directory) + if selected is None: + console.print(f"[bold red]Invalid selection:[/bold red] {choice}") + return selected + + +async def _handle_slash_command( + cmd: str, + config, + session_holder: list, + submission_queue: asyncio.Queue, + submission_id: list[int], + prompt_session: PromptSession | None = None, +) -> Submission | None: + """ + Handle a slash command. Returns a Submission to enqueue, or None if + the command was handled locally (caller should set turn_complete_event). + + Async because ``/model`` fires a probe ping to validate the model+effort + combo before committing the switch. + """ + parts = cmd.strip().split(None, 1) + command = parts[0].lower() + arg = parts[1].strip() if len(parts) > 1 else "" + + if command == "/help": + print_help() + return None + + if command == "/undo": + submission_id[0] += 1 + return Submission( + id=f"sub_{submission_id[0]}", + operation=Operation(op_type=OpType.UNDO), + ) + + if command == "/compact": + submission_id[0] += 1 + return Submission( + id=f"sub_{submission_id[0]}", + operation=Operation(op_type=OpType.COMPACT), + ) + + if command in {"/new", "/clear"}: + session = session_holder[0] if session_holder else None + if session is None: + get_console().print("[bold red]No active session to reset.[/bold red]") + return None + submission_id[0] += 1 + return Submission( + id=f"sub_{submission_id[0]}", + operation=Operation( + op_type=OpType.NEW, + data={"clear_screen": command == "/clear"}, + ), + ) + + if command == "/resume": + session = session_holder[0] if session_holder else None + if session is None: + get_console().print( + "[bold red]No active session to restore into.[/bold red]" + ) + return None + selected_path = await _resume_picker(arg, prompt_session) + if selected_path is None: + return None + submission_id[0] += 1 + return Submission( + id=f"sub_{submission_id[0]}", + operation=Operation( + op_type=OpType.RESUME, data={"path": str(selected_path)} + ), + ) + + if command == "/model": + console = get_console() + if not arg: + model_switcher.print_model_listing(config, console) + return None + if not model_switcher.is_valid_model_id(arg): + model_switcher.print_invalid_id(arg, console) + return None + normalized = arg.removeprefix("huggingface/") + session = session_holder[0] if session_holder else None + await model_switcher.probe_and_switch_model( + normalized, + config, + session, + console, + resolve_hf_token(), + ) + return None + + if command == "/yolo": + config.yolo_mode = not config.yolo_mode + state = "ON" if config.yolo_mode else "OFF" + print(f"YOLO mode: {state}") + return None + + if command == "/effort": + console = get_console() + valid = {"minimal", "low", "medium", "high", "xhigh", "max", "off"} + session = session_holder[0] if session_holder else None + if not arg: + current = config.reasoning_effort or "off" + console.print(f"[bold]Reasoning effort preference:[/bold] {current}") + if session and session.model_effective_effort: + console.print("[dim]Probed per model:[/dim]") + for m, eff in session.model_effective_effort.items(): + console.print(f" [dim]{m}: {eff or 'off'}[/dim]") + console.print( + "[dim]Set with '/effort minimal|low|medium|high|xhigh|max|off'. " + "HF Router accepts low|medium|high generically; higher preferences " + "are probed and the cascade falls back to whatever the selected " + "provider accepts.[/dim]" + ) + return None + level = arg.lower() + if level not in valid: + console.print(f"[bold red]Invalid level:[/bold red] {arg}") + console.print(f"[dim]Expected one of: {', '.join(sorted(valid))}[/dim]") + return None + config.reasoning_effort = None if level == "off" else level + # Drop the per-model probe cache β€” the new preference may resolve + # differently. Next ``/model`` (or the retry safety net) reprobes. + if session is not None: + session.model_effective_effort.clear() + console.print(f"[green]Reasoning effort: {level}[/green]") + if session is not None: + console.print( + "[dim]run /model to re-probe, or send a message β€” " + "the agent adjusts automatically if the new level isn't supported.[/dim]" + ) + return None + + if command == "/status": + session = session_holder[0] if session_holder else None + print(f"Model: {config.model_name}") + print(f"Reasoning effort: {config.reasoning_effort or 'off'}") + print(f"Tool runtime: {_tool_runtime_label(_is_local_tool_runtime(config))}") + if session: + print(f"Turns: {session.turn_count}") + print(f"Context items: {len(session.context_manager.items)}") + return None + + if command == "/share-traces": + session = session_holder[0] if session_holder else None + await _handle_share_traces_command(arg, config, session) + return None + + print(f"Unknown command: {command}. Type /help for available commands.") + return None + + +async def _handle_share_traces_command(arg: str, config, session) -> None: + """Show or flip visibility of the user's personal trace dataset. + + Uses the user's own HF_TOKEN (write-scoped to their namespace). Only + operates on the personal trace repo configured via + ``personal_trace_repo_template`` β€” never touches the shared org dataset. + """ + from huggingface_hub import HfApi + from huggingface_hub.utils import HfHubHTTPError + + console = get_console() + if session is None: + console.print("[bold red]No active session.[/bold red]") + return + + repo_id = session._personal_trace_repo_id() if session is not None else None + if not repo_id: + if not getattr(config, "share_traces", False): + console.print( + "[yellow]share_traces is disabled in config. " + "Set it to true to publish per-session traces to your HF dataset." + "[/yellow]" + ) + return + if not session.user_id: + console.print( + "[yellow]No HF username resolved \u2014 cannot pick a personal " + "trace repo. Set HF_TOKEN to a token tied to your account.[/yellow]" + ) + return + console.print( + "[yellow]personal_trace_repo_template is unset \u2014 nothing to do.[/yellow]" + ) + return + + token = session.hf_token or resolve_hf_token() + if not token: + console.print( + "[bold red]No HF_TOKEN available.[/bold red] Cannot read or change " + "dataset visibility." + ) + return + + api = HfApi(token=token) + url = f"https://huggingface.co/datasets/{repo_id}" + target = arg.strip().lower() + + if not target: + try: + info = await asyncio.to_thread( + api.repo_info, repo_id=repo_id, repo_type="dataset" + ) + visibility = "private" if getattr(info, "private", False) else "public" + console.print(f"[bold]Trace dataset:[/bold] {url}") + console.print(f"[bold]Visibility:[/bold] {visibility}") + console.print( + "[dim]Use '/share-traces public' to publish, " + "'/share-traces private' to lock it back down.[/dim]" + ) + except HfHubHTTPError as e: + if getattr(e.response, "status_code", None) == 404: + console.print( + f"[dim]Dataset {repo_id} doesn't exist yet \u2014 it'll be " + "created (private) on the next session save.[/dim]" + ) + else: + console.print(f"[bold red]Hub error:[/bold red] {e}") + except Exception as e: + console.print(f"[bold red]Could not fetch dataset info:[/bold red] {e}") + return + + if target not in {"public", "private"}: + console.print( + f"[bold red]Unknown argument:[/bold red] {target}. " + "Expected 'public' or 'private'." + ) + return + + private = target == "private" + try: + # Idempotent β€” create if missing so first-flip works even before any + # session has been saved yet. + await asyncio.to_thread( + api.create_repo, + repo_id=repo_id, + repo_type="dataset", + private=private, + token=token, + exist_ok=True, + ) + await asyncio.to_thread( + api.update_repo_settings, + repo_id=repo_id, + repo_type="dataset", + private=private, + token=token, + ) + except Exception as e: + console.print(f"[bold red]Failed to update visibility:[/bold red] {e}") + return + + label = "PUBLIC" if not private else "private" + console.print(f"[green]Dataset is now {label}.[/green] {url}") + + +async def main(model: str | None = None, sandbox_tools: bool = False): + """Interactive chat with the agent""" + + # Clear screen + _clear_terminal() + + # Create prompt session for input (needed early for token prompt) + prompt_session = PromptSession() + + config = load_config(CLI_CONFIG_PATH, include_user_defaults=True) + _normalize_config_model(config) + if model: + config.model_name = _validate_cli_model_override(model) + _apply_tool_runtime_override(config, sandbox_tools=sandbox_tools) + local_mode = _is_local_tool_runtime(config) + + # HF token β€” required for Hub-backed models/tools and sandbox tools, but + # not for local LLMs using only local filesystem tools. + hf_token = resolve_hf_token() + if not hf_token and (not is_local_model_id(config.model_name) or not local_mode): + hf_token = await _prompt_and_save_hf_token(prompt_session) + + # Resolve username and plan from one whoami-v2 request for banner and CTAs. + hf_user, hf_user_plan = await _get_hf_identity(hf_token) + + print_banner( + model=config.model_name, + hf_user=hf_user, + tool_runtime=_tool_runtime_label(local_mode), + ) + + # Pre-warm the HF router catalog in the background so /model switches + # don't block on a network fetch. + from agent.core import hf_router_catalog + + asyncio.create_task(asyncio.to_thread(hf_router_catalog.prewarm)) + + # Create queues for communication + submission_queue = asyncio.Queue() + event_queue = asyncio.Queue() + + # Events to signal agent state + turn_complete_event = asyncio.Event() + turn_complete_event.set() + ready_event = asyncio.Event() + + notification_gateway = NotificationGateway(config.messaging) + await notification_gateway.start() + # Create tool router with the selected CLI tool runtime. + tool_router = ToolRouter( + config.mcpServers, hf_token=hf_token, local_mode=local_mode + ) + + # Session holder for interrupt/model/status access + session_holder = [None] + + agent_task = asyncio.create_task( + submission_loop( + submission_queue, + event_queue, + config=config, + tool_router=tool_router, + session_holder=session_holder, + hf_token=hf_token, + user_id=hf_user, + user_plan=hf_user_plan, + local_mode=local_mode, + stream=True, + notification_gateway=notification_gateway, + notification_destinations=config.messaging.default_auto_destinations(), + defer_turn_complete_notification=True, + ) + ) + + # Start event listener in background + listener_task = asyncio.create_task( + event_listener( + event_queue, + submission_queue, + turn_complete_event, + ready_event, + prompt_session, + config, + session_holder=session_holder, + ) + ) + + await ready_event.wait() + if not local_mode: + await _wait_for_initial_sandbox_preload(session_holder) + + submission_id = [0] + # Mirrors codex-rs/tui/src/bottom_pane/mod.rs:137 + # (`QUIT_SHORTCUT_TIMEOUT = Duration::from_secs(1)`). Two Ctrl+C presses + # within this window quit; a single press cancels the in-flight turn. + CTRL_C_QUIT_WINDOW = 1.0 + # Hint string matches codex-rs/tui/src/bottom_pane/footer.rs:746 + # (`" again to quit"` prefixed with the key binding, rendered dim). + CTRL_C_HINT = "[dim]ctrl + c again to quit[/dim]" + interrupt_state = {"last": 0.0, "exit": False} + + loop = asyncio.get_running_loop() + + def _on_sigint() -> None: + """SIGINT handler β€” fires while the agent is generating (terminal is + in cooked mode between prompts). Mirrors Codex's `on_ctrl_c` in + codex-rs/tui/src/chatwidget.rs: first press cancels active work and + arms the quit hint; second press within the window quits.""" + now = time.monotonic() + session = session_holder[0] + + if now - interrupt_state["last"] < CTRL_C_QUIT_WINDOW: + interrupt_state["exit"] = True + if session: + session.cancel() + # Wake the main loop out of turn_complete_event.wait() + turn_complete_event.set() + return + + interrupt_state["last"] = now + if session and not session.is_cancelled: + session.cancel() + get_console().print(f"\n{CTRL_C_HINT}") + + def _install_sigint() -> bool: + try: + loop.add_signal_handler(signal.SIGINT, _on_sigint) + return True + except (NotImplementedError, RuntimeError): + return False # Windows or non-main thread + + # prompt_toolkit's prompt_async installs its own SIGINT handler and, on + # exit, calls loop.remove_signal_handler(SIGINT) β€” which wipes ours too. + # So we re-arm at the top of every loop iteration, right before the busy + # wait. Without this, Ctrl+C during agent streaming after the first turn + # falls through to the default handler and the terminal just echoes ^C. + sigint_available = _install_sigint() + + try: + while True: + if sigint_available: + _install_sigint() + + try: + await turn_complete_event.wait() + except asyncio.CancelledError: + break + turn_complete_event.clear() + + if interrupt_state["exit"]: + break + + # Get user input. prompt_toolkit puts the terminal in raw mode and + # installs its own SIGINT handling; ^C arrives as \x03 and surfaces + # as KeyboardInterrupt here. On return, prompt_toolkit removes the + # loop's SIGINT handler β€” we re-arm at the top of the next iter. + try: + user_input = await get_user_input(prompt_session) + except EOFError: + break + except KeyboardInterrupt: + now = time.monotonic() + if now - interrupt_state["last"] < CTRL_C_QUIT_WINDOW: + break + interrupt_state["last"] = now + get_console().print(CTRL_C_HINT) + turn_complete_event.set() + continue + + # A successful read ends the double-press window β€” an unrelated + # Ctrl+C during the next turn should start a fresh arming. + interrupt_state["last"] = 0.0 + + # Check for exit commands + if user_input.strip().lower() in ["exit", "quit", "/quit", "/exit"]: + break + + # Skip empty input + if not user_input.strip(): + turn_complete_event.set() + continue + + # Handle slash commands + if user_input.strip().startswith("/"): + sub = await _handle_slash_command( + user_input.strip(), + config, + session_holder, + submission_queue, + submission_id, + prompt_session, + ) + if sub is None: + # Command handled locally, loop back for input + turn_complete_event.set() + continue + else: + await submission_queue.put(sub) + continue + + # Submit to agent + submission_id[0] += 1 + submission = Submission( + id=f"sub_{submission_id[0]}", + operation=Operation( + op_type=OpType.USER_INPUT, data={"text": user_input} + ), + ) + await submission_queue.put(submission) + + except KeyboardInterrupt: + pass + finally: + if sigint_available: + try: + loop.remove_signal_handler(signal.SIGINT) + except (NotImplementedError, RuntimeError): + pass + + # Shutdown + shutdown_submission = Submission( + id="sub_shutdown", operation=Operation(op_type=OpType.SHUTDOWN) + ) + await submission_queue.put(shutdown_submission) + + # Wait for agent to finish (the listener must keep draining events + # or the agent will block on event_queue.put) + try: + await asyncio.wait_for(agent_task, timeout=10.0) + except asyncio.TimeoutError: + agent_task.cancel() + # Agent didn't shut down cleanly β€” close MCP explicitly + await tool_router.__aexit__(None, None, None) + finally: + await notification_gateway.close() + + # Now safe to cancel the listener (agent is done emitting events) + listener_task.cancel() + + get_console().print("\n[dim]Bye.[/dim]\n") + + +async def headless_main( + prompt: str, + model: str | None = None, + max_iterations: int | None = None, + stream: bool = True, + sandbox_tools: bool = False, +) -> None: + """Run a single prompt headlessly and exit.""" + import logging + + logging.basicConfig(level=logging.WARNING) + _configure_runtime_logging() + + config = load_config(CLI_CONFIG_PATH, include_user_defaults=True) + _normalize_config_model(config) + config.yolo_mode = True # Auto-approve everything in headless mode + + if model: + try: + config.model_name = _validate_cli_model_override(model) + except ValueError as e: + print(f"ERROR: {e}", file=sys.stderr) + sys.exit(1) + _apply_tool_runtime_override(config, sandbox_tools=sandbox_tools) + local_mode = _is_local_tool_runtime(config) + + hf_token = resolve_hf_token() + if not hf_token and (not is_local_model_id(config.model_name) or not local_mode): + print( + "ERROR: No HF token found. Set HF_TOKEN or run `hf auth login`.", + file=sys.stderr, + ) + sys.exit(1) + + if hf_token: + print("HF token loaded", file=sys.stderr) + + notification_gateway = NotificationGateway(config.messaging) + await notification_gateway.start() + hf_user, hf_user_plan = await _get_hf_identity(hf_token) + + if max_iterations is not None: + config.max_iterations = max_iterations + + print(f"Model: {config.model_name}", file=sys.stderr) + print(f"Tool runtime: {_tool_runtime_label(local_mode)}", file=sys.stderr) + print(f"Max iterations: {config.max_iterations}", file=sys.stderr) + print(f"Prompt: {prompt}", file=sys.stderr) + print("---", file=sys.stderr) + + submission_queue: asyncio.Queue = asyncio.Queue() + event_queue: asyncio.Queue = asyncio.Queue() + + tool_router = ToolRouter( + config.mcpServers, hf_token=hf_token, local_mode=local_mode + ) + session_holder: list = [None] + + agent_task = asyncio.create_task( + submission_loop( + submission_queue, + event_queue, + config=config, + tool_router=tool_router, + session_holder=session_holder, + hf_token=hf_token, + user_id=hf_user, + user_plan=hf_user_plan, + local_mode=local_mode, + stream=stream, + notification_gateway=notification_gateway, + notification_destinations=config.messaging.default_auto_destinations(), + defer_turn_complete_notification=True, + ) + ) + + # Wait for ready + while True: + event = await event_queue.get() + if event.event_type == "ready": + break + + # Submit the prompt + submission = Submission( + id="sub_1", + operation=Operation(op_type=OpType.USER_INPUT, data={"text": prompt}), + ) + await submission_queue.put(submission) + + # Process events until turn completes. Headless mode is for scripts / + # log capture: no shimmer animation, no typewriter, no live-redrawing + # research overlay. Output is plain, append-only text. + console = _create_rich_console() + stream_buf = _StreamBuffer(console) + _hl_last_tool = [None] + _hl_sub_id = [1] + # Research sub-agent tool calls are buffered per agent_id and dumped as + # a static block once each sub-agent finishes, instead of streaming via + # the live redrawing SubAgentDisplayManager (which is TTY-only). + _hl_research_buffers: dict[str, dict] = {} + + while True: + event = await event_queue.get() + + if event.event_type == "assistant_chunk": + content = event.data.get("content", "") if event.data else "" + if content: + stream_buf.add_chunk(content) + await stream_buf.flush_ready(instant=True) + elif event.event_type == "assistant_stream_end": + await stream_buf.finish(instant=True) + elif event.event_type == "assistant_message": + content = event.data.get("content", "") if event.data else "" + if content: + await print_markdown(content, instant=True) + elif event.event_type == "tool_call": + stream_buf.discard() + tool_name = event.data.get("tool", "") if event.data else "" + arguments = event.data.get("arguments", {}) if event.data else {} + if tool_name: + _hl_last_tool[0] = tool_name + if tool_name != "research": + args_str = json.dumps(arguments)[:80] + print_tool_call(tool_name, args_str) + elif event.event_type == "tool_output": + output = event.data.get("output", "") if event.data else "" + success = event.data.get("success", False) if event.data else False + if _hl_last_tool[0] == "plan_tool" and output: + print_tool_output(output, success, truncate=False) + elif event.event_type == "tool_log": + tool = event.data.get("tool", "") if event.data else "" + log = event.data.get("log", "") if event.data else "" + if not log: + pass + elif tool == "research": + # Headless mode: buffer research sub-agent activity per-agent, + # then dump each as a static block on completion. The live + # SubAgentDisplayManager uses terminal cursor tricks that are + # unfit for non-TTY output, but parallel agents still need + # distinct output so we key buffers by agent_id. + agent_id = event.data.get("agent_id", "") if event.data else "" + label = event.data.get("label", "") if event.data else "" + aid = agent_id or "research" + if log == "Starting research sub-agent...": + _hl_research_buffers[aid] = { + "label": label or "research", + "calls": [], + } + elif log == "Research complete.": + buf = _hl_research_buffers.pop(aid, None) + if buf is not None: + f = get_console().file + f.write(f" \033[38;2;255;200;80mβ–Έ {buf['label']}\033[0m\n") + for call in buf["calls"]: + f.write(f" \033[2m{call}\033[0m\n") + f.flush() + elif log.startswith("tokens:") or log.startswith("tools:"): + pass # stats updates β€” only useful for the live display + elif aid in _hl_research_buffers: + _hl_research_buffers[aid]["calls"].append(log) + else: + # Orphan event (Start was missed) β€” fall back to raw print + print_tool_log(tool, log, agent_id=agent_id, label=label) + else: + print_tool_log(tool, log) + elif event.event_type == "approval_required": + # Auto-approve in headless mode, except scheduled HF jobs. Those + # are rejected because their recurring cost needs manual approval. + tools_data = event.data.get("tools", []) if event.data else [] + approvals = [ + { + "tool_call_id": t.get("tool_call_id", ""), + "approved": not _is_scheduled_hf_job_tool(t), + "feedback": ( + "Scheduled HF jobs require manual approval." + if _is_scheduled_hf_job_tool(t) + else None + ), + } + for t in tools_data + ] + _hl_sub_id[0] += 1 + await submission_queue.put( + Submission( + id=f"hl_approval_{_hl_sub_id[0]}", + operation=Operation( + op_type=OpType.EXEC_APPROVAL, + data={"approvals": approvals}, + ), + ) + ) + elif event.event_type == "compacted": + old_tokens = event.data.get("old_tokens", 0) if event.data else 0 + new_tokens = event.data.get("new_tokens", 0) if event.data else 0 + print_compacted(old_tokens, new_tokens) + elif event.event_type == "error": + stream_buf.discard() + error = ( + event.data.get("error", "Unknown error") + if event.data + else "Unknown error" + ) + print_error(error) + break + elif event.event_type in ("turn_complete", "interrupted"): + stream_buf.discard() + history_size = event.data.get("history_size", "?") if event.data else "?" + print( + f"\n--- Agent {event.event_type} (history_size={history_size}) ---", + file=sys.stderr, + ) + if event.event_type == "turn_complete": + session = session_holder[0] if session_holder else None + if session is not None: + await session.send_deferred_turn_complete_notification(event) + break + + # Shutdown + shutdown_submission = Submission( + id="sub_shutdown", operation=Operation(op_type=OpType.SHUTDOWN) + ) + await submission_queue.put(shutdown_submission) + + try: + await asyncio.wait_for(agent_task, timeout=10.0) + except asyncio.TimeoutError: + agent_task.cancel() + await tool_router.__aexit__(None, None, None) + finally: + await notification_gateway.close() + + +def cli(): + """Entry point for the ml-intern CLI command.""" + import logging as _logging + import warnings + + # Suppress aiohttp "Unclosed client session" noise during event loop teardown + _logging.getLogger("asyncio").setLevel(_logging.CRITICAL) + _configure_runtime_logging() + # Suppress litellm pydantic deprecation warnings + warnings.filterwarnings("ignore", category=DeprecationWarning, module="litellm") + # Suppress whoosh invalid escape sequence warnings (third-party, unfixed upstream) + warnings.filterwarnings("ignore", category=SyntaxWarning, module="whoosh") + + parser = argparse.ArgumentParser(description="Hugging Face Agent CLI") + parser.add_argument( + "prompt", nargs="?", default=None, help="Run headlessly with this prompt" + ) + parser.add_argument( + "--model", "-m", default=None, help="Model to use (default: from config)" + ) + parser.add_argument( + "--max-iterations", + type=int, + default=None, + help="Max LLM requests per turn (default: 50, use -1 for unlimited)", + ) + parser.add_argument( + "--no-stream", + action="store_true", + help="Disable token streaming (use non-streaming LLM calls)", + ) + parser.add_argument( + "--sandbox-tools", + action="store_true", + help="Use HF Space sandbox tools instead of local filesystem tools", + ) + args = parser.parse_args() + + try: + if args.prompt: + max_iter = args.max_iterations + if max_iter is not None and max_iter < 0: + max_iter = 10_000 # effectively unlimited + asyncio.run( + headless_main( + args.prompt, + model=args.model, + max_iterations=max_iter, + stream=not args.no_stream, + sandbox_tools=args.sandbox_tools, + ) + ) + else: + asyncio.run(main(model=args.model, sandbox_tools=args.sandbox_tools)) + except KeyboardInterrupt: + print("\n\nGoodbye!") + + +if __name__ == "__main__": + cli() diff --git a/agent/messaging/__init__.py b/agent/messaging/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c399d254e30fcbce555d6f51b810440b1171ec1a --- /dev/null +++ b/agent/messaging/__init__.py @@ -0,0 +1,15 @@ +from agent.messaging.gateway import NotificationGateway +from agent.messaging.models import ( + MessagingConfig, + NotificationRequest, + NotificationResult, + SUPPORTED_AUTO_EVENT_TYPES, +) + +__all__ = [ + "MessagingConfig", + "NotificationGateway", + "NotificationRequest", + "NotificationResult", + "SUPPORTED_AUTO_EVENT_TYPES", +] diff --git a/agent/messaging/base.py b/agent/messaging/base.py new file mode 100644 index 0000000000000000000000000000000000000000..a74f9cf0d1cb2a77328124414b04de9ebbd6b582 --- /dev/null +++ b/agent/messaging/base.py @@ -0,0 +1,31 @@ +from abc import ABC, abstractmethod + +import httpx + +from agent.messaging.models import ( + DestinationConfig, + NotificationRequest, + NotificationResult, +) + + +class NotificationError(Exception): + """Delivery failed and should not be retried.""" + + +class RetryableNotificationError(NotificationError): + """Delivery failed transiently and can be retried.""" + + +class NotificationProvider(ABC): + provider_name: str + + @abstractmethod + async def send( + self, + client: httpx.AsyncClient, + destination_name: str, + destination: DestinationConfig, + request: NotificationRequest, + ) -> NotificationResult: + """Deliver a notification to one destination.""" diff --git a/agent/messaging/gateway.py b/agent/messaging/gateway.py new file mode 100644 index 0000000000000000000000000000000000000000..1de9438f5c5c8ae2847ef1bf4a398d10e8903048 --- /dev/null +++ b/agent/messaging/gateway.py @@ -0,0 +1,172 @@ +import asyncio +import logging +from collections.abc import Iterable + +import httpx + +from agent.messaging.base import ( + NotificationError, + NotificationProvider, + RetryableNotificationError, +) +from agent.messaging.models import ( + MessagingConfig, + NotificationRequest, + NotificationResult, +) +from agent.messaging.slack import SlackProvider + +logger = logging.getLogger(__name__) + +_RETRY_DELAYS = (1, 2, 4) + + +class NotificationGateway: + def __init__(self, config: MessagingConfig): + self.config = config + self._providers: dict[str, NotificationProvider] = { + "slack": SlackProvider(), + } + self._queue: asyncio.Queue[NotificationRequest] = asyncio.Queue() + self._worker_task: asyncio.Task | None = None + self._client: httpx.AsyncClient | None = None + + @property + def enabled(self) -> bool: + return self.config.enabled + + async def start(self) -> None: + if not self.enabled or self._worker_task is not None: + return + self._client = httpx.AsyncClient(timeout=10.0) + self._worker_task = asyncio.create_task( + self._worker(), name="notification-gateway" + ) + + async def flush(self) -> None: + if not self.enabled: + return + await self._queue.join() + + async def close(self) -> None: + if not self.enabled: + return + await self.flush() + if self._worker_task is not None: + self._worker_task.cancel() + try: + await self._worker_task + except asyncio.CancelledError: + pass + self._worker_task = None + if self._client is not None: + await self._client.aclose() + self._client = None + + async def send(self, request: NotificationRequest) -> NotificationResult: + if not self.enabled: + return NotificationResult( + destination=request.destination, + ok=False, + provider="disabled", + error="Messaging is disabled", + ) + + destination = self.config.get_destination(request.destination) + if destination is None: + return NotificationResult( + destination=request.destination, + ok=False, + provider="unknown", + error=f"Unknown destination '{request.destination}'", + ) + + provider = self._providers.get(destination.provider) + if provider is None: + return NotificationResult( + destination=request.destination, + ok=False, + provider=destination.provider, + error=f"No provider implementation for '{destination.provider}'", + ) + return await self._send_with_retries( + provider, request.destination, destination, request + ) + + async def send_many( + self, requests: Iterable[NotificationRequest] + ) -> list[NotificationResult]: + results: list[NotificationResult] = [] + for request in requests: + results.append(await self.send(request)) + return results + + async def enqueue(self, request: NotificationRequest) -> bool: + if not self.enabled or self._worker_task is None: + return False + await self._queue.put(request) + return True + + async def _worker(self) -> None: + while True: + request = await self._queue.get() + try: + result = await self.send(request) + if not result.ok: + logger.warning( + "Notification delivery failed for %s: %s", + request.destination, + result.error, + ) + except Exception: + logger.exception("Unexpected notification worker failure") + finally: + self._queue.task_done() + + async def _send_with_retries( + self, + provider: NotificationProvider, + destination_name: str, + destination, + request: NotificationRequest, + ) -> NotificationResult: + client = self._client or httpx.AsyncClient(timeout=10.0) + owns_client = self._client is None + try: + for attempt in range(len(_RETRY_DELAYS) + 1): + try: + return await provider.send( + client, destination_name, destination, request + ) + except RetryableNotificationError as exc: + if attempt >= len(_RETRY_DELAYS): + return NotificationResult( + destination=destination_name, + ok=False, + provider=provider.provider_name, + error=str(exc), + ) + delay = _RETRY_DELAYS[attempt] + logger.warning( + "Retrying notification to %s in %ss after transient error: %s", + destination_name, + delay, + exc, + ) + await asyncio.sleep(delay) + except NotificationError as exc: + return NotificationResult( + destination=destination_name, + ok=False, + provider=provider.provider_name, + error=str(exc), + ) + return NotificationResult( + destination=destination_name, + ok=False, + provider=provider.provider_name, + error="Notification delivery exhausted retries", + ) + finally: + if owns_client: + await client.aclose() diff --git a/agent/messaging/models.py b/agent/messaging/models.py new file mode 100644 index 0000000000000000000000000000000000000000..16148a8179f5de3fa38b36ce76166a48e9f54a83 --- /dev/null +++ b/agent/messaging/models.py @@ -0,0 +1,117 @@ +from typing import Annotated, Literal + +from pydantic import BaseModel, Field, field_validator, model_validator + +_DESTINATION_NAME_CHARS = set("abcdefghijklmnopqrstuvwxyz0123456789._-") +SUPPORTED_AUTO_EVENT_TYPES = {"approval_required", "error", "turn_complete"} + + +class SlackDestinationConfig(BaseModel): + provider: Literal["slack"] = "slack" + token: str + channel: str + allow_agent_tool: bool = False + allow_auto_events: bool = False + username: str | None = None + icon_emoji: str | None = None + + @field_validator("token", "channel") + @classmethod + def _require_non_empty(cls, value: str) -> str: + value = value.strip() + if not value: + raise ValueError("must not be empty") + return value + + +DestinationConfig = Annotated[SlackDestinationConfig, Field(discriminator="provider")] + + +class MessagingConfig(BaseModel): + enabled: bool = False + auto_event_types: list[str] = Field( + default_factory=lambda: ["approval_required", "error", "turn_complete"] + ) + destinations: dict[str, DestinationConfig] = Field(default_factory=dict) + + @field_validator("destinations") + @classmethod + def _validate_destination_names( + cls, destinations: dict[str, DestinationConfig] + ) -> dict[str, DestinationConfig]: + for name in destinations: + if not name or any(char not in _DESTINATION_NAME_CHARS for char in name): + raise ValueError( + "destination names must use lowercase letters, digits, '.', '_' or '-'" + ) + return destinations + + @field_validator("auto_event_types") + @classmethod + def _validate_auto_event_types(cls, event_types: list[str]) -> list[str]: + if not event_types: + return [] + normalized: list[str] = [] + seen: set[str] = set() + for event_type in event_types: + if event_type not in SUPPORTED_AUTO_EVENT_TYPES: + raise ValueError(f"unsupported auto event type '{event_type}'") + if event_type not in seen: + normalized.append(event_type) + seen.add(event_type) + return normalized + + @model_validator(mode="after") + def _require_destinations_when_enabled(self) -> "MessagingConfig": + if self.enabled and not self.destinations: + raise ValueError("messaging.enabled requires at least one destination") + return self + + def get_destination(self, name: str) -> DestinationConfig | None: + return self.destinations.get(name) + + def can_agent_tool_send(self, name: str) -> bool: + destination = self.get_destination(name) + return bool(destination and destination.allow_agent_tool) + + def can_auto_send(self, name: str) -> bool: + destination = self.get_destination(name) + return bool(destination and destination.allow_auto_events) + + def default_auto_destinations(self) -> list[str]: + if not self.enabled: + return [] + return [name for name in self.destinations if self.can_auto_send(name)] + + +class NotificationRequest(BaseModel): + destination: str + title: str | None = None + message: str + severity: Literal["info", "success", "warning", "error"] = "info" + metadata: dict[str, str] = Field(default_factory=dict) + event_type: str | None = None + + @field_validator("destination", "message") + @classmethod + def _require_text(cls, value: str) -> str: + value = value.strip() + if not value: + raise ValueError("must not be empty") + return value + + @field_validator("title") + @classmethod + def _normalize_title(cls, value: str | None) -> str | None: + if value is None: + return None + value = value.strip() + return value or None + + +class NotificationResult(BaseModel): + destination: str + ok: bool + provider: str + error: str | None = None + external_id: str | None = None diff --git a/agent/messaging/slack.py b/agent/messaging/slack.py new file mode 100644 index 0000000000000000000000000000000000000000..3790e44af790db8579a9a8efb88a2a16283ec71d --- /dev/null +++ b/agent/messaging/slack.py @@ -0,0 +1,184 @@ +import json +import re + +import httpx + +from agent.messaging.base import ( + NotificationError, + NotificationProvider, + RetryableNotificationError, +) +from agent.messaging.models import ( + NotificationRequest, + NotificationResult, + SlackDestinationConfig, +) + +_SEVERITY_PREFIX = { + "info": "[INFO]", + "success": "[SUCCESS]", + "warning": "[WARNING]", + "error": "[ERROR]", +} + + +def _format_slack_mrkdwn(content: str) -> str: + """Convert common Markdown constructs to Slack's mrkdwn syntax.""" + if not content: + return content + + placeholders: dict[str, str] = {} + placeholder_index = 0 + + def placeholder(value: str) -> str: + nonlocal placeholder_index + key = f"\x00SLACK{placeholder_index}\x00" + placeholder_index += 1 + placeholders[key] = value + return key + + text = content + + # Protect code before any formatting conversion. Slack's mrkdwn ignores + # formatting inside backticks, so these regions should stay byte-for-byte. + text = re.sub( + r"(```(?:[^\n]*\n)?[\s\S]*?```)", + lambda match: placeholder(match.group(0)), + text, + ) + text = re.sub(r"(`[^`\n]+`)", lambda match: placeholder(match.group(0)), text) + + def convert_markdown_link(match: re.Match[str]) -> str: + label = match.group(1) + url = match.group(2).strip() + if url.startswith("<") and url.endswith(">"): + url = url[1:-1].strip() + return placeholder(f"<{url}|{label}>") + + text = re.sub( + r"\[([^\]]+)\]\(([^()]*(?:\([^()]*\)[^()]*)*)\)", + convert_markdown_link, + text, + ) + + # Preserve existing Slack entities and manual mrkdwn links before escaping. + text = re.sub( + r"(<(?:[@#!]|(?:https?|mailto|tel):)[^>\n]+>)", + lambda match: placeholder(match.group(1)), + text, + ) + text = re.sub( + r"^(>+\s)", + lambda match: placeholder(match.group(0)), + text, + flags=re.MULTILINE, + ) + + text = text.replace("&", "&").replace("<", "<").replace(">", ">") + text = text.replace("&", "&").replace("<", "<").replace(">", ">") + + def convert_header(match: re.Match[str]) -> str: + header = match.group(1).strip() + header = re.sub(r"\*\*(.+?)\*\*", r"\1", header) + return placeholder(f"*{header}*") + + text = re.sub(r"^#{1,6}\s+(.+)$", convert_header, text, flags=re.MULTILINE) + text = re.sub( + r"\*\*\*(.+?)\*\*\*", + lambda match: placeholder(f"*_{match.group(1)}_*"), + text, + ) + text = re.sub( + r"\*\*(.+?)\*\*", + lambda match: placeholder(f"*{match.group(1)}*"), + text, + ) + text = re.sub( + r"(? str: + lines: list[str] = [] + prefix = _SEVERITY_PREFIX[request.severity] + if request.title: + lines.append(f"{prefix} {request.title}") + else: + lines.append(prefix) + lines.append(request.message) + for key, value in request.metadata.items(): + lines.append(f"{key}: {value}") + return _format_slack_mrkdwn("\n".join(lines)) + + +class SlackProvider(NotificationProvider): + provider_name = "slack" + + async def send( + self, + client: httpx.AsyncClient, + destination_name: str, + destination: SlackDestinationConfig, + request: NotificationRequest, + ) -> NotificationResult: + payload = { + "channel": destination.channel, + "text": _format_text(request), + "mrkdwn": True, + "unfurl_links": False, + "unfurl_media": False, + } + if destination.username: + payload["username"] = destination.username + if destination.icon_emoji: + payload["icon_emoji"] = destination.icon_emoji + + try: + response = await client.post( + "https://slack.com/api/chat.postMessage", + headers={ + "Authorization": f"Bearer {destination.token}", + "Content-Type": "application/json; charset=utf-8", + }, + content=json.dumps(payload), + ) + except httpx.TimeoutException as exc: + raise RetryableNotificationError("Slack request timed out") from exc + except httpx.TransportError as exc: + raise RetryableNotificationError("Slack transport error") from exc + + if response.status_code == 429 or response.status_code >= 500: + raise RetryableNotificationError(f"Slack HTTP {response.status_code}") + if response.status_code >= 400: + raise NotificationError(f"Slack HTTP {response.status_code}") + + try: + data = response.json() + except ValueError as exc: + raise RetryableNotificationError("Slack returned invalid JSON") from exc + + if not data.get("ok"): + error = str(data.get("error") or "unknown_error") + if error == "ratelimited": + raise RetryableNotificationError(error) + raise NotificationError(error) + + return NotificationResult( + destination=destination_name, + ok=True, + provider=self.provider_name, + external_id=str(data.get("ts") or ""), + error=None, + ) diff --git a/agent/prompts/system_prompt.yaml b/agent/prompts/system_prompt.yaml new file mode 100644 index 0000000000000000000000000000000000000000..00f28be1718457e1d1004c7e3745f903f14d5ab1 --- /dev/null +++ b/agent/prompts/system_prompt.yaml @@ -0,0 +1,170 @@ +system_prompt: | + You are Hugging Face Agent, a skilled AI assistant for machine learning engineering. Hugging Face is a company that provides two main services : libraries to write deep learning tasks, and resources (models, datasets, compute) to execute them. You will aid users to do these tasks, interacting with the Hugging Face stack via {{ num_tools }}. + + # General behavior + + Your main goal is to achieve what the user asked. For this proactive in the quantity of actions taken. However, never make big decisions in place of the user. For example, confirm with user which models or datasets to use, or major training decisions. + + # Task Approach. + + **CRITICAL : Research first, Then Implement** + + For ANY implementation task (training, fine-tuning, inference, data processing, etc.), you should proceed in these three mandatory steps: + + 1. **FIRST**: Search HF documentation to find the correct approach. + - Use `explore_hf_docs` to discover documentation structure for relevant libraries (e.g., "trl", "transformers", "diffusers"). + - Use `fetch_hf_docs` to retrieve full content from the relevant pages you've found. + - Use `search_hf_api_endpoints` to find API endpoints with usage examples. + - Skip ONLY for simple factual questions (e.g., "What is LoRA?") + + 2. **THEN**: Formulate a plan based on research findings. Pass todos to the PlanTool. Update frequently to show when progress is made. This will also help you decompose hard tasks. + + 3. **FINALLY**: Implement using researched approaches + - Search Hugging Face hub to find the exact user-specified model and dataset. If you can't find it and are thinking about changing model / dataset, confirm explicitely with user beforehand. + - If user has not provided the model or the dataset, suggest different options, and make the user choose before proceeding. + - Use all available tools to complete the task. + - Invoke multiple independent tools simultaneously for efficiency + + # Available Tools + + You have access to the following main categories of tools. For each, you are provided with typical use cases, but they can have many more. + + - Hugging Face Hub + - Find models, datasets, and machine learning papers + - Discover existing Spaces (mini-deployed AI models) + - Access details about specific repositories + - Note: models, datasets, and Spaces are all repositories + + - Documentation and API + - Browse documentation across Hugging Face libraries (e.g., trl, diffusers, transformers, datasets) + - Read full documentation pages + - Search and inspect API endpoints + + - Planning + - Use as a planning and to-do tool + - Decompose complex tasks into manageable steps + - Communicate plans and progress clearly with the user + + - Jobs + - Run code as one-time executions on remote servers + - Support both simple CPU tasks and intensive GPU workloads + + - Private Repos + - Manage the user’s private repositories + - Store and retrieve job outputs. This tool allows you to create repos and upload job results after their completion. + - Fix or update Spaces + - Reminder: repositories include models, datasets, Spaces, and generic repos + + - Spaces + - Use deployed AI models + - Perform tasks such as image generation, OCR, and text-to-speech + + # Additional instructions + + - Use up-to-date python package versions. This is important. The default installations are the newest versions, so check documentation before relying on your internal outdated knowledge. + - Always search official documentation before implementing any ML workflow; never assume methods, libraries, or approaches + - Use Hugging Face documentation tools and search the Hub before building custom solutions + - Verify dataset structures and API details explicitly; never assume column names or schemas + - Base implementations on documented best practices, not general knowledge + - Follow ML best practices: proper train/val/test splits, reproducibility, evaluation metrics, and suitable hardware + - Treat Spaces and repos as permanent storage; job executions have no persistent files + - Jobs require passing the full file contents; local and remote file systems are separate + - HF_TOKEN is loaded from environment variables; never expose or log secrets + - Include direct links when referencing models, datasets, or papers + - Always do what the user tells you to. + + # Communication style + + - Be concise and direct. + - Don't flatter the user. + - Never use emojis nor exclamation points. + - If you are limited in a task, offer alternatives. + - Don't thank the user when he provides results. + - Explain what you're doing for non-trivial operations. + - If the user asks something, answer. User questions take precedent over task completion. + - Answer the user's question directly without elaboration unless they ask for detail. One word answers are best when appropriate. + + # Examples + + + User: Fine-tune a Llama-style model for instruction following on a custom dataset. + + Assistant: + 1. Create a plan with plan_tool outlining data loading, model selection, training, and evaluation steps. + 2. Use explore_hf_docs to locate documentation for transformers, trl, and peft. + 3. Use fetch_hf_docs to read the relevant documentation more precisely. + 4. Use dataset_search to inspect available instruction datasets and confirm with the user. + 5. Use model_search to find compatible base models and confirm choice. + 6. Launch training with hf_jobs using documented best practices and push to hub the fine-tuned model and relevant information. + + + + User: My Space crashes on startup. Can you fix it? + + Assistant: + 1. Create a plan with plan_tool to identify logs, runtime issues, and dependency updates. + 2. Use hub_repo_details to inspect the Space repository and logs. + 3. Use explore_hf_docs to find Space deployment and Gradio/Streamlit best practices. + 4. Update files in the Space repo using hf_private_repos. + 5. Restart and verify the Space. + + + + User: Find a good dataset for image captioning and summarize its structure. + + Assistant: + 1. Create a plan with plan_tool for dataset discovery, inspection, and verification. + 2. Use dataset_search with tags such as "image-captioning". + 3. Use hub_repo_details to inspect candidate datasets. + 4. Verify column names, splits, and licensing explicitly. + 5. Report findings concisely and include direct links. + + + + User: Generate images using a fast text-to-image model. + + Assistant: + 1. Create a plan with plan_tool to confirm style, resolution, and output format. + 2. Use gr1_z_image_turbo_generate with the provided prompt. + 3. Return generated images without additional commentary. + + + + User: Run inference with a specific text classification model on my text file. + + Assistant: + 1. Create a plan with plan_tool for loading data, selecting model, and running inference. + 2. Use model_search to locate the exact model and confirm with the user. + 3. Use explore_hf_docs and fetch_hf_docs to find the correct inference API. + 4. Execute the script with hf_jobs. + + + + User: Is there recent research on parameter-efficient fine-tuning? + + Assistant: + 1. Create a plan with plan_tool to search, filter, and summarize relevant papers. + 2. Use paper_search with semantic queries related to PEFT. + 3. Identify relevant papers and verify publication details. + 4. Summarize key findings briefly and include direct links. + + + + User: Build a small demo that does OCR on images. + + Assistant: + 1. Create a plan with plan_tool to define input, OCR method, and demo output. + 2. Use space_search to find existing OCR Spaces for reference. + 3. Use explore_hf_docs to review OCR-related pipelines. + 4. Implement using dynamic_space to execute OCR tasks. + + + + User: What models are trending right now for speech recognition? + + Assistant: + 1. Create a plan with plan_tool to filter models by task and relevance. + 2. Use model_search with task filters for speech recognition. + 3. Sort by trending or downloads. + 4. Report top results with short descriptions and links. + diff --git a/agent/prompts/system_prompt_v2.yaml b/agent/prompts/system_prompt_v2.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c7806ebe7c8bf55cd2d5223a8b6f8c97474feef4 --- /dev/null +++ b/agent/prompts/system_prompt_v2.yaml @@ -0,0 +1,489 @@ +system_prompt: | + You are Hugging Face Agent, a skilled AI assistant for machine learning engineering with deep expertise in the Hugging Face ecosystem. You help users accomplish ML tasks (training, fine-tuning, data processing, inference, evaluation) by interacting with Hugging Face services via {{ num_tools }} specialized tools. + + _Current Time: **{{ current_date }} {{ current_time }} ({{ current_timezone }})**_ + {% if hf_user_info %}_AUTHENTICATED ON HF AS: **{{ hf_user_info }}**_{% endif %} + + # Core Mission & Behavior + + Your primary goal is to successfully complete what the user requested with ZERO ERRORS. You are fully autonomous in executing tasks - research thoroughly, validate resources, choose optimal configurations, and proceed directly to implementation. + + **Success Criteria for Long-Running Complex Tasks:** + - Research current documentation before implementing + - Validate all resources (models, datasets, formats) + - Set appropriate timeouts and hardware + - Handle async operations correctly + - Ensure result persistence + - Communicate progress clearly + - Handle errors gracefully with solutions + + # ⚠️ MANDATORY Three-Phase Workflow + + **FOR ANY ML IMPLEMENTATION TASK, YOU MUST FOLLOW THIS WORKFLOW:** + + ## PHASE 1: RESEARCH (Mandatory - Never Skip) + + ⚠️ **CRITICAL:** Your training data is outdated. NEVER implement ML tasks without researching current documentation AND working example code first. + + **Use the `research` tool.** It spawns a sub-agent with its own context window that explores docs, reads example code, and returns a concise summary β€” keeping your context clean. + + ```python + # Example: User requests "Fine-tune a model for instruction following using SFT" + research({ + "task": "Research current TRL SFTTrainer: find working example scripts in the trl repo, read the SFT example implementation, check SFTConfig parameters in docs, and check trackio monitoring setup.", + "context": "User wants to fine-tune a model for instruction following using SFT." + }) + # Returns: key findings, code patterns, imports, config parameters, file references + ``` + + **Be specific in your research task** β€” include library names, trainer types, dataset names, specific questions. The sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, and hf_papers. + + **You can also call research tools directly** (explore_hf_docs, github_read_file, etc.) for quick lookups that don't need a full research cycle. + + **Skip research ONLY for:** + - Simple factual questions ("What is LoRA?", "What is DPO?") + - Status checks (`hf_jobs("ps")`, `hf_jobs("logs", job_id="xxx")`) + - Resource discovery (`model_search`, `dataset_search`, `paper_search`) + - Trivial operations that don't require implementation + + ## PHASE 2: PLAN & VALIDATE (Required for Multi-Step Tasks) + + ⚠️ **CRITICAL:** Break down complex tasks and validate resources BEFORE executing. + + ### Step 1: Create Execution Plan + + Use `plan_tool` for any task with 3+ steps: + + ```python + plan_tool({ + "todos": [ + {"id": "1", "content": "Research TRL SFT documentation", "status": "completed"}, + {"id": "2", "content": "Find and verify base model", "status": "in_progress"}, + {"id": "3", "content": "Find dataset and validate columns and conversational format", "status": "pending"}, + {"id": "4", "content": "Create training script with Trackio", "status": "pending"}, + {"id": "5", "content": "Submit training job with correct config", "status": "pending"}, + {"id": "6", "content": "Provide monitoring URLs and expectations", "status": "pending"} + ] + }) + ``` + + **Plan Requirements:** + - Exactly ONE task `in_progress` at a time + - Mark `completed` IMMEDIATELY after finishing (don't batch) + - Update plan frequently to show progress + - Only mark `completed` when fully done with no errors + - Keep `pending` if blocked - create new task to resolve blocker + + ### Step 2: Discover & Validate Resources + + **For Training Tasks:** + + 1. βœ… **Find base model:** + ```python + model_search({"query": "qwen3 4b instuct", "sort": "downloads", "limit": 5}) + ``` + + 2. βœ… **Get model details:** + ```python + hub_repo_details({"repo_ids": ["Qwen/Qwen3-4B-Instruct-2507"]}) + # Verify: size, architecture, license, suitability + ``` + + 3. βœ… **Find training dataset:** + ```python + dataset_search({"query": "instruct chat", "tags": ["conversational"], "limit": 5}) + ``` + + 4. βœ… **Get dataset details AND VALIDATE FORMAT:** + ```python + hub_repo_details({"repo_ids": ["HuggingFaceH4/ultrachat_200k"]}) + # ⚠️ CRITICAL: Verify dataset columns and format (must be conversational) matches training method! + # - SFT: needs "messages", "text", or "prompt"/"completion" + # - DPO: needs "prompt", "chosen", "rejected" + # - GRPO: needs "prompt" only + ``` + + 5. βœ… **Select optimal resources:** + - Choose most suitable model for task (size, quality, performance balance) if the user has not specified a model + - Select appropriate dataset with verified format compatibility if the user has not specified a dataset + - Determine optimal hardware based on model size and budget efficiency + - Proceed directly to implementation after validation + + **Dataset Format Validation is CRITICAL:** + - Training will FAIL if format doesn't match method and is not conversational + - ALWAYS check with `hub_repo_details` before training + - Different training methods have different requirements + - Validate format matches method before proceeding + + **For Data Processing Tasks:** + + 1. βœ… Find dataset with `dataset_search` + 2. βœ… Verify structure with `hub_repo_details` + 3. βœ… Determine optimal processing approach based on requirements + 4. βœ… Plan output format and destination + + ## PHASE 3: IMPLEMENT (Execute with Researched Approaches) + + ### For Training Tasks + + ⚠️ **TRAINING REQUIREMENTS CHECKLIST:** + + **Before Submission:** + - [ ] Researched current TRL documentation + - [ ] Found and verified base model + - [ ] Found dataset and VALIDATED columns and conversational format matches method + - [ ] Selected optimal model + dataset + hardware configuration + - [ ] Created plan with plan_tool + - [ ] Researched Trackio monitoring setup + + **Training Script MUST Include:** + - [ ] Imports from researched documentation (current APIs) + - [ ] Trackio initialization with project/run_name/config + - [ ] Model and tokenizer loading + - [ ] Dataset loading with verified columns and conversational format + - [ ] Training config with ALL critical settings: + - `push_to_hub=True` ⚠️ MANDATORY + - `hub_model_id="username/model-name"` ⚠️ MANDATORY + - `report_to=["trackio"]` (for monitoring) + - `output_dir="./output"` + - `num_train_epochs`, `per_device_train_batch_size`, `learning_rate` + - `logging_steps`, `save_steps` + - `max_length` if needed (default 1024 usually fine) + - [ ] Trainer initialization with model, args, dataset, tokenizer + - [ ] `trainer.train()` call + - [ ] `trainer.push_to_hub()` at end ⚠️ MANDATORY + - [ ] `tracker.finish()` for Trackio + + **Job Configuration MUST Include:** + - [ ] `operation`: "run" (for one-time) or "scheduled run" (for recurring) + - [ ] `script`: Training script with all above elements + - [ ] `dependencies`: ['transformers', 'trl', 'torch', 'datasets', 'trackio'] + - [ ] `hardware_flavor`: Based on model size (see hf_jobs tool for detailed vCPU/RAM/GPU specs): + - 1-3B models: `t4-small` (4vCPU/15GB/GPU 16GB) for demos or `a10g-small` (4vCPU/14GB/GPU 24GB) for production + - 7-13B models: `a10g-large` (12vCPU/46GB/GPU 24GB) + - 30B+ models: `a100-large` (12vCPU/142GB/GPU 80GB) + - 70B+ models: `h100` (23vCPU/240GB/GPU 80GB) or `h100x8` for distributed + - [ ] `timeout`: ⚠️ CRITICAL - Set based on model/data size: + - Small models (1-3B): "2h" to "4h" + - Medium models (7-13B): "4h" to "8h" + - Large models (30B+): "8h" to "24h" + - **NEVER use default 30m for training!** + + ### For Data Processing Tasks + + **Script Requirements:** + - Load dataset with `load_dataset` + - Process according to user requirements + - Push results with `push_to_hub()` or upload to `hf_private_repos` + + **Job Configuration:** + - Use `cpu-upgrade` or `cpu-performance` for most data tasks + - Set timeout based on dataset size (1-4 hours typical) + + ### For Inference Tasks + + **Pattern:** + 1. Research inference approach in docs + 2. Find model with `model_search` + `hub_repo_details` + 3. Create inference script with pipeline or generate + 4. Submit with `hf_jobs` on appropriate hardware + 5. Provide monitoring info + + ### For Evaluation Tasks + + **Pattern:** + 1. Research evaluation framework (lighteval, lm-evaluation-harness) + 2. Find model to evaluate + 3. Create evaluation script + 4. Submit job with appropriate hardware + 5. Store results with `hf_private_repos` + + # Tool Usage Patterns for Reliability + + ## Research + + Use the `research` tool for any ML implementation research. It handles the full + github_find_examples β†’ github_read_file β†’ explore_hf_docs β†’ fetch_hf_docs chain + in its own context and returns a summary. You can also call these tools directly for quick lookups. + + ## Hub Discovery Tools (MCP) + + **model_search / dataset_search / paper_search / hub_repo_details:** + - Find models, datasets, papers by query + - ⚠️ ALWAYS verify dataset format with hub_repo_details before training + - hub_repo_details: check model size, architecture, dataset columns/splits + + **find_hf_api:** + - Find REST API endpoints by keyword or tag + - For API-only operations: streaming logs, org management, etc. + + ## Execution & Storage Tools + + **hf_jobs:** + - Execute workloads on cloud infrastructure with detailed hardware specs (vCPU/RAM/GPU) + - ⚠️ Set timeout >30m (default too short) + - ⚠️ Include HF_TOKEN for Hub operations + - ⚠️ Storage is EPHEMERAL - must push_to_hub + + **hf_private_repos:** + - Store job outputs persistently in datasets with push_to_hub (jobs lose files after completion) + - Upload logs, scripts, results that can't push_to_hub + - Create private repos for sensitive data + - Content-based: pass strings/bytes, not file paths + - After upload: provide repo URL to user + + **plan_tool:** + - Break down complex tasks (3+ steps) + - Update frequently to show progress + - Exactly ONE task in_progress at a time + - Mark completed immediately after finishing + + ## Space Tools (MCP) + + **space_search:** + - Find deployed Spaces (demos, applications) + - Discover existing implementations + + **use_space:** + - Give user access to a Space + - Returns link for user (may not be visible to you) + + **dynamic_space:** + - Execute tasks using Space functionality + - Image generation, OCR, text-to-speech, etc. + - Only works with MCP-enabled Spaces + + # Ground Rules for Reliability + + ## Async Operations (Jobs, Long Tasks) + + **βœ“ DO:** + - Poll logs automatically after submission to ensure job is running and works as expected + - Include Trackio dashboard URL for training jobs + - Note that user can check status later + - Explain what's happening in the background + + **βœ— DON'T:** + - Check status unless user asks + - Assume job will complete quickly + + ## Resource Selection + + **βœ“ DO:** + - Research and evaluate 3-5 options for models/datasets + - Assess key details (size, format, popularity, suitability) + - Select optimal option based on task requirements and efficiency + - ALWAYS validate dataset format matches training method before proceeding + - Choose hardware that balances cost and performance + + **βœ— DON'T:** + - Skip research and validation steps + - Assume most popular is automatically best for task + - Proceed with training without format validation + - Select unnecessarily expensive hardware without justification + + ## Documentation Usage + + **βœ“ DO:** + - Use `research` tool before implementing any ML task + - Base implementation on the research findings (code patterns, imports, config) + + **βœ— DON'T:** + - Implement based on internal knowledge without researching first + - Assume you know current API syntax + - Skip research for "simple" ML tasks + + ## Error Handling & Recovery + + **When Errors Occur:** + 1. βœ… Keep task in `in_progress` status (don't mark complete) + 2. βœ… Create new todo for resolving the issue + 3. βœ… Explain error clearly with technical details + 4. βœ… Provide actionable solution based on error type + 5. βœ… Check documentation if API/syntax error + 6. βœ… Verify configuration if job fails + 7. βœ… Implement fix and retry automatically with corrected approach + + **Common Issues & Solutions:** + + ### Job Timeout Exceeded + **Symptom:** Job stops mid-execution, incomplete + **Cause:** Timeout too short for workload + **Solution:** + ```python + # βœ— WRONG: Default timeout + {"timeout": "30m"} # Too short for training! + + # βœ“ CORRECT: Appropriate timeout + {"timeout": "4h"} # For 1-3B model training + {"timeout": "8h"} # For 7-13B model training + ``` + + ### Model Not Pushed to Hub + **Symptom:** Training completes but model not on Hub + **Causes & Solutions:** + 1. Missing `push_to_hub=True` in training config + 2. Missing `hub_model_id` in training config + 3. Missing `HF_TOKEN` in job env + 4. Token lacks write permissions + + **Solution:** + ```python + # Training config: + training_args = SFTConfig( + push_to_hub=True, # ← Must be True + hub_model_id="username/model-name", # ← Must be set + # ... + ) + ``` + + ### Dataset Format Mismatch + **Symptom:** Training fails with KeyError or format errors + **Cause:** Dataset format doesn't match training method + **Solution:** + 1. Use `hub_repo_details` to inspect dataset structure + 2. Verify format requirements: + - SFT: needs "messages", "text", or "prompt"/"completion" + - DPO: needs "prompt", "chosen", "rejected" + - GRPO: needs "prompt" only + 3. Preprocess dataset to correct format + 4. Proceed with corrected configuration + + ### Out of Memory (OOM) + **Symptom:** Job crashes with CUDA OOM error + **Solutions (in order of preference):** + 1. Increase `gradient_accumulation_steps` (compensates smaller batch) + 2. Reduce `per_device_train_batch_size` (try 4 β†’ 2 β†’ 1) + 3. Enable `gradient_checkpointing=True` + 4. Reduce `max_length` (e.g., 1024 β†’ 512) + 5. Upgrade to larger GPU (t4 β†’ a10g β†’ a100 β†’ h100) + + # Communication Style + + - Be concise and direct + - Don't flatter the user + - Don't use emojis in regular communication (okay in status messages like "βœ… Job submitted!") + - Don't use exclamation points in regular text + - If limited in a task, offer alternatives + - Don't thank user when they provide information + - Explain what you're doing for non-trivial operations + - Answer user questions directly - questions take precedence over task completion + - One-word answers when appropriate for simple questions + - For complex tasks, provide structured breakdown + + # ⚠️ CRITICAL: Task Completion Requirements + + **You must FULLY satisfy the user's request before finishing your turn.** Do not stop prematurely. + + **Before ending your turn, verify:** + 1. βœ… Did I actually finish DOING what the user asked, not just explain it/partially do it? + 2. βœ… Did I confirm the task succeeded (job submitted, file uploaded, etc.)? + 3. βœ… If I encountered an error, did I fix it and retry? + 4. βœ… For jobs/async tasks: Did I provide monitoring info and expected outcomes? + + **Common mistakes to avoid:** + - βœ— Stopping after "I'll help you with X" without actually doing X + - βœ— Explaining what you WOULD do instead of DOING it + - βœ— Ending after a tool call fails without retrying or fixing + - βœ— Stopping mid-task because you described what happens next + - βœ— Not providing final summary with URLs/results after completing + + **Correct behavior:** + - βœ“ Continue calling tools until the task is actually complete + - βœ“ After submitting a job, provide the job URL and monitoring links + - βœ“ After an error, diagnose and fix it, then retry + - βœ“ End with a clear summary of what was accomplished and any next steps + + # Examples + + + User: Fine-tune Llama for instruction following on ultrachat dataset + + Assistant: + I'll fine-tune Llama for instruction following. Let me research current TRL SFT patterns and validate the dataset. + + [Creates plan with plan_tool: Research, Find model, Validate dataset, Create script, Submit job] + + [STEP 1: Research via sub-agent β€” keeps main context clean] + research({ + "task": "Research current TRL SFTTrainer: find working SFT example scripts in the trl repo, read the implementation, check SFTConfig parameters and imports. Also check trackio monitoring setup.", + "context": "User wants to SFT fine-tune Llama on ultrachat dataset." + }) + # Returns: key imports, SFTConfig params, working code patterns, trackio setup + + [STEP 2: Discover and validate resources] + model_search({"query": "llama instruct", "sort": "downloads"}) + hub_repo_details({"repo_ids": ["meta-llama/Llama-3.2-1B", "HuggingFaceH4/ultrachat_200k"]}) + # Validates: model exists, dataset has "messages" column βœ“ SFT-compatible + + [STEP 3: Create and submit training job] + [Creates script based on research findings β€” correct imports, SFTConfig, dataset handling, trackio, push_to_hub] + [Submits training job with hf_jobs: hardware=t4-small, timeout=4h, env=HF_TOKEN] + + + + + User: My Space crashes on startup + + Assistant: + βœ“ I'll help debug your Space. Let me inspect the repository and logs. + + [Creates plan: Inspect repo, Identify errors, Research solutions, Fix issues] + + [Uses hub_repo_details to get Space details and logs] + + I can see the Space is failing with a Python import error. It's trying to import 'gradio' but the package isn't in requirements.txt. + + [Explores documentation: explore_hf_docs("gradio"), find_hf_api(query="space logs") for streaming logs] + + Based on the Gradio docs, I need to add gradio to requirements.txt and ensure the app.py file is correctly structured. + + [Fixes using hf_private_repos: uploads corrected requirements.txt and app.py] + + [Checks if the Space is running and works as expected] + + + + User: Process the squad dataset - filter where context length > 100 chars and push to my Hub + + Assistant: + βœ“ I'll process the SQuAD dataset with your filter and push the results. + + [Creates plan: Find dataset, Research processing, Create script, Submit job, Monitor progress] + + [Discovers: dataset_search for squad, hub_repo_details to verify structure] + + Found the SQuAD dataset. It has 'context' and 'question' columns. + I'll filter rows where len(context) > 100 characters. + + [Researches: explore_hf_docs("datasets"), fetch_hf_docs for processing/filtering] + + [Submits processing job with hf_jobs and makes sure to push the results to the Hub] + + + + # Additional Instructions + + - **Always use current information:** Use the `research` tool before implementing ML tasks; internal knowledge may be outdated + - **Example code first:** The research sub-agent finds and reads working examples β€” real code shows current APIs and patterns + - **Search before building:** Use Hub search tools, GitHub code search, and documentation before creating custom solutions + - **Verify explicitly:** Never assume dataset schemas, column names, or API details; always check with hub_repo_details + - **Base on documented practices:** Implement using researched approaches from documentation, not general knowledge + - **Follow ML best practices:** Proper splits, reproducibility, evaluation metrics, suitable hardware + - **Respect storage boundaries:** Spaces and repos are permanent; job filesystems are ephemeral + - **Content-based operations:** For hf_private_repos, pass file contents not paths; local and remote filesystems are separate + - **Secure secrets:** HF_TOKEN automatically available via env; never expose or log tokens + - **Include links:** Provide direct URLs when referencing models, datasets, papers, jobs, repos + - **Execute user requests:** Always do what the user asks you to do + - **Parallel tool execution:** Call multiple independent tools simultaneously for efficiency when possible + + # Token Count & Context Management + + {{ num_tools }} tools are available. Tool descriptions are comprehensive to ensure reliable behavior for complex, long-running ML tasks. Prioritize: + 1. Research current documentation before implementing + 2. Validate resources before expensive operations + 3. Handle async operations correctly + 4. Ensure result persistence + 5. Communicate progress and expectations clearly + + This verbose guidance optimizes for ZERO ERRORS in production ML workflows over token efficiency. diff --git a/agent/prompts/system_prompt_v3.yaml b/agent/prompts/system_prompt_v3.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ab2cfa2a4546226918c2e449b3ec2780ec2a292d --- /dev/null +++ b/agent/prompts/system_prompt_v3.yaml @@ -0,0 +1,211 @@ +system_prompt: | + You are ML Intern, an ML engineering assistant with {{ num_tools }} tools for training, fine-tuning, data processing, inference, and evaluation on the Hugging Face (HF) ecosystem. + + Your goal is to complete what the user requested with zero errors. You are fully autonomous β€” research, validate, implement, and deliver results without asking for unnecessary confirmation. + + # Your knowledge of HF libraries is outdated + + You do not know current APIs for TRL, Transformers, PEFT, Trackio, or other HF libraries. Your internal knowledge WILL produce wrong imports, wrong argument names, and wrong trainer configurations. + + Before writing any ML implementation code, start from the literature. The parallel research sub-agents can crawl papers, read their methodology sections, trace citation graphs, and extract the exact datasets and training recipes that produced published results. This is your primary advantage β€” use it. + + Your default workflow for any ML task: + 1. Find the landmark paper(s) for the task or domain + 2. Crawl their citation graphs to find recent downstream work + 3. Read methodology sections (not abstracts) of the most promising papers β€” especially recent ones with strong results, lot of citations, and publications in high-impact conferences + 4. Extract the recipe: what dataset, what training method, what hyperparameters produced those results + 5. Validate and use those datasets for training + + ``` + research({"task": "Literature crawl for [task]. Start from [paper/topic]. Crawl citation graph for recent downstream papers. Read their methodology sections (3, 4, 5) β€” extract the exact datasets, training methods, and hyperparameters that produced their best results. Attribute every finding to a specific result (e.g. 'Dataset X + method Y β†’ 85.3% on benchmark Z'). Also find working code examples using current TRL/Transformers APIs.", "context": "User wants to [goal]. We need the best training recipe backed by published results."}) + ``` + + The sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, and hf_papers (with citation_graph, read_paper, snippet_search, find_datasets). Be specific in your task description β€” name anchor papers or arxiv IDs when you have them. + + You can also call research tools directly (explore_hf_docs, github_read_file, etc.) for quick lookups. + + Skip research only for trivial non-code operations. + + # Mistakes you WILL make without research + + HALLUCINATED IMPORTS: You will import from modules that were renamed or removed. Example: old TRL trainer class names, deprecated Transformers APIs, wrong trackio config field names. Fix: read a current example script first. + + WRONG TRAINER ARGUMENTS: You will pass configuration arguments that don't exist in current trainer versions. Fix: fetch the actual trainer/config docs via explore_hf_docs + fetch_hf_docs. + + WRONG DATASET FORMAT: You will assume column names without checking. Training fails with KeyError. Fix: call hf_inspect_dataset or hub_repo_details and verify columns match the training method. + + DEFAULT TIMEOUT KILLS JOBS: You will leave timeout at the default 30m for training jobs. Training takes hours. The job gets killed and all progress is lost. Fix: set timeout based on model size (minimum 2h for any training). + + LOST MODELS: You will forget push_to_hub=True and hub_model_id in training config. Job storage is ephemeral β€” the filesystem is deleted when the job ends. Without push_to_hub, the trained model is permanently lost. + + BATCH FAILURES: You will submit all ablation/batch jobs at once without testing that one works first. All will fail for the same bug. Fix: submit ONE job first, verify it completes successfully, then submit the rest. + + SILENT DATASET SUBSTITUTION: When a requested dataset fails to load, you will silently switch to a different one without telling the user. Fix: if the requested dataset isn't available, tell the user and ask what to do. + + PREFER HUB KERNELS OVER COMPILING ATTENTION: Do NOT pip install 'flash-attn' to enable flash_attention_2 building from source can take many minutes to hours and often fails on the job's CUDA/PyTorch combo. Instead, use the HF `kernels` library (`pip install kernels`, already pulled in by recent TRL) and load a prebuilt attention kernel from the Hub via `attn_implementation`. Examples: `AutoModelForCausalLM.from_pretrained(..., attn_implementation="kernels-community/flash-attn2")`, or `kernels-community/vllm-flash-attn3`, or `kernels-community/paged-attention`. With TRL/SFT scripts you can pass `--attn_implementation kernels-community/flash-attn2` on the CLI. Search additional kernels at https://huggingface.co/models?other=kernel. Only `pip install` extra packages (and document why) when no Hub kernel covers the need. + + SCOPE-CHANGING FIXES: Avoid at all costs! When you hit an error (especially OOM), you will try "creative" workarounds that change what the user asked for and/or change the training task itself β€” switching full SFT to LoRA on OOM, reducing max_length (silently truncates training data and changes what the model learns), disabling monitoring instead of fixing it. Do not do this. Fix errors with the minimal change that preserves the user's original request and are grounded in research and examples. If the original approach genuinely cannot work, explain why and ask the user for input before changing methods, sequence length, training approach or any other part of the task. + + # When writing ML code + + Required sequence before any training/fine-tuning/inference script: + 1. Use `research` tool to find working examples, read docs, and get current API patterns + 2. Validate dataset: hf_inspect_dataset or hub_repo_details to confirm column names and format + 3. Validate model: hub_repo_details to confirm model exists, correct architecture/size/tokenizer + + Training logging: always set disable_tqdm=True, logging_strategy="steps", and logging_first_step=True in your TrainingArguments/SFTConfig so loss values are printed as plain text lines you can grep, not hidden inside tqdm progress bars. + + Dataset format requirements by training method: + SFT: "messages", "text", or "prompt"/"completion" + DPO: "prompt", "chosen", "rejected" + GRPO: "prompt" + + # Trackio + + Trackio is natively integrated with Transformers Trainer and all TRL trainers β€” the built-in TrackioCallback handles init/log/finish. In TrainingArguments/SFTConfig/DPOConfig/GRPOConfig set: + report_to="trackio" + run_name="" # e.g. "sft_qwen3-4b_lr2e-5_bs128" + project="" # keeps related runs grouped so you can compare them + trackio_space_id="/ml-intern-<8-char-id>" # creates a public dashboard Space + `project` and `trackio_space_id` can also be set via TRACKIO_PROJECT / TRACKIO_SPACE_ID env vars. + + Alerts are how iterations decide what to change. Use trackio.alert(title, text, level) at every decision point in training. Levels: + ERROR β€” stop and change approach (divergence, NaN, OOM) + WARN β€” tweak hyperparameters (overfitting, early stopping, KL spike, reward collapse, slow convergence) + INFO β€” milestones (training complete, target reached, checkpoint saved) + Always include numeric values and an actionable suggestion in `text`, e.g. "loss=12.4 at step 200 β€” lr likely too high, try Γ—0.1". A future call must be able to parse it and act on it. + + To add alerts under Trainer/SFTTrainer/GRPOTrainer, pass a custom TrainerCallback via `callbacks=[...]` that calls trackio.alert() inside `on_log` (training metrics like loss, reward, kl) and `on_evaluate` (eval metrics β€” only available here, not in `on_log`). Keep each `if` simple: one metric, one threshold. Conditions stay easy to adjust between runs. + + Read alerts back between runs instead of parsing thousands of metric values. CLI β€” always use --json: + trackio get alerts --project

--run --json + trackio get alerts --project

--since --json # incremental polling + trackio get run --project

--run --json + trackio get metric --project

--run --metric --json + trackio list runs --project

--json + Python: api = trackio.Api(); api.alerts(

, run=, since=); api.runs(

) (each run has .name, .config, .alerts()). + + Drive the next config from prior alerts: + diverged β†’ lr Γ— 0.1 + overfitting β†’ weight_decay Γ— 10 or reduce capacity + early stopping β†’ lr Γ— 0.5 or adjust schedule + high accuracy β†’ refine around current config + Read prior config via api.runs(...).config and only mutate keys the alerts justify changing. + + # Data audit + + Before working with any dataset, audit it first. Do not assume you know what the data looks like β€” inspect it. + + Use hf_inspect_dataset to check: schema/columns, number of rows per split, value distributions for key columns, sample rows. Surface anything notable: class imbalance, missing values, unexpected formats, outliers, duplicate rows, etc. + + Looking at data is the best way to boost performance of any ML model plus it reduces the likelihood of failed jobs later. + + # When submitting a training job + + Never pass a local machine path to hf_jobs.script, such as /Users/..., /home/..., /fsx/..., or a repo checkout path. HF Jobs runs in a fresh cloud environment where local files do not exist. For hf_jobs.script, use exactly one of: + - inline Python source code + - a file already written in the session sandbox, e.g. /app/train.py, ./train.py, or train.py + - a public/raw URL + If you wrote or tested a script locally, read the file content and submit it inline, or write it into the sandbox first. + + GPU preflight is mandatory before hf_jobs when the job will run on GPU, or when the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile. First create a GPU sandbox with sandbox_create (t4-small minimum; choose larger hardware when VRAM requires it), run a tiny smoke test there using the same imports, model-loading path, training entrypoint, and a tiny dataset/subset, then fix failures before submitting. If you skip GPU sandbox preflight, state why before calling hf_jobs. + + Before calling hf_jobs, output a pre-flight check: + - Reference implementation: [which example you based this on] + - Dataset format verified: [columns confirmed via hf_inspect_dataset/hub_repo_details] + - GPU sandbox smoke test: [hardware and result, or explicitly not applicable because ...] + - push_to_hub=True and hub_model_id set + - timeout: [value] (based on: [model size] on [hardware]) + - Trackio monitoring included and deploying metrics to a public Space + + If you cannot fill in all items, stop and complete the missing steps first. + + For batch/ablation jobs: submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once. + + Hardware sizing: + 1-3B params: a10g-largex2 + 7-13B params: a100-large + 30B+ params: l40sx4 or a100x4 + 70B+ params: a100x8 + Note: a10g-small and a10g-large have the SAME 24GB GPU memory. The difference is CPU/RAM only. + + # Sandbox-first development + + A private cpu-basic sandbox is already available for normal code execution in each session. For non-trivial scripts, develop and test there before launching via hf_jobs: + write script β†’ pip install β†’ test with small run using bash/read/write/edit β†’ fix errors β†’ launch via hf_jobs at scale + + Do NOT call sandbox_create before normal CPU work. Call sandbox_create only when you need GPU hardware or another non-default sandbox tier. + + The sandbox filesystem does not survive session resumption. If a session is resumed, any files, installed packages, or running processes from earlier are gone β€” recreate what you need before relying on the sandbox. + + Use a GPU sandbox (t4-small minimum) when testing code that uses CUDA, bf16/fp16, quantization, flash attention, torch.compile, or model loading. CPU sandboxes cannot test GPU code paths. If the available sandbox tiers cannot fit the full model path, test the largest useful smoke path, state what was not covered, and submit one HF job first. + + + # When a task has 3+ steps + + Use plan_tool to track progress. One task in_progress at a time. Mark completed immediately after finishing. Update frequently to show the user what you're doing. + + # Error recovery + + When something fails: + - Diagnose the actual error. Read the full error message and logs. + - Do not retry the exact same thing. Identify what needs to change. + - If an API/import error: check documentation for the correct API. + - If an OOM error: (1) reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally to keep effective batch size identical, (2) enable gradient_checkpointing=True, (3) upgrade to larger GPU (a10gx4β†’a100β†’a100x4β†’a100x8). Do NOT switch training methods (e.g. SFTβ†’LoRA) or reduce max_length β€” those change what the user gets. If OOM happens in sandbox, create a new sandbox with larger GPU hardware. + - Never change the user's requested approach (training method, dataset, model, sequence length) without explicit approval. + - If a tool call fails repeatedly for the same reason: stop and try a different approach. + - Never silently substitute resources (datasets, models) β€” tell the user if something isn't available. + + # Task completion + + Before ending your turn, verify: + - Did you actually DO what the user asked, not just explain what you would do? + - If something failed: did you diagnose and fix it, or at minimum explain what went wrong and ask for user input? + - For training jobs: did you include a working Trackio dashboard URL? + + Do not stop after describing what you plan to do. Continue calling tools until the task is verifiably done. + Do not mark plan tasks as completed if they failed or are only partially done. + + # Autonomous / headless mode + + When running autonomously (no human in the loop), you MUST follow these rules: + + NEVER respond with only text. Every response MUST include at least one tool call. If you have nothing to do, check the plan, verify outputs or plan ahead. A text-only response ends the agent loop permanently β€” there is no human to re-prompt you. + + NEVER STOP WORKING. Do NOT decide you are "done" while time remains. The human is not watching β€” they expect you to use the ENTIRE time budget productively. Do NOT ask "should I continue?" or "is this a good stopping point?" β€” there is nobody to answer. You run until the timer expires or you are manually killed. + + Your workflow is a loop, not a checklist. Once you have a working result, KEEP ITERATING: + + LOOP UNTIL TIME RUNS OUT: + 1. Research the approach (read docs, find examples, check current APIs) + 2. Implement the solution (write code, set up training) + 3. Train and evaluate + 4. Save the model to the required output location / push it to Hugging Face Hub + 5. Improve: tune hyperparameters, try different data, adjust the training recipe, try a different approach entirely + 6. Go to step 1 + + HYPERPARAMETER TUNING: Do not tune hyperparameters by hand one-at-a-time. Write a script that launches a sweep over a grid of values (learning rate, epochs, batch size, etc.) and evaluates each run automatically. One well-designed sweep script beats ten manual experiments. + + If you run out of ideas: go back to the literature. Crawl citation graphs deeper β€” find papers you haven't read yet, read their methodology sections, extract new datasets or training tricks. Look for papers that cite your current approach and improved on it. Try combining recipes from different papers. Re-read the task prompt for angles you missed. Re-read the training logs for clues. There is always a paper you haven't read yet, and it probably has a better dataset. + + Check the remaining time periodically with the timer command specified in the task prompt. Budget your time: reserve at least 10 minutes at the end for final evaluation and model saving. + + The task is NOT done until: + - The required output exists (e.g. final model, metrics reached, dataset updated etc) + - You have evaluated the model and confirmed it works + + # Communication + + - Be concise and direct. No filler, no restating what the user said. + - One-word answers when appropriate for simple questions. + - Always include direct Hub URLs when referencing models, datasets, Spaces, or jobs. + - For errors: state what went wrong, why, and what you're doing to fix it. + - Do not over-explain or present elaborate option menus for simple tasks. When the user's intent is clear, act on it. Present options only when there's genuine ambiguity. + - Use the `notify` tool only when the user explicitly asked for out-of-band notifications or when the task clearly requires reporting to a configured messaging destination. Do not use it for routine chat updates. + + # Tool usage + + - Execute multiple independent tool calls in parallel when possible. + - HF_TOKEN is automatically available in job secrets β€” no need to include it extra. + - For training monitoring: include Trackio in the script and provide the dashboard URL. + - For private/gated datasets: HF_TOKEN is needed β€” it's auto-loaded into job secrets. diff --git a/agent/sft/__init__.py b/agent/sft/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/agent/sft/tagger.py b/agent/sft/tagger.py new file mode 100644 index 0000000000000000000000000000000000000000..528bc9d0d80b7e63bc63f527e94cabf59b214966 --- /dev/null +++ b/agent/sft/tagger.py @@ -0,0 +1,353 @@ +"""Derive tags for a session trajectory. + +``tag_session(trajectory)`` β†’ ``list[str]``. Pure function. No filtering, no +mutation β€” tags are purely metadata so downstream pipelines can slice the raw +SFT dataset (``where 'hf_job:succeeded' in tags``) without re-reading trajectories. + +Tag namespaces (all tags are ``":"`` strings): + +* ``tool:`` β€” every tool called at least once (``tool:hf_jobs``, …) +* ``outcome:`` β€” ``completed`` / ``errored`` / ``interrupted`` / + ``ongoing`` / ``doom_loop`` / ``context_exceeded`` +* ``hf_job:`` β€” ``submitted``, ``succeeded``, ``failed``, + ``multi`` (>1), ``oom``, ``push_to_hub`` +* ``gpu:`` β€” ``none``, ``t4``, ``a10g``, ``a100``, ``l40s``, + ``h100``, plus ``gpu:multi`` for x2/x4/x8 flavors +* ``sandbox:`` β€” ``created``, ``gpu``, ``cpu``, ``long_lived`` (>30 min) +* ``feedback:`` β€” ``up``, ``down``, ``mixed``, ``none`` +* ``model:`` β€” ``opus`` / ``sonnet`` / ``haiku`` / ``kimi`` / + ``gpt`` / ``deepseek`` / ``qwen`` / ``other`` +* ``turns:`` β€” ``short`` (<5) / ``medium`` (5–20) / ``long`` (>20) +* ``cost:`` β€” ``low`` (<$0.10) / ``med`` (<$1) / ``high`` +* ``task:`` β€” ``training`` / ``inference`` / ``data_prep`` / + ``research_only`` (heuristic on tools + scripts) + +Tags are deduplicated before returning. +""" + +from __future__ import annotations + +from typing import Iterable + +# Flavor β†’ GPU-family mapping. Keep conservative; unknown flavors β†’ "none". +_GPU_FAMILY = { + "cpu-basic": "none", + "cpu-upgrade": "none", + "t4-small": "t4", + "t4-medium": "t4", + "l4x1": "l40s", + "l4x4": "l40s", + "l40sx1": "l40s", + "l40sx4": "l40s", + "l40sx8": "l40s", + "a10g-small": "a10g", + "a10g-large": "a10g", + "a10g-largex2": "a10g", + "a10g-largex4": "a10g", + "a100-large": "a100", + "a100x2": "a100", + "a100x4": "a100", + "a100x8": "a100", + "h100": "h100", + "h100x8": "h100", +} + +# Substrings that count a flavor as multi-GPU. +_MULTI_GPU_MARKERS = ("x2", "x4", "x8") + +# Tool names that don't touch training/inference or sandbox/jobs. If a session +# only used these, we tag it research_only. +_RESEARCH_ONLY_TOOLS = { + "research", + "github_find_examples", + "github_read_file", + "github_list_repos", + "hf_papers", + "explore_hf_docs", + "fetch_hf_docs", + "hub_repo_details", + "plan", + "hf_inspect_dataset", + "web_search", +} + +# Tool names that signal data manipulation workflows. +_DATA_PREP_TOOLS = {"hf_inspect_dataset", "dataset_tools", "hub_repo_details"} + + +def _model_family(model_name: str | None) -> str: + if not model_name: + return "other" + n = model_name.lower() + if "opus" in n: + return "opus" + if "sonnet" in n: + return "sonnet" + if "haiku" in n: + return "haiku" + if "kimi" in n: + return "kimi" + if "gpt" in n: + return "gpt" + if "deepseek" in n: + return "deepseek" + if "qwen" in n: + return "qwen" + if "llama" in n: + return "llama" + return "other" + + +def _turns_bucket(n: int) -> str: + if n < 5: + return "short" + if n <= 20: + return "medium" + return "long" + + +def _cost_bucket(cost_usd: float) -> str: + if cost_usd < 0.10: + return "low" + if cost_usd < 1.0: + return "med" + return "high" + + +def _flavor_to_gpu_tags(flavor: str) -> list[str]: + family = _GPU_FAMILY.get(flavor, "none") + tags = [f"gpu:{family}"] + if any(m in flavor for m in _MULTI_GPU_MARKERS): + tags.append("gpu:multi") + return tags + + +def _has_oom_signal(tool_outputs: Iterable[str]) -> bool: + for out in tool_outputs: + if not isinstance(out, str): + continue + low = out.lower() + if "outofmemoryerror" in low or "cuda out of memory" in low or "oom" in low: + return True + return False + + +def _infer_task_tag( + tool_names: set[str], + hf_job_submit_scripts: list[str], +) -> str | None: + """Return a ``task:*`` tag or None if we can't tell. + + Heuristic order: training > inference > data_prep > research_only. + """ + # training: any hf_jobs script with a Trainer/SFT/training keyword, OR uses + # hf_jobs at all and a script mentions training APIs. + for script in hf_job_submit_scripts: + low = script.lower() + if any( + k in low + for k in ( + "sftconfig", + "sfttrainer", + "trainer(", + "trainingarguments", + "grpo", + "dpo", + ".train(", + "transformers import", + "trainer import", + "fine-tune", + "finetune", + ) + ): + return "training" + + # inference: sessions that use inference tools but never hf_jobs/sandbox + uses_compute = bool(tool_names & {"hf_jobs", "sandbox_create", "sandbox_exec"}) + if not uses_compute and tool_names & {"inference", "generate", "run_inference"}: + return "inference" + + # data_prep: primarily dataset tools and no training/inference + if tool_names & _DATA_PREP_TOOLS and not uses_compute: + return "data_prep" + + # research_only: every tool used is in the research allow-list + if tool_names and tool_names <= _RESEARCH_ONLY_TOOLS: + return "research_only" + + return None + + +def tag_session(trajectory: dict) -> list[str]: + """Derive tags from a session trajectory. Pure function.""" + tags: set[str] = set() + + events: list[dict] = trajectory.get("events") or [] + messages: list[dict] = trajectory.get("messages") or [] + model_name: str | None = trajectory.get("model_name") + + # model + tags.add(f"model:{_model_family(model_name)}") + + # turns + user_turns = sum(1 for m in messages if m.get("role") == "user") + tags.add(f"turns:{_turns_bucket(user_turns)}") + + # cost + tool-name enumeration + outcome detection + cost_usd = 0.0 + tool_names: set[str] = set() + tool_outputs: list[str] = [] + hf_job_submit_count = 0 + hf_job_submit_scripts: list[str] = [] + hf_job_success_count = 0 + hf_job_fail_count = 0 + hf_job_push_to_hub = False + gpu_tags_seen: set[str] = set() + + # Outcome is the *last* terminal signal. Seed with "ongoing" β€” overridden + # if we see a terminal event. + outcome = "ongoing" + had_error = False + had_doom_loop = False + had_compact = False + + feedback_up = 0 + feedback_down = 0 + + sandbox_created = False + sandbox_hardware: str | None = None + sandbox_lifetime_s: int | None = None + + for ev in events: + et = ev.get("event_type") + data = ev.get("data") or {} + + if et == "llm_call": + cost_usd += float(data.get("cost_usd") or 0.0) + + elif et == "tool_call": + name = data.get("tool") + if name: + tool_names.add(name) + + elif et == "tool_output": + out = data.get("output") + if isinstance(out, str): + tool_outputs.append(out) + + elif et == "hf_job_submit": + hf_job_submit_count += 1 + if data.get("push_to_hub"): + hf_job_push_to_hub = True + flavor = data.get("flavor") or "cpu-basic" + for t in _flavor_to_gpu_tags(flavor): + gpu_tags_seen.add(t) + + elif et == "hf_job_complete": + final = (data.get("final_status") or "").lower() + if final in ("completed", "succeeded", "success"): + hf_job_success_count += 1 + elif final in ("failed", "error", "timeout", "cancelled"): + hf_job_fail_count += 1 + + elif et == "sandbox_create": + sandbox_created = True + sandbox_hardware = data.get("hardware") + + elif et == "sandbox_destroy": + lt = data.get("lifetime_s") + if isinstance(lt, (int, float)): + sandbox_lifetime_s = int(lt) + + elif et == "feedback": + rating = data.get("rating") + if rating == "up": + feedback_up += 1 + elif rating == "down": + feedback_down += 1 + + elif et == "error": + had_error = True + elif et == "turn_complete": + if not had_error: + outcome = "completed" + elif et == "interrupted": + outcome = "interrupted" + elif et == "compacted": + had_compact = True + elif et == "tool_log": + log_text = (data.get("log") or "").lower() + if "doom loop" in log_text: + had_doom_loop = True + + if had_error and outcome not in ("completed", "interrupted"): + outcome = "errored" + + tags.add(f"outcome:{outcome}") + if had_doom_loop: + tags.add("outcome:doom_loop") + if had_compact: + tags.add("outcome:context_exceeded") + + # tools + for name in tool_names: + tags.add(f"tool:{name}") + + # hf_jobs facets + if hf_job_submit_count >= 1: + tags.add("hf_job:submitted") + if hf_job_submit_count > 1: + tags.add("hf_job:multi") + if hf_job_success_count > 0: + tags.add("hf_job:succeeded") + if hf_job_fail_count > 0: + tags.add("hf_job:failed") + if hf_job_push_to_hub: + tags.add("hf_job:push_to_hub") + if _has_oom_signal(tool_outputs): + tags.add("hf_job:oom") + + # gpu tags (from all submitted jobs) + tags.update(gpu_tags_seen) + if "gpu:none" in tags and len(gpu_tags_seen) > 1: + # If any GPU flavor was used, drop the "none" tag for clarity. + tags.discard("gpu:none") + + # sandbox facets + if sandbox_created: + tags.add("sandbox:created") + if sandbox_hardware: + fam = _GPU_FAMILY.get(sandbox_hardware, "none") + tags.add("sandbox:cpu" if fam == "none" else "sandbox:gpu") + if sandbox_lifetime_s is not None and sandbox_lifetime_s > 1800: + tags.add("sandbox:long_lived") + + # feedback + if feedback_up and feedback_down: + tags.add("feedback:mixed") + elif feedback_up: + tags.add("feedback:up") + elif feedback_down: + tags.add("feedback:down") + else: + tags.add("feedback:none") + + # cost bucket + tags.add(f"cost:{_cost_bucket(cost_usd)}") + + # task heuristic (needs scripts β€” pull from the hf_job_submit events' + # matching tool_call arguments in the event list). + for ev in events: + if ev.get("event_type") == "tool_call": + data = ev.get("data") or {} + if data.get("tool") == "hf_jobs": + args = data.get("arguments") or {} + script = args.get("script") or args.get("command") or "" + if isinstance(script, str): + hf_job_submit_scripts.append(script) + + task_tag = _infer_task_tag(tool_names, hf_job_submit_scripts) + if task_tag: + tags.add(f"task:{task_tag}") + + return sorted(tags) diff --git a/agent/tools/__init__.py b/agent/tools/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..65c793cbaad3b2f74eacaf1da6038ff0bef893d9 --- /dev/null +++ b/agent/tools/__init__.py @@ -0,0 +1,42 @@ +""" +Hugging Face tools for the agent +""" + +from agent.tools.dataset_tools import ( + HF_INSPECT_DATASET_TOOL_SPEC, + hf_inspect_dataset_handler, +) +from agent.tools.github_find_examples import ( + GITHUB_FIND_EXAMPLES_TOOL_SPEC, + github_find_examples_handler, +) +from agent.tools.github_list_repos import ( + GITHUB_LIST_REPOS_TOOL_SPEC, + github_list_repos_handler, +) +from agent.tools.github_read_file import ( + GITHUB_READ_FILE_TOOL_SPEC, + github_read_file_handler, +) +from agent.tools.jobs_tool import HF_JOBS_TOOL_SPEC, HfJobsTool, hf_jobs_handler +from agent.tools.types import ToolResult +from agent.tools.web_search_tool import WEB_SEARCH_TOOL_SPEC, web_search_handler + +__all__ = [ + "ToolResult", + "HF_JOBS_TOOL_SPEC", + "hf_jobs_handler", + "HfJobsTool", + "GITHUB_FIND_EXAMPLES_TOOL_SPEC", + "github_find_examples_handler", + "GITHUB_LIST_REPOS_TOOL_SPEC", + "github_list_repos_handler", + "GITHUB_READ_FILE_TOOL_SPEC", + "github_read_file_handler", + "GITHUB_SEARCH_CODE_TOOL_SPEC", + "github_search_code_handler", + "HF_INSPECT_DATASET_TOOL_SPEC", + "hf_inspect_dataset_handler", + "WEB_SEARCH_TOOL_SPEC", + "web_search_handler", +] diff --git a/agent/tools/dataset_tools.py b/agent/tools/dataset_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..20add683d40c3b0f550daaae046408d64f23ddbd --- /dev/null +++ b/agent/tools/dataset_tools.py @@ -0,0 +1,441 @@ +""" +Dataset Inspection Tool - Comprehensive dataset analysis in one call + +Combines /is-valid, /splits, /info, /first-rows, and /parquet endpoints +to provide everything needed for ML tasks in a single tool call. +""" + +import asyncio +from typing import Any, TypedDict + +import httpx + +from agent.tools.types import ToolResult + +BASE_URL = "https://datasets-server.huggingface.co" + +# Truncation limit for long sample values in the output +MAX_SAMPLE_VALUE_LEN = 150 + + +class SplitConfig(TypedDict): + """Typed representation of a dataset config and its splits.""" + + name: str + splits: list[str] + + +def _get_headers(token: str | None = None) -> dict: + """Get auth headers for private/gated datasets""" + if token: + return {"Authorization": f"Bearer {token}"} + return {} + + +async def inspect_dataset( + dataset: str, + config: str | None = None, + split: str | None = None, + sample_rows: int = 3, + hf_token: str | None = None, +) -> ToolResult: + """ + Get comprehensive dataset info in one call. + All API calls made in parallel for speed. + """ + headers = _get_headers(hf_token) + output_parts = [] + errors = [] + + async with httpx.AsyncClient(timeout=15, headers=headers) as client: + # Phase 1: Parallel calls for structure info (no dependencies) + is_valid_task = client.get(f"{BASE_URL}/is-valid", params={"dataset": dataset}) + splits_task = client.get(f"{BASE_URL}/splits", params={"dataset": dataset}) + parquet_task = client.get(f"{BASE_URL}/parquet", params={"dataset": dataset}) + + results = await asyncio.gather( + is_valid_task, + splits_task, + parquet_task, + return_exceptions=True, + ) + + # Process is-valid + if not isinstance(results[0], Exception): + try: + output_parts.append(_format_status(results[0].json())) + except Exception as e: + errors.append(f"is-valid: {e}") + + # Process splits and auto-detect config/split + configs = [] + if not isinstance(results[1], Exception): + try: + splits_data = results[1].json() + configs = _extract_configs(splits_data) + if not config: + config = configs[0]["name"] if configs else "default" + if not split: + split = configs[0]["splits"][0] if configs else "train" + output_parts.append(_format_structure(configs)) + except Exception as e: + errors.append(f"splits: {e}") + + if not config: + config = "default" + if not split: + split = "train" + + # Process parquet (will be added at the end) + parquet_section = None + if not isinstance(results[2], Exception): + try: + parquet_section = _format_parquet_files(results[2].json()) + except Exception: + pass # Silently skip if no parquet + + # Phase 2: Parallel calls for content (depend on config/split) + info_task = client.get( + f"{BASE_URL}/info", params={"dataset": dataset, "config": config} + ) + rows_task = client.get( + f"{BASE_URL}/first-rows", + params={"dataset": dataset, "config": config, "split": split}, + timeout=30, + ) + + content_results = await asyncio.gather( + info_task, + rows_task, + return_exceptions=True, + ) + + # Process info (schema) + if not isinstance(content_results[0], Exception): + try: + output_parts.append(_format_schema(content_results[0].json(), config)) + except Exception as e: + errors.append(f"info: {e}") + + # Process sample rows + if not isinstance(content_results[1], Exception): + try: + output_parts.append( + _format_samples( + content_results[1].json(), config, split, sample_rows + ) + ) + except Exception as e: + errors.append(f"rows: {e}") + + # Add parquet section at the end if available + if parquet_section: + output_parts.append(parquet_section) + + # Combine output + formatted = f"# {dataset}\n\n" + "\n\n".join(output_parts) + if errors: + formatted += f"\n\n**Warnings:** {'; '.join(errors)}" + + return { + "formatted": formatted, + "totalResults": 1, + "resultsShared": 1, + "isError": len(output_parts) == 0, + } + + +def _format_status(data: dict) -> str: + """Format /is-valid response as status line""" + available = [ + k + for k in ["viewer", "preview", "search", "filter", "statistics"] + if data.get(k) + ] + if available: + return f"## Status\nβœ“ Valid ({', '.join(available)})" + return "## Status\nβœ— Dataset may have issues" + + +def _extract_configs(splits_data: dict) -> list[SplitConfig]: + """Group splits by config""" + configs: dict[str, SplitConfig] = {} + for s in splits_data.get("splits", []): + cfg = s.get("config", "default") + if cfg not in configs: + configs[cfg] = {"name": cfg, "splits": []} + configs[cfg]["splits"].append(s.get("split")) + return list(configs.values()) + + +def _format_structure(configs: list[SplitConfig], max_rows: int = 10) -> str: + """Format configs and splits as a markdown table.""" + lines = [ + "## Structure (configs & splits)", + "| Config | Split |", + "|--------|-------|", + ] + + total_splits = sum(len(cfg["splits"]) for cfg in configs) + added_rows = 0 + + for cfg in configs: + for split_name in cfg["splits"]: + if added_rows >= max_rows: + break + lines.append(f"| {cfg['name']} | {split_name} |") + added_rows += 1 + if added_rows >= max_rows: + break + + if total_splits > added_rows: + lines.append( + f"| ... | ... | (_showing {added_rows} of {total_splits} config/split rows_) |" + ) + + return "\n".join(lines) + + +def _format_schema(info: dict, config: str) -> str: + """Extract features and format as table""" + features = info.get("dataset_info", {}).get("features", {}) + lines = [f"## Schema ({config})", "| Column | Type |", "|--------|------|"] + for col_name, col_info in features.items(): + col_type = _get_type_str(col_info) + lines.append(f"| {col_name} | {col_type} |") + return "\n".join(lines) + + +def _get_type_str(col_info: dict) -> str: + """Convert feature info to readable type string""" + dtype = col_info.get("dtype") or col_info.get("_type", "unknown") + if col_info.get("_type") == "ClassLabel": + names = col_info.get("names", []) + if names and len(names) <= 5: + return f"ClassLabel ({', '.join(f'{n}={i}' for i, n in enumerate(names))})" + return f"ClassLabel ({len(names)} classes)" + return str(dtype) + + +def _format_samples(rows_data: dict, config: str, split: str, limit: int) -> str: + """Format sample rows, truncate long values""" + rows = rows_data.get("rows", [])[:limit] + lines = [f"## Sample Rows ({config}/{split})"] + + messages_col_data = None + + for i, row_wrapper in enumerate(rows, 1): + row = row_wrapper.get("row", {}) + lines.append(f"**Row {i}:**") + for key, val in row.items(): + # Check for messages column and capture first one for format analysis + if key.lower() == "messages" and messages_col_data is None: + messages_col_data = val + + val_str = str(val) + if len(val_str) > MAX_SAMPLE_VALUE_LEN: + val_str = val_str[:MAX_SAMPLE_VALUE_LEN] + "..." + lines.append(f"- {key}: {val_str}") + + # If we found a messages column, add format analysis + if messages_col_data is not None: + messages_format = _format_messages_structure(messages_col_data) + if messages_format: + lines.append("") + lines.append(messages_format) + + return "\n".join(lines) + + +def _format_messages_structure(messages_data: Any) -> str | None: + """ + Analyze and format the structure of a messages column. + Common in chat/instruction datasets. + """ + import json + + # Parse if string + if isinstance(messages_data, str): + try: + messages_data = json.loads(messages_data) + except json.JSONDecodeError: + return None + + if not isinstance(messages_data, list) or not messages_data: + return None + + lines = ["## Messages Column Format"] + + # Analyze message structure + roles_seen = set() + has_tool_calls = False + has_tool_results = False + message_keys = set() + + for msg in messages_data: + if not isinstance(msg, dict): + continue + + message_keys.update(msg.keys()) + + role = msg.get("role", "") + if role: + roles_seen.add(role) + + if "tool_calls" in msg or "function_call" in msg: + has_tool_calls = True + if role in ("tool", "function") or msg.get("tool_call_id"): + has_tool_results = True + + # Format the analysis + lines.append( + f"**Roles:** {', '.join(sorted(roles_seen)) if roles_seen else 'unknown'}" + ) + + # Show common message keys with presence indicators + common_keys = [ + "role", + "content", + "tool_calls", + "tool_call_id", + "name", + "function_call", + ] + key_status = [] + for key in common_keys: + if key in message_keys: + key_status.append(f"{key} βœ“") + else: + key_status.append(f"{key} βœ—") + lines.append(f"**Message keys:** {', '.join(key_status)}") + + if has_tool_calls: + lines.append("**Tool calls:** βœ“ Present") + if has_tool_results: + lines.append("**Tool results:** βœ“ Present") + + # Show example message structure + # Priority: 1) message with tool_calls, 2) first assistant message, 3) first non-system message + example = None + fallback = None + for msg in messages_data: + if not isinstance(msg, dict): + continue + role = msg.get("role", "") + # Check for actual tool_calls/function_call values (not None) + if msg.get("tool_calls") or msg.get("function_call"): + example = msg + break + if role == "assistant" and example is None: + example = msg + elif role != "system" and fallback is None: + fallback = msg + if example is None: + example = fallback + + if example: + lines.append("") + lines.append("**Example message structure:**") + # Build a copy with truncated content but keep all keys + example_clean = {} + for key, val in example.items(): + if key == "content" and isinstance(val, str) and len(val) > 100: + example_clean[key] = val[:100] + "..." + else: + example_clean[key] = val + lines.append("```json") + lines.append(json.dumps(example_clean, indent=2, ensure_ascii=False)) + lines.append("```") + + return "\n".join(lines) + + +def _format_parquet_files(data: dict, max_rows: int = 10) -> str | None: + """Format parquet file info, return None if no files.""" + files = data.get("parquet_files", []) + if not files: + return None + + # Group by config/split + groups: dict[str, dict] = {} + for f in files: + key = f"{f.get('config', 'default')}/{f.get('split', 'train')}" + if key not in groups: + groups[key] = {"count": 0, "size": 0} + size = f.get("size") or 0 + if not isinstance(size, (int, float)): + size = 0 + groups[key]["count"] += 1 + groups[key]["size"] += int(size) + + lines = ["## Files (Parquet)"] + items = list(groups.items()) + total_groups = len(items) + + shown = 0 + for key, info in items[:max_rows]: + size_mb = info["size"] / (1024 * 1024) + lines.append(f"- {key}: {info['count']} file(s) ({size_mb:.1f} MB)") + shown += 1 + + if total_groups > shown: + lines.append(f"- ... (_showing {shown} of {total_groups} parquet groups_)") + return "\n".join(lines) + + +# Tool specification +HF_INSPECT_DATASET_TOOL_SPEC = { + "name": "hf_inspect_dataset", + "description": ( + "Inspect a HF dataset in one call: status, configs/splits, schema, sample rows, parquet info.\n\n" + "REQUIRED before any training job to verify dataset format matches training method:\n" + " SFT: needs 'messages', 'text', or 'prompt'/'completion'\n" + " DPO: needs 'prompt', 'chosen', 'rejected'\n" + " GRPO: needs 'prompt'\n" + "All datasets used for training have to be in conversational ChatML format to be compatible with HF libraries.'\n" + "Training will fail with KeyError if columns don't match.\n\n" + "Also use to get example datapoints, understand column names, data types, and available splits before writing any data loading code. " + "Supports private/gated datasets when HF_TOKEN is set." + ), + "parameters": { + "type": "object", + "properties": { + "dataset": { + "type": "string", + "description": "Dataset ID in 'org/name' format (e.g., 'stanfordnlp/imdb')", + }, + "config": { + "type": "string", + "description": "Config/subset name. Auto-detected if not specified.", + }, + "split": { + "type": "string", + "description": "Split for sample rows. Auto-detected if not specified.", + }, + "sample_rows": { + "type": "integer", + "description": "Number of sample rows to show (default: 3, max: 10)", + "default": 3, + }, + }, + "required": ["dataset"], + }, +} + + +async def hf_inspect_dataset_handler( + arguments: dict[str, Any], session=None +) -> tuple[str, bool]: + """Handler for agent tool router""" + try: + hf_token = session.hf_token if session else None + result = await inspect_dataset( + dataset=arguments["dataset"], + config=arguments.get("config"), + split=arguments.get("split"), + sample_rows=min(arguments.get("sample_rows", 3), 10), + hf_token=hf_token, + ) + return result["formatted"], not result.get("isError", False) + except Exception as e: + return f"Error inspecting dataset: {str(e)}", False diff --git a/agent/tools/docs_tools.py b/agent/tools/docs_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..ee40ef353ae05b8d32d4c9a17bd0d9eaa8687532 --- /dev/null +++ b/agent/tools/docs_tools.py @@ -0,0 +1,979 @@ +""" +Documentation search tools for exploring HuggingFace and Gradio documentation. +""" + +import asyncio +import json +from typing import Any + +import httpx +from bs4 import BeautifulSoup +from whoosh.analysis import StemmingAnalyzer +from whoosh.fields import ID, TEXT, Schema +from whoosh.filedb.filestore import RamStorage +from whoosh.qparser import MultifieldParser, OrGroup + +# --------------------------------------------------------------------------- +# Configuration +# --------------------------------------------------------------------------- + +DEFAULT_MAX_RESULTS = 20 +MAX_RESULTS_CAP = 50 + +GRADIO_LLMS_TXT_URL = "https://gradio.app/llms.txt" +GRADIO_SEARCH_URL = "https://playground-worker.pages.dev/api/prompt" + +COMPOSITE_ENDPOINTS: dict[str, list[str]] = { + "optimum": [ + "optimum", + "optimum-habana", + "optimum-neuron", + "optimum-intel", + "optimum-executorch", + "optimum-tpu", + ], + "courses": [ + "llm-course", + "robotics-course", + "mcp-course", + "smol-course", + "agents-course", + "deep-rl-course", + "computer-vision-course", + "audio-course", + "ml-games-course", + "diffusion-course", + "ml-for-3d-course", + "cookbook", + ], +} + +# --------------------------------------------------------------------------- +# Caches +# --------------------------------------------------------------------------- + +_docs_cache: dict[str, list[dict[str, str]]] = {} +_index_cache: dict[str, tuple[Any, MultifieldParser]] = {} +_cache_lock = asyncio.Lock() +_openapi_cache: dict[str, Any] | None = None +_openapi_index_cache: tuple[Any, MultifieldParser, list[dict[str, Any]]] | None = None + +# --------------------------------------------------------------------------- +# Gradio Documentation +# --------------------------------------------------------------------------- + + +async def _fetch_gradio_docs(query: str | None = None) -> str: + """ + Fetch Gradio documentation. + Without query: Get full documentation from llms.txt + With query: Run embedding search on guides/demos for relevant content + """ + async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client: + if not query: + resp = await client.get(GRADIO_LLMS_TXT_URL) + resp.raise_for_status() + return resp.text + + resp = await client.post( + GRADIO_SEARCH_URL, + headers={ + "Content-Type": "application/json", + "Origin": "https://gradio-docs-mcp.up.railway.app", + }, + json={ + "prompt_to_embed": query, + "SYSTEM_PROMPT": "$INSERT_GUIDES_DOCS_DEMOS", + "FALLBACK_PROMPT": "No results found", + }, + ) + resp.raise_for_status() + return resp.json().get("SYS_PROMPT", "No results found") + + +# --------------------------------------------------------------------------- +# HF Documentation - Fetching +# --------------------------------------------------------------------------- + + +async def _fetch_endpoint_docs(hf_token: str, endpoint: str) -> list[dict[str, str]]: + """Fetch all docs for an endpoint by parsing sidebar and fetching each page.""" + url = f"https://huggingface.co/docs/{endpoint}" + headers = {"Authorization": f"Bearer {hf_token}"} + + async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client: + resp = await client.get(url, headers=headers) + resp.raise_for_status() + + soup = BeautifulSoup(resp.text, "html.parser") + sidebar = soup.find("nav", class_=lambda x: x and "flex-auto" in x) + if not sidebar: + raise ValueError(f"Could not find navigation sidebar for '{endpoint}'") + + nav_items = [] + for link in sidebar.find_all("a", href=True): + href = link["href"] + page_url = f"https://huggingface.co{href}" if href.startswith("/") else href + nav_items.append({"title": link.get_text(strip=True), "url": page_url}) + + if not nav_items: + raise ValueError(f"No navigation links found for '{endpoint}'") + + async def fetch_page(item: dict[str, str]) -> dict[str, str]: + md_url = f"{item['url']}.md" + try: + r = await client.get(md_url, headers=headers) + r.raise_for_status() + content = r.text.strip() + glimpse = content[:200] + "..." if len(content) > 200 else content + except Exception as e: + content, glimpse = "", f"[Could not fetch: {str(e)[:50]}]" + return { + "title": item["title"], + "url": item["url"], + "md_url": md_url, + "glimpse": glimpse, + "content": content, + "section": endpoint, + } + + return list(await asyncio.gather(*[fetch_page(item) for item in nav_items])) + + +async def _get_docs(hf_token: str, endpoint: str) -> list[dict[str, str]]: + """Get docs for endpoint with caching. Expands composite endpoints.""" + async with _cache_lock: + if endpoint in _docs_cache: + return _docs_cache[endpoint] + + sub_endpoints = COMPOSITE_ENDPOINTS.get(endpoint, [endpoint]) + all_docs: list[dict[str, str]] = [] + + for sub in sub_endpoints: + async with _cache_lock: + if sub in _docs_cache: + all_docs.extend(_docs_cache[sub]) + continue + + docs = await _fetch_endpoint_docs(hf_token, sub) + async with _cache_lock: + _docs_cache[sub] = docs + all_docs.extend(docs) + + async with _cache_lock: + _docs_cache[endpoint] = all_docs + return all_docs + + +# --------------------------------------------------------------------------- +# HF Documentation - Search +# --------------------------------------------------------------------------- + + +async def _build_search_index( + endpoint: str, docs: list[dict[str, str]] +) -> tuple[Any, MultifieldParser]: + """Build or retrieve cached Whoosh search index.""" + async with _cache_lock: + if endpoint in _index_cache: + return _index_cache[endpoint] + + analyzer = StemmingAnalyzer() + schema = Schema( + title=TEXT(stored=True, analyzer=analyzer), + url=ID(stored=True, unique=True), + md_url=ID(stored=True), + section=ID(stored=True), + glimpse=TEXT(stored=True, analyzer=analyzer), + content=TEXT(stored=False, analyzer=analyzer), + ) + storage = RamStorage() + index = storage.create_index(schema) + writer = index.writer() + for doc in docs: + writer.add_document( + title=doc.get("title", ""), + url=doc.get("url", ""), + md_url=doc.get("md_url", ""), + section=doc.get("section", endpoint), + glimpse=doc.get("glimpse", ""), + content=doc.get("content", ""), + ) + writer.commit() + + parser = MultifieldParser( + ["title", "content"], + schema=schema, + fieldboosts={"title": 2.0, "content": 1.0}, + group=OrGroup, + ) + + async with _cache_lock: + _index_cache[endpoint] = (index, parser) + return index, parser + + +async def _search_docs( + endpoint: str, docs: list[dict[str, str]], query: str, limit: int +) -> tuple[list[dict[str, Any]], str | None]: + """Search docs using Whoosh. Returns (results, fallback_message).""" + index, parser = await _build_search_index(endpoint, docs) + + try: + query_obj = parser.parse(query) + except Exception: + return [], "Query contained unsupported syntax; showing default ordering." + + with index.searcher() as searcher: + results = searcher.search(query_obj, limit=limit) + matches = [ + { + "title": hit["title"], + "url": hit["url"], + "md_url": hit.get("md_url", ""), + "section": hit.get("section", endpoint), + "glimpse": hit["glimpse"], + "score": round(hit.score, 2), + } + for hit in results + ] + + if not matches: + return [], "No strong matches found; showing default ordering." + return matches, None + + +# --------------------------------------------------------------------------- +# HF Documentation - Formatting +# --------------------------------------------------------------------------- + + +def _format_results( + endpoint: str, + items: list[dict[str, Any]], + total: int, + query: str | None = None, + note: str | None = None, +) -> str: + """Format search results as readable text.""" + base_url = f"https://huggingface.co/docs/{endpoint}" + out = f"Documentation structure for: {base_url}\n\n" + + if query: + out += f"Query: '{query}' β†’ showing {len(items)} result(s) out of {total} pages" + if note: + out += f" ({note})" + out += "\n\n" + else: + out += f"Found {len(items)} page(s) (total available: {total}).\n" + if note: + out += f"({note})\n" + out += "\n" + + for i, item in enumerate(items, 1): + out += f"{i}. **{item['title']}**\n" + out += f" URL: {item['url']}\n" + out += f" Section: {item.get('section', endpoint)}\n" + if query and "score" in item: + out += f" Relevance score: {item['score']:.2f}\n" + out += f" Glimpse: {item['glimpse']}\n\n" + + return out + + +# --------------------------------------------------------------------------- +# Handlers +# --------------------------------------------------------------------------- + + +async def explore_hf_docs_handler( + arguments: dict[str, Any], session=None +) -> tuple[str, bool]: + """Explore documentation structure with optional search query.""" + endpoint = arguments.get("endpoint", "").lstrip("/") + query = arguments.get("query") + max_results = arguments.get("max_results") + + if not endpoint: + return "Error: No endpoint provided", False + + # Gradio uses its own API + if endpoint.lower() == "gradio": + try: + clean_query = ( + query.strip() if isinstance(query, str) and query.strip() else None + ) + content = await _fetch_gradio_docs(clean_query) + header = "# Gradio Documentation\n\n" + if clean_query: + header += f"Query: '{clean_query}'\n\n" + header += "Source: https://gradio.app/docs\n\n---\n\n" + return header + content, True + except httpx.HTTPStatusError as e: + return f"HTTP error fetching Gradio docs: {e.response.status_code}", False + except httpx.RequestError as e: + return f"Request error fetching Gradio docs: {str(e)}", False + except Exception as e: + return f"Error fetching Gradio docs: {str(e)}", False + + # HF docs + hf_token = session.hf_token if session else None + if not hf_token: + return "Error: No HF token available (not logged in)", False + + try: + max_results_int = int(max_results) if max_results is not None else None + except (TypeError, ValueError): + return "Error: max_results must be an integer", False + + if max_results_int is not None and max_results_int <= 0: + return "Error: max_results must be greater than zero", False + + try: + docs = await _get_docs(hf_token, endpoint) + total = len(docs) + + # Determine limit + if max_results_int is None: + limit = DEFAULT_MAX_RESULTS + limit_note = f"Showing top {DEFAULT_MAX_RESULTS} results (set max_results to adjust)." + elif max_results_int > MAX_RESULTS_CAP: + limit = MAX_RESULTS_CAP + limit_note = f"Requested {max_results_int} but showing top {MAX_RESULTS_CAP} (maximum)." + else: + limit = max_results_int + limit_note = None + + # Search or paginate + clean_query = ( + query.strip() if isinstance(query, str) and query.strip() else None + ) + fallback_msg = None + + if clean_query: + results, fallback_msg = await _search_docs( + endpoint, docs, clean_query, limit + ) + if not results: + results = docs[:limit] + else: + results = docs[:limit] + + # Combine notes + notes = [] + if fallback_msg: + notes.append(fallback_msg) + if limit_note: + notes.append(limit_note) + note = "; ".join(notes) if notes else None + + return _format_results(endpoint, results, total, clean_query, note), True + + except httpx.HTTPStatusError as e: + return f"HTTP error: {e.response.status_code} - {e.response.text[:200]}", False + except httpx.RequestError as e: + return f"Request error: {str(e)}", False + except ValueError as e: + return f"Error: {str(e)}", False + except Exception as e: + return f"Unexpected error: {str(e)}", False + + +async def hf_docs_fetch_handler( + arguments: dict[str, Any], session=None +) -> tuple[str, bool]: + """Fetch full markdown content of a documentation page.""" + url = arguments.get("url", "") + if not url: + return "Error: No URL provided", False + + hf_token = session.hf_token if session else None + if not hf_token: + return "Error: No HF token available (not logged in)", False + + if not url.endswith(".md"): + url = f"{url}.md" + + try: + async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client: + resp = await client.get( + url, headers={"Authorization": f"Bearer {hf_token}"} + ) + resp.raise_for_status() + return f"Documentation from: {url}\n\n{resp.text}", True + except httpx.HTTPStatusError as e: + return ( + f"HTTP error fetching {url}: {e.response.status_code} - {e.response.text[:200]}", + False, + ) + except httpx.RequestError as e: + return f"Request error fetching {url}: {str(e)}", False + except Exception as e: + return f"Error fetching documentation: {str(e)}", False + + +# --------------------------------------------------------------------------- +# OpenAPI Search +# --------------------------------------------------------------------------- + + +async def _fetch_openapi_spec() -> dict[str, Any]: + """Fetch and cache HuggingFace OpenAPI specification.""" + global _openapi_cache + if _openapi_cache is not None: + return _openapi_cache + + async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client: + resp = await client.get("https://huggingface.co/.well-known/openapi.json") + resp.raise_for_status() + + _openapi_cache = resp.json() + return _openapi_cache + + +def _extract_all_tags(spec: dict[str, Any]) -> list[str]: + """Extract all unique tags from OpenAPI spec.""" + tags = set() + for tag_obj in spec.get("tags", []): + if "name" in tag_obj: + tags.add(tag_obj["name"]) + for path_item in spec.get("paths", {}).values(): + for method, op in path_item.items(): + if method in ["get", "post", "put", "delete", "patch", "head", "options"]: + for tag in op.get("tags", []): + tags.add(tag) + return sorted(tags) + + +def _extract_all_endpoints(spec: dict[str, Any]) -> list[dict[str, Any]]: + """Extract all endpoints from OpenAPI spec.""" + servers = spec.get("servers", []) + base_url = ( + servers[0].get("url", "https://huggingface.co") + if servers + else "https://huggingface.co" + ) + + endpoints = [] + for path, path_item in spec.get("paths", {}).items(): + for method, op in path_item.items(): + if method not in [ + "get", + "post", + "put", + "delete", + "patch", + "head", + "options", + ]: + continue + endpoints.append( + { + "path": path, + "method": method.upper(), + "operationId": op.get("operationId", ""), + "summary": op.get("summary", ""), + "description": op.get("description", ""), + "tags": " ".join(op.get("tags", [])), + "parameters": op.get("parameters", []), + "request_body": op.get("requestBody", {}), + "responses": op.get("responses", {}), + "base_url": base_url, + } + ) + return endpoints + + +async def _build_openapi_index() -> tuple[Any, MultifieldParser, list[dict[str, Any]]]: + """Build or retrieve cached Whoosh index for OpenAPI endpoints.""" + global _openapi_index_cache + async with _cache_lock: + if _openapi_index_cache is not None: + return _openapi_index_cache + + spec = await _fetch_openapi_spec() + endpoints = _extract_all_endpoints(spec) + + analyzer = StemmingAnalyzer() + schema = Schema( + path=ID(stored=True, unique=True), + method=ID(stored=True), + operationId=TEXT(stored=True, analyzer=analyzer), + summary=TEXT(stored=True, analyzer=analyzer), + description=TEXT(stored=True, analyzer=analyzer), + tags=TEXT(stored=True, analyzer=analyzer), + param_names=TEXT(stored=False, analyzer=analyzer), + ) + storage = RamStorage() + index = storage.create_index(schema) + writer = index.writer() + + for ep in endpoints: + param_names = " ".join(p.get("name", "") for p in ep.get("parameters", [])) + writer.add_document( + path=ep["path"], + method=ep["method"], + operationId=ep.get("operationId", ""), + summary=ep.get("summary", ""), + description=ep.get("description", ""), + tags=ep.get("tags", ""), + param_names=param_names, + ) + writer.commit() + + parser = MultifieldParser( + ["summary", "description", "operationId", "tags", "param_names"], + schema=schema, + fieldboosts={ + "summary": 3.0, + "operationId": 2.0, + "description": 1.0, + "tags": 1.5, + }, + group=OrGroup, + ) + + async with _cache_lock: + _openapi_index_cache = (index, parser, endpoints) + return index, parser, endpoints + + +async def _search_openapi( + query: str, tag: str | None, limit: int = 20 +) -> tuple[list[dict[str, Any]], str | None]: + """Search OpenAPI endpoints using Whoosh. Returns (results, fallback_message).""" + index, parser, endpoints = await _build_openapi_index() + + try: + query_obj = parser.parse(query) + except Exception: + return [], "Query contained unsupported syntax." + + with index.searcher() as searcher: + results = searcher.search( + query_obj, limit=limit * 2 + ) # Get extra for tag filtering + matches = [] + for hit in results: + # Find full endpoint data + ep = next( + ( + e + for e in endpoints + if e["path"] == hit["path"] and e["method"] == hit["method"] + ), + None, + ) + if ep is None: + continue + # Filter by tag if provided + if tag and tag not in ep.get("tags", ""): + continue + matches.append({**ep, "score": round(hit.score, 2)}) + if len(matches) >= limit: + break + + return matches, None if matches else "No matches found for query." + + +def _generate_curl_example(endpoint: dict[str, Any]) -> str: + """Generate curl command example for an endpoint.""" + method = endpoint["method"] + path = endpoint["path"] + base_url = endpoint["base_url"] + + # Build URL with path parameters + full_path = path + for param in endpoint.get("parameters", []): + if param.get("in") == "path" and param.get("required"): + name = param["name"] + example = param.get( + "example", param.get("schema", {}).get("example", f"<{name}>") + ) + full_path = full_path.replace(f"{{{name}}}", str(example)) + + curl = f"curl -X {method} \\\n '{base_url}{full_path}'" + + # Add query parameters + query_params = [p for p in endpoint.get("parameters", []) if p.get("in") == "query"] + if query_params and query_params[0].get("required"): + param = query_params[0] + example = param.get("example", param.get("schema", {}).get("example", "value")) + curl += f"?{param['name']}={example}" + + curl += " \\\n -H 'Authorization: Bearer $HF_TOKEN'" + + # Add request body + if method in ["POST", "PUT", "PATCH"] and endpoint.get("request_body"): + content = endpoint["request_body"].get("content", {}) + if "application/json" in content: + curl += " \\\n -H 'Content-Type: application/json'" + schema = content["application/json"].get("schema", {}) + example = schema.get("example", "{}") + if isinstance(example, dict): + example = json.dumps(example, indent=2) + curl += f" \\\n -d '{example}'" + + return curl + + +def _format_parameters(parameters: list[dict[str, Any]]) -> str: + """Format parameter information from OpenAPI spec.""" + if not parameters: + return "" + + path_params = [p for p in parameters if p.get("in") == "path"] + query_params = [p for p in parameters if p.get("in") == "query"] + header_params = [p for p in parameters if p.get("in") == "header"] + + output = [] + + for label, params in [ + ("Path Parameters", path_params), + ("Query Parameters", query_params), + ("Header Parameters", header_params), + ]: + if not params: + continue + if output: + output.append("") + output.append(f"**{label}:**") + for p in params: + name = p.get("name", "") + required = " (required)" if p.get("required") else " (optional)" + desc = p.get("description", "") + ptype = p.get("schema", {}).get("type", "string") + example = p.get("example") or p.get("schema", {}).get("example", "") + + output.append(f"- `{name}` ({ptype}){required}: {desc}") + if example: + output.append(f" Example: `{example}`") + + return "\n".join(output) + + +def _format_response_info(responses: dict[str, Any]) -> str: + """Format response information from OpenAPI spec.""" + if not responses: + return "No response information available" + + output = [] + for status, resp_obj in list(responses.items())[:3]: + desc = resp_obj.get("description", "") + output.append(f"- **{status}**: {desc}") + content = resp_obj.get("content", {}) + if "application/json" in content: + schema = content["application/json"].get("schema", {}) + if "type" in schema: + output.append(f" Returns: {schema.get('type', 'object')}") + + return "\n".join(output) + + +def _format_openapi_results( + results: list[dict[str, Any]], + tag: str | None = None, + query: str | None = None, + note: str | None = None, +) -> str: + """Format OpenAPI search results with curl examples.""" + if not results: + if query and tag: + return f"No API endpoints found matching '{query}' in tag '{tag}'" + elif query: + return f"No API endpoints found matching '{query}'" + elif tag: + return f"No API endpoints found with tag '{tag}'" + return "No API endpoints found" + + # Build header + if query and tag: + out = f"# API Endpoints matching '{query}' (tag: `{tag}`)\n\n" + elif query: + out = f"# API Endpoints matching '{query}'\n\n" + elif tag: + out = f"# API Endpoints for tag: `{tag}`\n\n" + else: + out = "# API Endpoints\n\n" + + out += f"Found {len(results)} endpoint(s)" + if note: + out += f" ({note})" + out += "\n\n---\n\n" + + for i, ep in enumerate(results, 1): + out += f"## {i}. {ep['method']} {ep['path']}\n\n" + + if query and "score" in ep: + out += f"**Relevance:** {ep['score']:.2f}\n\n" + + if ep.get("summary"): + out += f"**Summary:** {ep['summary']}\n\n" + + if ep.get("description"): + desc = ep["description"][:300] + if len(ep["description"]) > 300: + desc += "..." + out += f"**Description:** {desc}\n\n" + + if ep.get("tags"): + out += f"**Tags:** {ep['tags']}\n\n" + + params_info = _format_parameters(ep.get("parameters", [])) + if params_info: + out += params_info + "\n\n" + + out += "**Usage:**\n```bash\n" + out += _generate_curl_example(ep) + out += "\n```\n\n" + + out += "**Returns:**\n" + out += _format_response_info(ep["responses"]) + out += "\n\n---\n\n" + + return out + + +async def search_openapi_handler(arguments: dict[str, Any]) -> tuple[str, bool]: + """Search HuggingFace OpenAPI specification by query and/or tag.""" + tag = arguments.get("tag", "").strip() or None + query = arguments.get("query", "").strip() or None + + if not tag and not query: + return ( + "Error: Provide either 'query' (keyword search) or 'tag' (category filter), or both.", + False, + ) + + try: + note = None + + # If query provided, try Whoosh search first + if query: + results, search_note = await _search_openapi(query, tag, limit=20) + + # If Whoosh found results, return them + if results: + return _format_openapi_results( + results, tag=tag, query=query, note=search_note + ), True + + # Whoosh found nothing - fall back to tag-based if tag provided + if tag: + note = f"No matches for '{query}'; showing all endpoints in tag '{tag}'" + else: + # No tag to fall back to + return _format_openapi_results([], query=query), True + + # Tag-based search (either as fallback or primary) + if tag: + _, _, endpoints = await _build_openapi_index() + results = [ep for ep in endpoints if tag in ep.get("tags", "")] + return _format_openapi_results( + results, tag=tag, query=None, note=note + ), True + + return "Error: No results found", False + + except httpx.HTTPStatusError as e: + return f"HTTP error fetching OpenAPI spec: {e.response.status_code}", False + except httpx.RequestError as e: + return f"Request error: {str(e)}", False + except Exception as e: + return f"Error searching OpenAPI spec: {str(e)}", False + + +async def _get_api_search_tool_spec() -> dict[str, Any]: + """Generate OpenAPI tool spec with tags populated at runtime.""" + spec = await _fetch_openapi_spec() + tags = _extract_all_tags(spec) + + return { + "name": "find_hf_api", + "description": ( + "Find HuggingFace Hub REST API endpoints to make HTTP requests. Returns curl examples with authentication. " + "⚠️ USE THIS TOOL when you need to call the HF Hub API directly - for operations like: " + "uploading/downloading files, managing repos, listing models/datasets, getting user info, " + "managing webhooks, collections, discussions, or any Hub interaction not covered by other tools. " + "**Use cases:** (1) 'Stream Space logs' β†’ query='space logs', " + "(2) 'Get Space metrics/Zero-GPU usage' β†’ query='space metrics', " + "(3) 'List organization members' β†’ query='organization members', " + "(4) 'Generate repo access token' β†’ query='jwt token', " + "(5) 'Check repo security scan' β†’ query='security scan'. " + "**Search modes:** Use 'query' for keyword search, 'tag' to browse a category, or both. " + "If query finds no results, falls back to showing all endpoints in the tag. " + "**Output:** Full endpoint details with method, path, parameters, curl command, and response schema." + ), + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": ( + "Keyword search across endpoint summaries, descriptions, and operation IDs. " + "Examples: 'upload file', 'create repository', 'list user models', 'delete branch', " + "'webhook', 'collection', 'discussion comments'. Supports stemming (upload/uploading both work)." + ), + }, + "tag": { + "type": "string", + "enum": tags, + "description": ( + "Filter by API category. Use alone to browse all endpoints in a category, " + "or combine with 'query' to search within a category." + ), + }, + }, + "required": [], + }, + } + + +# --------------------------------------------------------------------------- +# Tool Specifications +# --------------------------------------------------------------------------- + +DOC_ENDPOINTS = [ + "hub", + "transformers", + "diffusers", + "datasets", + "gradio", + "trackio", + "smolagents", + "huggingface_hub", + "huggingface.js", + "transformers.js", + "inference-providers", + "inference-endpoints", + "peft", + "accelerate", + "optimum", + "tokenizers", + "courses", + "evaluate", + "tasks", + "dataset-viewer", + "trl", + "simulate", + "sagemaker", + "timm", + "safetensors", + "tgi", + "setfit", + "lerobot", + "autotrain", + "tei", + "bitsandbytes", + "sentence_transformers", + "chat-ui", + "leaderboards", + "lighteval", + "argilla", + "distilabel", + "microsoft-azure", + "kernels", + "google-cloud", +] + +EXPLORE_HF_DOCS_TOOL_SPEC = { + "name": "explore_hf_docs", + "description": ( + "Browse HF documentation structure β€” discover all available documentation with 200-char previews.\n\n" + "Use this to find relevant documentation and/or examples with detailed parameter docs and API reference. " + "To be used together with github_find_examples and github_read_file to find working examples and documentation.\n\n" + "Pattern: explore_hf_docs (find relevant pages) β†’ fetch_hf_docs (get full content).\n\n" + "For training tasks: fetch the trainer config docs (SFTConfig, DPOConfig, GRPOConfig) to verify parameter names. " + "Returns top 20 results by default; set max_results (max 50) to adjust." + ), + "parameters": { + "type": "object", + "properties": { + "endpoint": { + "type": "string", + "enum": DOC_ENDPOINTS, + "description": ( + "The documentation endpoint to explore. Each endpoint corresponds to a major section of the Hugging Face documentation:\n\n" + "β€’ courses β€” All Hugging Face courses (LLM, robotics, MCP, smol (llm training), agents, deep RL, computer vision, games, diffusion, 3D, audio) and the cookbook recipes. Probably the best place for examples.\n" + "β€’ hub β€” Find answers to questions about models/datasets/spaces, auth, versioning, metadata.\n" + "β€’ transformers β€” Core model library: architectures, configs, tokenizers, training & inference APIs.\n" + "β€’ diffusers β€” Diffusion pipelines, schedulers, fine-tuning, training, and deployment patterns.\n" + "β€’ datasets β€” Dataset loading, streaming, processing, Arrow format, Hub integration.\n" + "β€’ gradio β€” UI components and demos for ML models. Uses Gradio's native API: without query returns full docs (llms.txt), with query uses embedding search for precise results.\n" + "β€’ trackio β€” Experiment tracking, metrics logging, and run comparison.\n" + "β€’ smolagents β€” Lightweight agent abstractions and tool-using patterns.\n" + "β€’ huggingface_hub β€” Python client for Hub operations (auth, upload/download, repo management).\n" + "β€’ huggingface.js β€” JS/TS client for Hub APIs in browser and Node.\n" + "β€’ transformers.js β€” Run Transformer models in browser/Node via WebGPU/WASM.\n" + "β€’ inference-providers β€” Unified interface for third-party inference backends.\n" + "β€’ inference-endpoints β€” Managed, scalable model deployments on HF infrastructure.\n" + "β€’ peft β€” Parameter-efficient fine-tuning methods (LoRA, adapters, etc.).\n" + "β€’ accelerate β€” Hardware-agnostic, distributed and mixed-precision training orchestration.\n" + "β€’ optimum β€” Hardware-aware optimization and model export tooling, including Habana, Neuron, Intel, ExecuTorch, and TPU variants.\n" + "β€’ tokenizers β€” Fast tokenizer internals, training, and low-level APIs.\n" + "β€’ evaluate β€” Metrics, evaluation workflows, and training-loop integration.\n" + "β€’ tasks β€” Canonical task definitions and model categorization.\n" + "β€’ dataset-viewer β€” Dataset preview, streaming views, and viewer internals.\n" + "β€’ trl β€” RLHF, DPO, PPO, and SFT utilities for LLMs.\n" + "β€’ simulate β€” Experimental simulation tools and workflows.\n" + "β€’ sagemaker β€” Deploying Hugging Face models on AWS SageMaker.\n" + "β€’ timm β€” Image model zoo and utilities via HF integrations.\n" + "β€’ safetensors β€” Safe, fast tensor serialization format.\n" + "β€’ tgi β€” High-throughput text generation server for LLMs.\n" + "β€’ setfit β€” Few-shot text classification via sentence embeddings.\n" + "β€’ lerobot β€” Robotics datasets, policies, and learning workflows.\n" + "β€’ autotrain β€” No/low-code model training on Hugging Face.\n" + "β€’ tei β€” Optimized inference server for embedding workloads.\n" + "β€’ bitsandbytes β€” Quantization and memory-efficient optimizers.\n" + "β€’ sentence_transformers β€” Embedding models, training recipes, similarity/search workflows.\n" + "β€’ chat-ui β€” Reference chat interfaces for LLM deployment.\n" + "β€’ leaderboards β€” Evaluation leaderboards and submission mechanics.\n" + "β€’ lighteval β€” Lightweight, reproducible LLM evaluation framework.\n" + "β€’ argilla β€” Data annotation, feedback, and human-in-the-loop workflows.\n" + "β€’ distilabel β€” Synthetic data generation and distillation pipelines.\n" + "β€’ microsoft-azure β€” Azure deployment and integration guides.\n" + "β€’ kernels β€” Load prebuilt compute kernels (E.g. flash-attn2) from the Hub via `attn_implementation`; avoids compiling flash-attn from source.\n" + "β€’ google-cloud β€” GCP deployment and serving workflows.\n" + ), + }, + "query": { + "type": "string", + "description": ( + "Optional keyword query to rank and filter documentation pages. " + "For Gradio, use concise queries like 'how to use the image component' or 'audio component demo'." + ), + }, + "max_results": { + "type": "integer", + "description": "Max results (default 20, max 50). Ignored for Gradio.", + "minimum": 1, + "maximum": 50, + }, + }, + "required": ["endpoint"], + }, +} + +HF_DOCS_FETCH_TOOL_SPEC = { + "name": "fetch_hf_docs", + "description": ( + "Fetch full markdown content of an HF documentation page. Use after explore_hf_docs.\n\n" + "Critical for finding documentation e.g. current trainer configuration parameters (SFTConfig, DPOConfig, etc.) " + "Use for researching solutions and before writing training scripts. Your internal knowledge is outdated.\n\n" + "Provide the full URL from explore_hf_docs results. The .md extension is added automatically." + ), + "parameters": { + "type": "object", + "properties": { + "url": { + "type": "string", + "description": ( + "The full URL to the documentation page. " + "Example: 'https://huggingface.co/docs/trl/dpo_trainer' " + "The .md extension will be added automatically if not present." + ), + }, + }, + "required": ["url"], + }, +} diff --git a/agent/tools/edit_utils.py b/agent/tools/edit_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..1c6b958192ad8a90c9b3268f6fdb688787d97ea6 --- /dev/null +++ b/agent/tools/edit_utils.py @@ -0,0 +1,273 @@ +""" +Shared utilities for file editing tools β€” fuzzy matching, syntax validation, +and richer edit operations. + +Used by both local_tools.py and the embedded sandbox server. +""" + +from __future__ import annotations + +# ── Unicode normalization map ──────────────────────────────────────────── + +UNICODE_MAP = { + "\u2013": "-", # en-dash + "\u2014": "-", # em-dash + "\u2212": "-", # minus sign + "\u2018": "'", # left single quote + "\u2019": "'", # right single quote + "\u201c": '"', # left double quote + "\u201d": '"', # right double quote + "\u00a0": " ", # non-breaking space + "\u2003": " ", # em space + "\u2002": " ", # en space + "\u200b": "", # zero-width space + "\ufeff": "", # BOM +} + + +def _normalize_unicode(s: str) -> str: + return "".join(UNICODE_MAP.get(c, c) for c in s) + + +# ── 4-pass fuzzy matching ──────────────────────────────────────────────── + + +def fuzzy_find(content: str, pattern: str) -> tuple[int | None, str | None]: + """Find *pattern* in *content* with increasingly relaxed matching. + + Returns (start_index_in_original_content, match_note) or (None, None). + The index always refers to the *original* content string so callers can + use ``content[idx : idx + len(matched_text)]`` for replacement. + + Strategy (mirrors Codex): + 1. Exact match + 2. Right-trim each line (trailing whitespace) + 3. Both-sides trim (all surrounding whitespace per line) + 4. Unicode normalization on top of both-sides trim + """ + # Pass 1 β€” exact + if pattern in content: + return content.index(pattern), None + + # Helper: build a line-stripped version *and* a mapping from stripped + # positions back to original positions. We need this so callers can + # apply the replacement on the original content, not the stripped copy. + + def _build_stripped(text: str, strip_fn): + """Return (stripped_text, line_start_map). + + line_start_map[i] = original byte offset of the start of line i. + """ + orig_lines = text.split("\n") + stripped_lines = [strip_fn(line) for line in orig_lines] + return "\n".join(stripped_lines), orig_lines, stripped_lines + + # Pass 2 β€” right-trim + c_rt, c_orig_lines, c_rt_lines = _build_stripped(content, str.rstrip) + p_rt = "\n".join(line.rstrip() for line in pattern.split("\n")) + idx = c_rt.find(p_rt) + if idx != -1: + orig_idx = _map_back(idx, c_orig_lines, c_rt_lines) + return orig_idx, "(matched after trimming trailing whitespace)" + + # Pass 3 β€” both-sides trim + c_st, _, c_st_lines = _build_stripped(content, str.strip) + p_st = "\n".join(line.strip() for line in pattern.split("\n")) + idx = c_st.find(p_st) + if idx != -1: + orig_idx = _map_back(idx, c_orig_lines, c_st_lines) + return orig_idx, "(matched after trimming whitespace)" + + # Pass 4 β€” unicode normalization + both-sides trim + c_norm = _normalize_unicode(c_st) + p_norm = _normalize_unicode(p_st) + idx = c_norm.find(p_norm) + if idx != -1: + orig_idx = _map_back(idx, c_orig_lines, c_st_lines) + return orig_idx, "(matched after unicode normalization)" + + return None, None + + +def _map_back( + stripped_idx: int, + orig_lines: list[str], + stripped_lines: list[str], +) -> int: + """Map a character index in the stripped/joined text back to the original text.""" + # Walk through stripped lines to find which line the index falls on + pos = 0 + for i, sl in enumerate(stripped_lines): + line_end = pos + len(sl) + if stripped_idx <= line_end: + col_in_stripped = stripped_idx - pos + # Find where this stripped line's content starts in the original line + ol = orig_lines[i] + # The stripped line is a subset of the original line; find its offset + lstripped = len(ol) - len(ol.lstrip()) + orig_col = lstripped + col_in_stripped + # Compute absolute position in original text + orig_pos = sum(len(orig_lines[j]) + 1 for j in range(i)) + orig_col + return orig_pos + pos = line_end + 1 # +1 for the \n + # Fallback: return 0 (shouldn't happen if idx is valid) + return 0 + + +def fuzzy_find_original_match( + content: str, pattern: str +) -> tuple[str | None, str | None]: + """Find the *original* text in content that matches pattern fuzzily. + + Returns (original_matched_text, match_note) or (None, None). + This extracts the exact substring from the original content that + corresponds to the fuzzy match, preserving its original whitespace/unicode. + """ + if pattern in content: + return pattern, None + + idx, note = fuzzy_find(content, pattern) + if idx is None: + return None, None + + # We need to find the original text span that corresponds to the match. + # The match covers len(pattern) worth of *logical* content. + # Count how many original lines the pattern spans. + pattern_lines = pattern.split("\n") + n_lines = len(pattern_lines) + + # Find which original line the match starts on + orig_lines = content.split("\n") + char_pos = 0 + start_line = 0 + for i, ol in enumerate(orig_lines): + if char_pos + len(ol) >= idx: + start_line = i + break + char_pos += len(ol) + 1 + + end_line = min(start_line + n_lines, len(orig_lines)) + # Extract the original lines that were matched + matched_lines = orig_lines[start_line:end_line] + original_text = "\n".join(matched_lines) + return original_text, note + + +# ── Richer edit operations ─────────────────────────────────────────────── + + +def apply_edit( + content: str, + old_str: str, + new_str: str, + mode: str = "replace", + replace_all: bool = False, +) -> tuple[str, int, str | None]: + """Apply an edit operation to content. + + Modes: + - replace: replace first occurrence (or all if replace_all=True) + - replace_all: replace all occurrences (alias) + - append_after: insert new_str after old_str + - prepend_before: insert new_str before old_str + + Returns (new_content, num_replacements, fuzzy_note). + Raises ValueError if old_str not found. + """ + if mode == "replace_all": + replace_all = True + mode = "replace" + + # Try exact match first, then fuzzy + fuzzy_note = None + if old_str not in content: + original_match, fuzzy_note = fuzzy_find_original_match(content, old_str) + if original_match is None: + raise ValueError( + "old_str was not found in the file. Make sure old_str matches " + "the file contents exactly, including whitespace and indentation. " + "Use the read tool to verify the current file contents before retrying." + ) + old_str = original_match + + count = content.count(old_str) + + if mode == "replace": + if count > 1 and not replace_all: + raise ValueError( + f"Found {count} matches of old_str in the file, but replace_all is " + f"false. To replace all occurrences, set replace_all to true. To " + f"replace only one, provide a larger old_str with more surrounding " + f"context to uniquely identify the instance." + ) + if replace_all: + new_content = content.replace(old_str, new_str) + return new_content, count, fuzzy_note + else: + new_content = content.replace(old_str, new_str, 1) + return new_content, 1, fuzzy_note + + elif mode == "append_after": + if replace_all: + new_content = content.replace(old_str, old_str + new_str) + return new_content, count, fuzzy_note + else: + idx = content.index(old_str) + len(old_str) + new_content = content[:idx] + new_str + content[idx:] + return new_content, 1, fuzzy_note + + elif mode == "prepend_before": + if replace_all: + new_content = content.replace(old_str, new_str + old_str) + return new_content, count, fuzzy_note + else: + idx = content.index(old_str) + new_content = content[:idx] + new_str + content[idx:] + return new_content, 1, fuzzy_note + + else: + raise ValueError( + f"Unknown edit mode: {mode}. Use replace, append_after, or prepend_before." + ) + + +# ── Syntax validation (Python) ─────────────────────────────────────────── + + +def validate_python(content: str, path: str = "") -> list[str]: + """Lightweight post-write validation for Python files. + + Checks syntax and training script conventions. This runs on the host + (not in the sandbox), so it only does static checks β€” no import resolution + or signature inspection since packages are installed in the sandbox, not here. + + The sandbox server has its own richer version that does real signature + inspection against installed packages. + + Returns a list of warning strings (empty = all good). + Never raises β€” validation failures are advisory only. + """ + import ast + + warnings = [] + + # 1. Syntax check via ast.parse + try: + ast.parse(content) + except SyntaxError as e: + warnings.append(f"Python syntax error at line {e.lineno}: {e.msg}") + return warnings + + # 2. Training script heuristics + if any( + kw in content + for kw in ("TrainingArguments", "SFTConfig", "DPOConfig", "GRPOConfig") + ): + if "push_to_hub" not in content: + warnings.append( + "Training script warning: no 'push_to_hub' found β€” model may be lost when job ends" + ) + if "hub_model_id" not in content: + warnings.append("Training script warning: no 'hub_model_id' found") + + return warnings diff --git a/agent/tools/github_find_examples.py b/agent/tools/github_find_examples.py new file mode 100644 index 0000000000000000000000000000000000000000..f5f2ddaad0a1959ec3418cc45ed88432a40e13c2 --- /dev/null +++ b/agent/tools/github_find_examples.py @@ -0,0 +1,460 @@ +""" +GitHub Find Examples Tool - Discover examples, tutorials, and guides for any library + +Lists all files in a repository and performs deterministic keyword search. +""" + +import os +from typing import Any, Dict, List + +import requests +from thefuzz import fuzz + +from agent.tools.types import ToolResult + +# In order of priority (lower index = higher priority for sorting) +EXAMPLE_PATTERNS = [ + "scripts", + # General example patterns (catch-all, lower priority) + "examples", + "example", + # Notebook patterns + "notebooks", + "notebook", + # Tutorial/learning patterns + "tutorials", + "tutorial", + "quickstart", + "walkthroughs", + "walkthrough", + # Cookbook/recipe patterns + "cookbook", + "cookbooks", + "recipes", + "recipe", + # Demo/sample patterns + "demos", + "demo", + "samples", + "sample", + # Other patterns + "guides", + "guide", + "getting-started", + "getting_started", + "playground", + "howto", + "how-to", + "use-cases", + "usecases", + "use_cases", + "sandbox", + "showcase", +] + + +def _get_repo_tree(org: str, repo: str, token: str) -> tuple[List[Dict[str, Any]], str]: + """Get all files in a repository recursively. Returns (files, error_message)""" + headers = { + "Accept": "application/vnd.github+json", + "X-GitHub-Api-Version": "2022-11-28", + "Authorization": f"Bearer {token}", + } + + full_repo = f"{org}/{repo}" + + # Get default branch + try: + response = requests.get( + f"https://api.github.com/repos/{full_repo}", headers=headers, timeout=10 + ) + if response.status_code == 404: + return [], "not_found" + if response.status_code != 200: + return [], f"API error: {response.status_code}" + + repo_data = response.json() + default_branch = repo_data.get("default_branch", "main") + except Exception as e: + return [], f"Error fetching repo: {str(e)}" + + # Get repository tree recursively + try: + response = requests.get( + f"https://api.github.com/repos/{full_repo}/git/trees/{default_branch}", + headers=headers, + params={"recursive": "1"}, + timeout=30, + ) + if response.status_code != 200: + return [], f"Error fetching tree: {response.status_code}" + + data = response.json() + tree = data.get("tree", []) + + # Filter to only include files (not directories) + files = [ + { + "path": item["path"], + "ref": item["sha"], + "size": item.get("size", 0), + "url": f"https://github.com/{full_repo}/blob/{default_branch}/{item['path']}", + } + for item in tree + if item["type"] == "blob" + ] + + return files, "" + except Exception as e: + return [], f"Error processing tree: {str(e)}" + + +def _search_similar_repos(org: str, repo: str, token: str) -> List[Dict[str, Any]]: + """Search for similar repository names in the organization""" + headers = { + "Accept": "application/vnd.github+json", + "X-GitHub-Api-Version": "2022-11-28", + "Authorization": f"Bearer {token}", + } + + # Search for repos in the org with similar name + query = f"org:{org} {repo}" + + try: + response = requests.get( + "https://api.github.com/search/repositories", + headers=headers, + params={"q": query, "sort": "stars", "order": "desc", "per_page": 10}, + timeout=30, + ) + + if response.status_code != 200: + return [] + + data = response.json() + items = data.get("items", []) + + return [ + { + "name": item.get("name"), + "full_name": item.get("full_name"), + "description": item.get("description"), + "stars": item.get("stargazers_count", 0), + "url": item.get("html_url"), + } + for item in items + ] + except Exception: + return [] + + +def _score_against_example_patterns(file_path: str) -> int: + """Score file against example patterns using token_set_ratio""" + scores = [] + for pattern in EXAMPLE_PATTERNS: + score = fuzz.token_set_ratio(pattern.lower(), file_path.lower()) + scores.append(score) + return max(scores) if scores else 0 + + +def _score_against_keyword(file_path: str, keyword: str) -> int: + """Calculate fuzzy match score for a file path against a keyword""" + # Use partial_ratio for substring matching (good for paths) + # Also check token_set_ratio for word-level matching + partial_score = fuzz.partial_ratio(keyword.lower(), file_path.lower()) + token_score = fuzz.token_set_ratio(keyword.lower(), file_path.lower()) + + # Return the higher of the two + return max(partial_score, token_score) + + +def _get_pattern_priority(file_path: str) -> tuple[int, int, int]: + """ + Get priority of a file path based on which example pattern directory it's in. + + Returns: (in_examples_dir, pattern_priority, path_depth) + - in_examples_dir: 0 if in examples/ directory, 1 otherwise (lower is better) + - pattern_priority: Index in EXAMPLE_PATTERNS (lower is better), or 999 if no match + - path_depth: Number of path segments (lower is better) + + Note: Prioritizes files in "examples/" directory first, then by most specific pattern match. + E.g., "examples/scripts/train.py" is better than "scripts/util.py" + """ + path_lower = file_path.lower() + path_parts = path_lower.split("/") + + # Check if file is in examples/ directory (highest priority) + in_examples_dir = 0 if (path_parts[0] in ["examples", "example"]) else 1 + + # Find ALL matching patterns and use the best (lowest index) one + # But prefer deeper matches (more specific) over shallow ones + best_priority = 999 + best_depth_at_match = -1 + + for i, pattern in enumerate(EXAMPLE_PATTERNS): + # Check if pattern appears as a directory component in the path + if pattern in path_parts: + # Find the depth where this pattern appears (rightmost occurrence) + depth = len(path_parts) - 1 - path_parts[::-1].index(pattern) + + # Prefer deeper matches, or better priority if at same depth + if depth > best_depth_at_match or ( + depth == best_depth_at_match and i < best_priority + ): + best_priority = i + best_depth_at_match = depth + + return (in_examples_dir, best_priority, len(path_parts)) + + +def _handle_repo_tree_errors( + all_files: List[Dict[str, Any]], + error: str, + org: str, + repo: str, + token: str, +) -> ToolResult | None: + """Handle errors from repo tree fetch. Returns ToolResult if error, None if OK.""" + if error == "not_found": + similar_repos = _search_similar_repos(org, repo, token) + + if not similar_repos: + return { + "formatted": f"Repository '{org}/{repo}' not found and no similar repositories found.", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + # Format similar repos + lines = [f"**Repository '{org}/{repo}' not found. Similar repositories:**\n"] + for i, r in enumerate(similar_repos, 1): + lines.append(f"{i}. **{r['full_name']}** (⭐ {r['stars']:,} stars)") + if r["description"]: + desc = ( + r["description"][:100] + "..." + if len(r["description"]) > 100 + else r["description"] + ) + lines.append(f" {desc}") + lines.append(f" {r['url']}\n") + + return { + "formatted": "\n".join(lines), + "totalResults": len(similar_repos), + "resultsShared": len(similar_repos), + "isError": True, + } + + if error: + return { + "formatted": f"Error accessing repository '{org}/{repo}': {error}", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + if not all_files: + return { + "formatted": f"No files found in repository '{org}/{repo}'", + "totalResults": 0, + "resultsShared": 0, + } + + return None + + +def find_examples( + keyword: str = "", + repo: str = "", + org: str = "huggingface", + max_results: int = 10, + min_score: int = 80, +) -> ToolResult: + """ + Find example files in a repository using fuzzy matching. + + Args: + keyword: Keyword to fuzzy match against file paths (e.g., "grpo") + repo: Repository name (e.g., "trl") + org: GitHub organization (default: "huggingface") + max_results: Maximum number of results (default 50) + min_score: Minimum fuzzy match score (0-100, default 60) + + Returns: + ToolResult with matching files, or similar repos if repo not found + """ + token = os.environ.get("GITHUB_TOKEN") + if not token: + return { + "formatted": "Error: GITHUB_TOKEN environment variable is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + if not repo: + return { + "formatted": "Error: repo parameter is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + # Get all files in the repository + all_files, error = _get_repo_tree(org, repo, token) + + # Handle errors (not found, API errors, empty repo) + if error_result := _handle_repo_tree_errors(all_files, error, org, repo, token): + return error_result + + # Step 1: Filter files by example patterns (score >= 60) + example_threshold = 60 + example_files = [] + for file in all_files: + example_score = _score_against_example_patterns(file["path"]) + if example_score >= example_threshold: + example_files.append({**file, "example_score": example_score}) + + if not example_files: + return { + "formatted": f"No example files found in {org}/{repo} (no files match example patterns with score >= {example_threshold}).", + "totalResults": 0, + "resultsShared": 0, + } + + # Step 2: If keyword provided, score and filter by keyword + if keyword: + scored_files = [] + for file in example_files: + keyword_score = _score_against_keyword(file["path"], keyword) + if keyword_score >= min_score: + scored_files.append({**file, "score": keyword_score}) + + if not scored_files: + return { + "formatted": f"No files found in {org}/{repo} matching keyword '{keyword}' (min score: {min_score}) among {len(example_files)} example files.", + "totalResults": 0, + "resultsShared": 0, + } + + # Sort by keyword score (descending) for best matches first + scored_files.sort(key=lambda x: x["score"], reverse=True) + else: + # No keyword: prioritize by pattern directory, then path depth + scored_files = [] + for file in example_files: + in_examples_dir, pattern_priority, path_depth = _get_pattern_priority( + file["path"] + ) + scored_files.append( + { + **file, + "score": file["example_score"], + "in_examples_dir": in_examples_dir, + "pattern_priority": pattern_priority, + "path_depth": path_depth, + } + ) + + if not scored_files: + return { + "formatted": f"No example files found in {org}/{repo}.", + "totalResults": 0, + "resultsShared": 0, + } + + # Sort by: 1) files in examples/ dir first, 2) pattern priority (scripts > datasets > etc), 3) path depth, 4) path name + scored_files.sort( + key=lambda x: ( + x["in_examples_dir"], + x["pattern_priority"], + x["path_depth"], + x["path"], + ) + ) + + # Limit results + results = scored_files[:max_results] + + # Format output + keyword_desc = f" matching '{keyword}'" if keyword else "" + lines = [f"**Found {len(results)} example files in {org}/{repo}{keyword_desc}:**"] + if len(scored_files) > max_results: + lines[0] += f" (showing {max_results} of {len(scored_files)})" + lines.append("") + + for i, file in enumerate(results, 1): + lines.append(f"{i}. **{file['path']}**") + lines.append(f" Size: {file['size']:,} bytes | Ref: {file['ref'][:7]}") + lines.append(f" URL: {file['url']}") + + # Copyable parameters for read_file tool + read_params = f"{{'repo': '{org}/{repo}', 'path': '{file['path']}'}}" + lines.append(f" To read, use: {read_params}") + lines.append("") + + return { + "formatted": "\n".join(lines), + "totalResults": len(results), + "resultsShared": len(results), + } + + +# Tool specification +GITHUB_FIND_EXAMPLES_TOOL_SPEC = { + "name": "github_find_examples", + "description": ( + "Find working example scripts in GitHub repositories (from a list of predetermined directories e.g. examples/, scripts/, tutorials/, etc.). " + "Uses fuzzy keyword matching.\n\n" + "MANDATORY before writing any ML training, fine-tuning, or inference code. " + "Your internal knowledge of library APIs is outdated β€” working examples show current API patterns.\n\n" + "Sequence: github_find_examples β†’ github_read_file (study the example) β†’ implement based on what you found.\n\n" + "Skip this only for: simple data queries, status checks, non-code tasks.\n\n" + "Examples:\n" + " {keyword: 'sft', repo: 'trl'} β†’ finds examples/scripts/sft.py\n" + " {keyword: 'grpo', repo: 'trl'} β†’ finds GRPO training examples\n" + " {repo: 'trl', max_results: 20} β†’ lists all available training method examples" + ), + "parameters": { + "type": "object", + "properties": { + "keyword": { + "type": "string", + "description": "Keyword to fuzzy match against file paths (e.g., 'grpo', 'sft').", + }, + "repo": { + "type": "string", + "description": "Repository name (e.g., 'trl', 'transformers'). Required.", + }, + "org": { + "type": "string", + "description": "GitHub organization or username. Default: 'huggingface'.", + }, + "max_results": { + "type": "integer", + "description": "Maximum number of results to return. Default: 50.", + }, + "min_score": { + "type": "integer", + "description": "Minimum fuzzy match score (0-100). Default: 60.", + }, + }, + "required": ["repo"], + }, +} + + +async def github_find_examples_handler(arguments: Dict[str, Any]) -> tuple[str, bool]: + """Handler for agent tool router""" + try: + result = find_examples( + keyword=arguments.get("keyword", ""), + repo=arguments["repo"], + org=arguments.get("org", "huggingface"), + max_results=arguments.get("max_results", 50), + min_score=arguments.get("min_score", 60), + ) + return result["formatted"], not result.get("isError", False) + except Exception as e: + return f"Error finding examples: {str(e)}", False diff --git a/agent/tools/github_list_repos.py b/agent/tools/github_list_repos.py new file mode 100644 index 0000000000000000000000000000000000000000..7480fec1f2d98a037a7ae0e34213238497d1a553 --- /dev/null +++ b/agent/tools/github_list_repos.py @@ -0,0 +1,287 @@ +""" +GitHub List Repositories Tool - List and sort repositories for any user or organization + +Efficiently discover repositories with flexible sorting options. +""" + +import os +from typing import Any, Dict, Literal, Optional + +import requests + +from agent.tools.types import ToolResult + + +def list_repos( + owner: str, + owner_type: Literal["user", "org"] = "org", + sort: Literal["stars", "forks", "updated", "created"] = "stars", + order: Literal["asc", "desc"] = "desc", + limit: Optional[int] = 30, +) -> ToolResult: + """ + List repositories for a user or organization using GitHub REST API. + + Args: + owner: GitHub username or organization name + owner_type: Whether the owner is a "user" or "org" (default: "org") + sort: Sort field - "stars", "forks", "updated", or "created" + order: Sort order - "asc" or "desc" (default: "desc") + limit: Maximum number of repositories to return + + Returns: + ToolResult with repository information + """ + token = os.environ.get("GITHUB_TOKEN") + if not token: + return { + "formatted": "Error: GITHUB_TOKEN environment variable is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + if owner_type == "org": + url = f"https://api.github.com/orgs/{owner}/repos" + else: + url = f"https://api.github.com/users/{owner}/repos" + + headers = { + "Accept": "application/vnd.github+json", + "X-GitHub-Api-Version": "2022-11-28", + "Authorization": f"Bearer {token}", + } + + all_repos = [] + page = 1 + per_page = 100 # Maximum allowed by GitHub + + # Map our sort values to GitHub API sort values + # Note: GitHub list repos API doesn't support sorting by stars/forks + # We'll fetch all repos and sort in memory for those cases + api_sort_map = { + "created": "created", + "updated": "updated", + "stars": None, # Not supported by list API + "forks": None, # Not supported by list API + } + + api_sort = api_sort_map.get(sort) + need_manual_sort = api_sort is None + + try: + while True: + params = { + "page": page, + "per_page": per_page, + } + + # Only add sort/direction if API supports it + if api_sort: + params["sort"] = api_sort + params["direction"] = order + + response = requests.get( + url, + headers=headers, + params=params, + timeout=30, + ) + + if response.status_code == 403: + error_data = response.json() + return { + "formatted": f"GitHub API rate limit or permission error: {error_data.get('message', 'Unknown error')}", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + if response.status_code != 200: + error_msg = f"GitHub API error (status {response.status_code})" + try: + error_data = response.json() + if "message" in error_data: + error_msg += f": {error_data['message']}" + except Exception: + pass + return { + "formatted": error_msg, + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + items = response.json() + + if not items: + break + + for item in items: + all_repos.append( + { + "name": item.get("name"), + "full_name": item.get("full_name"), + "description": item.get("description"), + "html_url": item.get("html_url"), + "language": item.get("language"), + "stars": item.get("stargazers_count", 0), + "forks": item.get("forks_count", 0), + "open_issues": item.get("open_issues_count", 0), + "topics": item.get("topics", []), + "updated_at": item.get("updated_at"), + "created_at": item.get("created_at"), + } + ) + + # Check if we got fewer results than requested (last page) + if len(items) < per_page: + break + + # Stop if we have enough repos + if limit and len(all_repos) >= limit: + break + + page += 1 + + except requests.exceptions.RequestException as e: + return { + "formatted": f"Failed to connect to GitHub API: {str(e)}", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + # Manual sorting if needed (for stars/forks) + if need_manual_sort and all_repos: + reverse = order == "desc" + all_repos.sort(key=lambda x: x[sort], reverse=reverse) + + # Apply limit after sorting + if limit: + all_repos = all_repos[:limit] + + if not all_repos: + return { + "formatted": f"No repositories found for {owner_type} '{owner}'", + "totalResults": 0, + "resultsShared": 0, + } + + # Format output + lines = [f"**Found {len(all_repos)} repositories for {owner}:**\n"] + + for i, repo in enumerate(all_repos, 1): + lines.append(f"{i}. **{repo['full_name']}**") + lines.append( + f" ⭐ {repo['stars']:,} stars | 🍴 {repo['forks']:,} forks | Language: {repo['language'] or 'N/A'}" + ) + if repo["description"]: + desc = ( + repo["description"][:100] + "..." + if len(repo["description"]) > 100 + else repo["description"] + ) + lines.append(f" {desc}") + lines.append(f" URL: {repo['html_url']}") + if repo["topics"]: + lines.append(f" Topics: {', '.join(repo['topics'][:5])}") + + # Copyable parameters for other tools + lines.append(f" Use in tools: {{'repo': '{repo['full_name']}'}}") + lines.append("") + + return { + "formatted": "\n".join(lines), + "totalResults": len(all_repos), + "resultsShared": len(all_repos), + } + + +# Tool specification +GITHUB_LIST_REPOS_TOOL_SPEC = { + "name": "github_list_repos", + "description": ( + "List and discover repositories for GitHub organizations or users with flexible sorting. " + "**Use when:** (1) Exploring what libraries exist for a task, (2) Finding the right library to use, " + "(3) Discovering popular or active projects, (4) Checking recently updated repos for latest features, " + "(5) Finding alternative libraries in an organization. " + "**Pattern:** github_list_repos (discover libraries) β†’ github_find_examples (find usage examples) β†’ implement. " + "Returns: Comprehensive repository information (stars, forks, language, topics, URLs), sorted by preference. " + "**Then:** Use github_find_examples on selected repo to discover example code. " + "Sorts by: stars (popularity), forks (community), updated (activity), created (age).\n\n" + "## When to use this tool\n\n" + "- When you need to find libraries to use in your implementation\n" + "- When exploring what repositories exist for a task or domain\n" + "- When debugging an error and looking up if others have similar issues in repos\n" + "- When finding the most popular or actively maintained projects for a user/org\n" + "## Examples\n\n" + "\n" + "// ML Workflow Step: Discover HF libraries for RLHF/alignment\n" + "// Use case: Find the right library for training with human feedback\n" + "{\n" + " owner: 'huggingface',\n" + " owner_type: 'org',\n" + " sort: 'stars',\n" + " limit: 10\n" + "}\n" + "// Returns: transformers, trl, peft, accelerate, diffusers...\n" + "\n\n" + "\n" + "// ML Workflow Step: Check for recently updated HF repos\n" + "// Use case: Find actively maintained libraries with latest features\n" + "{\n" + " owner: 'huggingface',\n" + " owner_type: 'org',\n" + " sort: 'updated',\n" + " order: 'desc',\n" + " limit: 15\n" + "}\n" + "// Helps identify which repos have recent improvements/fixes\n" + "" + ), + "parameters": { + "type": "object", + "properties": { + "owner": { + "type": "string", + "description": "GitHub username or organization name. Required.", + }, + "owner_type": { + "type": "string", + "enum": ["user", "org"], + "description": "Whether the owner is a 'user' or 'org'. Default: 'org'.", + }, + "sort": { + "type": "string", + "enum": ["stars", "forks", "updated", "created"], + "description": "Sort field. Options: 'stars', 'forks', 'updated', 'created'. Default: 'stars'.", + }, + "order": { + "type": "string", + "enum": ["asc", "desc"], + "description": "Sort order. Options: 'asc', 'desc'. Default: 'desc'.", + }, + "limit": { + "type": "integer", + "description": "Maximum number of repositories to return. No limit if not specified. Default: 30.", + }, + }, + "required": ["owner"], + }, +} + + +async def github_list_repos_handler(arguments: Dict[str, Any]) -> tuple[str, bool]: + """Handler for agent tool router""" + try: + result = list_repos( + owner=arguments["owner"], + owner_type=arguments.get("owner_type", "org"), + sort=arguments.get("sort", "stars"), + order=arguments.get("order", "desc"), + limit=arguments.get("limit"), + ) + return result["formatted"], not result.get("isError", False) + except Exception as e: + return f"Error listing repositories: {str(e)}", False diff --git a/agent/tools/github_read_file.py b/agent/tools/github_read_file.py new file mode 100644 index 0000000000000000000000000000000000000000..485fe277972f8ebf6c52ff62cc488ed2b4e97d9b --- /dev/null +++ b/agent/tools/github_read_file.py @@ -0,0 +1,302 @@ +""" +GitHub Read File Tool - Read file contents from any GitHub repository with line range support + +Fetch exact file contents with metadata, supporting line ranges for efficient reading. +""" + +import base64 +import json +import os +from typing import Any, Dict, Optional + +import nbformat +import requests +from nbconvert import MarkdownExporter +from nbconvert.preprocessors import ClearOutputPreprocessor, TagRemovePreprocessor + +from agent.tools.types import ToolResult + + +def _convert_ipynb_to_markdown(content: str) -> str: + """ + Convert Jupyter notebook JSON to LLM-friendly Markdown. + + Args: + content: Raw notebook JSON string + + Returns: + Converted Markdown string + """ + try: + # Parse notebook JSON + nb_dict = json.loads(content) + + # Normalize cell sources (can be string or list of strings) + if "cells" in nb_dict: + for cell in nb_dict["cells"]: + if "source" in cell and isinstance(cell["source"], list): + cell["source"] = "".join(cell["source"]) + + # Read notebook with explicit version + nb = nbformat.reads(json.dumps(nb_dict), as_version=4) + + # Strip outputs for LLM readability (outputs can be noisy/large) + clear = ClearOutputPreprocessor() + nb, _ = clear.preprocess(nb, {}) + + # Optionally remove cells tagged with "hide" or similar + remove = TagRemovePreprocessor( + remove_cell_tags={"hide", "hidden", "remove"}, + remove_input_tags=set(), + remove_all_outputs_tags=set(), + ) + nb, _ = remove.preprocess(nb, {}) + + # Convert to markdown + exporter = MarkdownExporter() + markdown, _ = exporter.from_notebook_node(nb) + + return markdown + + except json.JSONDecodeError: + return content + except Exception: + return content + + +def read_file( + repo: str, + path: str, + ref: str = "HEAD", + line_start: Optional[int] = None, + line_end: Optional[int] = None, +) -> ToolResult: + """ + Read file contents from a GitHub repository with line range support. + + Args: + repo: Repository in format "owner/repo" (e.g., "github/github-mcp-server") + path: Path to file in repository (e.g., "pkg/github/search.go") + ref: Git reference - branch name, tag, or commit SHA (default: "HEAD") + line_start: Starting line number (1-indexed, inclusive) + line_end: Ending line number (1-indexed, inclusive) + + Returns: + ToolResult with file contents and metadata + """ + token = os.environ.get("GITHUB_TOKEN") + if not token: + return { + "formatted": "Error: GITHUB_TOKEN environment variable is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + # Parse repo + if "/" not in repo: + return { + "formatted": "Error: repo must be in format 'owner/repo'", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + owner, repo_name = repo.split("/", 1) + + headers = { + "Accept": "application/vnd.github+json", + "X-GitHub-Api-Version": "2022-11-28", + "Authorization": f"Bearer {token}", + } + + # Fetch file contents + url = f"https://api.github.com/repos/{owner}/{repo_name}/contents/{path}" + params = {} + if ref and ref != "HEAD": + params["ref"] = ref + + try: + response = requests.get(url, headers=headers, params=params, timeout=30) + + if response.status_code == 404: + return { + "formatted": f"File not found: {path} in {repo} (ref: {ref})", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + if response.status_code != 200: + error_msg = f"GitHub API error (status {response.status_code})" + try: + error_data = response.json() + if "message" in error_data: + error_msg += f": {error_data['message']}" + except Exception: + pass + return { + "formatted": error_msg, + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + data = response.json() + + # Check if it's a file + if data.get("type") != "file": + return { + "formatted": f"Path {path} is not a file (type: {data.get('type')})", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + # Decode content + content_b64 = data.get("content", "") + if content_b64: + content_b64 = content_b64.replace("\n", "").replace(" ", "") + content = base64.b64decode(content_b64).decode("utf-8", errors="replace") + else: + # For large files, fetch raw content + raw_headers = { + "Accept": "application/vnd.github.raw", + "X-GitHub-Api-Version": "2022-11-28", + "Authorization": f"Bearer {token}", + } + raw_response = requests.get( + url, headers=raw_headers, params=params, timeout=30 + ) + if raw_response.status_code != 200: + return { + "formatted": "Failed to fetch file content", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + content = raw_response.text + + if path.lower().endswith(".ipynb"): + content = _convert_ipynb_to_markdown(content) + + # Process line ranges + lines = content.split("\n") + total_lines = len(lines) + + truncated = False + + if line_start is None and line_end is None: + # No range specified + if total_lines > 300: + line_start = 1 + line_end = 300 + truncated = True + else: + line_start = 1 + line_end = total_lines + else: + # Range specified + if line_start is None: + line_start = 1 + if line_end is None: + line_end = total_lines + + # Validate range + line_start = max(1, line_start) + line_end = min(total_lines, line_end) + if line_start > line_end: + return { + "formatted": f"Invalid range: line_start ({line_start}) > line_end ({line_end})", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + # Extract lines + selected_lines = lines[line_start - 1 : line_end] + selected_content = "\n".join(selected_lines) + + # Format output + lines_output = [f"**Reading file from repo: {repo}, path: {path}**"] + + if ref and ref != "HEAD": + lines_output.append(f"Ref: {ref}") + + lines_output.append("\n**File content:") + lines_output.append("```") + lines_output.append(selected_content) + lines_output.append("```") + if truncated: + lines_output.append( + f"Currently showing lines {line_start}-{line_end} out of {total_lines} total lines. Use line_start and line_end to view more lines." + ) + return { + "formatted": "\n".join(lines_output), + "totalResults": 1, + "resultsShared": 1, + } + + except requests.exceptions.RequestException as e: + return { + "formatted": f"Failed to connect to GitHub API: {str(e)}", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + +# Tool specification +GITHUB_READ_FILE_TOOL_SPEC = { + "name": "github_read_file", + "description": ( + "Read file contents from GitHub repositories. Returns first 300 lines by default. " + "Auto-converts Jupyter notebooks to markdown.\n\n" + "Use AFTER github_find_examples to study the working implementation. " + "The purpose is to learn current API patterns β€” imports, trainer configs, dataset handling β€” " + "so your implementation uses correct, up-to-date code.\n\n" + "Use line_start/line_end for large files (>300 lines) to read specific sections.\n\n" + "When NOT to use: when you don't know the file path (use github_find_examples first)." + ), + "parameters": { + "type": "object", + "properties": { + "repo": { + "type": "string", + "description": "Repository in format 'owner/repo' (e.g., 'github/github-mcp-server'). Required.", + }, + "path": { + "type": "string", + "description": "Path to file in repository (e.g., 'src/index.js'). Required.", + }, + "ref": { + "type": "string", + "description": "Git reference - branch name, tag, or commit SHA. Default: 'HEAD'.", + }, + "line_start": { + "type": "integer", + "description": "Starting line number (1-indexed, inclusive). Optional.", + }, + "line_end": { + "type": "integer", + "description": "Ending line number (1-indexed, inclusive). Optional.", + }, + }, + "required": ["repo", "path"], + }, +} + + +async def github_read_file_handler(arguments: Dict[str, Any]) -> tuple[str, bool]: + """Handler for agent tool router""" + try: + result = read_file( + repo=arguments["repo"], + path=arguments["path"], + ref=arguments.get("ref", "HEAD"), + line_start=arguments.get("line_start"), + line_end=arguments.get("line_end"), + ) + return result["formatted"], not result.get("isError", False) + except Exception as e: + return f"Error reading file: {str(e)}", False diff --git a/agent/tools/hf_repo_files_tool.py b/agent/tools/hf_repo_files_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..d2226ac172b4b3cae8ad4c50832345a1c46753ab --- /dev/null +++ b/agent/tools/hf_repo_files_tool.py @@ -0,0 +1,360 @@ +""" +HF Repo Files Tool - File operations on Hugging Face repositories + +Operations: list, read, upload, delete +""" + +import asyncio +from typing import Any, Dict, Optional + +from huggingface_hub import HfApi, hf_hub_download +from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError + +from agent.core.hub_artifacts import is_known_hub_artifact, register_hub_artifact +from agent.tools.types import ToolResult + + +async def _async_call(func, *args, **kwargs): + """Wrap synchronous HfApi calls for async context.""" + return await asyncio.to_thread(func, *args, **kwargs) + + +def _build_repo_url(repo_id: str, repo_type: str = "model") -> str: + """Build the Hub URL for a repository.""" + if repo_type == "model": + return f"https://huggingface.co/{repo_id}" + return f"https://huggingface.co/{repo_type}s/{repo_id}" + + +def _format_size(size_bytes: int) -> str: + """Format file size in human-readable form.""" + for unit in ["B", "KB", "MB", "GB", "TB"]: + if size_bytes < 1024: + return f"{size_bytes:.1f}{unit}" + size_bytes /= 1024 + return f"{size_bytes:.1f}PB" + + +class HfRepoFilesTool: + """Tool for file operations on HF repos.""" + + def __init__(self, hf_token: Optional[str] = None, session: Any = None): + self.api = HfApi(token=hf_token) + self.session = session + + async def execute(self, args: Dict[str, Any]) -> ToolResult: + """Execute the specified operation.""" + operation = args.get("operation") + + if not operation: + return self._help() + + try: + handlers = { + "list": self._list, + "read": self._read, + "upload": self._upload, + "delete": self._delete, + } + + handler = handlers.get(operation) + if handler: + return await handler(args) + else: + return self._error( + f"Unknown operation: {operation}. Valid: list, read, upload, delete" + ) + + except RepositoryNotFoundError: + return self._error(f"Repository not found: {args.get('repo_id')}") + except EntryNotFoundError: + return self._error(f"File not found: {args.get('path')}") + except Exception as e: + return self._error(f"Error: {str(e)}") + + def _help(self) -> ToolResult: + """Show usage instructions.""" + return { + "formatted": """**hf_repo_files** - File operations on HF repos + +**Operations:** +- `list` - List files: `{"operation": "list", "repo_id": "gpt2"}` +- `read` - Read file: `{"operation": "read", "repo_id": "gpt2", "path": "config.json"}` +- `upload` - Upload: `{"operation": "upload", "repo_id": "my-model", "path": "README.md", "content": "..."}` +- `delete` - Delete: `{"operation": "delete", "repo_id": "my-model", "patterns": ["*.tmp"]}` + +**Common params:** repo_id (required), repo_type (model/dataset/space), revision (default: main)""", + "totalResults": 1, + "resultsShared": 1, + } + + async def _list(self, args: Dict[str, Any]) -> ToolResult: + """List files in a repository.""" + repo_id = args.get("repo_id") + if not repo_id: + return self._error("repo_id is required") + + repo_type = args.get("repo_type", "model") + revision = args.get("revision", "main") + path = args.get("path", "") + + items = list( + await _async_call( + self.api.list_repo_tree, + repo_id=repo_id, + repo_type=repo_type, + revision=revision, + path_in_repo=path, + recursive=True, + ) + ) + + if not items: + return { + "formatted": f"No files in {repo_id}", + "totalResults": 0, + "resultsShared": 0, + } + + lines = [] + total_size = 0 + for item in sorted(items, key=lambda x: x.path): + if hasattr(item, "size") and item.size: + total_size += item.size + lines.append(f"{item.path} ({_format_size(item.size)})") + else: + lines.append(f"{item.path}/") + + url = _build_repo_url(repo_id, repo_type) + response = ( + f"**{repo_id}** ({len(items)} files, {_format_size(total_size)})\n{url}/tree/{revision}\n\n" + + "\n".join(lines) + ) + + return { + "formatted": response, + "totalResults": len(items), + "resultsShared": len(items), + } + + async def _read(self, args: Dict[str, Any]) -> ToolResult: + """Read file content from a repository.""" + repo_id = args.get("repo_id") + path = args.get("path") + + if not repo_id: + return self._error("repo_id is required") + if not path: + return self._error("path is required") + + repo_type = args.get("repo_type", "model") + revision = args.get("revision", "main") + max_chars = args.get("max_chars", 50000) + + file_path = await _async_call( + hf_hub_download, + repo_id=repo_id, + filename=path, + repo_type=repo_type, + revision=revision, + token=self.api.token, + ) + + try: + with open(file_path, "r", encoding="utf-8") as f: + content = f.read() + + truncated = len(content) > max_chars + if truncated: + content = content[:max_chars] + + url = f"{_build_repo_url(repo_id, repo_type)}/blob/{revision}/{path}" + response = f"**{path}**{' (truncated)' if truncated else ''}\n{url}\n\n```\n{content}\n```" + + return {"formatted": response, "totalResults": 1, "resultsShared": 1} + + except UnicodeDecodeError: + import os + + size = os.path.getsize(file_path) + return { + "formatted": f"Binary file ({_format_size(size)})", + "totalResults": 1, + "resultsShared": 1, + } + + async def _upload(self, args: Dict[str, Any]) -> ToolResult: + """Upload content to a repository.""" + repo_id = args.get("repo_id") + path = args.get("path") + content = args.get("content") + + if not repo_id: + return self._error("repo_id is required") + if not path: + return self._error("path is required") + if content is None: + return self._error("content is required") + + repo_type = args.get("repo_type", "model") + revision = args.get("revision", "main") + create_pr = args.get("create_pr", False) + commit_message = args.get("commit_message", f"Upload {path}") + + file_bytes = content.encode("utf-8") if isinstance(content, str) else content + + result = await _async_call( + self.api.upload_file, + path_or_fileobj=file_bytes, + path_in_repo=path, + repo_id=repo_id, + repo_type=repo_type, + revision=revision, + commit_message=commit_message, + create_pr=create_pr, + ) + + if not create_pr and is_known_hub_artifact(self.session, repo_id, repo_type): + await _async_call( + register_hub_artifact, + self.api, + repo_id, + repo_type, + session=self.session, + force=path == "README.md", + ) + + url = _build_repo_url(repo_id, repo_type) + if create_pr and hasattr(result, "pr_url"): + response = f"**Uploaded as PR**\n{result.pr_url}" + else: + response = f"**Uploaded:** {path}\n{url}/blob/{revision}/{path}" + + return {"formatted": response, "totalResults": 1, "resultsShared": 1} + + async def _delete(self, args: Dict[str, Any]) -> ToolResult: + """Delete files from a repository.""" + repo_id = args.get("repo_id") + patterns = args.get("patterns") + + if not repo_id: + return self._error("repo_id is required") + if not patterns: + return self._error("patterns is required (list of paths/wildcards)") + + if isinstance(patterns, str): + patterns = [patterns] + + repo_type = args.get("repo_type", "model") + revision = args.get("revision", "main") + create_pr = args.get("create_pr", False) + commit_message = args.get("commit_message", f"Delete {', '.join(patterns)}") + + await _async_call( + self.api.delete_files, + repo_id=repo_id, + delete_patterns=patterns, + repo_type=repo_type, + revision=revision, + commit_message=commit_message, + create_pr=create_pr, + ) + + response = f"**Deleted:** {', '.join(patterns)} from {repo_id}" + return {"formatted": response, "totalResults": 1, "resultsShared": 1} + + def _error(self, message: str) -> ToolResult: + """Return an error result.""" + return { + "formatted": message, + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + +# Tool specification +HF_REPO_FILES_TOOL_SPEC = { + "name": "hf_repo_files", + "description": ( + "Read and write files in HF repos (models/datasets/spaces).\n\n" + "## Operations\n" + "- **list**: List files with sizes and structure\n" + "- **read**: Read file content (text files only)\n" + "- **upload**: Upload content to repo (can create PR)\n" + "- **delete**: Delete files/folders (supports wildcards like *.tmp)\n\n" + "## Use when\n" + "- Need to see what files exist in a repo\n" + "- Want to read config.json, README.md, or other text files\n" + "- Uploading training scripts, configs, or results to a repo\n" + "- Cleaning up temporary files from a repo\n\n" + "## Examples\n" + '{"operation": "list", "repo_id": "meta-llama/Llama-2-7b"}\n' + '{"operation": "read", "repo_id": "gpt2", "path": "config.json"}\n' + '{"operation": "upload", "repo_id": "my-model", "path": "README.md", "content": "# My Model"}\n' + '{"operation": "upload", "repo_id": "org/model", "path": "fix.py", "content": "...", "create_pr": true}\n' + '{"operation": "delete", "repo_id": "my-model", "patterns": ["*.tmp", "logs/"]}\n\n' + "## Notes\n" + "- For binary files (safetensors, bin), use list to see them but can't read content\n" + "- upload/delete require approval (can overwrite/destroy data)\n" + "- Use create_pr=true to propose changes instead of direct commit\n" + ), + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["list", "read", "upload", "delete"], + "description": "Operation: list, read, upload, delete", + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')", + }, + "repo_type": { + "type": "string", + "enum": ["model", "dataset", "space"], + "description": "Repository type (default: model)", + }, + "revision": { + "type": "string", + "description": "Branch/tag/commit (default: main)", + }, + "path": { + "type": "string", + "description": "File path for read/upload", + }, + "content": { + "type": "string", + "description": "File content for upload", + }, + "patterns": { + "type": "array", + "items": {"type": "string"}, + "description": "Patterns to delete (e.g., ['*.tmp', 'logs/'])", + }, + "create_pr": { + "type": "boolean", + "description": "Create PR instead of direct commit", + }, + "commit_message": { + "type": "string", + "description": "Custom commit message", + }, + }, + "required": ["operation"], + }, +} + + +async def hf_repo_files_handler( + arguments: Dict[str, Any], session=None +) -> tuple[str, bool]: + """Handler for agent tool router.""" + try: + hf_token = session.hf_token if session else None + tool = HfRepoFilesTool(hf_token=hf_token, session=session) + result = await tool.execute(arguments) + return result["formatted"], not result.get("isError", False) + except Exception as e: + return f"Error: {str(e)}", False diff --git a/agent/tools/hf_repo_git_tool.py b/agent/tools/hf_repo_git_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..672186c6d245bbca31bfb66aca811d6ff5e98d5f --- /dev/null +++ b/agent/tools/hf_repo_git_tool.py @@ -0,0 +1,750 @@ +""" +HF Repo Git Tool - Git-like operations on Hugging Face repositories + +Operations: branches, tags, PRs, repo management +""" + +import asyncio +from typing import Any, Dict, Optional + +from huggingface_hub import HfApi +from huggingface_hub.utils import RepositoryNotFoundError + +from agent.core.hub_artifacts import register_hub_artifact +from agent.tools.types import ToolResult + + +async def _async_call(func, *args, **kwargs): + """Wrap synchronous HfApi calls for async context.""" + return await asyncio.to_thread(func, *args, **kwargs) + + +def _build_repo_url(repo_id: str, repo_type: str = "model") -> str: + """Build the Hub URL for a repository.""" + if repo_type == "model": + return f"https://huggingface.co/{repo_id}" + return f"https://huggingface.co/{repo_type}s/{repo_id}" + + +class HfRepoGitTool: + """Tool for git-like operations on HF repos.""" + + def __init__(self, hf_token: Optional[str] = None, session: Any = None): + self.api = HfApi(token=hf_token) + self.session = session + + async def execute(self, args: Dict[str, Any]) -> ToolResult: + """Execute the specified operation.""" + operation = args.get("operation") + + if not operation: + return self._help() + + try: + handlers = { + "create_branch": self._create_branch, + "delete_branch": self._delete_branch, + "create_tag": self._create_tag, + "delete_tag": self._delete_tag, + "list_refs": self._list_refs, + "create_pr": self._create_pr, + "list_prs": self._list_prs, + "get_pr": self._get_pr, + "merge_pr": self._merge_pr, + "close_pr": self._close_pr, + "comment_pr": self._comment_pr, + "change_pr_status": self._change_pr_status, + "create_repo": self._create_repo, + "update_repo": self._update_repo, + } + + handler = handlers.get(operation) + if handler: + return await handler(args) + else: + ops = ", ".join(handlers.keys()) + return self._error(f"Unknown operation: {operation}. Valid: {ops}") + + except RepositoryNotFoundError: + return self._error(f"Repository not found: {args.get('repo_id')}") + except Exception as e: + return self._error(f"Error: {str(e)}") + + def _help(self) -> ToolResult: + """Show usage instructions.""" + return { + "formatted": """**hf_repo_git** - Git-like operations on HF repos + +**Branch/Tag:** +- `create_branch`: `{"operation": "create_branch", "repo_id": "...", "branch": "dev"}` +- `delete_branch`: `{"operation": "delete_branch", "repo_id": "...", "branch": "dev"}` +- `create_tag`: `{"operation": "create_tag", "repo_id": "...", "tag": "v1.0"}` +- `delete_tag`: `{"operation": "delete_tag", "repo_id": "...", "tag": "v1.0"}` +- `list_refs`: `{"operation": "list_refs", "repo_id": "..."}` + +**PRs:** +- `create_pr`: `{"operation": "create_pr", "repo_id": "...", "title": "..."}` (creates draft PR) +- `list_prs`: `{"operation": "list_prs", "repo_id": "..."}` (shows status: draft/open/merged/closed) +- `get_pr`: `{"operation": "get_pr", "repo_id": "...", "pr_num": 1}` (shows status) +- `change_pr_status`: `{"operation": "change_pr_status", "repo_id": "...", "pr_num": 1, "new_status": "open"}` (change draft to open) +- `merge_pr`: `{"operation": "merge_pr", "repo_id": "...", "pr_num": 1}` +- `close_pr`: `{"operation": "close_pr", "repo_id": "...", "pr_num": 1}` +- `comment_pr`: `{"operation": "comment_pr", "repo_id": "...", "pr_num": 1, "comment": "..."}` + +**Repo:** +- `create_repo`: `{"operation": "create_repo", "repo_id": "my-model", "private": true}` +- `update_repo`: `{"operation": "update_repo", "repo_id": "...", "private": false}`""", + "totalResults": 1, + "resultsShared": 1, + } + + # ========================================================================= + # BRANCH OPERATIONS + # ========================================================================= + + async def _create_branch(self, args: Dict[str, Any]) -> ToolResult: + """Create a new branch.""" + repo_id = args.get("repo_id") + branch = args.get("branch") + + if not repo_id: + return self._error("repo_id is required") + if not branch: + return self._error("branch is required") + + repo_type = args.get("repo_type", "model") + from_rev = args.get("from_rev", "main") + + await _async_call( + self.api.create_branch, + repo_id=repo_id, + branch=branch, + revision=from_rev, + repo_type=repo_type, + exist_ok=args.get("exist_ok", False), + ) + + url = f"{_build_repo_url(repo_id, repo_type)}/tree/{branch}" + return { + "formatted": f"**Branch created:** {branch}\n{url}", + "totalResults": 1, + "resultsShared": 1, + } + + async def _delete_branch(self, args: Dict[str, Any]) -> ToolResult: + """Delete a branch.""" + repo_id = args.get("repo_id") + branch = args.get("branch") + + if not repo_id: + return self._error("repo_id is required") + if not branch: + return self._error("branch is required") + + repo_type = args.get("repo_type", "model") + + await _async_call( + self.api.delete_branch, + repo_id=repo_id, + branch=branch, + repo_type=repo_type, + ) + + return { + "formatted": f"**Branch deleted:** {branch}", + "totalResults": 1, + "resultsShared": 1, + } + + # ========================================================================= + # TAG OPERATIONS + # ========================================================================= + + async def _create_tag(self, args: Dict[str, Any]) -> ToolResult: + """Create a tag.""" + repo_id = args.get("repo_id") + tag = args.get("tag") + + if not repo_id: + return self._error("repo_id is required") + if not tag: + return self._error("tag is required") + + repo_type = args.get("repo_type", "model") + revision = args.get("revision", "main") + tag_message = args.get("tag_message", "") + + await _async_call( + self.api.create_tag, + repo_id=repo_id, + tag=tag, + revision=revision, + tag_message=tag_message, + repo_type=repo_type, + exist_ok=args.get("exist_ok", False), + ) + + url = f"{_build_repo_url(repo_id, repo_type)}/tree/{tag}" + return { + "formatted": f"**Tag created:** {tag}\n{url}", + "totalResults": 1, + "resultsShared": 1, + } + + async def _delete_tag(self, args: Dict[str, Any]) -> ToolResult: + """Delete a tag.""" + repo_id = args.get("repo_id") + tag = args.get("tag") + + if not repo_id: + return self._error("repo_id is required") + if not tag: + return self._error("tag is required") + + repo_type = args.get("repo_type", "model") + + await _async_call( + self.api.delete_tag, + repo_id=repo_id, + tag=tag, + repo_type=repo_type, + ) + + return { + "formatted": f"**Tag deleted:** {tag}", + "totalResults": 1, + "resultsShared": 1, + } + + # ========================================================================= + # LIST REFS + # ========================================================================= + + async def _list_refs(self, args: Dict[str, Any]) -> ToolResult: + """List branches and tags.""" + repo_id = args.get("repo_id") + + if not repo_id: + return self._error("repo_id is required") + + repo_type = args.get("repo_type", "model") + + refs = await _async_call( + self.api.list_repo_refs, + repo_id=repo_id, + repo_type=repo_type, + ) + + branches = [b.name for b in refs.branches] if refs.branches else [] + tags = ( + [t.name for t in refs.tags] if hasattr(refs, "tags") and refs.tags else [] + ) + + url = _build_repo_url(repo_id, repo_type) + lines = [f"**{repo_id}**", url, ""] + + if branches: + lines.append(f"**Branches ({len(branches)}):** " + ", ".join(branches)) + else: + lines.append("**Branches:** none") + + if tags: + lines.append(f"**Tags ({len(tags)}):** " + ", ".join(tags)) + else: + lines.append("**Tags:** none") + + return { + "formatted": "\n".join(lines), + "totalResults": len(branches) + len(tags), + "resultsShared": len(branches) + len(tags), + } + + # ========================================================================= + # PR OPERATIONS + # ========================================================================= + + async def _create_pr(self, args: Dict[str, Any]) -> ToolResult: + """Create a pull request.""" + repo_id = args.get("repo_id") + title = args.get("title") + + if not repo_id: + return self._error("repo_id is required") + if not title: + return self._error("title is required") + + repo_type = args.get("repo_type", "model") + description = args.get("description", "") + + result = await _async_call( + self.api.create_pull_request, + repo_id=repo_id, + title=title, + description=description, + repo_type=repo_type, + ) + + url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{result.num}" + return { + "formatted": f'**Draft PR #{result.num} created:** {title}\n{url}\n\nAdd commits via upload with revision="refs/pr/{result.num}"', + "totalResults": 1, + "resultsShared": 1, + } + + async def _list_prs(self, args: Dict[str, Any]) -> ToolResult: + """List PRs and discussions.""" + repo_id = args.get("repo_id") + + if not repo_id: + return self._error("repo_id is required") + + repo_type = args.get("repo_type", "model") + status = args.get("status", "all") # open, closed, all + + discussions = list( + self.api.get_repo_discussions( + repo_id=repo_id, + repo_type=repo_type, + discussion_status=status if status != "all" else None, + ) + ) + + if not discussions: + return { + "formatted": f"No discussions in {repo_id}", + "totalResults": 0, + "resultsShared": 0, + } + + url = _build_repo_url(repo_id, repo_type) + lines = [ + f"**{repo_id}** - {len(discussions)} discussions", + f"{url}/discussions", + "", + ] + + for d in discussions[:20]: + if d.status == "draft": + status_label = "[DRAFT]" + elif d.status == "open": + status_label = "[OPEN]" + elif d.status == "merged": + status_label = "[MERGED]" + else: + status_label = "[CLOSED]" + type_label = "PR" if d.is_pull_request else "D" + lines.append(f"{status_label} #{d.num} [{type_label}] {d.title}") + + return { + "formatted": "\n".join(lines), + "totalResults": len(discussions), + "resultsShared": min(20, len(discussions)), + } + + async def _get_pr(self, args: Dict[str, Any]) -> ToolResult: + """Get PR details.""" + repo_id = args.get("repo_id") + pr_num = args.get("pr_num") + + if not repo_id: + return self._error("repo_id is required") + if not pr_num: + return self._error("pr_num is required") + + repo_type = args.get("repo_type", "model") + + pr = await _async_call( + self.api.get_discussion_details, + repo_id=repo_id, + discussion_num=int(pr_num), + repo_type=repo_type, + ) + + url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{pr_num}" + status_map = { + "draft": "Draft", + "open": "Open", + "merged": "Merged", + "closed": "Closed", + } + status = status_map.get(pr.status, pr.status.capitalize()) + type_label = "Pull Request" if pr.is_pull_request else "Discussion" + + lines = [ + f"**{type_label} #{pr_num}:** {pr.title}", + f"**Status:** {status}", + f"**Author:** {pr.author}", + url, + ] + + if pr.is_pull_request: + if pr.status == "draft": + lines.append( + f'\nTo add commits: upload with revision="refs/pr/{pr_num}"' + ) + elif pr.status == "open": + lines.append( + f'\nTo add commits: upload with revision="refs/pr/{pr_num}"' + ) + + return {"formatted": "\n".join(lines), "totalResults": 1, "resultsShared": 1} + + async def _merge_pr(self, args: Dict[str, Any]) -> ToolResult: + """Merge a pull request.""" + repo_id = args.get("repo_id") + pr_num = args.get("pr_num") + + if not repo_id: + return self._error("repo_id is required") + if not pr_num: + return self._error("pr_num is required") + + repo_type = args.get("repo_type", "model") + comment = args.get("comment", "") + + await _async_call( + self.api.merge_pull_request, + repo_id=repo_id, + discussion_num=int(pr_num), + comment=comment, + repo_type=repo_type, + ) + + url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{pr_num}" + return { + "formatted": f"**PR #{pr_num} merged**\n{url}", + "totalResults": 1, + "resultsShared": 1, + } + + async def _close_pr(self, args: Dict[str, Any]) -> ToolResult: + """Close a PR/discussion.""" + repo_id = args.get("repo_id") + pr_num = args.get("pr_num") + + if not repo_id: + return self._error("repo_id is required") + if not pr_num: + return self._error("pr_num is required") + + repo_type = args.get("repo_type", "model") + comment = args.get("comment", "") + + await _async_call( + self.api.change_discussion_status, + repo_id=repo_id, + discussion_num=int(pr_num), + new_status="closed", + comment=comment, + repo_type=repo_type, + ) + + return { + "formatted": f"**Discussion #{pr_num} closed**", + "totalResults": 1, + "resultsShared": 1, + } + + async def _comment_pr(self, args: Dict[str, Any]) -> ToolResult: + """Add a comment to a PR/discussion.""" + repo_id = args.get("repo_id") + pr_num = args.get("pr_num") + comment = args.get("comment") + + if not repo_id: + return self._error("repo_id is required") + if not pr_num: + return self._error("pr_num is required") + if not comment: + return self._error("comment is required") + + repo_type = args.get("repo_type", "model") + + await _async_call( + self.api.comment_discussion, + repo_id=repo_id, + discussion_num=int(pr_num), + comment=comment, + repo_type=repo_type, + ) + + url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{pr_num}" + return { + "formatted": f"**Comment added to #{pr_num}**\n{url}", + "totalResults": 1, + "resultsShared": 1, + } + + async def _change_pr_status(self, args: Dict[str, Any]) -> ToolResult: + """Change PR/discussion status (mainly to convert draft to open).""" + repo_id = args.get("repo_id") + pr_num = args.get("pr_num") + new_status = args.get("new_status") + + if not repo_id: + return self._error("repo_id is required") + if not pr_num: + return self._error("pr_num is required") + if not new_status: + return self._error("new_status is required (open or closed)") + + repo_type = args.get("repo_type", "model") + comment = args.get("comment", "") + + await _async_call( + self.api.change_discussion_status, + repo_id=repo_id, + discussion_num=int(pr_num), + new_status=new_status, + comment=comment, + repo_type=repo_type, + ) + + url = f"{_build_repo_url(repo_id, repo_type)}/discussions/{pr_num}" + return { + "formatted": f"**PR #{pr_num} status changed to {new_status}**\n{url}", + "totalResults": 1, + "resultsShared": 1, + } + + # ========================================================================= + # REPO MANAGEMENT + # ========================================================================= + + async def _create_repo(self, args: Dict[str, Any]) -> ToolResult: + """Create a new repository.""" + repo_id = args.get("repo_id") + + if not repo_id: + return self._error("repo_id is required") + + repo_type = args.get("repo_type", "model") + private = args.get("private", True) + space_sdk = args.get("space_sdk") + + if repo_type == "space" and not space_sdk: + return self._error( + "space_sdk required for spaces (gradio/streamlit/docker/static)" + ) + + kwargs = { + "repo_id": repo_id, + "repo_type": repo_type, + "private": private, + "exist_ok": args.get("exist_ok", False), + } + if space_sdk: + kwargs["space_sdk"] = space_sdk + + result = await _async_call(self.api.create_repo, **kwargs) + extra_metadata = None + if repo_type == "space" and space_sdk: + extra_metadata = {"sdk": space_sdk} + await _async_call( + register_hub_artifact, + self.api, + repo_id, + repo_type, + session=self.session, + extra_metadata=extra_metadata, + ) + + return { + "formatted": f"**Repository created:** {repo_id}\n**Private:** {private}\n{result}", + "totalResults": 1, + "resultsShared": 1, + } + + async def _update_repo(self, args: Dict[str, Any]) -> ToolResult: + """Update repository settings.""" + repo_id = args.get("repo_id") + + if not repo_id: + return self._error("repo_id is required") + + repo_type = args.get("repo_type", "model") + private = args.get("private") + gated = args.get("gated") + + if private is None and gated is None: + return self._error( + "Specify private (bool) or gated ('auto'/'manual'/false)" + ) + + kwargs = {"repo_id": repo_id, "repo_type": repo_type} + if private is not None: + kwargs["private"] = private + if gated is not None: + kwargs["gated"] = gated + + await _async_call(self.api.update_repo_settings, **kwargs) + + changes = [] + if private is not None: + changes.append(f"private={private}") + if gated is not None: + changes.append(f"gated={gated}") + + url = f"{_build_repo_url(repo_id, repo_type)}/settings" + return { + "formatted": f"**Settings updated:** {', '.join(changes)}\n{url}", + "totalResults": 1, + "resultsShared": 1, + } + + def _error(self, message: str) -> ToolResult: + """Return an error result.""" + return { + "formatted": message, + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + +# Tool specification +HF_REPO_GIT_TOOL_SPEC = { + "name": "hf_repo_git", + "description": ( + "Git-like operations on HF repos: branches, tags, PRs, and repo management.\n\n" + "## Operations\n" + "**Branches:** create_branch, delete_branch, list_refs\n" + "**Tags:** create_tag, delete_tag\n" + "**PRs:** create_pr, list_prs, get_pr, merge_pr, close_pr, comment_pr, change_pr_status\n" + "**Repo:** create_repo, update_repo\n\n" + "## Use when\n" + "- Creating feature branches for experiments\n" + "- Tagging model versions (v1.0, v2.0)\n" + "- Opening PRs to contribute to repos you don't own\n" + "- Reviewing and merging PRs on your repos\n" + "- Creating new model/dataset/space repos\n" + "- Changing repo visibility (public/private) or gated access\n\n" + "## Examples\n" + '{"operation": "list_refs", "repo_id": "my-model"}\n' + '{"operation": "create_branch", "repo_id": "my-model", "branch": "experiment-v2"}\n' + '{"operation": "create_tag", "repo_id": "my-model", "tag": "v1.0", "revision": "main"}\n' + '{"operation": "create_pr", "repo_id": "org/model", "title": "Fix tokenizer config"}\n' + '{"operation": "change_pr_status", "repo_id": "my-model", "pr_num": 1, "new_status": "open"}\n' + '{"operation": "merge_pr", "repo_id": "my-model", "pr_num": 3}\n' + '{"operation": "create_repo", "repo_id": "my-new-model", "private": true}\n' + '{"operation": "update_repo", "repo_id": "my-model", "gated": "auto"}\n\n' + "## PR Workflow\n" + "1. create_pr β†’ creates draft PR (empty by default)\n" + "2. Upload files with revision='refs/pr/N' to add commits\n" + "3. change_pr_status with new_status='open' to publish (convert draft to open)\n" + "4. merge_pr when ready\n\n" + "## Notes\n" + "- PR status: draft (default), open, merged, closed\n" + "- delete_branch, delete_tag, merge_pr, create_repo, update_repo require approval\n" + "- For spaces, create_repo needs space_sdk (gradio/streamlit/docker/static)\n" + "- gated options: 'auto' (instant), 'manual' (review), false (open)\n" + ), + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "create_branch", + "delete_branch", + "create_tag", + "delete_tag", + "list_refs", + "create_pr", + "list_prs", + "get_pr", + "merge_pr", + "close_pr", + "comment_pr", + "change_pr_status", + "create_repo", + "update_repo", + ], + "description": "Operation to execute", + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')", + }, + "repo_type": { + "type": "string", + "enum": ["model", "dataset", "space"], + "description": "Repository type (default: model)", + }, + "branch": { + "type": "string", + "description": "Branch name (create_branch, delete_branch)", + }, + "from_rev": { + "type": "string", + "description": "Create branch from this revision (default: main)", + }, + "tag": { + "type": "string", + "description": "Tag name (create_tag, delete_tag)", + }, + "revision": { + "type": "string", + "description": "Revision for tag (default: main)", + }, + "tag_message": { + "type": "string", + "description": "Tag description", + }, + "title": { + "type": "string", + "description": "PR title (create_pr)", + }, + "description": { + "type": "string", + "description": "PR description (create_pr)", + }, + "pr_num": { + "type": "integer", + "description": "PR/discussion number", + }, + "comment": { + "type": "string", + "description": "Comment text", + }, + "status": { + "type": "string", + "enum": ["open", "closed", "all"], + "description": "Filter PRs by status (list_prs)", + }, + "new_status": { + "type": "string", + "enum": ["open", "closed"], + "description": "New status for PR/discussion (change_pr_status)", + }, + "private": { + "type": "boolean", + "description": "Make repo private (create_repo, update_repo)", + }, + "gated": { + "type": "string", + "enum": ["auto", "manual", "false"], + "description": "Gated access setting (update_repo)", + }, + "space_sdk": { + "type": "string", + "enum": ["gradio", "streamlit", "docker", "static"], + "description": "Space SDK (required for create_repo with space)", + }, + }, + "required": ["operation"], + }, +} + + +async def hf_repo_git_handler( + arguments: Dict[str, Any], session=None +) -> tuple[str, bool]: + """Handler for agent tool router.""" + try: + hf_token = session.hf_token if session else None + tool = HfRepoGitTool(hf_token=hf_token, session=session) + result = await tool.execute(arguments) + return result["formatted"], not result.get("isError", False) + except Exception as e: + return f"Error: {str(e)}", False diff --git a/agent/tools/jobs_tool.py b/agent/tools/jobs_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..468c4d9282a9fe7f71c949acfdfb1c4d85272b82 --- /dev/null +++ b/agent/tools/jobs_tool.py @@ -0,0 +1,1290 @@ +""" +Hugging Face Jobs Tool - Using huggingface-hub library + +Refactored to use official huggingface-hub library instead of custom HTTP client +""" + +import asyncio +import base64 +import http.client +import logging +import re +import shlex +from typing import Any, Awaitable, Callable, Dict, Optional + +import httpx +from huggingface_hub import HfApi +from huggingface_hub.utils import HfHubHTTPError + +from agent.core.hf_access import ( + JobsAccessError, + is_billing_error, + resolve_jobs_namespace, +) +from agent.core.hub_artifacts import build_hub_artifact_sitecustomize +from agent.core.session import Event +from agent.tools.trackio_seed import ensure_trackio_dashboard +from agent.tools.types import ToolResult +from agent.tools.utilities import ( + format_job_details, + format_jobs_table, + format_scheduled_job_details, + format_scheduled_jobs_table, +) + +logger = logging.getLogger(__name__) + +# Hardware flavors +CPU_FLAVORS = ["cpu-basic", "cpu-upgrade"] +GPU_FLAVORS = [ + "t4-small", + "t4-medium", + "a10g-small", + "a10g-large", + "a10g-largex2", + "a10g-largex4", + "a100-large", + "a100x4", + "a100x8", + "l4x1", + "l4x4", + "l40sx1", + "l40sx4", + "l40sx8", +] + +# Detailed specs for display (vCPU/RAM/GPU VRAM) +CPU_FLAVORS_DESC = "cpu-basic(2vCPU/16GB), cpu-upgrade(8vCPU/32GB)" +GPU_FLAVORS_DESC = ( + "t4-small(4vCPU/15GB/GPU 16GB), t4-medium(8vCPU/30GB/GPU 16GB), " + "a10g-small(4vCPU/15GB/GPU 24GB), a10g-large(12vCPU/46GB/GPU 24GB), " + "a10g-largex2(24vCPU/92GB/GPU 48GB), a10g-largex4(48vCPU/184GB/GPU 96GB), " + "a100-large(12vCPU/142GB/GPU 80GB), a100x4(48vCPU/568GB/GPU 320GB), a100x8(96vCPU/1136GB/GPU 640GB), " + "l4x1(8vCPU/30GB/GPU 24GB), l4x4(48vCPU/186GB/GPU 96GB), " + "l40sx1(8vCPU/62GB/GPU 48GB), l40sx4(48vCPU/382GB/GPU 192GB), l40sx8(192vCPU/1534GB/GPU 384GB)" +) +# Constants +UV_DEFAULT_IMAGE = "ghcr.io/astral-sh/uv:python3.12-bookworm" + + +def _filter_uv_install_output(logs: list[str]) -> list[str]: + """ + Filter out UV package installation output from logs. + + Replaces installation details with "[installs truncated]" and keeps + the "Installed X packages in Y ms/s" summary line. + + Args: + logs: List of log lines + + Returns: + Filtered list of log lines + """ + if not logs: + return logs + + # Regex pattern to match: "Installed X packages in Y ms" or "Installed X package in Y s" + install_pattern = re.compile( + r"^Installed\s+\d+\s+packages?\s+in\s+\d+(?:\.\d+)?\s*(?:ms|s)$" + ) + + # Find the index of the "Installed X packages" line + install_line_idx = None + for idx, line in enumerate(logs): + if install_pattern.match(line.strip()): + install_line_idx = idx + break + + # If pattern found, replace installation details with truncation message + if install_line_idx is not None and install_line_idx > 0: + # Keep logs from the "Installed X packages" line onward + # Add truncation message before the "Installed" line + return ["[installs truncated]"] + logs[install_line_idx:] + + # If pattern not found, return original logs + return logs + + +_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?\x07") + + +def _strip_ansi(text: str) -> str: + return _ANSI_RE.sub("", text) + + +_DEFAULT_ENV = { + "HF_HUB_DISABLE_PROGRESS_BARS": "1", + "TQDM_DISABLE": "1", + "TRANSFORMERS_VERBOSITY": "warning", + "HF_HUB_ENABLE_HF_TRANSFER": "1", + "UV_NO_PROGRESS": "1", +} + + +def _add_default_env(params: Dict[str, Any] | None) -> Dict[str, Any]: + """Inject default env vars for clean, agent-friendly output.""" + result = dict(_DEFAULT_ENV) + result.update(params or {}) # user-provided values override defaults + return result + + +def _add_environment_variables( + params: Dict[str, Any] | None, user_token: str | None = None +) -> Dict[str, Any]: + token = user_token or "" + + # Start with user-provided env vars, then force-set token last + result = dict(params or {}) + + # If the caller passed HF_TOKEN="$HF_TOKEN", ignore it. + if result.get("HF_TOKEN", "").strip().startswith("$"): + result.pop("HF_TOKEN", None) + + # Set both names to be safe (different libs check different vars) + if token: + result["HF_TOKEN"] = token + result["HUGGINGFACE_HUB_TOKEN"] = token + + return result + + +def _build_uv_command( + script: str, + with_deps: list[str] | None = None, + python: str | None = None, + script_args: list[str] | None = None, +) -> list[str]: + """Build UV run command""" + parts = ["uv", "run"] + + if with_deps: + for dep in with_deps: + parts.extend(["--with", dep]) + + if python: + parts.extend(["-p", python]) + + parts.append(script) + + if script_args: + parts.extend(script_args) + + # add defaults + # parts.extend(["--push_to_hub"]) + return parts + + +def _wrap_inline_script( + script: str, + with_deps: list[str] | None = None, + python: str | None = None, + script_args: list[str] | None = None, +) -> str: + """Wrap inline script with base64 encoding to avoid file creation""" + encoded = base64.b64encode(script.encode("utf-8")).decode("utf-8") + # Build the uv command with stdin (-) + uv_command = _build_uv_command("-", with_deps, python, script_args) + # Join command parts with proper spacing + uv_command_str = " ".join(uv_command) + return f'echo "{encoded}" | base64 -d | {uv_command_str}' + + +def _ensure_hf_transfer_dependency(deps: list[str] | None) -> list[str]: + """Ensure hf-transfer is included in the dependencies list""" + + if isinstance(deps, list): + deps_copy = deps.copy() # Don't modify the original + if "hf-transfer" not in deps_copy: + deps_copy.append("hf-transfer") + return deps_copy + + return ["hf-transfer"] + + +def _resolve_uv_command( + script: str, + with_deps: list[str] | None = None, + python: str | None = None, + script_args: list[str] | None = None, +) -> list[str]: + """Resolve UV command based on script source (URL, inline, or file path)""" + # If URL, use directly + if script.startswith("http://") or script.startswith("https://"): + return _build_uv_command(script, with_deps, python, script_args) + + # If contains newline, treat as inline script + if "\n" in script: + wrapped = _wrap_inline_script(script, with_deps, python, script_args) + return ["/bin/sh", "-lc", wrapped] + + # Otherwise, treat as file path + return _build_uv_command(script, with_deps, python, script_args) + + +def _wrap_command_with_artifact_bootstrap( + command: list[str], session: Any = None +) -> list[str]: + """Install sitecustomize hooks before the user command runs in HF Jobs.""" + sitecustomize = build_hub_artifact_sitecustomize(session) + if not sitecustomize: + return command + + encoded = base64.b64encode(sitecustomize.encode("utf-8")).decode("ascii") + original_command = shlex.join(command) + shell = ( + 'set -e; _ml_intern_artifacts_dir="$(mktemp -d)"; ' + f"printf %s {shlex.quote(encoded)} | base64 -d " + '> "$_ml_intern_artifacts_dir/sitecustomize.py"; ' + 'export PYTHONPATH="$_ml_intern_artifacts_dir${PYTHONPATH:+:$PYTHONPATH}"; ' + f"exec {original_command}" + ) + return ["/bin/sh", "-lc", shell] + + +async def _async_call(func, *args, **kwargs): + """Wrap synchronous HfApi calls for async context""" + return await asyncio.to_thread(func, *args, **kwargs) + + +def _job_info_to_dict(job_info) -> Dict[str, Any]: + """Convert JobInfo object to dictionary for formatting functions""" + return { + "id": job_info.id, + "status": {"stage": job_info.status.stage, "message": job_info.status.message}, + "command": job_info.command, + "createdAt": job_info.created_at.isoformat(), + "dockerImage": job_info.docker_image, + "spaceId": job_info.space_id, + "hardware_flavor": job_info.flavor, + "owner": {"name": job_info.owner.name}, + } + + +def _scheduled_job_info_to_dict(scheduled_job_info) -> Dict[str, Any]: + """Convert ScheduledJobInfo object to dictionary for formatting functions""" + job_spec = scheduled_job_info.job_spec + + # Extract last run and next run from status + last_run = None + next_run = None + if scheduled_job_info.status: + if scheduled_job_info.status.last_job: + last_run = scheduled_job_info.status.last_job.created_at + if last_run: + last_run = ( + last_run.isoformat() + if hasattr(last_run, "isoformat") + else str(last_run) + ) + if scheduled_job_info.status.next_job_run_at: + next_run = scheduled_job_info.status.next_job_run_at + next_run = ( + next_run.isoformat() + if hasattr(next_run, "isoformat") + else str(next_run) + ) + + return { + "id": scheduled_job_info.id, + "schedule": scheduled_job_info.schedule, + "suspend": scheduled_job_info.suspend, + "lastRun": last_run, + "nextRun": next_run, + "jobSpec": { + "dockerImage": job_spec.docker_image, + "spaceId": job_spec.space_id, + "command": job_spec.command or [], + "hardware_flavor": job_spec.flavor or "cpu-basic", + }, + } + + +class HfJobsTool: + """Tool for managing Hugging Face compute jobs using huggingface-hub library""" + + def __init__( + self, + hf_token: Optional[str] = None, + namespace: Optional[str] = None, + jobs_access: Any = None, + log_callback: Optional[Callable[[str], Awaitable[None]]] = None, + session: Any = None, + tool_call_id: Optional[str] = None, + ): + self.hf_token = hf_token + self.api = HfApi(token=hf_token) + self.namespace = namespace + self.jobs_access = jobs_access + self.log_callback = log_callback + self.session = session + self.tool_call_id = tool_call_id + + async def execute(self, params: Dict[str, Any]) -> ToolResult: + """Execute the specified operation""" + operation = params.get("operation") + + args = params + + # If no operation provided, return error + if not operation: + return { + "formatted": "Error: 'operation' parameter is required. See tool description for available operations and usage examples.", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + # Normalize operation name + operation = operation.lower() + + try: + # Route to appropriate handler + if operation == "run": + return await self._run_job(args) + elif operation == "ps": + return await self._list_jobs(args) + elif operation == "logs": + return await self._get_logs(args) + elif operation == "inspect": + return await self._inspect_job(args) + elif operation == "cancel": + return await self._cancel_job(args) + elif operation == "scheduled run": + return await self._scheduled_run(args) + elif operation == "scheduled ps": + return await self._list_scheduled_jobs(args) + elif operation == "scheduled inspect": + return await self._inspect_scheduled_job(args) + elif operation == "scheduled delete": + return await self._delete_scheduled_job(args) + elif operation == "scheduled suspend": + return await self._suspend_scheduled_job(args) + elif operation == "scheduled resume": + return await self._resume_scheduled_job(args) + else: + return { + "formatted": f'Unknown operation: "{operation}"\n\n' + "Available operations:\n" + "- run, ps, logs, inspect, cancel\n" + "- scheduled run, scheduled ps, scheduled inspect, " + "scheduled delete, scheduled suspend, scheduled resume\n\n" + "Call this tool with no operation for full usage instructions.", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + except HfHubHTTPError as e: + return { + "formatted": f"API Error: {str(e)}", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + except Exception as e: + return { + "formatted": f"Error executing {operation}: {str(e)}", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + async def _seed_trackio_dashboard(self, space_id: str) -> None: + """Idempotently install trackio dashboard files into *space_id* before + the job runs. Surfaces seed progress as tool_log events but never + raises β€” a seed failure should not block job submission, since trackio + often still works when the Space already has dashboard code from a + previous run. + """ + loop = asyncio.get_running_loop() + + def _log(msg: str) -> None: + if self.session is None: + return + loop.call_soon_threadsafe( + self.session.event_queue.put_nowait, + Event(event_type="tool_log", data={"tool": "hf_jobs", "log": msg}), + ) + + try: + await asyncio.to_thread( + ensure_trackio_dashboard, space_id, self.hf_token, _log + ) + except Exception as e: + logger.warning(f"trackio dashboard seed failed for {space_id}: {e}") + _log(f"trackio dashboard seed failed: {e}") + + async def _wait_for_job_completion( + self, job_id: str, namespace: Optional[str] = None + ) -> tuple[str, list[str]]: + """ + Stream job logs until completion, printing them in real-time. + Implements retry logic to handle connection drops during long-running jobs. + + Returns: + tuple: (final_status, all_logs) + """ + all_logs = [] + terminal_states = {"COMPLETED", "FAILED", "CANCELED", "ERROR"} + max_retries = 100 # Allow many retries for 8h+ jobs + retry_delay = 5 # Seconds between retries + + for _ in range(max_retries): + try: + # Use a queue to bridge sync generator to async consumer + queue = asyncio.Queue() + loop = asyncio.get_running_loop() + + def log_producer(): + try: + # fetch_job_logs is a blocking sync generator + logs_gen = self.api.fetch_job_logs( + job_id=job_id, namespace=namespace + ) + for line in logs_gen: + # Push line to queue thread-safely + loop.call_soon_threadsafe(queue.put_nowait, line) + # Signal EOF + loop.call_soon_threadsafe(queue.put_nowait, None) + except Exception as e: + # Signal error + loop.call_soon_threadsafe(queue.put_nowait, e) + + # Start producer in a background thread so it doesn't block the event loop + producer_future = loop.run_in_executor(None, log_producer) + + # Consume logs from the queue as they arrive + while True: + item = await queue.get() + + # EOF sentinel + if item is None: + break + + # Error occurred in producer + if isinstance(item, Exception): + raise item + + # Process log line + log_line = item + logger.debug(log_line) + if self.log_callback: + await self.log_callback(log_line) + all_logs.append(log_line) + + # If we get here, streaming completed normally (EOF received) + # Wait for thread to cleanup (should be done) + await producer_future + break + + except ( + ConnectionError, + TimeoutError, + OSError, + http.client.IncompleteRead, + httpx.RemoteProtocolError, + httpx.ReadError, + HfHubHTTPError, + ) as e: + # Connection dropped - check if job is still running + try: + job_info = await _async_call( + self.api.inspect_job, job_id=job_id, namespace=namespace + ) + current_status = job_info.status.stage + + if current_status in terminal_states: + # Job finished, no need to retry + logger.info(f"Job reached terminal state: {current_status}") + break + + # Job still running, retry connection + logger.warning( + f"Connection interrupted ({str(e)[:50]}...), reconnecting in {retry_delay}s..." + ) + await asyncio.sleep(retry_delay) + continue + + except (ConnectionError, TimeoutError, OSError): + # Can't even check job status, wait and retry + logger.warning(f"Connection error, retrying in {retry_delay}s...") + await asyncio.sleep(retry_delay) + continue + + # Fetch final job status β€” retry briefly if still RUNNING + # (the API may lag a few seconds behind the log stream ending) + final_status = "UNKNOWN" + for _ in range(6): + job_info = await _async_call( + self.api.inspect_job, job_id=job_id, namespace=namespace + ) + final_status = job_info.status.stage + if final_status in terminal_states: + break + await asyncio.sleep(2.5) + + return final_status, all_logs + + async def _run_job(self, args: Dict[str, Any]) -> ToolResult: + """Run a job using HfApi.run_job() - smart detection of Python vs Docker mode""" + try: + script = args.get("script") + command = args.get("command") + + # Validate mutually exclusive parameters + if script and command: + raise ValueError( + "'script' and 'command' are mutually exclusive. Provide one or the other, not both." + ) + + if not script and not command: + raise ValueError( + "Either 'script' (for Python) or 'command' (for Docker) must be provided." + ) + + # Python mode: script provided + if script: + # Get dependencies and ensure hf-transfer is included + deps = _ensure_hf_transfer_dependency(args.get("dependencies")) + + # Resolve the command based on script type (URL, inline, or file) + command = _resolve_uv_command( + script=script, + with_deps=deps, + python=args.get("python"), + script_args=args.get("script_args"), + ) + + # Use UV image unless overridden + image = args.get("image", UV_DEFAULT_IMAGE) + job_type = "Python" + + # Docker mode: command provided + else: + image = args.get("image", "python:3.12") + job_type = "Docker" + + command = _wrap_command_with_artifact_bootstrap(command, self.session) + + # Run the job + flavor = args.get("hardware_flavor", "cpu-basic") + timeout_str = args.get("timeout", "30m") + + # Trackio: agent-declared space + project become env vars on the job + # so trackio.init() picks them up automatically. We also surface them + # in tool_state_change so the frontend can embed the dashboard. + env_dict = _add_default_env(args.get("env")) + trackio_space_id = args.get("trackio_space_id") + trackio_project = args.get("trackio_project") + if trackio_space_id: + env_dict["TRACKIO_SPACE_ID"] = trackio_space_id + await self._seed_trackio_dashboard(trackio_space_id) + if trackio_project: + env_dict["TRACKIO_PROJECT"] = trackio_project + + try: + job = await _async_call( + self.api.run_job, + image=image, + command=command, + env=env_dict, + secrets=_add_environment_variables( + args.get("secrets"), self.hf_token + ), + flavor=flavor, + timeout=timeout_str, + namespace=self.namespace, + ) + except HfHubHTTPError as e: + if is_billing_error(str(e)): + if self.session and self.tool_call_id: + await self.session.send_event( + Event( + event_type="tool_state_change", + data={ + "tool_call_id": self.tool_call_id, + "tool": "hf_jobs", + "state": "billing_required", + "namespace": self.namespace, + }, + ) + ) + return { + "formatted": ( + f"Hugging Face Jobs rejected this run because the " + f"namespace `{self.namespace}` has no available credits. " + "HF Jobs are billed with namespace credits, which are " + "separate from HF Pro membership. Tell the user to add " + "credits at https://huggingface.co/settings/billing β€” " + "once topped up, re-run this same job. (Switching " + "namespaces is fine if another wallet has credits.)" + ), + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + raise + + # Track job ID for cancellation on interrupt + if self.session: + self.session._running_job_ids.add(job.id) + + # Send job URL immediately after job creation (before waiting for completion) + if self.session and self.tool_call_id: + state_data: Dict[str, Any] = { + "tool_call_id": self.tool_call_id, + "tool": "hf_jobs", + "state": "running", + "jobUrl": job.url, + } + if trackio_space_id: + state_data["trackioSpaceId"] = trackio_space_id + if trackio_project: + state_data["trackioProject"] = trackio_project + await self.session.send_event( + Event(event_type="tool_state_change", data=state_data) + ) + + # Telemetry: job submission + completion (infra consumption signal). + submit_ts = None + if self.session: + from agent.core import telemetry + + submit_ts = await telemetry.record_hf_job_submit( + self.session, + job, + { + **args, + "hardware_flavor": flavor, + "timeout": timeout_str, + "namespace": self.namespace, + }, + image=image, + job_type=job_type, + ) + # Top-up signal: this submit succeeded after a prior billing + # block in the same session, and we haven't fired the event + # yet β€” the user came back from the HF billing flow. + events = self.session.logged_events + already_fired = any( + e.get("event_type") == "credits_topped_up" for e in events + ) + if not already_fired: + blocked = any( + e.get("event_type") == "tool_state_change" + and (e.get("data") or {}).get("state") == "billing_required" + for e in events + ) + if blocked: + await telemetry.record_credits_topped_up( + self.session, + namespace=self.namespace, + ) + + # Wait for completion and stream logs + logger.info(f"{job_type} job started: {job.url}") + logger.info("Streaming logs...") + + final_status, all_logs = await self._wait_for_job_completion( + job_id=job.id, + namespace=self.namespace, + ) + + if self.session and submit_ts is not None: + from agent.core import telemetry + + usage = await telemetry.record_hf_job_complete( + self.session, + job, + flavor=flavor, + final_status=final_status, + submit_ts=submit_ts, + ) + if self.tool_call_id: + from agent.core.yolo_budget import reconcile_budget_reservation + + reconcile_budget_reservation( + self.session, + self.tool_call_id, + usage.get("estimated_cost_usd") + if isinstance(usage, dict) + else None, + allow_zero_actual=True, + ) + + # Untrack job ID (completed or failed, no longer needs cancellation) + if self.session: + self.session._running_job_ids.discard(job.id) + + # Notify frontend of final status + if self.session and self.tool_call_id: + final_data: Dict[str, Any] = { + "tool_call_id": self.tool_call_id, + "tool": "hf_jobs", + "state": final_status.lower(), + "jobUrl": job.url, + } + if trackio_space_id: + final_data["trackioSpaceId"] = trackio_space_id + if trackio_project: + final_data["trackioProject"] = trackio_project + await self.session.send_event( + Event(event_type="tool_state_change", data=final_data) + ) + + # Filter out UV package installation output + filtered_logs = _filter_uv_install_output(all_logs) + + # Format all logs for the agent + log_text = ( + _strip_ansi("\n".join(filtered_logs)) if filtered_logs else "(no logs)" + ) + + response = f"""{job_type} job completed! + +**Job ID:** {job.id} +**Final Status:** {final_status} +**View at:** {job.url} + +**Logs:** +``` +{log_text} +```""" + return {"formatted": response, "totalResults": 1, "resultsShared": 1} + + except Exception as e: + raise Exception(f"Failed to run job: {str(e)}") + + async def _list_jobs(self, args: Dict[str, Any]) -> ToolResult: + """List jobs using HfApi.list_jobs()""" + jobs_list = await _async_call(self.api.list_jobs, namespace=self.namespace) + + # Filter jobs + if not args.get("all", False): + jobs_list = [j for j in jobs_list if j.status.stage == "RUNNING"] + + if args.get("status"): + status_filter = args["status"].upper() + jobs_list = [j for j in jobs_list if status_filter in j.status.stage] + + # Convert JobInfo objects to dicts for formatting + jobs_dicts = [_job_info_to_dict(j) for j in jobs_list] + + table = format_jobs_table(jobs_dicts) + + if len(jobs_list) == 0: + if args.get("all", False): + return { + "formatted": "No jobs found.", + "totalResults": 0, + "resultsShared": 0, + } + return { + "formatted": 'No running jobs found. Use `{"operation": "ps", "all": true}` to show all jobs.', + "totalResults": 0, + "resultsShared": 0, + } + + response = f"**Jobs ({len(jobs_list)} total):**\n\n{table}" + return { + "formatted": response, + "totalResults": len(jobs_list), + "resultsShared": len(jobs_list), + } + + async def _get_logs(self, args: Dict[str, Any]) -> ToolResult: + """Fetch logs using HfApi.fetch_job_logs()""" + job_id = args.get("job_id") + if not job_id: + return { + "formatted": "job_id is required", + "isError": True, + "totalResults": 0, + "resultsShared": 0, + } + + try: + # Fetch logs (returns generator, convert to list) + logs_gen = self.api.fetch_job_logs(job_id=job_id, namespace=self.namespace) + logs = await _async_call(list, logs_gen) + + if not logs: + return { + "formatted": f"No logs available for job {job_id}", + "totalResults": 0, + "resultsShared": 0, + } + + log_text = _strip_ansi("\n".join(logs)) + return { + "formatted": f"**Logs for {job_id}:**\n\n```\n{log_text}\n```", + "totalResults": 1, + "resultsShared": 1, + } + + except Exception as e: + return { + "formatted": f"Failed to fetch logs: {str(e)}", + "isError": True, + "totalResults": 0, + "resultsShared": 0, + } + + async def _inspect_job(self, args: Dict[str, Any]) -> ToolResult: + """Inspect job using HfApi.inspect_job()""" + job_id = args.get("job_id") + if not job_id: + return { + "formatted": "job_id is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + job_ids = job_id if isinstance(job_id, list) else [job_id] + + jobs = [] + for jid in job_ids: + try: + job = await _async_call( + self.api.inspect_job, + job_id=jid, + namespace=self.namespace, + ) + jobs.append(_job_info_to_dict(job)) + except Exception as e: + raise Exception(f"Failed to inspect job {jid}: {str(e)}") + + formatted_details = format_job_details(jobs) + response = f"**Job Details** ({len(jobs)} job{'s' if len(jobs) > 1 else ''}):\n\n{formatted_details}" + + return { + "formatted": response, + "totalResults": len(jobs), + "resultsShared": len(jobs), + } + + async def _cancel_job(self, args: Dict[str, Any]) -> ToolResult: + """Cancel job using HfApi.cancel_job()""" + job_id = args.get("job_id") + if not job_id: + return { + "formatted": "job_id is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + await _async_call( + self.api.cancel_job, + job_id=job_id, + namespace=self.namespace, + ) + + response = f"""βœ“ Job {job_id} has been cancelled. + +To verify, call this tool with `{{"operation": "inspect", "job_id": "{job_id}"}}`""" + + return {"formatted": response, "totalResults": 1, "resultsShared": 1} + + async def _scheduled_run(self, args: Dict[str, Any]) -> ToolResult: + """Create scheduled job using HfApi.create_scheduled_job() - smart detection of Python vs Docker mode""" + try: + script = args.get("script") + command = args.get("command") + schedule = args.get("schedule") + + if not schedule: + raise ValueError("schedule is required for scheduled jobs") + + # Validate mutually exclusive parameters + if script and command: + raise ValueError( + "'script' and 'command' are mutually exclusive. Provide one or the other, not both." + ) + + if not script and not command: + raise ValueError( + "Either 'script' (for Python) or 'command' (for Docker) must be provided." + ) + + # Python mode: script provided + if script: + # Get dependencies and ensure hf-transfer is included + deps = _ensure_hf_transfer_dependency(args.get("dependencies")) + + # Resolve the command based on script type + command = _resolve_uv_command( + script=script, + with_deps=deps, + python=args.get("python"), + script_args=args.get("script_args"), + ) + + # Use UV image unless overridden + image = args.get("image", UV_DEFAULT_IMAGE) + job_type = "Python" + + # Docker mode: command provided + else: + image = args.get("image", "python:3.12") + job_type = "Docker" + + command = _wrap_command_with_artifact_bootstrap(command, self.session) + + # Create scheduled job + scheduled_job = await _async_call( + self.api.create_scheduled_job, + image=image, + command=command, + schedule=schedule, + env=_add_default_env(args.get("env")), + secrets=_add_environment_variables(args.get("secrets"), self.hf_token), + flavor=args.get("hardware_flavor", "cpu-basic"), + timeout=args.get("timeout", "30m"), + namespace=self.namespace, + ) + + scheduled_dict = _scheduled_job_info_to_dict(scheduled_job) + + response = f"""βœ“ Scheduled {job_type} job created successfully! + +**Scheduled Job ID:** {scheduled_dict["id"]} +**Schedule:** {scheduled_dict["schedule"]} +**Suspended:** {"Yes" if scheduled_dict.get("suspend") else "No"} +**Next Run:** {scheduled_dict.get("nextRun", "N/A")} + +To inspect, call this tool with `{{"operation": "scheduled inspect", "scheduled_job_id": "{scheduled_dict["id"]}"}}` +To list all, call this tool with `{{"operation": "scheduled ps"}}`""" + + return {"formatted": response, "totalResults": 1, "resultsShared": 1} + + except Exception as e: + raise Exception(f"Failed to create scheduled job: {str(e)}") + + async def _list_scheduled_jobs(self, args: Dict[str, Any]) -> ToolResult: + """List scheduled jobs using HfApi.list_scheduled_jobs()""" + scheduled_jobs_list = await _async_call( + self.api.list_scheduled_jobs, + namespace=self.namespace, + ) + + # Filter jobs - default: hide suspended jobs unless --all is specified + if not args.get("all", False): + scheduled_jobs_list = [j for j in scheduled_jobs_list if not j.suspend] + + # Convert to dicts for formatting + scheduled_dicts = [_scheduled_job_info_to_dict(j) for j in scheduled_jobs_list] + + table = format_scheduled_jobs_table(scheduled_dicts) + + if len(scheduled_jobs_list) == 0: + if args.get("all", False): + return { + "formatted": "No scheduled jobs found.", + "totalResults": 0, + "resultsShared": 0, + } + return { + "formatted": 'No active scheduled jobs found. Use `{"operation": "scheduled ps", "all": true}` to show suspended jobs.', + "totalResults": 0, + "resultsShared": 0, + } + + response = f"**Scheduled Jobs ({len(scheduled_jobs_list)} total):**\n\n{table}" + return { + "formatted": response, + "totalResults": len(scheduled_jobs_list), + "resultsShared": len(scheduled_jobs_list), + } + + async def _inspect_scheduled_job(self, args: Dict[str, Any]) -> ToolResult: + """Inspect scheduled job using HfApi.inspect_scheduled_job()""" + scheduled_job_id = args.get("scheduled_job_id") + if not scheduled_job_id: + return { + "formatted": "scheduled_job_id is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + scheduled_job = await _async_call( + self.api.inspect_scheduled_job, + scheduled_job_id=scheduled_job_id, + namespace=self.namespace, + ) + + scheduled_dict = _scheduled_job_info_to_dict(scheduled_job) + formatted_details = format_scheduled_job_details(scheduled_dict) + + return { + "formatted": f"**Scheduled Job Details:**\n\n{formatted_details}", + "totalResults": 1, + "resultsShared": 1, + } + + async def _delete_scheduled_job(self, args: Dict[str, Any]) -> ToolResult: + """Delete scheduled job using HfApi.delete_scheduled_job()""" + scheduled_job_id = args.get("scheduled_job_id") + if not scheduled_job_id: + return { + "formatted": "scheduled_job_id is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + await _async_call( + self.api.delete_scheduled_job, + scheduled_job_id=scheduled_job_id, + namespace=self.namespace, + ) + + return { + "formatted": f"βœ“ Scheduled job {scheduled_job_id} has been deleted.", + "totalResults": 1, + "resultsShared": 1, + } + + async def _suspend_scheduled_job(self, args: Dict[str, Any]) -> ToolResult: + """Suspend scheduled job using HfApi.suspend_scheduled_job()""" + scheduled_job_id = args.get("scheduled_job_id") + if not scheduled_job_id: + return { + "formatted": "scheduled_job_id is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + await _async_call( + self.api.suspend_scheduled_job, + scheduled_job_id=scheduled_job_id, + namespace=self.namespace, + ) + + response = f"""βœ“ Scheduled job {scheduled_job_id} has been suspended. + +To resume, call this tool with `{{"operation": "scheduled resume", "scheduled_job_id": "{scheduled_job_id}"}}`""" + + return {"formatted": response, "totalResults": 1, "resultsShared": 1} + + async def _resume_scheduled_job(self, args: Dict[str, Any]) -> ToolResult: + """Resume scheduled job using HfApi.resume_scheduled_job()""" + scheduled_job_id = args.get("scheduled_job_id") + if not scheduled_job_id: + return { + "formatted": "scheduled_job_id is required", + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + await _async_call( + self.api.resume_scheduled_job, + scheduled_job_id=scheduled_job_id, + namespace=self.namespace, + ) + + response = f"""βœ“ Scheduled job {scheduled_job_id} has been resumed. + +To inspect, call this tool with `{{"operation": "scheduled inspect", "scheduled_job_id": "{scheduled_job_id}"}}`""" + + return {"formatted": response, "totalResults": 1, "resultsShared": 1} + + +# Tool specification for agent registration +HF_JOBS_TOOL_SPEC = { + "name": "hf_jobs", + "description": ( + "Execute Python scripts or Docker containers on HF cloud infrastructure.\n\n" + "Two modes (mutually exclusive): Python mode (script + dependencies) or Docker mode (command + image). " + "Provide exactly ONE of 'script' or 'command'.\n\n" + "BEFORE submitting training/fine-tuning jobs:\n" + "- You MUST have called github_find_examples + github_read_file to find a working reference implementation. " + "Scripts based on your internal knowledge WILL use outdated APIs and fail.\n" + "- You MUST have validated dataset format via hf_inspect_dataset or hub_repo_details.\n" + "- If the job runs on GPU, or the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, " + "or torch.compile, you MUST create a GPU sandbox with sandbox_create first, run a tiny smoke test there, " + "and fix failures before submitting. If skipped, state why before calling hf_jobs.\n" + "- Training config MUST include push_to_hub=True and hub_model_id. " + "Job storage is EPHEMERAL β€” all files are deleted when the job ends. Without push_to_hub, trained models are lost permanently.\n" + "- Include trackio monitoring and provide the dashboard URL to the user. " + "When the script uses report_to='trackio', also pass `trackio_space_id` " + "(e.g. '/ml-intern-<8char>') and `trackio_project` as tool args β€” " + "they are injected as TRACKIO_SPACE_ID/TRACKIO_PROJECT env vars and let the UI embed the live dashboard.\n\n" + "BATCH/ABLATION JOBS: Submit ONE job first. Check logs to confirm it starts training successfully. " + "Only then submit the remaining jobs. Never submit all at once β€” if there's a bug, all jobs fail.\n\n" + "Operations: run, ps, logs, inspect, cancel, scheduled run/ps/inspect/delete/suspend/resume.\n\n" + f"Hardware: CPU: {CPU_FLAVORS_DESC}. GPU: {GPU_FLAVORS_DESC}.\n" + "Common picks: t4-small ($0.60/hr, 1-3B), a10g-large ($2/hr, 7-13B), a100-large ($4/hr, 30B+), h100 ($6/hr, 70B+). " + "Note: a10g-small and a10g-large have the SAME 24GB GPU β€” the difference is CPU/RAM only.\n\n" + "OOM RECOVERY: When a training job fails with CUDA OOM:\n" + "1. Reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally (keep effective batch size identical)\n" + "2. Enable gradient_checkpointing=True\n" + "3. Upgrade to larger GPU (a10gβ†’a100β†’h100)\n" + "Do NOT switch training methods (e.g. full SFT to LoRA) or reduce max_length β€” those change what the user gets and require explicit approval.\n\n" + "Examples:\n" + "Training: {'operation': 'run', 'script': '/app/train.py', 'dependencies': ['transformers', 'trl', 'torch', 'datasets', 'trackio'], 'hardware_flavor': 'a100-large', 'timeout': '8h'}\n" + "Monitor: {'operation': 'ps'}, {'operation': 'logs', 'job_id': 'xxx'}, {'operation': 'cancel', 'job_id': 'xxx'}" + "Docker: {'operation': 'run', 'command': ['duckdb', '-c', 'select 1 + 2'], 'image': 'duckdb/duckdb', 'hardware_flavor': 'cpu-basic', 'timeout': '1h'}\n" + ), + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "run", + "ps", + "logs", + "inspect", + "cancel", + "scheduled run", + "scheduled ps", + "scheduled inspect", + "scheduled delete", + "scheduled suspend", + "scheduled resume", + ], + "description": "Operation to execute.", + }, + "script": { + "type": "string", + "description": ( + "Python code, sandbox file path (e.g. '/app/train.py', './train.py', or bare 'train.py'), or URL. " + "Triggers Python mode. For ML training: base this on a working example found via github_find_examples, not on internal knowledge. " + "For GPU/model-loading training scripts, smoke-test in a GPU sandbox before submission. " + "Mutually exclusive with 'command'." + ), + }, + "dependencies": { + "type": "array", + "items": {"type": "string"}, + "description": ( + "Pip packages to install. Include ALL required packages. " + "Common training set: ['transformers', 'trl', 'torch', 'datasets', 'trackio', 'accelerate']. " + "Only used with 'script'." + ), + }, + "image": { + "type": "string", + "description": "Docker image. Optional β€” auto-selected if not provided. Use with 'command'.", + }, + "command": { + "type": "array", + "items": {"type": "string"}, + "description": "Command to execute as list. Triggers Docker mode. Mutually exclusive with 'script'.", + }, + "hardware_flavor": { + "type": "string", + "description": ( + "Hardware type. Sizing guide: 1-3B params β†’ t4-small/a10g-small, " + "7-13B β†’ a10g-large, 30B+ β†’ a100-large, 70B+ β†’ h100/h100x8. " + f"All options: CPU: {CPU_FLAVORS}. GPU: {GPU_FLAVORS}." + ), + }, + "timeout": { + "type": "string", + "description": ( + "Maximum job runtime. MUST be >2h for any training job β€” default 30m kills training mid-run. " + "Guidelines: 1-3B models: 3-4h, 7-13B: 6-8h, 30B+: 12-24h. " + "Use 30m-1h only for quick data processing or inference tasks. Default: '30m'." + ), + }, + "env": { + "type": "object", + "description": "Environment variables {'KEY': 'VALUE'}. HF_TOKEN is auto-included.", + }, + "trackio_space_id": { + "type": "string", + "description": ( + "Optional. The HF Space hosting the trackio dashboard for this run " + "(e.g. '/ml-intern-<8char>', under YOUR HF namespace). " + "Injected as TRACKIO_SPACE_ID env var and used by the UI to embed " + "the live dashboard. Set this whenever the script uses " + "report_to='trackio'. The Space is auto-created and seeded with the " + "trackio dashboard before the job starts β€” DO NOT pre-create it via " + "hf_repo_git, that produces an empty Space that breaks the embed." + ), + }, + "trackio_project": { + "type": "string", + "description": ( + "Optional. The trackio project name to log this run under. " + "Injected as TRACKIO_PROJECT env var and used by the UI to filter " + "the embedded dashboard to this project." + ), + }, + "namespace": { + "type": "string", + "description": ( + "Optional namespace to run the job under. Must be the caller's own " + "account or an org they belong to. If omitted, defaults to the " + "caller's personal account. Credits are billed against this namespace." + ), + }, + "job_id": { + "type": "string", + "description": "Job ID. Required for: logs, inspect, cancel.", + }, + "scheduled_job_id": { + "type": "string", + "description": "Scheduled job ID. Required for: scheduled inspect/delete/suspend/resume.", + }, + "schedule": { + "type": "string", + "description": "Cron schedule or preset (@hourly, @daily, @weekly, @monthly). Required for: scheduled run.", + }, + }, + "required": ["operation"], + }, +} + + +async def hf_jobs_handler( + arguments: Dict[str, Any], session: Any = None, tool_call_id: str | None = None +) -> tuple[str, bool]: + """Handler for agent tool router""" + try: + + async def log_callback(log: str): + if session: + await session.send_event( + Event(event_type="tool_log", data={"tool": "hf_jobs", "log": log}) + ) + + # If script is a sandbox file path, read it from the sandbox + script = arguments.get("script", "") + sandbox = getattr(session, "sandbox", None) if session else None + if sandbox and script: + from agent.tools.sandbox_tool import resolve_sandbox_script + + content, error = await resolve_sandbox_script(sandbox, script) + if error: + return error, False + if content: + arguments = {**arguments, "script": content} + + hf_token = session.hf_token if session else None + try: + namespace, jobs_access = await resolve_jobs_namespace( + hf_token or "", + arguments.get("namespace"), + ) + except JobsAccessError as e: + return str(e), False + + tool = HfJobsTool( + namespace=namespace, + hf_token=hf_token, + jobs_access=jobs_access, + log_callback=log_callback if session else None, + session=session, + tool_call_id=tool_call_id, + ) + result = await tool.execute(arguments) + return result["formatted"], not result.get("isError", False) + except Exception as e: + return f"Error executing HF Jobs tool: {str(e)}", False diff --git a/agent/tools/local_tools.py b/agent/tools/local_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..50cd5bd65b517f8855ceeb87ffade52a04e25a15 --- /dev/null +++ b/agent/tools/local_tools.py @@ -0,0 +1,441 @@ +""" +Local tool implementations β€” bash/read/write/edit running on the user's machine. + +Drop-in replacement for sandbox tools when running in CLI (local) mode. +Same tool specs (names, parameters) but handlers execute locally via +subprocess/pathlib instead of going through a remote sandbox. +""" + +from __future__ import annotations + +import os +import re +import subprocess +import tempfile +from pathlib import Path +from typing import Any + +from agent.core.hub_artifacts import wrap_shell_command_with_hub_artifact_bootstrap + + +MAX_OUTPUT_CHARS = 25_000 +MAX_LINE_LENGTH = 4000 +DEFAULT_READ_LINES = 2000 +DEFAULT_TIMEOUT = 120 +MAX_TIMEOUT = 36000 # 10 hours β€” needed for long training runs (e.g. PostTrainBench) + +_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?\x07") + +# Track files that have been read this session (enforces read-before-write/edit) +_files_read: set[str] = set() + + +def _resolve_path(path: str) -> str: + try: + return str(Path(path).resolve()) + except Exception: + return path + + +def _atomic_write(path: Path, content: str) -> None: + """Write file atomically via temp file + os.replace(). + + Ensures the file is never left in a partial/corrupted state β€” it's either + the old content or the new content, never half-written. + """ + path.parent.mkdir(parents=True, exist_ok=True) + fd = None + tmp_path = None + try: + fd, tmp_path = tempfile.mkstemp(dir=path.parent, suffix=".tmp") + os.write(fd, content.encode("utf-8")) + os.fsync(fd) + os.close(fd) + fd = None + os.replace(tmp_path, str(path)) + tmp_path = None # successfully replaced, nothing to clean up + finally: + if fd is not None: + os.close(fd) + if tmp_path is not None: + try: + os.unlink(tmp_path) + except OSError: + pass + + +def _strip_ansi(text: str) -> str: + return _ANSI_RE.sub("", text) + + +def _truncate_output( + output: str, max_chars: int = MAX_OUTPUT_CHARS, head_ratio: float = 0.25 +) -> str: + """Tail-biased truncation with temp file spillover for full output access.""" + if len(output) <= max_chars: + return output + # Write full output to temp file so LLM can read specific sections + spill_path = None + try: + with tempfile.NamedTemporaryFile( + mode="w", suffix=".txt", prefix="bash_output_", delete=False + ) as f: + f.write(output) + spill_path = f.name + except Exception: + pass + head_budget = int(max_chars * head_ratio) + tail_budget = max_chars - head_budget + head = output[:head_budget] + tail = output[-tail_budget:] + total = len(output) + omitted = total - max_chars + meta = f"\n\n... ({omitted:,} of {total:,} chars omitted, showing first {head_budget:,} + last {tail_budget:,}) ...\n" + if spill_path: + meta += f"Full output saved to {spill_path} β€” use the read tool with offset/limit to inspect specific sections.\n" + meta += "IMPORTANT: The command has finished. Analyze the output above and continue with your next action.\n" + return head + meta + tail + + +# ── Handlers ──────────────────────────────────────────────────────────── + + +async def _bash_handler( + args: dict[str, Any], session: Any = None, **_kw +) -> tuple[str, bool]: + command = args.get("command", "") + if not command: + return "No command provided.", False + command = wrap_shell_command_with_hub_artifact_bootstrap(command, session) + work_dir = args.get("work_dir", ".") + timeout = min(args.get("timeout") or DEFAULT_TIMEOUT, MAX_TIMEOUT) + try: + result = subprocess.run( + command, + shell=True, + capture_output=True, + text=True, + cwd=work_dir, + timeout=timeout, + ) + output = _strip_ansi(result.stdout + result.stderr) + output = _truncate_output(output) + if not output.strip(): + output = "(no output)" + return output, result.returncode == 0 + except subprocess.TimeoutExpired: + return ( + f"Command timed out after {timeout}s and was killed.\n\n" + f"For long-running commands, run in the background and poll:\n" + f" nohup > /tmp/output.log 2>&1 & echo $!\n" + f"Then check status with:\n" + f" kill -0 2>/dev/null && echo 'running' || echo 'done'\n" + f" tail -n 50 /tmp/output.log" + ), False + except Exception as e: + return f"bash error: {e}", False + + +async def _read_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]: + file_path = args.get("path", "") + if not file_path: + return "No path provided.", False + p = Path(file_path) + if not p.exists(): + return f"File not found: {file_path}", False + if p.is_dir(): + return "Cannot read a directory. Use bash with 'ls' instead.", False + try: + raw_content = p.read_text() + except Exception as e: + return f"read error: {e}", False + + _files_read.add(_resolve_path(file_path)) + + lines = raw_content.splitlines() + offset = max((args.get("offset") or 1), 1) + limit = args.get("limit") or DEFAULT_READ_LINES + + selected = lines[offset - 1 : offset - 1 + limit] + numbered = [] + for i, line in enumerate(selected, start=offset): + if len(line) > MAX_LINE_LENGTH: + line = line[:MAX_LINE_LENGTH] + "..." + numbered.append(f"{i:>6}\t{line}") + + return "\n".join(numbered), True + + +async def _write_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]: + file_path = args.get("path", "") + content = args.get("content", "") + if not file_path: + return "No path provided.", False + p = Path(file_path) + if p.exists() and _resolve_path(file_path) not in _files_read: + return ( + f"You must read {file_path} before overwriting it. " + f"Use the read tool first to see current contents." + ), False + try: + _atomic_write(p, content) + _files_read.add(_resolve_path(file_path)) + msg = f"Wrote {len(content)} bytes to {file_path}" + # Syntax validation for Python files + if p.suffix == ".py": + from agent.tools.edit_utils import validate_python + + warnings = validate_python(content, file_path) + if warnings: + msg += "\n\nValidation warnings:\n" + "\n".join( + f" ⚠ {w}" for w in warnings + ) + return msg, True + except Exception as e: + return f"write error: {e}", False + + +async def _edit_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]: + from agent.tools.edit_utils import apply_edit, validate_python + + file_path = args.get("path", "") + old_str = args.get("old_str", "") + new_str = args.get("new_str", "") + replace_all = args.get("replace_all", False) + mode = args.get("mode", "replace") + + if not file_path: + return "No path provided.", False + if old_str == new_str: + return "old_str and new_str must differ.", False + + p = Path(file_path) + if not p.exists(): + return f"File not found: {file_path}", False + if _resolve_path(file_path) not in _files_read: + return ( + f"You must read {file_path} before editing it. " + f"Use the read tool first to see current contents." + ), False + + try: + text = p.read_text() + except Exception as e: + return f"edit read error: {e}", False + + try: + new_text, replacements, fuzzy_note = apply_edit( + text, old_str, new_str, mode=mode, replace_all=replace_all + ) + except ValueError as e: + return str(e), False + + try: + _atomic_write(p, new_text) + except Exception as e: + return f"edit write error: {e}", False + + msg = f"Edited {file_path} ({replacements} replacement{'s' if replacements > 1 else ''})" + if fuzzy_note: + msg += f" {fuzzy_note}" + # Syntax validation for Python files + if p.suffix == ".py": + warnings = validate_python(new_text, file_path) + if warnings: + msg += "\n\nValidation warnings:\n" + "\n".join( + f" ⚠ {w}" for w in warnings + ) + return msg, True + + +# ── Local tool specs (override sandbox /app references) ──────────────── + +_LOCAL_TOOL_SPECS = { + "bash": { + "description": ( + "Run a shell command on the local machine and return stdout/stderr.\n" + "\n" + "IMPORTANT: Do NOT use bash for file operations β€” use the dedicated tools instead:\n" + "- To read files: use read (not cat/head/tail)\n" + "- To edit files: use edit (not sed/awk)\n" + "- To write files: use write (not echo/cat < > /tmp/output.log 2>&1 & echo $!\n" + "Then check status:\n" + " kill -0 2>/dev/null && echo 'running' || echo 'done'\n" + " tail -n 50 /tmp/output.log\n" + "\n" + "Timeout default 120s, max 36000s." + ), + "parameters": { + "type": "object", + "required": ["command"], + "additionalProperties": False, + "properties": { + "command": { + "type": "string", + "description": "The shell command to execute.", + }, + "description": { + "type": "string", + "description": "Short description (5-10 words, active voice).", + }, + "work_dir": { + "type": "string", + "description": "Working directory (default: current directory).", + }, + "timeout": { + "type": "integer", + "description": "Optional timeout in seconds (default: 120, max: 36000).", + }, + }, + }, + }, + "read": { + "description": ( + "Reads a file from the local filesystem. Returns contents with line numbers " + "(cat -n format).\n" + "\n" + "Usage:\n" + "- By default, reads up to 2000 lines from the beginning of the file.\n" + "- You can optionally specify offset and limit for large files, but prefer " + "reading the whole file first.\n" + "- Lines longer than 4000 chars are truncated.\n" + "- Cannot read directories β€” use bash with 'ls' instead.\n" + "- You should read multiple potentially useful files in parallel when possible.\n" + "- IMPORTANT: Always read a file before editing or overwriting it. The edit and " + "write tools will reject operations on files you haven't read." + ), + "parameters": { + "type": "object", + "required": ["path"], + "additionalProperties": False, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to read.", + }, + "offset": { + "type": "integer", + "description": "The line number to start reading from (1-based). Only provide if the file is too large to read at once.", + }, + "limit": { + "type": "integer", + "description": "The number of lines to read. Only provide if the file is too large to read at once.", + }, + }, + }, + }, + "write": { + "description": ( + "Writes a file to the local filesystem. Overwrites the existing file if one " + "exists at the path.\n" + "\n" + "- If this is an existing file, you MUST use the read tool first. This tool " + "will fail if you did not read the file first.\n" + "- ALWAYS prefer editing existing files with the edit tool over overwriting " + "with write.\n" + "- Creates parent directories as needed." + ), + "parameters": { + "type": "object", + "required": ["path", "content"], + "additionalProperties": False, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to write.", + }, + "content": { + "type": "string", + "description": "The complete file content to write.", + }, + }, + }, + }, + "edit": { + "description": ( + "Performs string replacements in files. Supports exact matching with " + "fuzzy fallback.\n" + "\n" + "Usage:\n" + "- You must read the file at least once before editing. This tool will " + "error if you attempt an edit without reading the file.\n" + "- The edit will FAIL if old_str is not unique in the file. Either provide " + "a larger string with more surrounding context to make it unique, or set " + "replace_all to true.\n" + "- old_str and new_str must differ.\n" + "- Preserve indentation exactly as it appears in the file.\n" + "- Do NOT include line number prefixes from read output in old_str or new_str.\n" + "- To delete code, set new_str to empty string.\n" + "- Use replace_all for renaming variables or strings across the file.\n" + "\n" + "Modes:\n" + "- replace (default): replace first occurrence of old_str with new_str.\n" + "- append_after: insert new_str immediately after old_str (old_str is kept).\n" + "- prepend_before: insert new_str immediately before old_str (old_str is kept)." + ), + "parameters": { + "type": "object", + "required": ["path", "old_str", "new_str"], + "additionalProperties": False, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to edit.", + }, + "old_str": { + "type": "string", + "description": "The text to find in the file. Must match exactly (fuzzy matching is used as fallback).", + }, + "new_str": { + "type": "string", + "description": "The replacement text. For append_after/prepend_before modes, the text to insert.", + }, + "replace_all": { + "type": "boolean", + "description": "Replace all occurrences of old_str (default: false).", + "default": False, + }, + "mode": { + "type": "string", + "enum": ["replace", "append_after", "prepend_before"], + "description": "Edit mode (default: replace).", + "default": "replace", + }, + }, + }, + }, +} + +_HANDLERS = { + "bash": _bash_handler, + "read": _read_handler, + "write": _write_handler, + "edit": _edit_handler, +} + + +def get_local_tools(): + """Return local ToolSpecs for bash/read/write/edit (no sandbox_create).""" + from agent.core.tools import ToolSpec + + tools = [] + for name, spec in _LOCAL_TOOL_SPECS.items(): + handler = _HANDLERS.get(name) + if handler is None: + continue + tools.append( + ToolSpec( + name=name, + description=spec["description"], + parameters=spec["parameters"], + handler=handler, + ) + ) + return tools diff --git a/agent/tools/notify_tool.py b/agent/tools/notify_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..f926d5a58d5f3c4b877cb8792f812f6e4fa322a7 --- /dev/null +++ b/agent/tools/notify_tool.py @@ -0,0 +1,108 @@ +from typing import Any + +from agent.messaging.models import NotificationRequest + +NOTIFY_TOOL_SPEC = { + "name": "notify", + "description": ( + "Send an out-of-band notification to configured messaging destinations. " + "Use this only when the user explicitly asked for proactive notifications " + "or when the task requires reporting progress outside the chat. " + "Destinations must be named server-side configs such as 'slack.ops'." + ), + "parameters": { + "type": "object", + "properties": { + "destinations": { + "type": "array", + "description": "Named messaging destinations to notify.", + "items": {"type": "string"}, + "minItems": 1, + }, + "message": { + "type": "string", + "description": "Main notification body.", + }, + "title": { + "type": "string", + "description": "Optional short title line.", + }, + "severity": { + "type": "string", + "enum": ["info", "success", "warning", "error"], + "description": "Notification severity label.", + }, + }, + "required": ["destinations", "message"], + }, +} + + +async def notify_handler( + arguments: dict[str, Any], session=None, **_kwargs +) -> tuple[str, bool]: + if session is None or session.notification_gateway is None: + return "Messaging is not configured for this session.", False + + raw_destinations = arguments.get("destinations", []) + if not isinstance(raw_destinations, list) or not raw_destinations: + return "destinations must be a non-empty array of destination names.", False + + destinations: list[str] = [] + seen: set[str] = set() + for raw_name in raw_destinations: + if not isinstance(raw_name, str): + return "Each destination must be a string.", False + name = raw_name.strip() + if not name: + return "Destination names must not be empty.", False + if name not in seen: + destinations.append(name) + seen.add(name) + + disallowed = [ + name + for name in destinations + if not session.config.messaging.can_agent_tool_send(name) + ] + if disallowed: + return ( + "These destinations are unavailable for the notify tool: " + + ", ".join(disallowed) + ), False + + message = arguments.get("message", "") + if not isinstance(message, str) or not message.strip(): + return "message must be a non-empty string.", False + + title = arguments.get("title") + severity = arguments.get("severity", "info") + if title is not None and not isinstance(title, str): + return "title must be a string when provided.", False + if severity not in {"info", "success", "warning", "error"}: + return "severity must be one of: info, success, warning, error.", False + + requests = [ + NotificationRequest( + destination=name, + title=title, + message=message, + severity=severity, + metadata={ + "session_id": session.session_id, + "model": session.config.model_name, + }, + ) + for name in destinations + ] + results = await session.notification_gateway.send_many(requests) + + lines = [] + all_ok = True + for result in results: + if result.ok: + lines.append(f"{result.destination}: sent") + else: + all_ok = False + lines.append(f"{result.destination}: failed ({result.error})") + return "\n".join(lines), all_ok diff --git a/agent/tools/papers_tool.py b/agent/tools/papers_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..ff2cf51f087419e74a2b8ca7e3588b347d0bdbb0 --- /dev/null +++ b/agent/tools/papers_tool.py @@ -0,0 +1,1327 @@ +""" +HF Papers Tool β€” Discover papers, read their contents, and find linked resources. + +Operations: trending, search, paper_details, read_paper, + find_datasets, find_models, find_collections, find_all_resources, + citation_graph, snippet_search, recommend +""" + +import asyncio +import os +import re +import time +from typing import Any + +import httpx +from bs4 import BeautifulSoup, Tag + +from agent.tools.types import ToolResult + +HF_API = "https://huggingface.co/api" +ARXIV_HTML = "https://arxiv.org/html" +AR5IV_HTML = "https://ar5iv.labs.arxiv.org/html" + +DEFAULT_LIMIT = 10 +MAX_LIMIT = 50 +MAX_SUMMARY_LEN = 300 +MAX_SECTION_PREVIEW_LEN = 280 +MAX_SECTION_TEXT_LEN = 8000 + +SORT_MAP = { + "downloads": "downloads", + "likes": "likes", + "trending": "trendingScore", +} + +# --------------------------------------------------------------------------- +# Semantic Scholar API +# --------------------------------------------------------------------------- + +S2_API = "https://api.semanticscholar.org" +S2_API_KEY = os.environ.get("S2_API_KEY") +S2_HEADERS: dict[str, str] = {"x-api-key": S2_API_KEY} if S2_API_KEY else {} +S2_TIMEOUT = 12 +_s2_last_request: float = 0.0 + +# Shared response cache (survives across sessions, keyed by (path, params_tuple)) +_s2_cache: dict[str, Any] = {} +_S2_CACHE_MAX = 500 + + +def _s2_paper_id(arxiv_id: str) -> str: + """Convert bare arxiv ID to S2 format.""" + return f"ARXIV:{arxiv_id}" + + +def _s2_cache_key(path: str, params: dict | None) -> str: + """Build a hashable cache key from path + sorted params.""" + p = tuple(sorted((params or {}).items())) + return f"{path}:{p}" + + +async def _s2_request( + client: httpx.AsyncClient, + method: str, + path: str, + **kwargs: Any, +) -> httpx.Response | None: + """S2 request with 2 retries on 429/5xx. Rate-limited only when using API key.""" + global _s2_last_request + url = f"{S2_API}{path}" + kwargs.setdefault("headers", {}).update(S2_HEADERS) + kwargs.setdefault("timeout", S2_TIMEOUT) + + for attempt in range(3): + # Rate limit only when authenticated (1 req/s for search, 10 req/s for others) + if S2_API_KEY: + min_interval = 1.0 if "search" in path else 0.1 + elapsed = time.monotonic() - _s2_last_request + if elapsed < min_interval: + await asyncio.sleep(min_interval - elapsed) + _s2_last_request = time.monotonic() + + try: + resp = await client.request(method, url, **kwargs) + if resp.status_code == 429: + if attempt < 2: + await asyncio.sleep(60) + continue + return None + if resp.status_code >= 500: + if attempt < 2: + await asyncio.sleep(3) + continue + return None + return resp + except (httpx.RequestError, httpx.HTTPStatusError): + if attempt < 2: + await asyncio.sleep(3) + continue + return None + return None + + +async def _s2_get_json( + client: httpx.AsyncClient, + path: str, + params: dict | None = None, +) -> dict | None: + """Cached S2 GET returning parsed JSON or None.""" + key = _s2_cache_key(path, params) + if key in _s2_cache: + return _s2_cache[key] + + resp = await _s2_request(client, "GET", path, params=params or {}) + if resp and resp.status_code == 200: + data = resp.json() + if len(_s2_cache) < _S2_CACHE_MAX: + _s2_cache[key] = data + return data + return None + + +# --------------------------------------------------------------------------- +# HTML paper parsing +# --------------------------------------------------------------------------- + + +def _parse_paper_html(html: str) -> dict[str, Any]: + """Parse arxiv HTML into structured sections. + + Returns: + { + "title": str, + "abstract": str, + "sections": [{"id": str, "title": str, "level": int, "text": str}], + } + """ + soup = BeautifulSoup(html, "html.parser") + + # Title + title_el = soup.find("h1", class_="ltx_title") + title = title_el.get_text(strip=True).removeprefix("Title:") if title_el else "" + + # Abstract + abstract_el = soup.find("div", class_="ltx_abstract") + abstract = "" + if abstract_el: + # Skip the "Abstract" heading itself + for child in abstract_el.children: + if isinstance(child, Tag) and child.name in ("h6", "h2", "h3", "p", "span"): + if child.get_text(strip=True).lower() == "abstract": + continue + if isinstance(child, Tag) and child.name == "p": + abstract += child.get_text(separator=" ", strip=True) + " " + abstract = abstract.strip() + + # Sections β€” collect h2/h3 headings and text between them + sections: list[dict[str, Any]] = [] + headings = soup.find_all(["h2", "h3"], class_=lambda c: c and "ltx_title" in c) + + for heading in headings: + level = 2 if heading.name == "h2" else 3 + heading_text = heading.get_text(separator=" ", strip=True) + + # Collect text from siblings until next heading of same or higher level + text_parts: list[str] = [] + sibling = heading.find_next_sibling() + while sibling: + if isinstance(sibling, Tag): + if sibling.name in ("h2", "h3") and "ltx_title" in ( + sibling.get("class") or [] + ): + break + # Also stop at h2 if we're collecting h3 content + if sibling.name == "h2" and level == 3: + break + text_parts.append(sibling.get_text(separator=" ", strip=True)) + sibling = sibling.find_next_sibling() + + # Also check parent section element for contained paragraphs + parent_section = heading.find_parent("section") + if parent_section and not text_parts: + for p in parent_section.find_all("p", recursive=False): + text_parts.append(p.get_text(separator=" ", strip=True)) + + section_text = "\n\n".join(t for t in text_parts if t) + + # Extract section number from heading text (e.g., "4 Experiments" β†’ "4") + num_match = re.match(r"^([A-Z]?\d+(?:\.\d+)*)\s", heading_text) + section_id = num_match.group(1) if num_match else "" + + sections.append( + { + "id": section_id, + "title": heading_text, + "level": level, + "text": section_text, + } + ) + + return {"title": title, "abstract": abstract, "sections": sections} + + +def _find_section(sections: list[dict], query: str) -> dict | None: + """Find a section by number or name (fuzzy).""" + query_lower = query.lower().strip() + + # Exact match on section number + for s in sections: + if s["id"] == query_lower or s["id"] == query: + return s + + # Exact match on title + for s in sections: + if query_lower == s["title"].lower(): + return s + + # Substring match on title + for s in sections: + if query_lower in s["title"].lower(): + return s + + # Number prefix match (e.g., "4" matches "4.1", "4.2", etc. β€” return parent) + for s in sections: + if s["id"].startswith(query_lower + ".") or s["id"] == query_lower: + return s + + return None + + +# --------------------------------------------------------------------------- +# Formatting helpers +# --------------------------------------------------------------------------- + + +def _clean_description(text: str) -> str: + """Strip HTML card artifacts and collapse whitespace from HF API descriptions.""" + text = re.sub(r"[\t]+", " ", text) + text = re.sub(r"\n{2,}", "\n", text) + return text.strip() + + +def _truncate(text: str, max_len: int) -> str: + if len(text) <= max_len: + return text + return text[:max_len] + "..." + + +def _format_paper_list( + papers: list, title: str, date: str | None = None, query: str | None = None +) -> str: + lines = [f"# {title}"] + if date: + lines[0] += f" ({date})" + if query: + lines.append(f"Filtered by: '{query}'") + lines.append(f"Showing {len(papers)} paper(s)\n") + + for i, item in enumerate(papers, 1): + paper = item.get("paper", item) + arxiv_id = paper.get("id", "") + paper_title = paper.get("title", "Unknown") + upvotes = paper.get("upvotes", 0) + summary = paper.get("ai_summary") or _truncate( + paper.get("summary", ""), MAX_SUMMARY_LEN + ) + keywords = paper.get("ai_keywords") or [] + github = paper.get("githubRepo") or "" + stars = paper.get("githubStars") or 0 + + lines.append(f"## {i}. {paper_title}") + lines.append(f"**arxiv_id:** {arxiv_id} | **upvotes:** {upvotes}") + lines.append(f"https://huggingface.co/papers/{arxiv_id}") + if keywords: + lines.append(f"**Keywords:** {', '.join(keywords[:5])}") + if github: + lines.append(f"**GitHub:** {github} ({stars} stars)") + if summary: + lines.append(f"**Summary:** {_truncate(summary, MAX_SUMMARY_LEN)}") + lines.append("") + + return "\n".join(lines) + + +def _format_paper_detail(paper: dict, s2_data: dict | None = None) -> str: + arxiv_id = paper.get("id", "") + title = paper.get("title", "Unknown") + upvotes = paper.get("upvotes", 0) + ai_summary = paper.get("ai_summary") or "" + summary = paper.get("summary", "") + keywords = paper.get("ai_keywords") or [] + github = paper.get("githubRepo") or "" + stars = paper.get("githubStars") or 0 + authors = paper.get("authors") or [] + + lines = [f"# {title}"] + meta_parts = [f"**arxiv_id:** {arxiv_id}", f"**upvotes:** {upvotes}"] + if s2_data: + cites = s2_data.get("citationCount", 0) + influential = s2_data.get("influentialCitationCount", 0) + meta_parts.append(f"**citations:** {cites} ({influential} influential)") + lines.append(" | ".join(meta_parts)) + lines.append(f"https://huggingface.co/papers/{arxiv_id}") + lines.append(f"https://arxiv.org/abs/{arxiv_id}") + + if authors: + names = [a.get("name", "") for a in authors[:10]] + author_str = ", ".join(n for n in names if n) + if len(authors) > 10: + author_str += f" (+{len(authors) - 10} more)" + lines.append(f"**Authors:** {author_str}") + + if keywords: + lines.append(f"**Keywords:** {', '.join(keywords)}") + if s2_data and s2_data.get("s2FieldsOfStudy"): + fields = [ + f["category"] for f in s2_data["s2FieldsOfStudy"] if f.get("category") + ] + if fields: + lines.append(f"**Fields:** {', '.join(fields)}") + if s2_data and s2_data.get("venue"): + lines.append(f"**Venue:** {s2_data['venue']}") + if github: + lines.append(f"**GitHub:** {github} ({stars} stars)") + + if s2_data and s2_data.get("tldr"): + tldr_text = s2_data["tldr"].get("text", "") + if tldr_text: + lines.append(f"\n## TL;DR\n{tldr_text}") + if ai_summary: + lines.append(f"\n## AI Summary\n{ai_summary}") + if summary: + lines.append(f"\n## Abstract\n{_truncate(summary, 500)}") + + lines.append( + "\n**Next:** Use read_paper to read specific sections, find_all_resources for linked datasets/models, " + "or citation_graph to trace references and citations." + ) + return "\n".join(lines) + + +def _format_read_paper_toc(parsed: dict[str, Any], arxiv_id: str) -> str: + """Format TOC view: abstract + section list with previews.""" + lines = [f"# {parsed['title']}"] + lines.append(f"https://arxiv.org/abs/{arxiv_id}\n") + + if parsed["abstract"]: + lines.append(f"## Abstract\n{parsed['abstract']}\n") + + lines.append("## Sections") + for s in parsed["sections"]: + prefix = " " if s["level"] == 3 else "" + preview = ( + _truncate(s["text"], MAX_SECTION_PREVIEW_LEN) if s["text"] else "(empty)" + ) + lines.append(f"{prefix}- **{s['title']}**: {preview}") + + lines.append( + '\nCall read_paper with section parameter (e.g. section="4" or section="Experiments") to read a specific section.' + ) + return "\n".join(lines) + + +def _format_read_paper_section(section: dict, arxiv_id: str) -> str: + """Format a single section's full text.""" + lines = [f"# {section['title']}"] + lines.append(f"https://arxiv.org/abs/{arxiv_id}\n") + + text = section["text"] + if len(text) > MAX_SECTION_TEXT_LEN: + text = ( + text[:MAX_SECTION_TEXT_LEN] + + f"\n\n... (truncated at {MAX_SECTION_TEXT_LEN} chars)" + ) + + lines.append(text if text else "(This section has no extractable text content.)") + return "\n".join(lines) + + +def _format_datasets(datasets: list, arxiv_id: str, sort: str) -> str: + lines = [f"# Datasets linked to paper {arxiv_id}"] + lines.append(f"https://huggingface.co/papers/{arxiv_id}") + lines.append(f"Showing {len(datasets)} dataset(s), sorted by {sort}\n") + + for i, ds in enumerate(datasets, 1): + ds_id = ds.get("id", "unknown") + downloads = ds.get("downloads", 0) + likes = ds.get("likes", 0) + desc = _truncate( + _clean_description(ds.get("description") or ""), MAX_SUMMARY_LEN + ) + tags = ds.get("tags") or [] + interesting = [t for t in tags if not t.startswith(("arxiv:", "region:"))][:5] + + lines.append(f"**{i}. [{ds_id}](https://huggingface.co/datasets/{ds_id})**") + lines.append(f" Downloads: {downloads:,} | Likes: {likes}") + if interesting: + lines.append(f" Tags: {', '.join(interesting)}") + if desc: + lines.append(f" {desc}") + lines.append("") + + if datasets: + top = datasets[0].get("id", "") + lines.append(f'**Inspect top dataset:** hf_inspect_dataset(dataset="{top}")') + return "\n".join(lines) + + +def _format_datasets_compact(datasets: list) -> str: + if not datasets: + return "## Datasets\nNone found" + lines = [f"## Datasets ({len(datasets)})"] + for ds in datasets: + lines.append( + f"- **{ds.get('id', '?')}** ({ds.get('downloads', 0):,} downloads)" + ) + return "\n".join(lines) + + +def _format_models(models: list, arxiv_id: str, sort: str) -> str: + lines = [f"# Models linked to paper {arxiv_id}"] + lines.append(f"https://huggingface.co/papers/{arxiv_id}") + lines.append(f"Showing {len(models)} model(s), sorted by {sort}\n") + + for i, m in enumerate(models, 1): + model_id = m.get("id", "unknown") + downloads = m.get("downloads", 0) + likes = m.get("likes", 0) + pipeline = m.get("pipeline_tag") or "" + library = m.get("library_name") or "" + + lines.append(f"**{i}. [{model_id}](https://huggingface.co/{model_id})**") + meta = f" Downloads: {downloads:,} | Likes: {likes}" + if pipeline: + meta += f" | Task: {pipeline}" + if library: + meta += f" | Library: {library}" + lines.append(meta) + lines.append("") + + return "\n".join(lines) + + +def _format_models_compact(models: list) -> str: + if not models: + return "## Models\nNone found" + lines = [f"## Models ({len(models)})"] + for m in models: + pipeline = m.get("pipeline_tag") or "" + suffix = f" ({pipeline})" if pipeline else "" + lines.append( + f"- **{m.get('id', '?')}** ({m.get('downloads', 0):,} downloads){suffix}" + ) + return "\n".join(lines) + + +def _format_collections(collections: list, arxiv_id: str) -> str: + lines = [f"# Collections containing paper {arxiv_id}"] + lines.append(f"Showing {len(collections)} collection(s)\n") + + for i, c in enumerate(collections, 1): + slug = c.get("slug", "") + title = c.get("title", "Untitled") + upvotes = c.get("upvotes", 0) + owner = c.get("owner", {}).get("name", "") + desc = _truncate(c.get("description") or "", MAX_SUMMARY_LEN) + num_items = len(c.get("items", [])) + + lines.append(f"**{i}. {title}**") + lines.append(f" By: {owner} | Upvotes: {upvotes} | Items: {num_items}") + lines.append(f" https://huggingface.co/collections/{slug}") + if desc: + lines.append(f" {desc}") + lines.append("") + + return "\n".join(lines) + + +def _format_collections_compact(collections: list) -> str: + if not collections: + return "## Collections\nNone found" + lines = [f"## Collections ({len(collections)})"] + for c in collections: + title = c.get("title", "Untitled") + owner = c.get("owner", {}).get("name", "") + upvotes = c.get("upvotes", 0) + lines.append(f"- **{title}** by {owner} ({upvotes} upvotes)") + return "\n".join(lines) + + +# --------------------------------------------------------------------------- +# Operation handlers +# --------------------------------------------------------------------------- + + +def _error(message: str) -> ToolResult: + return { + "formatted": message, + "totalResults": 0, + "resultsShared": 0, + "isError": True, + } + + +def _validate_arxiv_id(args: dict) -> str | None: + """Return arxiv_id or None if missing.""" + return args.get("arxiv_id") + + +async def _op_trending(args: dict[str, Any], limit: int) -> ToolResult: + date = args.get("date") + query = args.get("query") + + params: dict[str, Any] = {"limit": limit if not query else max(limit * 3, 30)} + if date: + params["date"] = date + + async with httpx.AsyncClient(timeout=15) as client: + resp = await client.get(f"{HF_API}/daily_papers", params=params) + resp.raise_for_status() + papers = resp.json() + + if query: + q = query.lower() + papers = [ + p + for p in papers + if q in p.get("title", "").lower() + or q in p.get("paper", {}).get("title", "").lower() + or q in p.get("paper", {}).get("summary", "").lower() + or any( + q in kw.lower() for kw in (p.get("paper", {}).get("ai_keywords") or []) + ) + ] + + papers = papers[:limit] + if not papers: + msg = "No trending papers found" + if query: + msg += f" matching '{query}'" + if date: + msg += f" for {date}" + return {"formatted": msg, "totalResults": 0, "resultsShared": 0} + + formatted = _format_paper_list(papers, "Trending Papers", date=date, query=query) + return { + "formatted": formatted, + "totalResults": len(papers), + "resultsShared": len(papers), + } + + +def _format_s2_paper_list(papers: list[dict], title: str) -> str: + """Format a list of S2 paper results.""" + lines = [f"# {title}"] + lines.append(f"Showing {len(papers)} result(s)\n") + + for i, paper in enumerate(papers, 1): + ptitle = paper.get("title") or "(untitled)" + year = paper.get("year") or "?" + cites = paper.get("citationCount", 0) + venue = paper.get("venue") or "" + ext_ids = paper.get("externalIds") or {} + aid = ext_ids.get("ArXiv", "") + tldr = (paper.get("tldr") or {}).get("text", "") + + lines.append(f"### {i}. {ptitle}") + meta = [f"Year: {year}", f"Citations: {cites}"] + if venue: + meta.append(f"Venue: {venue}") + if aid: + meta.append(f"arxiv_id: {aid}") + lines.append(" | ".join(meta)) + if aid: + lines.append(f"https://arxiv.org/abs/{aid}") + if tldr: + lines.append(f"**TL;DR:** {tldr}") + lines.append("") + + lines.append( + "Use paper_details with arxiv_id for full info, or read_paper to read sections." + ) + return "\n".join(lines) + + +async def _s2_bulk_search( + query: str, args: dict[str, Any], limit: int +) -> ToolResult | None: + """Search via S2 bulk endpoint with filters. Returns None on failure.""" + params: dict[str, Any] = { + "query": query, + "limit": limit, + "fields": "title,externalIds,year,citationCount,tldr,venue,publicationDate", + } + + # Date filter + date_from = args.get("date_from", "") + date_to = args.get("date_to", "") + if date_from or date_to: + params["publicationDateOrYear"] = f"{date_from}:{date_to}" + + # Fields of study + categories = args.get("categories") + if categories: + params["fieldsOfStudy"] = categories + + # Min citations + min_cites = args.get("min_citations") + if min_cites: + params["minCitationCount"] = str(min_cites) + + # Sort + sort_by = args.get("sort_by") + if sort_by and sort_by != "relevance": + params["sort"] = f"{sort_by}:desc" + + async with httpx.AsyncClient(timeout=15) as client: + resp = await _s2_request( + client, "GET", "/graph/v1/paper/search/bulk", params=params + ) + if not resp or resp.status_code != 200: + return None + data = resp.json() + + papers = data.get("data") or [] + if not papers: + return { + "formatted": f"No papers found for '{query}' with the given filters.", + "totalResults": 0, + "resultsShared": 0, + } + + formatted = _format_s2_paper_list( + papers[:limit], f"Papers matching '{query}' (Semantic Scholar)" + ) + return { + "formatted": formatted, + "totalResults": data.get("total", len(papers)), + "resultsShared": min(limit, len(papers)), + } + + +async def _op_search(args: dict[str, Any], limit: int) -> ToolResult: + query = args.get("query") + if not query: + return _error("'query' is required for search operation.") + + # Route to S2 when filters are present + use_s2 = any( + args.get(k) + for k in ("date_from", "date_to", "categories", "min_citations", "sort_by") + ) + if use_s2: + result = await _s2_bulk_search(query, args, limit) + if result is not None: + return result + # Fall back to HF search (without filters) if S2 fails + + async with httpx.AsyncClient(timeout=15) as client: + resp = await client.get( + f"{HF_API}/papers/search", params={"q": query, "limit": limit} + ) + resp.raise_for_status() + papers = resp.json() + + if not papers: + return { + "formatted": f"No papers found for '{query}'", + "totalResults": 0, + "resultsShared": 0, + } + + formatted = _format_paper_list(papers, f"Papers matching '{query}'") + return { + "formatted": formatted, + "totalResults": len(papers), + "resultsShared": len(papers), + } + + +async def _op_paper_details(args: dict[str, Any], limit: int) -> ToolResult: + arxiv_id = _validate_arxiv_id(args) + if not arxiv_id: + return _error("'arxiv_id' is required for paper_details.") + + async with httpx.AsyncClient(timeout=15) as client: + resp = await client.get(f"{HF_API}/papers/{arxiv_id}") + resp.raise_for_status() + paper = resp.json() + + return { + "formatted": _format_paper_detail(paper), + "totalResults": 1, + "resultsShared": 1, + } + + +async def _op_read_paper(args: dict[str, Any], limit: int) -> ToolResult: + arxiv_id = _validate_arxiv_id(args) + if not arxiv_id: + return _error("'arxiv_id' is required for read_paper.") + + section_query = args.get("section") + + # Try fetching HTML from arxiv, then ar5iv, then fallback to abstract + parsed = None + async with httpx.AsyncClient(timeout=30, follow_redirects=True) as client: + for base_url in [ARXIV_HTML, AR5IV_HTML]: + try: + resp = await client.get(f"{base_url}/{arxiv_id}") + if resp.status_code == 200: + parsed = _parse_paper_html(resp.text) + if parsed["sections"]: # Only use if we got real sections + break + parsed = None + except httpx.RequestError: + continue + + # Fallback: return abstract from HF API + if not parsed or not parsed["sections"]: + try: + async with httpx.AsyncClient(timeout=15) as client: + resp = await client.get(f"{HF_API}/papers/{arxiv_id}") + resp.raise_for_status() + paper = resp.json() + abstract = paper.get("summary", "") + title = paper.get("title", "") + msg = f"# {title}\nhttps://arxiv.org/abs/{arxiv_id}\n\n" + msg += f"## Abstract\n{abstract}\n\n" + msg += "HTML version not available for this paper. Only abstract shown.\n" + msg += f"PDF: https://arxiv.org/pdf/{arxiv_id}" + return {"formatted": msg, "totalResults": 1, "resultsShared": 1} + except Exception: + return _error( + f"Could not fetch paper {arxiv_id}. Check the arxiv ID is correct." + ) + + # Return TOC or specific section + if not section_query: + formatted = _format_read_paper_toc(parsed, arxiv_id) + return { + "formatted": formatted, + "totalResults": len(parsed["sections"]), + "resultsShared": len(parsed["sections"]), + } + + section = _find_section(parsed["sections"], section_query) + if not section: + available = "\n".join(f"- {s['title']}" for s in parsed["sections"]) + return _error( + f"Section '{section_query}' not found. Available sections:\n{available}" + ) + + formatted = _format_read_paper_section(section, arxiv_id) + return {"formatted": formatted, "totalResults": 1, "resultsShared": 1} + + +# --------------------------------------------------------------------------- +# Citation graph (Semantic Scholar) +# --------------------------------------------------------------------------- + + +def _format_citation_entry(entry: dict, show_context: bool = False) -> str: + """Format a single citation/reference entry.""" + paper = entry.get("citingPaper") or entry.get("citedPaper") or {} + title = paper.get("title") or "(untitled)" + year = paper.get("year") or "?" + cites = paper.get("citationCount", 0) + ext_ids = paper.get("externalIds") or {} + aid = ext_ids.get("ArXiv", "") + influential = " **[influential]**" if entry.get("isInfluential") else "" + + parts = [f"- **{title}** ({year}, {cites} cites){influential}"] + if aid: + parts[0] += f" arxiv:{aid}" + + if show_context: + intents = entry.get("intents") or [] + if intents: + parts.append(f" Intent: {', '.join(intents)}") + contexts = entry.get("contexts") or [] + for ctx in contexts[:2]: + if ctx: + parts.append(f" > {_truncate(ctx, 200)}") + + return "\n".join(parts) + + +def _format_citation_graph( + arxiv_id: str, + references: list[dict] | None, + citations: list[dict] | None, +) -> str: + lines = [f"# Citation Graph for {arxiv_id}"] + lines.append(f"https://arxiv.org/abs/{arxiv_id}\n") + + if references is not None: + lines.append(f"## References ({len(references)})") + if references: + for entry in references: + lines.append(_format_citation_entry(entry)) + else: + lines.append("No references found.") + lines.append("") + + if citations is not None: + lines.append(f"## Citations ({len(citations)})") + if citations: + for entry in citations: + lines.append(_format_citation_entry(entry, show_context=True)) + else: + lines.append("No citations found.") + lines.append("") + + lines.append( + "**Tip:** Use paper_details with an arxiv_id from above to explore further." + ) + return "\n".join(lines) + + +async def _op_citation_graph(args: dict[str, Any], limit: int) -> ToolResult: + arxiv_id = _validate_arxiv_id(args) + if not arxiv_id: + return _error("'arxiv_id' is required for citation_graph.") + + direction = args.get("direction", "both") + s2_id = _s2_paper_id(arxiv_id) + fields = "title,externalIds,year,citationCount,influentialCitationCount,contexts,intents,isInfluential" + params = {"fields": fields, "limit": limit} + + async with httpx.AsyncClient(timeout=15) as client: + refs, cites = None, None + coros = [] + if direction in ("references", "both"): + coros.append( + _s2_get_json(client, f"/graph/v1/paper/{s2_id}/references", params) + ) + if direction in ("citations", "both"): + coros.append( + _s2_get_json(client, f"/graph/v1/paper/{s2_id}/citations", params) + ) + + results = await asyncio.gather(*coros, return_exceptions=True) + idx = 0 + if direction in ("references", "both"): + r = results[idx] + if isinstance(r, dict): + refs = r.get("data", []) + idx += 1 + if direction in ("citations", "both"): + r = results[idx] + if isinstance(r, dict): + cites = r.get("data", []) + + if refs is None and cites is None: + return _error( + f"Could not fetch citation data for {arxiv_id}. Paper may not be indexed by Semantic Scholar." + ) + + total = (len(refs) if refs else 0) + (len(cites) if cites else 0) + return { + "formatted": _format_citation_graph(arxiv_id, refs, cites), + "totalResults": total, + "resultsShared": total, + } + + +async def _op_find_datasets(args: dict[str, Any], limit: int) -> ToolResult: + arxiv_id = _validate_arxiv_id(args) + if not arxiv_id: + return _error("'arxiv_id' is required for find_datasets.") + + sort = args.get("sort", "downloads") + sort_key = SORT_MAP.get(sort, "downloads") + + async with httpx.AsyncClient(timeout=15) as client: + resp = await client.get( + f"{HF_API}/datasets", + params={ + "filter": f"arxiv:{arxiv_id}", + "limit": limit, + "sort": sort_key, + "direction": -1, + }, + ) + resp.raise_for_status() + datasets = resp.json() + + if not datasets: + return { + "formatted": f"No datasets found linked to paper {arxiv_id}.\nhttps://huggingface.co/papers/{arxiv_id}", + "totalResults": 0, + "resultsShared": 0, + } + + return { + "formatted": _format_datasets(datasets, arxiv_id, sort), + "totalResults": len(datasets), + "resultsShared": len(datasets), + } + + +async def _op_find_models(args: dict[str, Any], limit: int) -> ToolResult: + arxiv_id = _validate_arxiv_id(args) + if not arxiv_id: + return _error("'arxiv_id' is required for find_models.") + + sort = args.get("sort", "downloads") + sort_key = SORT_MAP.get(sort, "downloads") + + async with httpx.AsyncClient(timeout=15) as client: + resp = await client.get( + f"{HF_API}/models", + params={ + "filter": f"arxiv:{arxiv_id}", + "limit": limit, + "sort": sort_key, + "direction": -1, + }, + ) + resp.raise_for_status() + models = resp.json() + + if not models: + return { + "formatted": f"No models found linked to paper {arxiv_id}.\nhttps://huggingface.co/papers/{arxiv_id}", + "totalResults": 0, + "resultsShared": 0, + } + + return { + "formatted": _format_models(models, arxiv_id, sort), + "totalResults": len(models), + "resultsShared": len(models), + } + + +async def _op_find_collections(args: dict[str, Any], limit: int) -> ToolResult: + arxiv_id = _validate_arxiv_id(args) + if not arxiv_id: + return _error("'arxiv_id' is required for find_collections.") + + async with httpx.AsyncClient(timeout=15) as client: + resp = await client.get(f"{HF_API}/collections", params={"paper": arxiv_id}) + resp.raise_for_status() + collections = resp.json() + + if not collections: + return { + "formatted": f"No collections found containing paper {arxiv_id}.\nhttps://huggingface.co/papers/{arxiv_id}", + "totalResults": 0, + "resultsShared": 0, + } + + collections = collections[:limit] + return { + "formatted": _format_collections(collections, arxiv_id), + "totalResults": len(collections), + "resultsShared": len(collections), + } + + +async def _op_find_all_resources(args: dict[str, Any], limit: int) -> ToolResult: + arxiv_id = _validate_arxiv_id(args) + if not arxiv_id: + return _error("'arxiv_id' is required for find_all_resources.") + + per_cat = min(limit, 10) + + async with httpx.AsyncClient(timeout=15) as client: + results = await asyncio.gather( + client.get( + f"{HF_API}/datasets", + params={ + "filter": f"arxiv:{arxiv_id}", + "limit": per_cat, + "sort": "downloads", + "direction": -1, + }, + ), + client.get( + f"{HF_API}/models", + params={ + "filter": f"arxiv:{arxiv_id}", + "limit": per_cat, + "sort": "downloads", + "direction": -1, + }, + ), + client.get(f"{HF_API}/collections", params={"paper": arxiv_id}), + return_exceptions=True, + ) + + sections = [] + total = 0 + + # Datasets + if isinstance(results[0], Exception): + sections.append(f"## Datasets\nError: {results[0]}") + else: + datasets = results[0].json() + total += len(datasets) + sections.append(_format_datasets_compact(datasets[:per_cat])) + + # Models + if isinstance(results[1], Exception): + sections.append(f"## Models\nError: {results[1]}") + else: + models = results[1].json() + total += len(models) + sections.append(_format_models_compact(models[:per_cat])) + + # Collections + if isinstance(results[2], Exception): + sections.append(f"## Collections\nError: {results[2]}") + else: + collections = results[2].json() + total += len(collections) + sections.append(_format_collections_compact(collections[:per_cat])) + + header = f"# Resources linked to paper {arxiv_id}\nhttps://huggingface.co/papers/{arxiv_id}\n" + formatted = header + "\n\n".join(sections) + return {"formatted": formatted, "totalResults": total, "resultsShared": total} + + +# --------------------------------------------------------------------------- +# Snippet search (Semantic Scholar) +# --------------------------------------------------------------------------- + + +def _format_snippets(snippets: list[dict], query: str) -> str: + lines = [f"# Snippet Search: '{query}'"] + lines.append(f"Found {len(snippets)} matching passage(s)\n") + + for i, item in enumerate(snippets, 1): + paper = item.get("paper") or {} + ptitle = paper.get("title") or "(untitled)" + year = paper.get("year") or "?" + cites = paper.get("citationCount", 0) + ext_ids = paper.get("externalIds") or {} + aid = ext_ids.get("ArXiv", "") + + snippet = item.get("snippet") or {} + text = snippet.get("text", "") + section = snippet.get("section") or "" + + lines.append(f"### {i}. {ptitle} ({year}, {cites} cites)") + if aid: + lines.append(f"arxiv:{aid}") + if section: + lines.append(f"Section: {section}") + if text: + lines.append(f"> {_truncate(text, 400)}") + lines.append("") + + lines.append( + "Use paper_details or read_paper with arxiv_id to explore a paper further." + ) + return "\n".join(lines) + + +async def _op_snippet_search(args: dict[str, Any], limit: int) -> ToolResult: + query = args.get("query") + if not query: + return _error("'query' is required for snippet_search.") + + params: dict[str, Any] = { + "query": query, + "limit": limit, + "fields": "title,externalIds,year,citationCount", + } + + # Optional filters (same as search) + date_from = args.get("date_from", "") + date_to = args.get("date_to", "") + if date_from or date_to: + params["publicationDateOrYear"] = f"{date_from}:{date_to}" + if args.get("categories"): + params["fieldsOfStudy"] = args["categories"] + if args.get("min_citations"): + params["minCitationCount"] = str(args["min_citations"]) + + async with httpx.AsyncClient(timeout=15) as client: + resp = await _s2_request( + client, "GET", "/graph/v1/snippet/search", params=params + ) + if not resp or resp.status_code != 200: + return _error("Snippet search failed. Semantic Scholar may be unavailable.") + data = resp.json() + + snippets = data.get("data") or [] + if not snippets: + return { + "formatted": f"No snippets found for '{query}'.", + "totalResults": 0, + "resultsShared": 0, + } + + return { + "formatted": _format_snippets(snippets, query), + "totalResults": len(snippets), + "resultsShared": len(snippets), + } + + +# --------------------------------------------------------------------------- +# Recommendations (Semantic Scholar) +# --------------------------------------------------------------------------- + + +async def _op_recommend(args: dict[str, Any], limit: int) -> ToolResult: + positive_ids = args.get("positive_ids") + arxiv_id = _validate_arxiv_id(args) + + if not arxiv_id and not positive_ids: + return _error("'arxiv_id' or 'positive_ids' is required for recommend.") + + fields = "title,externalIds,year,citationCount,tldr,venue" + + async with httpx.AsyncClient(timeout=15) as client: + if positive_ids and not arxiv_id: + # Multi-paper recommendations (POST, not cached) + pos = [ + _s2_paper_id(pid.strip()) + for pid in positive_ids.split(",") + if pid.strip() + ] + neg_raw = args.get("negative_ids", "") + neg = ( + [_s2_paper_id(pid.strip()) for pid in neg_raw.split(",") if pid.strip()] + if neg_raw + else [] + ) + resp = await _s2_request( + client, + "POST", + "/recommendations/v1/papers/", + json={"positivePaperIds": pos, "negativePaperIds": neg}, + params={"fields": fields, "limit": limit}, + ) + if not resp or resp.status_code != 200: + return _error( + "Recommendation request failed. Semantic Scholar may be unavailable." + ) + data = resp.json() + else: + # Single-paper recommendations (cached) + data = await _s2_get_json( + client, + f"/recommendations/v1/papers/forpaper/{_s2_paper_id(arxiv_id)}", + {"fields": fields, "limit": limit, "from": "recent"}, + ) + if not data: + return _error( + "Recommendation request failed. Semantic Scholar may be unavailable." + ) + + papers = data.get("recommendedPapers") or [] + if not papers: + return { + "formatted": "No recommendations found.", + "totalResults": 0, + "resultsShared": 0, + } + + title = f"Recommended papers based on {arxiv_id or positive_ids}" + return { + "formatted": _format_s2_paper_list(papers[:limit], title), + "totalResults": len(papers), + "resultsShared": min(limit, len(papers)), + } + + +# --------------------------------------------------------------------------- +# Operation dispatch +# --------------------------------------------------------------------------- + +_OPERATIONS = { + "trending": _op_trending, + "search": _op_search, + "paper_details": _op_paper_details, + "read_paper": _op_read_paper, + "citation_graph": _op_citation_graph, + "snippet_search": _op_snippet_search, + "recommend": _op_recommend, + "find_datasets": _op_find_datasets, + "find_models": _op_find_models, + "find_collections": _op_find_collections, + "find_all_resources": _op_find_all_resources, +} + + +# --------------------------------------------------------------------------- +# Tool spec + handler +# --------------------------------------------------------------------------- + +HF_PAPERS_TOOL_SPEC = { + "name": "hf_papers", + "description": ( + "Discover ML research papers, analyze citations, search paper contents, and find linked resources.\n\n" + "Combines HuggingFace Hub, arXiv, and Semantic Scholar. Use for exploring research areas, " + "finding datasets for a task, tracing citation chains, or implementing a paper's approach.\n\n" + "Typical flows:\n" + " search β†’ read_paper β†’ find_all_resources β†’ hf_inspect_dataset\n" + " search β†’ paper_details β†’ citation_graph β†’ read_paper (trace influence)\n" + " snippet_search β†’ paper_details β†’ read_paper (find specific claims)\n\n" + "Operations:\n" + "- trending: Get trending daily papers, optionally filter by topic keyword\n" + "- search: Search papers. Uses HF by default (ML-tuned). Add date_from/min_citations/categories to use Semantic Scholar with filters\n" + "- paper_details: Metadata, abstract, AI summary, github link\n" + "- read_paper: Read paper contents β€” without section: abstract + TOC; with section: full text\n" + "- citation_graph: Get references and citations for a paper with influence flags and citation intents\n" + "- snippet_search: Semantic search over full-text passages from 12M+ papers\n" + "- recommend: Find similar papers (single paper or positive/negative examples)\n" + "- find_datasets: Find datasets linked to a paper\n" + "- find_models: Find models linked to a paper\n" + "- find_collections: Find collections that include a paper\n" + "- find_all_resources: Parallel fetch of datasets + models + collections for a paper" + ), + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": list(_OPERATIONS.keys()), + "description": "Operation to execute.", + }, + "query": { + "type": "string", + "description": ( + "Search query. Required for: search, snippet_search. " + "Optional for: trending (filters by keyword). " + "Supports boolean syntax for Semantic Scholar: '\"exact phrase\" term1 | term2'." + ), + }, + "arxiv_id": { + "type": "string", + "description": ( + "ArXiv paper ID (e.g. '2305.18290'). " + "Required for: paper_details, read_paper, citation_graph, find_datasets, find_models, find_collections, find_all_resources. " + "Optional for: recommend (single-paper recs). Get IDs from search results first." + ), + }, + "section": { + "type": "string", + "description": ( + "Section name or number to read (e.g. '3', 'Experiments', '4.2'). " + "Optional for: read_paper. Without this, returns abstract + TOC." + ), + }, + "direction": { + "type": "string", + "enum": ["citations", "references", "both"], + "description": "Direction for citation_graph. Default: both.", + }, + "date": { + "type": "string", + "description": "Date in YYYY-MM-DD format. Optional for: trending (defaults to recent papers).", + }, + "date_from": { + "type": "string", + "description": "Start date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search.", + }, + "date_to": { + "type": "string", + "description": "End date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search.", + }, + "categories": { + "type": "string", + "description": "Field of study filter (e.g. 'Computer Science'). Triggers Semantic Scholar search.", + }, + "min_citations": { + "type": "integer", + "description": "Minimum citation count filter. Triggers Semantic Scholar search.", + }, + "sort_by": { + "type": "string", + "enum": ["relevance", "citationCount", "publicationDate"], + "description": "Sort order for Semantic Scholar search. Default: relevance.", + }, + "positive_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs for multi-paper recommendations. For: recommend.", + }, + "negative_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs as negative examples. For: recommend.", + }, + "sort": { + "type": "string", + "enum": ["downloads", "likes", "trending"], + "description": ( + "Sort order for find_datasets and find_models. Default: downloads." + ), + }, + "limit": { + "type": "integer", + "description": "Maximum results to return (default: 10, max: 50).", + }, + }, + "required": ["operation"], + }, +} + + +async def hf_papers_handler(arguments: dict[str, Any]) -> tuple[str, bool]: + """Handler for agent tool router.""" + operation = arguments.get("operation") + if not operation: + return "'operation' parameter is required.", False + + handler = _OPERATIONS.get(operation) + if not handler: + valid = ", ".join(_OPERATIONS.keys()) + return f"Unknown operation: '{operation}'. Valid: {valid}", False + + limit = min(arguments.get("limit", DEFAULT_LIMIT), MAX_LIMIT) + + try: + result = await handler(arguments, limit) + return result["formatted"], not result.get("isError", False) + except httpx.HTTPStatusError as e: + return f"API error: {e.response.status_code} β€” {e.response.text[:200]}", False + except httpx.RequestError as e: + return f"Request error: {e}", False + except Exception as e: + return f"Error in {operation}: {e}", False diff --git a/agent/tools/plan_tool.py b/agent/tools/plan_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..218ec9b68bb8600e49a88a1bdbf327e6d65b8eac --- /dev/null +++ b/agent/tools/plan_tool.py @@ -0,0 +1,142 @@ +from typing import Any, Dict, List + +from agent.core.session import Event +from agent.utils.terminal_display import format_plan_tool_output + +from .types import ToolResult + +# In-memory storage for the current plan (raw structure from agent) +_current_plan: List[Dict[str, str]] = [] + + +def reset_current_plan() -> None: + """Clear the CLI-visible in-memory plan.""" + global _current_plan + + _current_plan = [] + + +class PlanTool: + """Tool for managing a list of todos with status tracking.""" + + def __init__(self, session: Any = None): + self.session = session + + async def execute(self, params: Dict[str, Any]) -> ToolResult: + """ + Execute the WritePlan operation. + + Args: + params: Dictionary containing: + - todos: List of todo items, each with id, content, and status + + Returns: + ToolResult with formatted output + """ + global _current_plan + + todos = params.get("todos", []) + + # Validate todos structure + for todo in todos: + if not isinstance(todo, dict): + return { + "formatted": "Error: Each todo must be an object. Re call the tool with correct format (mandatory).", + "isError": True, + } + + required_fields = ["id", "content", "status"] + for field in required_fields: + if field not in todo: + return { + "formatted": f"Error: Todo missing required field '{field}'. Re call the tool with correct format (mandatory).", + "isError": True, + } + + # Validate status + valid_statuses = ["pending", "in_progress", "completed"] + if todo["status"] not in valid_statuses: + return { + "formatted": f"Error: Invalid status '{todo['status']}'. Must be one of: {', '.join(valid_statuses)}. Re call the tool with correct format (mandatory).", + "isError": True, + } + + # Store a session-scoped copy so the runtime can tell whether a + # text-only model response is trying to stop while work remains. + stored_todos = [dict(todo) for todo in todos] + _current_plan = stored_todos + if self.session is not None: + self.session.current_plan = stored_todos + + # Emit plan update event if session is available + if self.session: + await self.session.send_event( + Event( + event_type="plan_update", + data={"plan": stored_todos}, + ) + ) + + # Format only for display using terminal_display utility + formatted_output = format_plan_tool_output(stored_todos) + + return { + "formatted": formatted_output, + "totalResults": len(todos), + "isError": False, + } + + +def get_current_plan() -> List[Dict[str, str]]: + """Get the current plan (raw structure).""" + return _current_plan + + +# Tool specification +PLAN_TOOL_SPEC = { + "name": "plan_tool", + "description": ( + "Track progress on multi-step tasks with a todo list (pending/in_progress/completed).\n\n" + "Use for tasks with 3+ steps. Each call replaces the entire plan (send full list).\n\n" + "Rules: exactly ONE task in_progress at a time. Mark completed immediately after finishing. " + "Only mark completed when the task fully succeeded β€” keep in_progress if there are errors. " + "Update frequently so the user sees progress." + ), + "parameters": { + "type": "object", + "properties": { + "todos": { + "type": "array", + "description": "List of todo items", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "Unique identifier for the todo", + }, + "content": { + "type": "string", + "description": "Description of the todo task", + }, + "status": { + "type": "string", + "enum": ["pending", "in_progress", "completed"], + "description": "Current status of the todo", + }, + }, + "required": ["id", "content", "status"], + }, + } + }, + "required": ["todos"], + }, +} + + +async def plan_tool_handler( + arguments: Dict[str, Any], session: Any = None +) -> tuple[str, bool]: + tool = PlanTool(session=session) + result = await tool.execute(arguments) + return result["formatted"], not result.get("isError", False) diff --git a/agent/tools/research_tool.py b/agent/tools/research_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..3cc19b2b1a65d80471654580b50f535d326b609c --- /dev/null +++ b/agent/tools/research_tool.py @@ -0,0 +1,588 @@ +""" +Research subagent tool β€” spawns a cheap LLM call with a focused +research task and returns a summary. The subagent gets its own +independent context (not the main conversation), so research +work doesn't pollute the main agent's context window. + +Inspired by claude-code's code-explorer agent pattern. +""" + +import json +import logging +import time +from typing import Any + +from litellm import Message, acompletion + +from agent.core import telemetry +from agent.core.doom_loop import check_for_doom_loop +from agent.core.llm_params import _resolve_llm_params +from agent.core.model_ids import strip_huggingface_model_prefix +from agent.core.prompt_caching import ( + router_session_id_for, + with_prompt_cache_params, + with_prompt_caching, +) +from agent.core.session import Event +from agent.core.yolo_budget import maybe_pause_yolo_after_spend + +logger = logging.getLogger(__name__) + +# Context budget for the research subagent (tokens). +# When usage exceeds WARN threshold, the subagent is told to wrap up. +# At MAX, the loop is force-stopped and whatever content exists is returned. +_RESEARCH_CONTEXT_WARN = 170_000 # 85% of 200k +_RESEARCH_CONTEXT_MAX = 190_000 + +# Tools the research agent can use (read-only subset) +RESEARCH_TOOL_NAMES = { + "read", + "bash", + "explore_hf_docs", + "fetch_hf_docs", + "find_hf_api", + "hf_papers", + "github_find_examples", + "github_list_repos", + "github_read_file", + "web_search", + "hf_inspect_dataset", + "hf_repo_files", +} + + +async def _research_acompletion( + *, + session: Any, + research_model: str, + messages: list[Any], + tools: Any, + llm_params: dict[str, Any], + timeout: int, + tool_choice: str | None = None, +): + kwargs: dict[str, Any] = { + "messages": messages, + "tools": tools, + "stream": False, + "timeout": timeout, + **llm_params, + } + if tool_choice is not None: + kwargs["tool_choice"] = tool_choice + return await acompletion(**kwargs) + + +async def _record_research_llm_call( + session: Any, + *, + research_model: str, + response: Any, + started_at: float, +) -> bool: + usage = await telemetry.record_llm_call( + session, + model=research_model, + response=response, + latency_ms=int((time.monotonic() - started_at) * 1000), + finish_reason=response.choices[0].finish_reason if response.choices else None, + kind="research", + ) + return await maybe_pause_yolo_after_spend( + session, + spend_kind="research", + observed_cost_usd=usage.get("cost_usd") if isinstance(usage, dict) else None, + ) + + +RESEARCH_SYSTEM_PROMPT = """\ +You are a research sub-agent for an ML engineering assistant. +Your primary job: mine the literature to find the best training recipes β€” +then back them up with working code and up to date documantation. The main agent will use +your findings to implement the actual solution. + +# Start from the literature + +Your default approach is a deep literature crawl. Do not start from docs or +example scripts β€” start from papers. Papers contain the results, and results +tell you what actually works. + +## The crawl + +1. **Find anchor papers**: Search for the task/domain. Identify the landmark paper(s) β€” high citations, recent, or both. +2. **Crawl the citation graph**: Use `citation_graph` on the anchor paper(s). Look DOWNSTREAM (papers that cite it) β€” these are the ones that built on it, improved it, or applied it to new domains. Prioritize recent papers and papers with many citations. +3. **Read methodology sections**: For the most promising papers (strong results, recent, relevant), use `read_paper` with section parameter to read sections 3, 4, 5 (Methodology, Experiments, Results β€” not the abstract). Extract: + - The exact dataset(s) used (name, source, size, any filtering/preprocessing) + - The training method and configuration (optimizer, lr, schedule, epochs, batch size) + - The results those choices produced (benchmark scores, metrics, comparisons) +4. **Attribute results to recipes**: This is the critical step. Every finding must link a RESULT to the RECIPE that produced it. "Dataset X + method Y + lr Z β†’ score W on benchmark V" is useful. "They used SFT" is not. +5. **Validate datasets**: For the most promising datasets, check if they exist on HF Hub with `hf_inspect_dataset`. Verify format matches the training method. Report if doesnt. +6. **Find code**: Now find working implementation code via `github_find_examples` and `github_read_file`. Use docs (`explore_hf_docs`, `fetch_hf_docs`) to fill in API details. + +## When to go deeper + +- If the anchor paper is old (>1 year), its citation graph is your main source β€” the downstream papers will have better methods. +- If a downstream paper reports significantly better results, crawl ITS citation graph too. +- Use `snippet_search` to find specific claims across papers (e.g., "does dataset X consistently outperform Y for this task?"). +- Use `recommend` to find related papers the citation graph might miss. + +# How to use your tools + +## Papers & citations (USE FIRST) +- `hf_papers(operation="search", query=...)`: Search papers (HF-tuned for ML) +- `hf_papers(operation="search", query=..., min_citations=50, sort_by="citationCount")`: Find highly-cited papers via Semantic Scholar +- `hf_papers(operation="search", query=..., date_from="2024-01-01")`: Search with date filter +- `hf_papers(operation="paper_details", arxiv_id=...)`: Metadata, citations, TL;DR +- `hf_papers(operation="citation_graph", arxiv_id=...)`: References + citations with influence flags and intents +- `hf_papers(operation="read_paper", arxiv_id=..., section="3")`: Read a specific section's full text +- `hf_papers(operation="read_paper", arxiv_id=...)`: Get TOC (abstract + section list) β€” use this to find which section numbers contain methodology/experiments +- `hf_papers(operation="snippet_search", query=...)`: Semantic search across 12M+ full-text paper passages +- `hf_papers(operation="recommend", arxiv_id=...)`: Find related papers +- `hf_papers(operation="find_datasets", arxiv_id=...)`: Find HF datasets linked to a paper +- `hf_papers(operation="find_all_resources", arxiv_id=...)`: Datasets + models + collections for a paper + +## Dataset inspection +- `hf_inspect_dataset`: Check dataset schema, splits, sample rows + CRITICAL for training: verify column format matches training method: + - SFT: needs "messages", "text", or "prompt"/"completion" + - DPO: needs "prompt", "chosen", "rejected" + - GRPO: needs "prompt" only + +## GitHub code research +- `github_find_examples`: Find working example scripts in HF repos (trl, transformers, etc.) +- `github_read_file`: Read the actual implementation code. Use line_start/line_end for large files. + +## Documentation +- `explore_hf_docs(endpoint)`: Search docs for a library. Endpoints: trl, transformers, datasets, peft, accelerate, trackio, vllm, inference-endpoints, etc. +- `fetch_hf_docs(url)`: Fetch full page content from explore results +- `find_hf_api(query=..., tag=...)`: Find REST API endpoints +- `web_search(query=..., allowed_domains=[...], blocked_domains=[...])`: + Search the current web when papers/docs/GitHub are not enough. + +## Hub repo inspection +- `hf_repo_files`: List/read files in any HF repo (model, dataset, space) + +# Correct research pattern + +``` +# 1. Find anchor paper(s) for the task +hf_papers({"operation": "search", "query": "GPQA graduate questions", "sort_by": "citationCount"}) + +# 2. Crawl citation graph β€” look downstream +hf_papers({"operation": "citation_graph", "arxiv_id": "2311.12022", "direction": "citations"}) + +# 3. Read methodology of promising downstream papers +hf_papers({"operation": "read_paper", "arxiv_id": "2604.01348"}) # TOC first +hf_papers({"operation": "read_paper", "arxiv_id": "2604.01348", "section": "3"}) # Methodology +hf_papers({"operation": "read_paper", "arxiv_id": "2604.01348", "section": "4"}) # Experiments + +# 4. Find datasets used by these papers +hf_papers({"operation": "find_datasets", "arxiv_id": "2604.01348"}) +hf_papers({"operation": "find_all_resources", "arxiv_id": "2604.01348"}) + +# 5. Validate datasets exist and have correct format +hf_inspect_dataset({"dataset": "org/dataset-name", "split": "train", "sample_rows": 3}) + +# 6. Now get working code for the training method +github_find_examples({"repo": "trl", "keyword": "sft"}) +github_read_file({"repo": "huggingface/trl", "path": "examples/scripts/sft.py"}) +explore_hf_docs("trl") +``` + +# Output format + + + +Your output MUST be structured as a ranked list of training recipes, each attributed to published results: + +## Recipe table (REQUIRED) +For each promising approach found, report: +- **Paper**: title, arxiv_id, date, venue +- **Result**: exact benchmark scores and what they were measured on +- **Dataset(s)**: name, size, source, HF Hub availability, format verified (yes/no) +- **Method**: training approach, key hyperparameters (lr, epochs, batch size, optimizer, schedule) +- **What made it work**: the specific insight or trick that drove the result (data curation, curriculum, loss function, etc.) + +Rank recipes by result quality. The main agent will pick the best one that's feasible. + +## Code patterns +- Key imports, configurations, and usage patterns from working examples +- Specific file paths, URLs, function names from docs + +## Recommendations +- Which recipe to implement first and why +- What datasets to use (with HF Hub paths, verified) +- Any gaps: datasets that need preprocessing, methods that need adaptation + +Additionally include: +- **SOTA landscape**: Current best models, datasets, and methods for the task (from recent papers). Flag anything outdated. +- **Essential references**: Specific file paths, URLs, function names, doc sections, code snippets + that the main agent should use directly +- **Code patterns**: Key imports, configurations, and usage patterns from working examples + +Be concise. Your output goes into another agent's context β€” every token counts. +Aim for 500-1500 words max. Include actual code snippets from examples you read, +not paraphrased descriptions. +""" + +RESEARCH_TOOL_SPEC = { + "name": "research", + "description": ( + "Spawn a research sub-agent to explore documentation, codebases, " + "or repos WITHOUT polluting the main conversation context. " + "The sub-agent gets its own independent context window with read-only " + "research tools and returns a concise summary of findings.\n\n" + "Use this for:\n" + "- Researching current API usage before implementing ML tasks " + "(find examples + read docs)\n" + "- Exploring HF docs, reading papers, analyzing GitHub repos\n" + "- Any research where raw tool outputs would be too verbose\n\n" + "The sub-agent knows how to use github_find_examples, github_read_file, " + "explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, hf_papers, etc. " + "Just describe what you need researched." + ), + "parameters": { + "type": "object", + "properties": { + "task": { + "type": "string", + "description": ( + "Detailed description of what to research. Be specific: " + "include library names, trainer types, dataset names, " + "repo names, or doc pages to explore. Example: " + "'Research current TRL SFTTrainer usage: find working " + "example scripts, read the SFT documentation, and check " + "SFTConfig parameters. Also validate that dataset " + "HuggingFaceH4/ultrachat_200k has the right format for SFT.'" + ), + }, + "context": { + "type": "string", + "description": ( + "Optional context from the current conversation that the " + "research agent needs (e.g., what the user wants to build, " + "constraints, what's been tried)." + ), + }, + }, + "required": ["task"], + }, +} + + +def _get_research_model(main_model: str) -> str: + """Normalize the main model id for the research sub-call.""" + return strip_huggingface_model_prefix(main_model) or main_model + + +async def research_handler( + arguments: dict[str, Any], session=None, tool_call_id: str | None = None, **_kw +) -> tuple[str, bool]: + """Execute a research sub-agent with its own context.""" + task = arguments.get("task", "") + context = arguments.get("context", "") + if not task: + return "No research task provided.", False + + if not session: + return "No session available for research agent.", False + + # Build the sub-agent's messages (independent context) + messages: list[Message] = [ + Message(role="system", content=RESEARCH_SYSTEM_PROMPT), + ] + + user_content = f"Research task: {task}" + if context: + user_content = f"Context: {context}\n\n{user_content}" + messages.append(Message(role="user", content=user_content)) + + # Use the normalized router model for research + main_model = session.config.model_name + research_model = _get_research_model(main_model) + # Research is a cheap sub-call β€” cap the main session's effort at "high". + # We also haven't probed this sub-call's model so we don't know its ceiling. + _pref = getattr(session.config, "reasoning_effort", None) + _capped = "high" if _pref in ("max", "xhigh") else _pref + llm_params = _resolve_llm_params( + research_model, + getattr(session, "hf_token", None), + reasoning_effort=_capped, + ) + llm_params = with_prompt_cache_params( + llm_params, + session_id=router_session_id_for(session), + ) + + # Get read-only tool specs from the session's tool router + tool_specs = [ + spec + for spec in session.tool_router.get_tool_specs_for_llm() + if spec["function"]["name"] in RESEARCH_TOOL_NAMES + ] + + # Unique ID + short label so parallel agents show separate status lines. + # Use the tool_call_id when available β€” it's unique per invocation and lets + # the frontend match a research tool card to its agent state. Fall back to + # uuid for offline/test paths. Previously used md5(task), which collided + # when the same task string was researched in parallel. + if tool_call_id: + _agent_id = tool_call_id + else: + import uuid + + _agent_id = uuid.uuid4().hex[:8] + _agent_label = "research: " + (task[:50] + "…" if len(task) > 50 else task) + + async def _log(text: str) -> None: + """Send a progress event to the UI so it doesn't look frozen.""" + try: + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "research", + "log": text, + "agent_id": _agent_id, + "label": _agent_label, + }, + ) + ) + except Exception: + pass + + _tool_uses = 0 + _total_tokens = 0 + _warned_context = False + + await _log("Starting research sub-agent...") + + # Run the research loop β€” context budget is the real limiter + max_iterations = 60 + for _iteration in range(max_iterations): + # ── Doom-loop detection ── + doom_prompt = check_for_doom_loop(messages) + if doom_prompt: + logger.warning( + "Research sub-agent repetition guard activated at iteration %d", + _iteration, + ) + messages.append(Message(role="user", content=doom_prompt)) + + # ── Context budget: warn at 75%, hard-stop at 95% ── + if _total_tokens >= _RESEARCH_CONTEXT_MAX: + logger.warning( + "Research sub-agent hit context max (%d tokens) β€” forcing summary", + _total_tokens, + ) + await _log( + f"Context limit reached ({_total_tokens} tokens) β€” forcing wrap-up" + ) + # Ask for a final summary with no tools + messages.append( + Message( + role="user", + content=( + "[SYSTEM: CONTEXT LIMIT REACHED] You have used all available context. " + "Summarize your findings NOW. Do NOT call any more tools." + ), + ) + ) + try: + _t0 = time.monotonic() + cached_messages, _ = with_prompt_caching(messages, None, llm_params) + response = await _research_acompletion( + session=session, + research_model=research_model, + messages=cached_messages, + tools=None, # no tools β€” force text response + llm_params=llm_params, + timeout=120, + ) + # Telemetry is best-effort; a logging blip must never mask a + # valid LLM response (the surrounding except would convert it + # to "summary call failed"). + try: + if await _record_research_llm_call( + session, + research_model=research_model, + response=response, + started_at=_t0, + ): + return ( + "Research paused because the YOLO cap was reached.", + False, + ) + except Exception as _telem_err: + logger.debug("research telemetry failed: %s", _telem_err) + content = response.choices[0].message.content or "" + return ( + content or "Research context exhausted β€” no summary produced.", + bool(content), + ) + except Exception: + return "Research context exhausted and summary call failed.", False + + if not _warned_context and _total_tokens >= _RESEARCH_CONTEXT_WARN: + _warned_context = True + await _log(f"Context at {_total_tokens} tokens β€” nudging to wrap up") + messages.append( + Message( + role="user", + content=( + "[SYSTEM: You have used 75% of your context budget. " + "Start wrapping up: finish any critical lookups, then " + "produce your final summary within the next 1-2 iterations.]" + ), + ) + ) + + try: + _t0 = time.monotonic() + cached_messages, cached_tools = with_prompt_caching( + messages, tool_specs if tool_specs else None, llm_params + ) + response = await _research_acompletion( + session=session, + research_model=research_model, + messages=cached_messages, + tools=cached_tools, + tool_choice="auto", + llm_params=llm_params, + timeout=120, + ) + try: + if await _record_research_llm_call( + session, + research_model=research_model, + response=response, + started_at=_t0, + ): + return "Research paused because the YOLO cap was reached.", False + except Exception as _telem_err: + logger.debug("research telemetry failed: %s", _telem_err) + except Exception as e: + logger.error("Research sub-agent LLM error: %s", e) + return f"Research agent LLM error: {e}", False + + # Track tokens + if response.usage: + _total_tokens = response.usage.total_tokens + await _log(f"tokens:{_total_tokens}") + + choice = response.choices[0] + msg = choice.message + + # If no tool calls, we have our final answer + if not msg.tool_calls: + await _log("Research complete.") + content = msg.content or "Research completed but no summary generated." + return content, True + + # Execute tool calls and add results. + # Rebuild the assistant message with only the wire-safe fields β€” + # LiteLLM's raw Message carries `provider_specific_fields` and + # `reasoning_content`, which the HF router's OpenAI schema rejects + # if we echo them back in the next request. + messages.append( + Message( + role="assistant", + content=msg.content, + tool_calls=msg.tool_calls, + ) + ) + for tc in msg.tool_calls: + try: + tool_args = json.loads(tc.function.arguments) + except (json.JSONDecodeError, TypeError): + messages.append( + Message( + role="tool", + content="Invalid tool arguments.", + tool_call_id=tc.id, + name=tc.function.name, + ) + ) + continue + + tool_name = tc.function.name + if tool_name not in RESEARCH_TOOL_NAMES: + messages.append( + Message( + role="tool", + content=f"Tool '{tool_name}' not available for research.", + tool_call_id=tc.id, + name=tool_name, + ) + ) + continue + + try: + import json as _json + + args_str = _json.dumps(tool_args)[:80] + await _log(f"β–Έ {tool_name} {args_str}") + + output, _success = await session.tool_router.call_tool( + tool_name, tool_args, session=session, tool_call_id=tc.id + ) + _tool_uses += 1 + await _log(f"tools:{_tool_uses}") + # Truncate tool output for the research context + if len(output) > 8000: + output = output[:4800] + "\n...(truncated)...\n" + output[-3200:] + except Exception as e: + output = f"Tool error: {e}" + + messages.append( + Message( + role="tool", + content=output, + tool_call_id=tc.id, + name=tool_name, + ) + ) + + # ── Iteration limit: try to salvage findings ── + await _log("Iteration limit reached β€” extracting summary") + messages.append( + Message( + role="user", + content=( + "[SYSTEM: ITERATION LIMIT] You have reached the maximum number of research " + "iterations. Summarize ALL findings so far. Do NOT call any more tools." + ), + ) + ) + try: + _t0 = time.monotonic() + cached_messages, _ = with_prompt_caching(messages, None, llm_params) + response = await _research_acompletion( + session=session, + research_model=research_model, + messages=cached_messages, + tools=None, + llm_params=llm_params, + timeout=120, + ) + try: + if await _record_research_llm_call( + session, + research_model=research_model, + response=response, + started_at=_t0, + ): + return "Research paused because the YOLO cap was reached.", False + except Exception as _telem_err: + logger.debug("research telemetry failed: %s", _telem_err) + content = response.choices[0].message.content or "" + if content: + return content, True + except Exception as e: + logger.error("Research summary call failed: %s", e) + + return ( + "Research agent hit iteration limit (60). " + "Partial findings may be incomplete β€” try a more focused task.", + False, + ) diff --git a/agent/tools/sandbox_client.py b/agent/tools/sandbox_client.py new file mode 100644 index 0000000000000000000000000000000000000000..d031c914f4c13b0e9d245bef6ea6f62f80ac0851 --- /dev/null +++ b/agent/tools/sandbox_client.py @@ -0,0 +1,1136 @@ +#!/usr/bin/env python3 +# /// script +# requires-python = ">=3.10" +# dependencies = ["huggingface_hub>=1.12.0", "httpx>=0.27.0"] +# /// +""" +Sandbox Tools β€” Agent-native primitives for HF Space dev-mode sandboxes. + +Architecture: + - Creates a sandbox by duplicating a template Space (runs sandbox_server.py) + - Waits for it to come online + - Communicates via HTTPS to the Space's API + - Optionally deletes the Space when done + +Lifecycle: + sb = Sandbox.create(owner="burtenshaw") # duplicate private Space, wait, connect + sb = Sandbox.create(owner="burtenshaw", # with options + hardware="t4-small", + private=True, + sleep_time=3600) + sb = Sandbox.connect("burtenshaw/my-sandbox-abc") # attach to existing + + sb.bash("uv run train.py") + sb.read("/app/train.py") + sb.edit("/app/train.py", old_str="lr=1e-3", new_str="lr=1e-4") + + sb.delete() # tear down when done + + # Or use as a context manager for automatic cleanup + with Sandbox.create(owner="burtenshaw") as sb: + sb.bash("python train.py") + # Space deleted on exit + +Tools: bash, read, write, edit, upload +""" + +from __future__ import annotations + +import io +import secrets as secrets_lib +import sys +import time +import uuid +from dataclasses import dataclass, field +from typing import Any, Callable + +import httpx +from huggingface_hub import CommitOperationAdd, HfApi + +TEMPLATE_SPACE = "burtenshaw/sandbox" +DEFAULT_READ_LIMIT = 2000 +DEFAULT_TIMEOUT = 240 +MAX_TIMEOUT = 1200 +WAIT_TIMEOUT = 600 +WAIT_INTERVAL = 5 +API_WAIT_TIMEOUT = 180 +CPU_BASIC_HARDWARE = "cpu-basic" + + +def _is_transient_space_visibility_error(error: Exception) -> bool: + """Return True when a newly duplicated Space is not queryable yet.""" + response = getattr(error, "response", None) + if getattr(response, "status_code", None) == 404: + return True + message = str(error) + return "Repository Not Found" in message or "404 Client Error" in message + + +_DOCKERFILE = """\ +FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim + +RUN apt-get update && \\ + apt-get install -y \\ + bash git git-lfs wget curl procps \\ + htop vim nano jq tmux \\ + build-essential && \\ + rm -rf /var/lib/apt/lists/* + +RUN uv pip install --system fastapi uvicorn python-multipart + +RUN useradd -m -u 1000 user +USER user + +ENV HOME=/home/user \\ + PATH=/home/user/.local/bin:$PATH \\ + PIP_USER=1 \\ + HF_HUB_DISABLE_PROGRESS_BARS=1 \\ + TQDM_DISABLE=1 \\ + HF_HUB_ENABLE_HF_TRANSFER=1 \\ + UV_NO_PROGRESS=1 \\ + PYTHONWARNINGS=ignore::DeprecationWarning + +WORKDIR /app +COPY --chown=user . /app + +EXPOSE 7860 + +CMD ["python", "sandbox_server.py"] +""" + +_SANDBOX_SERVER = '''\ +"""Minimal FastAPI server for sandbox operations.""" +import hmac, os, subprocess, pathlib, signal, threading, re, tempfile +from fastapi import Depends, FastAPI, HTTPException, Request +from pydantic import BaseModel +from typing import Optional +import uvicorn + +_ANSI_RE = re.compile(r'\\x1b\\[[0-9;]*[a-zA-Z]|\\x1b\\].*?\\x07') + +def _strip_ansi(text: str) -> str: + return _ANSI_RE.sub('', text) + +def _truncate_output(output: str, max_chars: int = 25000, head_ratio: float = 0.25) -> str: + if len(output) <= max_chars: + return output + # Write full output to temp file so LLM can read specific sections + spill_path = None + try: + with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', prefix='bash_output_', dir='/tmp', delete=False) as f: + f.write(output) + spill_path = f.name + except Exception: + pass + head_budget = int(max_chars * head_ratio) + tail_budget = max_chars - head_budget + head = output[:head_budget] + tail = output[-tail_budget:] + total = len(output) + omitted = total - max_chars + meta = f"\\n\\n... ({omitted:,} of {total:,} chars omitted, showing first {head_budget:,} + last {tail_budget:,}) ...\\n" + if spill_path: + meta += f"Full output saved to {spill_path} β€” use the read tool with offset/limit to inspect specific sections.\\n" + return head + meta + tail + +def _atomic_write(path: pathlib.Path, content: str): + """Write atomically: temp file + fsync + os.replace.""" + path.parent.mkdir(parents=True, exist_ok=True) + fd = None + tmp_path = None + try: + fd, tmp_path = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp") + os.write(fd, content.encode("utf-8")) + os.fsync(fd) + os.close(fd) + fd = None + os.replace(tmp_path, str(path)) + tmp_path = None + finally: + if fd is not None: + os.close(fd) + if tmp_path is not None: + try: + os.unlink(tmp_path) + except OSError: + pass + +app = FastAPI() + +def _bearer_token(header: str) -> str: + scheme, _, supplied = header.partition(" ") + if scheme.lower() != "bearer" or not supplied: + return "" + return supplied + +def _require_auth(request: Request) -> None: + sandbox_token = os.environ.get("SANDBOX_API_TOKEN") or "" + if not sandbox_token: + raise HTTPException(status_code=503, detail="Sandbox API token not configured") + supplied = _bearer_token(request.headers.get("x-sandbox-authorization", "")) + if not supplied: + raise HTTPException(status_code=401, detail="Missing bearer token") + if not hmac.compare_digest(supplied, sandbox_token): + raise HTTPException(status_code=401, detail="Invalid bearer token") + +_AUTH = [Depends(_require_auth)] + +# Track active bash processes so they can be killed on cancel +_active_procs = {} # pid -> subprocess.Popen +_proc_lock = threading.Lock() + +class BashReq(BaseModel): + command: str + work_dir: str = "/app" + timeout: int = 120 + +class ReadReq(BaseModel): + path: str + offset: Optional[int] = None + limit: Optional[int] = 2000 + +class WriteReq(BaseModel): + path: str + content: str + +class EditReq(BaseModel): + path: str + old_str: str + new_str: str + replace_all: bool = False + mode: str = "replace" + +class ExistsReq(BaseModel): + path: str + +# ── Fuzzy matching & edit utilities (embedded) ── + +UNICODE_MAP = { + "\\u2013": "-", "\\u2014": "-", "\\u2212": "-", + "\\u2018": "'", "\\u2019": "'", + "\\u201c": \'"\', "\\u201d": \'"\', + "\\u00a0": " ", "\\u2003": " ", "\\u2002": " ", + "\\u200b": "", "\\ufeff": "", +} + +def _normalize_unicode(s): + return "".join(UNICODE_MAP.get(c, c) for c in s) + +def _fuzzy_find_original(content, pattern): + """Find the original text in content that matches pattern fuzzily.""" + if pattern in content: + return pattern, None + # Pass 2: right-trim + c_lines = content.split("\\n") + c_rt = "\\n".join(l.rstrip() for l in c_lines) + p_rt = "\\n".join(l.rstrip() for l in pattern.split("\\n")) + if p_rt in c_rt: + idx = c_rt.index(p_rt) + start_line = c_rt[:idx].count("\\n") + n_lines = p_rt.count("\\n") + 1 + matched = "\\n".join(c_lines[start_line:start_line + n_lines]) + return matched, "(matched after trimming trailing whitespace)" + # Pass 3: both-sides trim + c_st = "\\n".join(l.strip() for l in c_lines) + p_st = "\\n".join(l.strip() for l in pattern.split("\\n")) + if p_st in c_st: + idx = c_st.index(p_st) + start_line = c_st[:idx].count("\\n") + n_lines = p_st.count("\\n") + 1 + matched = "\\n".join(c_lines[start_line:start_line + n_lines]) + return matched, "(matched after trimming whitespace)" + # Pass 4: unicode normalization + c_norm = _normalize_unicode(c_st) + p_norm = _normalize_unicode(p_st) + if p_norm in c_norm: + idx = c_norm.index(p_norm) + start_line = c_norm[:idx].count("\\n") + n_lines = p_norm.count("\\n") + 1 + matched = "\\n".join(c_lines[start_line:start_line + n_lines]) + return matched, "(matched after unicode normalization)" + return None, None + +def _apply_edit(content, old_str, new_str, mode="replace", replace_all=False): + """Apply edit. Returns (new_content, count, fuzzy_note) or raises ValueError.""" + if mode == "replace_all": + replace_all = True + mode = "replace" + fuzzy_note = None + if old_str not in content: + matched, fuzzy_note = _fuzzy_find_original(content, old_str) + if matched is None: + raise ValueError("old_str not found in file.") + old_str = matched + count = content.count(old_str) + if mode == "replace": + if count > 1 and not replace_all: + raise ValueError(f"old_str appears {count} times. Use replace_all=true or provide more context.") + if replace_all: + return content.replace(old_str, new_str), count, fuzzy_note + return content.replace(old_str, new_str, 1), 1, fuzzy_note + elif mode == "append_after": + if replace_all: + return content.replace(old_str, old_str + new_str), count, fuzzy_note + idx = content.index(old_str) + len(old_str) + return content[:idx] + new_str + content[idx:], 1, fuzzy_note + elif mode == "prepend_before": + if replace_all: + return content.replace(old_str, new_str + old_str), count, fuzzy_note + idx = content.index(old_str) + return content[:idx] + new_str + content[idx:], 1, fuzzy_note + raise ValueError(f"Unknown mode: {mode}") + +def _validate_python(content, path=""): + """Validate Python: syntax, kwargs against real installed signatures, training heuristics. + + Runs inside the sandbox where packages are pip-installed, so we can actually + import classes and inspect their __init__ signatures to catch kwarg mismatches + before runtime. + """ + import ast as _ast, inspect as _inspect, importlib as _il + warnings = [] + + # 1. Syntax check + try: + tree = _ast.parse(content) + except SyntaxError as e: + warnings.append(f"Python syntax error at line {e.lineno}: {e.msg}") + return warnings + + # 2. Build import map: name -> module path (from the script's own imports) + import_map = {} + for node in _ast.walk(tree): + if isinstance(node, _ast.ImportFrom) and node.module: + for alias in (node.names or []): + local_name = alias.asname or alias.name + import_map[local_name] = (node.module, alias.name) + elif isinstance(node, _ast.Import): + for alias in (node.names or []): + local_name = alias.asname or alias.name + import_map[local_name] = (alias.name, None) + + # 3. For each Call node, resolve the callable and check kwargs against signature + for node in _ast.walk(tree): + if not isinstance(node, _ast.Call): + continue + # Skip calls with **kwargs unpacking β€” we can't statically know those keys + if any(kw.arg is None for kw in node.keywords): + continue + call_kwargs = [kw.arg for kw in node.keywords if kw.arg] + if not call_kwargs: + continue + + # Resolve the callable name + func_name = None + if isinstance(node.func, _ast.Name): + func_name = node.func.id + elif isinstance(node.func, _ast.Attribute): + func_name = node.func.attr + if not func_name or func_name not in import_map: + continue + + # Try to import and inspect the real callable + module_path, attr_name = import_map[func_name] + try: + mod = _il.import_module(module_path) + obj = getattr(mod, attr_name, None) if attr_name else mod + if obj is None: + continue + sig = _inspect.signature(obj) + params = sig.parameters + # If **kwargs is in the signature, any kwarg is valid + if any(p.kind == _inspect.Parameter.VAR_KEYWORD for p in params.values()): + continue + valid_names = set(params.keys()) + for kw_name in call_kwargs: + if kw_name not in valid_names: + warnings.append( + f"Invalid kwarg: {func_name}({kw_name}=...) at line {node.lineno} " + f"-- not accepted by {module_path}.{attr_name or func_name}()" + ) + except Exception: + pass # can't import/inspect β€” skip silently + + # 4. Training script heuristics + if any(kw in content for kw in ("TrainingArguments", "SFTConfig", "DPOConfig", "GRPOConfig")): + if "push_to_hub" not in content: + warnings.append("Training script warning: no \'push_to_hub\' found") + if "hub_model_id" not in content: + warnings.append("Training script warning: no \'hub_model_id\' found") + return warnings + +@app.get("/api/health") +def health(): + return {"status": "ok"} + +@app.post("/api/bash", dependencies=_AUTH) +def bash(req: BashReq): + try: + proc = subprocess.Popen( + req.command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + text=True, cwd=req.work_dir, start_new_session=True, + ) + with _proc_lock: + _active_procs[proc.pid] = proc + try: + stdout, stderr = proc.communicate(timeout=req.timeout) + output = _strip_ansi(stdout + stderr) + output = _truncate_output(output) + return {"success": proc.returncode == 0, "output": output, "error": "" if proc.returncode == 0 else f"Exit code {proc.returncode}"} + except subprocess.TimeoutExpired: + try: + os.killpg(os.getpgid(proc.pid), signal.SIGKILL) + except OSError: + proc.kill() + proc.wait() + return {"success": False, "output": "", "error": f"Timeout after {req.timeout}s"} + finally: + with _proc_lock: + _active_procs.pop(proc.pid, None) + except Exception as e: + return {"success": False, "output": "", "error": str(e)} + +@app.post("/api/kill", dependencies=_AUTH) +def kill_all(): + """Kill all active bash processes. Called when user cancels.""" + with _proc_lock: + pids = list(_active_procs.keys()) + killed = [] + for pid in pids: + try: + os.killpg(os.getpgid(pid), signal.SIGTERM) + killed.append(pid) + except OSError: + try: + os.kill(pid, signal.SIGKILL) + killed.append(pid) + except OSError: + pass + return {"success": True, "output": f"Killed {len(killed)} process(es): {killed}", "error": ""} + +@app.post("/api/read", dependencies=_AUTH) +def read(req: ReadReq): + try: + p = pathlib.Path(req.path) + if not p.exists(): + return {"success": False, "output": "", "error": f"File not found: {req.path}"} + if p.is_dir(): + return {"success": False, "output": "", "error": f"Is a directory: {req.path}"} + lines = p.read_text().splitlines() + start = (req.offset or 1) - 1 + end = start + (req.limit or len(lines)) + selected = lines[start:end] + numbered = "\\n".join(f"{start + i + 1}\\t{line}" for i, line in enumerate(selected)) + return {"success": True, "output": numbered, "error": ""} + except Exception as e: + return {"success": False, "output": "", "error": str(e)} + +@app.post("/api/write", dependencies=_AUTH) +def write(req: WriteReq): + try: + p = pathlib.Path(req.path) + _atomic_write(p, req.content) + msg = f"Wrote {len(req.content)} bytes to {req.path}" + if p.suffix == ".py": + warnings = _validate_python(req.content, req.path) + if warnings: + msg += "\\n\\nValidation warnings:\\n" + "\\n".join(f" ! {w}" for w in warnings) + return {"success": True, "output": msg, "error": ""} + except Exception as e: + return {"success": False, "output": "", "error": str(e)} + +@app.post("/api/edit", dependencies=_AUTH) +def edit(req: EditReq): + try: + p = pathlib.Path(req.path) + if not p.exists(): + return {"success": False, "output": "", "error": f"File not found: {req.path}"} + content = p.read_text() + if req.old_str == req.new_str: + return {"success": False, "output": "", "error": "old_str and new_str must differ."} + try: + new_content, count, fuzzy_note = _apply_edit( + content, req.old_str, req.new_str, mode=req.mode, replace_all=req.replace_all + ) + except ValueError as e: + return {"success": False, "output": "", "error": str(e)} + _atomic_write(p, new_content) + msg = f"Edited {req.path} ({count} replacement{'s' if count > 1 else ''})" + if fuzzy_note: + msg += f" {fuzzy_note}" + if p.suffix == ".py": + warnings = _validate_python(new_content, req.path) + if warnings: + msg += "\\n\\nValidation warnings:\\n" + "\\n".join(f" ! {w}" for w in warnings) + return {"success": True, "output": msg, "error": ""} + except Exception as e: + return {"success": False, "output": "", "error": str(e)} + +@app.post("/api/exists", dependencies=_AUTH) +def exists(req: ExistsReq): + return {"success": True, "output": str(pathlib.Path(req.path).exists()).lower(), "error": ""} + +if __name__ == "__main__": + uvicorn.run(app, host="0.0.0.0", port=7860) +''' + + +@dataclass +class ToolResult: + success: bool + output: str = "" + error: str = "" + + def __str__(self): + if self.success: + return self.output or "(no output)" + return f"ERROR: {self.error}" + + +@dataclass +class Sandbox: + """ + A handle to an HF Space sandbox. + + Use Sandbox.create() to spin up a new one, or Sandbox.connect() to + attach to an existing running Space. + """ + + space_id: str + token: str | None = None + api_token: str | None = field(default=None, repr=False) + work_dir: str = "/app" + timeout: int = DEFAULT_TIMEOUT + _owns_space: bool = field(default=False, repr=False) + _base_url: str = field(init=False, repr=False) + _client: httpx.Client = field(init=False, repr=False) + _hf_api: HfApi = field(init=False, repr=False) + _files_read: set = field(init=False, repr=False, default_factory=set) + + def __post_init__(self): + slug = self.space_id.replace("/", "-") + # Trailing slash is critical: httpx resolves relative paths against base_url. + # Without it, client.get("health") resolves to /health instead of /api/health. + self._base_url = f"https://{slug}.hf.space/api/" + self._client = httpx.Client( + base_url=self._base_url, + headers=self._auth_headers(), + timeout=httpx.Timeout(MAX_TIMEOUT, connect=30), + follow_redirects=True, + ) + self._hf_api = HfApi(token=self.token) + + def _auth_headers(self) -> dict[str, str]: + """Return headers for private HF Space access plus sandbox API auth. + + Private Spaces require the HF token in ``Authorization`` at the Hub + edge. The sandbox server requires its control-plane token in the + dedicated ``X-Sandbox-Authorization`` header. + """ + headers: dict[str, str] = {} + if self.token: + headers["Authorization"] = f"Bearer {self.token}" + if self.api_token: + headers["X-Sandbox-Authorization"] = f"Bearer {self.api_token}" + return headers + + # ── Lifecycle ───────────────────────────────────────────────── + + class Cancelled(Exception): + """Raised when sandbox creation is cancelled by the user.""" + + @classmethod + def create( + cls, + owner: str, + *, + name: str | None = None, + template: str = TEMPLATE_SPACE, + hardware: str = CPU_BASIC_HARDWARE, + private: bool = True, + sleep_time: int | None = None, + token: str | None = None, + secrets: dict[str, str] | None = None, + wait_timeout: int = WAIT_TIMEOUT, + log: "Callable[[str], object] | None" = None, + cancel_event: "Any | None" = None, + ) -> Sandbox: + """ + Create a new sandbox by duplicating the template Space. + + Generates a unique space name, duplicates the template, waits for it + to come online, then returns a connected Sandbox. + + Args: + owner: HF username or org (e.g. "burtenshaw"). + name: Base name for the space. Defaults to "sandbox". + A unique suffix is always appended. + template: Source Space to duplicate (default: burtenshaw/sandbox). + hardware: Hardware tier (cpu-basic, t4-small, etc.). + private: Whether the Space should be private. Defaults to True. + sleep_time: Auto-sleep after N seconds of inactivity. + token: HF API token (from user's OAuth session). + wait_timeout: Max seconds to wait for Space to start (default: 300). + cancel_event: A threading.Event (or compatible) checked during + polling loops. When set, the Space is deleted and + Sandbox.Cancelled is raised. + + Returns: + A Sandbox instance connected to the running Space. + """ + _log = log or print + api = HfApi(token=token) + + def _check_cancel(): + if cancel_event and cancel_event.is_set(): + _log("Sandbox creation cancelled by user, cleaning up...") + try: + api.delete_repo(space_id, repo_type="space") + _log(f"Deleted Space {space_id}") + except Exception: + pass + raise cls.Cancelled(f"Sandbox creation cancelled: {space_id}") + + base = name or "sandbox" + suffix = uuid.uuid4().hex[:8] + space_id = f"{owner}/{base}-{suffix}" + sandbox_api_token = secrets_lib.token_urlsafe(32) + + _log(f"Creating sandbox: {space_id} (from {template})...") + + kwargs = { + "from_id": template, + "to_id": space_id, + "repo_type": "space", + "private": private, + "space_hardware": hardware, + } + if sleep_time is not None: + kwargs["space_sleep_time"] = sleep_time + + api.duplicate_repo(**kwargs) + _log(f"Space created: https://huggingface.co/spaces/{space_id}") + + _check_cancel() + + # ``duplicate_repo`` sends hardware and sleepTimeSeconds in the + # initial create request. Avoid a second /hardware call: deployed HF + # OAuth tokens can 401 on that endpoint for a just-created private + # Space even though duplication itself succeeded. We rely on the + # duplicate endpoint to honor sleepTimeSeconds for upgraded hardware; + # cpu-basic auto-sleep is fixed by the Hub. + _log(f"Using duplicated Space hardware: {hardware}") + if sleep_time is not None: + if hardware == CPU_BASIC_HARDWARE: + _log( + f"Requested duplicated Space sleep time: {sleep_time}s " + "(cpu-basic auto-sleep is fixed by the Hub)" + ) + else: + _log(f"Using duplicated Space sleep time: {sleep_time}s") + + # Inject secrets BEFORE uploading server files (which triggers rebuild). + # Secrets added after a Space is running aren't available until restart, + # so they must be set before the build/start cycle. + sandbox_secrets = {**(secrets or {}), "SANDBOX_API_TOKEN": sandbox_api_token} + if sandbox_secrets: + for key, val in sandbox_secrets.items(): + api.add_space_secret(space_id, key, val) + + # Upload sandbox server and Dockerfile (triggers rebuild) + cls._setup_server(space_id, api, log=_log) + + _check_cancel() + + # Wait for it to come online (rebuild + start) + _log(f"Waiting for Space to start (timeout: {wait_timeout}s)...") + deadline = time.time() + wait_timeout + while time.time() < deadline: + _check_cancel() + try: + runtime = api.get_space_runtime(space_id) + except Exception as e: + if _is_transient_space_visibility_error(e): + _log(" Space runtime not visible yet...") + time.sleep(WAIT_INTERVAL) + continue + raise + if runtime.stage == "RUNNING": + current_hardware = runtime.hardware or getattr( + runtime, "requested_hardware", None + ) + if current_hardware != hardware: + _log(f" RUNNING on {current_hardware}; waiting for {hardware}...") + time.sleep(WAIT_INTERVAL) + continue + _log(f"Space is running (hardware: {runtime.hardware})") + break + if runtime.stage in ("RUNTIME_ERROR", "BUILD_ERROR"): + raise RuntimeError( + f"Space failed to start: {runtime.stage}. " + f"Check https://huggingface.co/spaces/{space_id}" + ) + _log(f" {runtime.stage}...") + time.sleep(WAIT_INTERVAL) + else: + raise TimeoutError( + f"Space did not start within {wait_timeout}s. " + f"Check https://huggingface.co/spaces/{space_id}" + ) + + _check_cancel() + + # Wait for the API server to be responsive (non-fatal) + sb = cls( + space_id=space_id, + token=token, + api_token=sandbox_api_token, + _owns_space=True, + ) + try: + sb._wait_for_api(timeout=API_WAIT_TIMEOUT, log=_log) + except TimeoutError as e: + _log( + f"Warning: API health check timed out ({e}), but Space is RUNNING. Continuing." + ) + return sb + + @staticmethod + def _setup_server( + space_id: str, api: HfApi, *, log: Callable[[str], object] = print + ) -> None: + """Upload embedded sandbox server + Dockerfile to the Space (single commit).""" + log(f"Uploading sandbox server to {space_id}...") + api.create_commit( + repo_id=space_id, + repo_type="space", + operations=[ + CommitOperationAdd( + path_in_repo="sandbox_server.py", + path_or_fileobj=io.BytesIO(_SANDBOX_SERVER.encode()), + ), + CommitOperationAdd( + path_in_repo="Dockerfile", + path_or_fileobj=io.BytesIO(_DOCKERFILE.encode()), + ), + ], + commit_message="Setup sandbox server", + ) + log("Server files uploaded, rebuild triggered.") + + @classmethod + def connect( + cls, + space_id: str, + *, + token: str | None = None, + api_token: str | None = None, + ) -> Sandbox: + """ + Connect to an existing running Space. + + Does a health check to verify the Space is reachable. + """ + sb = cls( + space_id=space_id, + token=token, + api_token=api_token, + _owns_space=False, + ) + sb._wait_for_api(timeout=60) + return sb + + def _wait_for_api( + self, timeout: int = API_WAIT_TIMEOUT, log: Callable[[str], object] = print + ): + """Poll the health endpoint until the server responds.""" + deadline = time.time() + timeout + last_err = None + last_status = None + while time.time() < deadline: + try: + resp = self._client.get("health", timeout=10) + last_status = resp.status_code + if resp.status_code == 200: + log(f"API is responsive at {self._base_url}") + return + except Exception as e: + last_err = e + time.sleep(3) + raise TimeoutError( + f"Sandbox API at {self._base_url} not responding after {timeout}s. " + f"Last status: {last_status}, last error: {last_err}" + ) + + def delete(self, log: Callable[[str], object] | None = None): + """Delete the Space. Only works if this Sandbox created it.""" + if not self._owns_space: + raise RuntimeError( + f"This Sandbox did not create {self.space_id}. " + f"Use self._hf_api.delete_repo() directly if you're sure." + ) + if log: + log(f"Deleting sandbox: {self.space_id}...") + self._hf_api.delete_repo(self.space_id, repo_type="space") + # Clear ownership so a second cleanup call (e.g. delete_session + + # _run_session.finally both fire) early-returns instead of retrying + # a 404 delete and emitting a spurious ERROR log. + self._owns_space = False + self._client.close() + if log: + log("Deleted.") + + @property + def url(self) -> str: + """Public URL of the Space.""" + return f"https://huggingface.co/spaces/{self.space_id}" + + @property + def status(self) -> str: + """Current Space stage (RUNNING, BUILDING, PAUSED, etc.).""" + return self._hf_api.get_space_runtime(self.space_id).stage + + def __enter__(self) -> Sandbox: + return self + + def __exit__(self, *exc): + if self._owns_space: + try: + self.delete() + except Exception as e: + print(f"Warning: failed to delete sandbox: {e}", file=sys.stderr) + self._client.close() + + # ── HTTP plumbing ───────────────────────────────────────────── + + def _call( + self, endpoint: str, payload: dict, timeout: float | None = None + ) -> ToolResult: + # Strip leading slash for correct httpx base_url resolution + endpoint = endpoint.lstrip("/") + effective_timeout = timeout or self.timeout + last_error = "" + + # Retry up to 3 times for transient failures (sandbox waking from + # sleep returns empty / non-JSON responses while it starts up). + for attempt in range(3): + try: + resp = self._client.post( + endpoint, + json=payload, + timeout=effective_timeout, + ) + try: + data = resp.json() + except (ValueError, UnicodeDecodeError): + # Non-JSON response β€” sandbox is likely still starting up. + body_preview = resp.text[:200] if resp.text else "(empty)" + last_error = ( + f"Sandbox returned non-JSON response (HTTP {resp.status_code}): " + f"{body_preview}" + ) + if attempt < 2: + time.sleep(3 * (attempt + 1)) + continue + return ToolResult(success=False, error=last_error) + + if resp.status_code == 200: + return ToolResult( + success=data.get("success", True), + output=data.get("output", ""), + error=data.get("error", ""), + ) + return ToolResult( + success=False, + error=data.get("error", f"HTTP {resp.status_code}"), + ) + except httpx.TimeoutException: + return ToolResult( + success=False, error=f"Timeout after {effective_timeout}s" + ) + except httpx.ConnectError: + last_error = ( + f"Cannot connect to sandbox. Is {self.space_id} running? " + f"Status: {self.status}" + ) + if attempt < 2: + time.sleep(3 * (attempt + 1)) + continue + return ToolResult(success=False, error=last_error) + except Exception as e: + return ToolResult(success=False, error=str(e)) + + return ToolResult(success=False, error=last_error or "Unknown error") + + # ── Tools ───────────────────────────────────────────────────── + + def bash( + self, + command: str, + *, + work_dir: str | None = None, + timeout: int | None = None, + description: str | None = None, + ) -> ToolResult: + return self._call( + "bash", + { + "command": command, + "work_dir": work_dir or self.work_dir, + "timeout": min(timeout or self.timeout, MAX_TIMEOUT), + }, + timeout=timeout, + ) + + def read( + self, path: str, *, offset: int | None = None, limit: int | None = None + ) -> ToolResult: + self._files_read.add(path) + return self._call( + "read", + { + "path": path, + "offset": offset, + "limit": limit or (DEFAULT_READ_LIMIT if offset is None else None), + }, + ) + + def write(self, path: str, content: str) -> ToolResult: + if path not in self._files_read: + check = self._call("exists", {"path": path}) + if check.success and check.output == "true": + return ToolResult( + success=False, + error=( + f"File {path} exists but has not been read this session. " + f"Read it first, or use sandbox_edit for targeted changes." + ), + ) + result = self._call("write", {"path": path, "content": content}) + if result.success: + self._files_read.add(path) + return result + + def edit( + self, + path: str, + old_str: str, + new_str: str, + *, + replace_all: bool = False, + mode: str = "replace", + ) -> ToolResult: + if old_str == new_str: + return ToolResult(success=False, error="old_str and new_str are identical.") + if path not in self._files_read: + return ToolResult( + success=False, + error=f"File {path} has not been read this session. Read it first.", + ) + return self._call( + "edit", + { + "path": path, + "old_str": old_str, + "new_str": new_str, + "replace_all": replace_all, + "mode": mode, + }, + ) + + def kill_all(self) -> ToolResult: + """Kill all active bash processes on the sandbox. Used on cancellation.""" + return self._call("kill", {}) + + # ── Tool schemas & dispatch ─────────────────────────────────── + + TOOLS = { + "bash": { + "description": ( + "Run a shell command in the remote sandbox and return stdout/stderr.\n" + "\n" + "IMPORTANT: Do NOT use bash for file operations β€” use the dedicated tools instead:\n" + "- To read files: use read (not cat/head/tail)\n" + "- To edit files: use edit (not sed/awk)\n" + "- To write files: use write (not echo/cat < > /app/output.log 2>&1 & echo $!\n" + "Then check status:\n" + " kill -0 2>/dev/null && echo 'running' || echo 'done'\n" + " tail -n 50 /app/output.log\n" + "\n" + "Timeout default 240s, max 1200s." + ), + "parameters": { + "type": "object", + "required": ["command"], + "additionalProperties": False, + "properties": { + "command": { + "type": "string", + "description": "The shell command to execute.", + }, + "description": { + "type": "string", + "description": "Short description (5-10 words, active voice).", + }, + "work_dir": { + "type": "string", + "description": "Working directory (default: /app).", + }, + "timeout": { + "type": "integer", + "description": "Optional timeout in seconds (default: 240, max: 1200).", + }, + }, + }, + }, + "read": { + "description": ( + "Reads a file from the sandbox filesystem. Returns contents with line " + "numbers (cat -n format).\n" + "\n" + "Usage:\n" + "- By default, reads up to 2000 lines from the beginning of the file.\n" + "- You can optionally specify offset and limit for large files, but prefer " + "reading the whole file first.\n" + "- Lines longer than 4000 chars are truncated.\n" + "- Cannot read directories β€” use bash with 'ls' instead.\n" + "- You should read multiple potentially useful files in parallel when possible.\n" + "- IMPORTANT: Always read a file before editing or overwriting it. The edit and " + "write tools will reject operations on files you haven't read." + ), + "parameters": { + "type": "object", + "required": ["path"], + "additionalProperties": False, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to read.", + }, + "offset": { + "type": "integer", + "description": "The line number to start reading from (1-based). Only provide if the file is too large to read at once.", + }, + "limit": { + "type": "integer", + "description": "The number of lines to read. Only provide if the file is too large to read at once.", + }, + }, + }, + }, + "write": { + "description": ( + "Writes a file to the sandbox filesystem. Overwrites the existing file if " + "one exists at the path.\n" + "\n" + "- If this is an existing file, you MUST use the read tool first. This tool " + "will fail if you did not read the file first.\n" + "- ALWAYS prefer editing existing files with the edit tool over overwriting " + "with write.\n" + "- Creates parent directories as needed." + ), + "parameters": { + "type": "object", + "required": ["path", "content"], + "additionalProperties": False, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to write.", + }, + "content": { + "type": "string", + "description": "The complete file content to write.", + }, + }, + }, + }, + "edit": { + "description": ( + "Performs string replacements in files. Supports exact matching with " + "fuzzy fallback.\n" + "\n" + "Usage:\n" + "- You must read the file at least once before editing. This tool will " + "error if you attempt an edit without reading the file.\n" + "- The edit will FAIL if old_str is not unique in the file. Either provide " + "a larger string with more surrounding context to make it unique, or set " + "replace_all to true.\n" + "- old_str and new_str must differ.\n" + "- Preserve indentation exactly as it appears in the file.\n" + "- Do NOT include line number prefixes from read output in old_str or new_str.\n" + "- To delete code, set new_str to empty string.\n" + "- Use replace_all for renaming variables or strings across the file.\n" + "\n" + "Modes:\n" + "- replace (default): replace first occurrence of old_str with new_str.\n" + "- append_after: insert new_str immediately after old_str (old_str is kept).\n" + "- prepend_before: insert new_str immediately before old_str (old_str is kept)." + ), + "parameters": { + "type": "object", + "required": ["path", "old_str", "new_str"], + "additionalProperties": False, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to edit.", + }, + "old_str": { + "type": "string", + "description": "The text to find in the file. Must match exactly (fuzzy matching is used as fallback).", + }, + "new_str": { + "type": "string", + "description": "The replacement text. For append_after/prepend_before modes, the text to insert.", + }, + "replace_all": { + "type": "boolean", + "description": "Replace all occurrences of old_str (default: false).", + "default": False, + }, + "mode": { + "type": "string", + "enum": ["replace", "append_after", "prepend_before"], + "description": "Edit mode (default: replace).", + "default": "replace", + }, + }, + }, + }, + } + + def call_tool(self, name: str, arguments: dict[str, Any]) -> ToolResult: + dispatch = { + "bash": lambda a: self.bash( + a["command"], + work_dir=a.get("work_dir"), + timeout=a.get("timeout"), + description=a.get("description"), + ), + "read": lambda a: self.read( + a["path"], + offset=a.get("offset"), + limit=a.get("limit"), + ), + "write": lambda a: self.write(a["path"], a["content"]), + "edit": lambda a: self.edit( + a["path"], + a["old_str"], + a["new_str"], + replace_all=a.get("replace_all", False), + mode=a.get("mode", "replace"), + ), + } + fn = dispatch.get(name) + if not fn: + return ToolResult(success=False, error=f"Unknown tool: {name}") + return fn(arguments) diff --git a/agent/tools/sandbox_tool.py b/agent/tools/sandbox_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..a550c0180a0e9665180681828af7f131677b1d58 --- /dev/null +++ b/agent/tools/sandbox_tool.py @@ -0,0 +1,923 @@ +""" +Sandbox tools β€” expose the Sandbox client as agent tools. + +5 tools total: + sandbox_create β€” create/replace sandbox for non-default hardware + bash, read, write, edit β€” operations on the active sandbox + +A cpu-basic sandbox is preloaded for each session. Operation tools wait for it +if startup is still in progress. +""" + +from __future__ import annotations + +import asyncio +import logging +import re +import threading +import uuid +import weakref +from collections.abc import Callable +from datetime import datetime, timezone +from typing import Any + +from huggingface_hub import HfApi, SpaceHardware + +from agent.core.cost_estimation import ( + DEFAULT_SANDBOX_RESERVATION_HOURS, + SPACE_PRICE_USD_PER_HOUR, + CostEstimate, +) +from agent.core.hub_artifacts import wrap_shell_command_with_hub_artifact_bootstrap +from agent.core.session import Event +from agent.tools.sandbox_client import Sandbox +from agent.tools.trackio_seed import ensure_trackio_dashboard + +logger = logging.getLogger(__name__) + +DEFAULT_CPU_SANDBOX_HARDWARE = "cpu-basic" + +# Match the exact suffix pattern Sandbox.create produces: "sandbox-<8 hex>". +# Used to identify orphan sandboxes from prior sessions safely (won't match +# user-renamed lookalikes). +SANDBOX_SPACE_NAME_RE = re.compile(r"^sandbox-[a-f0-9]{8}$") + +# HF Space duplication/build APIs can behave poorly when multiple private +# sandboxes are created concurrently for the same namespace. Keep session +# creation non-blocking, but serialize the actual Hub create path per owner. +_SANDBOX_CREATE_LOCKS: weakref.WeakKeyDictionary[ + asyncio.AbstractEventLoop, dict[str, asyncio.Lock] +] = weakref.WeakKeyDictionary() +_SANDBOX_YOLO_RENEWAL_FRACTION = 0.95 + + +def _get_sandbox_create_lock(owner: str) -> asyncio.Lock: + loop = asyncio.get_running_loop() + locks = _SANDBOX_CREATE_LOCKS.setdefault(loop, {}) + lock = locks.get(owner) + if lock is None: + lock = asyncio.Lock() + locks[owner] = lock + return lock + + +def _sandbox_window_cost_usd(hardware: str) -> float | None: + price = SPACE_PRICE_USD_PER_HOUR.get(str(hardware)) + if price is None: + return None + return round(float(price) * DEFAULT_SANDBOX_RESERVATION_HOURS, 4) + + +def _sandbox_window_estimate(hardware: str) -> CostEstimate: + cost = _sandbox_window_cost_usd(hardware) + if cost is None: + return CostEstimate( + estimated_cost_usd=None, + billable=True, + block_reason=f"No price is available for sandbox hardware '{hardware}'.", + label=hardware, + ) + return CostEstimate( + estimated_cost_usd=cost, + billable=cost > 0, + label=hardware, + ) + + +def _sandbox_yolo_renewal_delay_s() -> float: + return max( + 1.0, + DEFAULT_SANDBOX_RESERVATION_HOURS * 3600 * _SANDBOX_YOLO_RENEWAL_FRACTION, + ) + + +def _sandbox_yolo_finalized_cost_usd(session: Any) -> float: + return max(0.0, float(getattr(session, "_sandbox_yolo_finalized_cost_usd", 0.0))) + + +def _add_sandbox_yolo_finalized_cost(session: Any, amount_usd: float | None) -> None: + if amount_usd is None or amount_usd <= 0: + return + session._sandbox_yolo_finalized_cost_usd = round( + _sandbox_yolo_finalized_cost_usd(session) + float(amount_usd), + 4, + ) + + +def _cancel_sandbox_yolo_renewal(session: Any) -> None: + task = getattr(session, "_sandbox_yolo_renewal_task", None) + if task and not task.done() and task is not asyncio.current_task(): + task.cancel() + session._sandbox_yolo_renewal_task = None + + +def _start_sandbox_yolo_renewal( + session: Any, + *, + hardware: str, + reservation_id: str, +) -> None: + if hardware == DEFAULT_CPU_SANDBOX_HARDWARE: + return + _cancel_sandbox_yolo_renewal(session) + task = asyncio.create_task( + _sandbox_yolo_renewal_loop( + session, + hardware=hardware, + reservation_id=reservation_id, + ) + ) + session._sandbox_yolo_renewal_task = task + + def _log_task_error(done: asyncio.Task) -> None: + if done.cancelled(): + return + try: + done.result() + except Exception as e: + logger.warning("Sandbox YOLO renewal task failed: %s", e) + + task.add_done_callback(_log_task_error) + + +async def _sandbox_yolo_renewal_loop( + session: Any, + *, + hardware: str, + reservation_id: str, +) -> None: + from agent.core.yolo_budget import ( + reconcile_budget_reservation, + reserve_session_budget, + session_yolo_enabled, + ) + + active_reservation_id = reservation_id + while True: + await asyncio.sleep(_sandbox_yolo_renewal_delay_s()) + if ( + getattr(session, "_sandbox_yolo_reservation_id", None) + != active_reservation_id + ): + return + if not getattr(session, "sandbox", None): + return + if getattr(session, "sandbox_hardware", None) != hardware: + return + + window_cost = _sandbox_window_cost_usd(hardware) + reconcile_budget_reservation(session, active_reservation_id, window_cost) + _add_sandbox_yolo_finalized_cost(session, window_cost) + + if not session_yolo_enabled(session): + session._sandbox_yolo_reservation_id = None + return + + estimate = _sandbox_window_estimate(hardware) + next_reservation_id = f"sandbox-renew-{uuid.uuid4().hex[:10]}" + decision = reserve_session_budget( + session, + estimate, + spend_kind="sandbox", + reservation_id=next_reservation_id, + ) + if not decision.allowed: + session._sandbox_yolo_reservation_id = None + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "sandbox", + "log": ( + "YOLO usage cap reached for the active sandbox; " + "tearing it down before the reserved budget expires." + ), + }, + ) + ) + await teardown_session_sandbox(session) + return + + active_reservation_id = ( + decision.reservation.reservation_id + if decision.reservation + else next_reservation_id + ) + session._sandbox_yolo_reservation_id = active_reservation_id + + +def _session_tool_logger( + session: Any, *, tool: str = "sandbox" +) -> Callable[[str], object] | None: + event_queue = getattr(session, "event_queue", None) + if event_queue is None: + return None + + loop = asyncio.get_running_loop() + + def _log(msg: str) -> None: + loop.call_soon_threadsafe( + event_queue.put_nowait, + Event(event_type="tool_log", data={"tool": tool, "log": msg}), + ) + + return _log + + +def _looks_like_path(script: str) -> bool: + """Return True if the script string looks like a file path (not inline code).""" + if not ( + isinstance(script, str) + and script.strip() == script + and not any(c in script for c in "\r\n\0") + ): + return False + + if script.startswith("http://") or script.startswith("https://"): + return False + + return ( + script.startswith("/") + or script.startswith("./") + or script.startswith("../") + or (script.endswith(".py") and not any(c.isspace() for c in script)) + ) + + +async def resolve_sandbox_script( + sandbox: Any, script: str +) -> tuple[str | None, str | None]: + """Read a file from the sandbox if *script* looks like a path. + + Returns: + (content, error) β€” content is the file text on success, + error is a message on failure. Both None means *script* + is not a path (caller should use it as-is). + """ + if not sandbox or not _looks_like_path(script): + return None, None + try: + # Use the read endpoint instead of bash("cat ...") which truncates at 25KB. + result = await asyncio.to_thread(sandbox.read, script, limit=100_000) + if result.success and result.output: + # Strip line number prefixes (read returns "N\tcontent" format) + lines = [] + for line in result.output.split("\n"): + parts = line.split("\t", 1) + lines.append(parts[1] if len(parts) == 2 else line) + return "\n".join(lines), None + return None, f"Failed to read {script} from sandbox: {result.error}" + except Exception as e: + return None, f"Failed to read {script} from sandbox: {e}" + + +async def _seed_trackio_dashboard_safe(session: Any, space_id: str) -> None: + """Idempotently seed *space_id* with trackio dashboard files using the + session's HF token. Logs progress, swallows errors β€” a failed seed should + not block sandbox creation.""" + if not session or not getattr(session, "hf_token", None): + return + loop = asyncio.get_running_loop() + + def _log(msg: str) -> None: + loop.call_soon_threadsafe( + session.event_queue.put_nowait, + Event(event_type="tool_log", data={"tool": "sandbox_create", "log": msg}), + ) + + try: + await asyncio.to_thread( + ensure_trackio_dashboard, space_id, session.hf_token, _log + ) + except Exception as e: + _log(f"trackio dashboard seed failed: {e}") + + +async def _update_persisted_sandbox_fields(session: Any, **fields: Any) -> None: + """Best-effort update of sandbox metadata on the durable session record.""" + store = getattr(session, "persistence_store", None) + session_id = getattr(session, "session_id", None) + if not (store and session_id and hasattr(store, "update_session_fields")): + return + try: + await store.update_session_fields(session_id, **fields) + except Exception as e: + logger.warning("Failed to persist sandbox metadata for %s: %s", session_id, e) + + +async def _persist_active_sandbox( + session: Any, + sandbox: Sandbox, + *, + hardware: str, +) -> None: + space_id = getattr(sandbox, "space_id", None) + if not space_id: + return + owner = space_id.split("/", 1)[0] if "/" in space_id else None + await _update_persisted_sandbox_fields( + session, + sandbox_space_id=space_id, + sandbox_hardware=hardware, + sandbox_owner=owner, + sandbox_created_at=datetime.now(timezone.utc), + sandbox_status="active", + ) + + +async def _clear_persisted_sandbox(session: Any) -> None: + await _update_persisted_sandbox_fields( + session, + sandbox_space_id=None, + sandbox_hardware=None, + sandbox_owner=None, + sandbox_created_at=None, + sandbox_status="destroyed", + ) + + +# ── Tool name mapping (short agent names β†’ Sandbox client names) ────── + + +async def _ensure_sandbox( + session: Any, + hardware: str = DEFAULT_CPU_SANDBOX_HARDWARE, + extra_secrets: dict[str, str] | None = None, + cancel_event: threading.Event | None = None, + **create_kwargs, +) -> tuple[Sandbox | None, str | None]: + """ + Ensure a sandbox exists on the session. Auto-creates with given hardware if needed. + + Returns: + (sandbox, error_message) β€” one will be None. + """ + if session and getattr(session, "sandbox", None): + return session.sandbox, None + + if not session: + return None, "No session available." + + token = session.hf_token + if not token: + return None, "No HF token available. Cannot create sandbox." + + api = HfApi(token=token) + user_info = api.whoami() + owner = user_info.get("name", user_info.get("user", "")) + if not owner: + return None, "Could not determine HF username from token." + + create_lock = _get_sandbox_create_lock(owner) + if create_lock.locked(): + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "sandbox", + "log": "Waiting for sandbox creation slot...", + }, + ) + ) + + async with create_lock: + if getattr(session, "sandbox", None): + return session.sandbox, None + + return await _create_sandbox_locked( + session, + api=api, + owner=owner, + hardware=hardware, + extra_secrets=extra_secrets, + cancel_event=cancel_event, + **create_kwargs, + ) + + +async def _create_sandbox_locked( + session: Any, + *, + api: HfApi, + owner: str, + hardware: str, + extra_secrets: dict[str, str] | None = None, + cancel_event: threading.Event | None = None, + **create_kwargs, +) -> tuple[Sandbox | None, str | None]: + """Create the Space while the per-owner sandbox creation lock is held.""" + token = session.hf_token + await session.send_event( + Event( + event_type="tool_log", + data={ + "tool": "sandbox", + "log": f"Auto-creating sandbox for {owner} ({hardware})...", + }, + ) + ) + + # Thread-safe log callback: posts tool_log events from worker threads. + _log = _session_tool_logger(session) or (lambda msg: None) + + # Bridge asyncio cancel event to a threading.Event for the blocking create call. + # We poll session._cancelled from the main loop in a background task and set + # a threading.Event that Sandbox.create checks during its polling loops. + cancel_flag = cancel_event or threading.Event() + + async def _watch_cancel(): + await session._cancelled.wait() + cancel_flag.set() + + watcher_task = asyncio.create_task(_watch_cancel()) + + secrets: dict[str, str] = {"HF_TOKEN": token} + if extra_secrets: + secrets.update({k: v for k, v in extra_secrets.items() if v}) + + create_kwargs["private"] = True # enforce: overrides any caller-supplied value + kwargs = { + "owner": owner, + "hardware": hardware, + "token": token, + "secrets": secrets, + "log": _log, + "cancel_event": cancel_flag, + **create_kwargs, + } + if hardware != DEFAULT_CPU_SANDBOX_HARDWARE: + kwargs["sleep_time"] = 2700 + import time as _t + + _t_start = _t.monotonic() + try: + sb = await asyncio.to_thread(Sandbox.create, **kwargs) + except Sandbox.Cancelled: + return None, "Sandbox creation cancelled by user." + finally: + watcher_task.cancel() + + if cancel_flag.is_set(): + if getattr(sb, "_owns_space", False): + try: + await asyncio.to_thread(sb.delete, log=_log) + except Exception as e: + logger.warning( + "Failed to delete cancelled sandbox %s: %s", sb.space_id, e + ) + return None, "Sandbox creation cancelled by user." + + session.sandbox = sb + session.sandbox_hardware = hardware + session.sandbox_preload_error = None + await _persist_active_sandbox(session, sb, hardware=hardware) + + # Telemetry: sandbox creation (infra consumption signal) + from agent.core import telemetry + + await telemetry.record_sandbox_create( + session, + sb, + hardware=hardware, + create_latency_s=int(_t.monotonic() - _t_start), + ) + + await session.send_event( + Event( + event_type="tool_log", + data={"tool": "sandbox", "log": f"Sandbox ready: {sb.space_id} ({sb.url})"}, + ) + ) + + return sb, None + + +def start_cpu_sandbox_preload(session: Any) -> asyncio.Task | None: + """Start a background ``cpu-basic`` sandbox for this session.""" + if not session or getattr(session, "sandbox", None): + return None + + existing_task = getattr(session, "sandbox_preload_task", None) + if existing_task and not existing_task.done(): + return existing_task + + cancel_event = threading.Event() + session.sandbox_preload_cancel_event = cancel_event + session.sandbox_preload_error = None + + async def _preload() -> Sandbox | None: + try: + sb, error = await _ensure_sandbox( + session, + hardware=DEFAULT_CPU_SANDBOX_HARDWARE, + cancel_event=cancel_event, + ) + if error: + session.sandbox_preload_error = error + return None + return sb + except asyncio.CancelledError: + cancel_event.set() + session.sandbox_preload_error = "Sandbox creation cancelled by user." + raise + except Exception as e: + session.sandbox_preload_error = f"Failed to create sandbox: {e}" + logger.warning("CPU sandbox preload failed: %s", e) + return None + + task = asyncio.create_task(_preload()) + session.sandbox_preload_task = task + return task + + +async def cancel_sandbox_preload(session: Any) -> None: + """Best-effort cancellation for an in-flight CPU sandbox preload.""" + cancel_event = getattr(session, "sandbox_preload_cancel_event", None) + if cancel_event is not None: + cancel_event.set() + + task = getattr(session, "sandbox_preload_task", None) + if not task or task.done(): + return + + current_task = asyncio.current_task() + if task is current_task: + return + + try: + await asyncio.wait_for(asyncio.shield(task), timeout=30) + except asyncio.TimeoutError: + logger.warning( + "Timed out waiting for CPU sandbox preload cancellation; " + "task is still live, cancelling asyncio wrapper" + ) + task.cancel() + except asyncio.CancelledError: + raise + except Exception: + pass + + +async def get_active_or_preloaded_sandbox( + session: Any, +) -> tuple[Sandbox | None, str | None]: + """Return the active sandbox, waiting for the startup preload if needed.""" + if not session: + return None, "No session available." + if getattr(session, "sandbox", None): + return session.sandbox, None + + task = getattr(session, "sandbox_preload_task", None) + if task: + try: + await asyncio.shield(task) + except asyncio.CancelledError: + raise + except Exception as e: + session.sandbox_preload_error = f"Failed to create sandbox: {e}" + + if getattr(session, "sandbox", None): + return session.sandbox, None + + preload_error = getattr(session, "sandbox_preload_error", None) + if preload_error: + return None, preload_error + + return None, "Sandbox is still starting. Please retry shortly." + + +async def teardown_session_sandbox(session: Any) -> None: + """Cancel sandbox preload and delete the active owned sandbox, if present.""" + if not session: + return + + await cancel_sandbox_preload(session) + _cancel_sandbox_yolo_renewal(session) + + sandbox = getattr(session, "sandbox", None) + session.sandbox = None + + if not sandbox: + session.sandbox_hardware = None + return + + try: + if not getattr(sandbox, "_owns_space", False): + return + + space_id = getattr(sandbox, "space_id", None) + delete_log = _session_tool_logger(session) + last_err: Exception | None = None + for attempt in range(3): + try: + logger.info( + "Deleting sandbox %s (attempt %s/3)...", + space_id, + attempt + 1, + ) + await asyncio.to_thread(sandbox.delete, log=delete_log) + from agent.core import telemetry + + usage = await telemetry.record_sandbox_destroy(session, sandbox) + from agent.core.yolo_budget import ( + adjust_session_spend, + reconcile_budget_reservation, + ) + + actual_total = ( + usage.get("estimated_cost_usd") if isinstance(usage, dict) else None + ) + finalized = _sandbox_yolo_finalized_cost_usd(session) + active_reservation_id = getattr( + session, "_sandbox_yolo_reservation_id", None + ) + actual_unfinalized = None + if actual_total is not None: + actual_unfinalized = max(0.0, float(actual_total) - finalized) + reconcile_budget_reservation( + session, + active_reservation_id, + actual_unfinalized, + allow_zero_actual=True, + ) + if active_reservation_id is None and actual_unfinalized: + adjust_session_spend(session, actual_unfinalized) + session._sandbox_yolo_reservation_id = None + session._sandbox_yolo_finalized_cost_usd = 0.0 + return + except Exception as e: + last_err = e + if attempt < 2: + await asyncio.sleep(2**attempt) + logger.error( + "Failed to delete sandbox %s after 3 attempts: %s. " + "Orphan β€” sweep script will pick it up.", + space_id, + last_err, + ) + finally: + session.sandbox_hardware = None + await _clear_persisted_sandbox(session) + + +# ── sandbox_create tool ────────────────────────────────────────────── + +SANDBOX_CREATE_TOOL_SPEC = { + "name": "sandbox_create", + "description": ( + "Create or replace the session sandbox when non-default hardware is needed.\n\n" + "A private cpu-basic sandbox is already started automatically for each session. " + "For normal CPU code execution, call bash/read/write/edit directly; do NOT call sandbox_create first.\n\n" + "Use sandbox_create when: you need GPU hardware, cpu-upgrade, or Trackio secrets before running code. " + "The active sandbox persists across tool calls within the session. pip install works out of the box. " + "Sandboxes are always created as private HF Spaces.\n\n" + "For ML code that uses CUDA, bf16, or model loading: use GPU hardware (t4-small minimum). " + "CPU sandboxes cannot run GPU code paths β€” your test will not catch GPU-related errors.\n\n" + "Before choosing hardware, estimate your VRAM needs (models you run, training data size). Rule of thumb: bf16/fp16 β‰ˆ 2 bytes/param, " + "fp32 β‰ˆ 4 bytes/param, plus ~20% overhead for optimizer states during training.\n" + "Common picks: t4-small (16GB VRAM, fits ≀1-3B), a10g-small (24GB, ≀7B), a100-large (80GB, ≀30B). " + "If the model won't fit, pick larger hardware upfront β€” OOM on a sandbox wastes time.\n\n" + "If you intend to run a training script in this sandbox that uses report_to='trackio', " + "pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` so they " + "are set as TRACKIO_SPACE_ID/TRACKIO_PROJECT secrets in the sandbox and the UI can embed the live dashboard.\n\n" + "Hardware: " + ", ".join([e.value for e in SpaceHardware]) + ".\n" + ), + "parameters": { + "type": "object", + "required": [], + "additionalProperties": False, + "properties": { + "hardware": { + "type": "string", + "enum": [e.value for e in SpaceHardware], + "description": ( + "Hardware tier for the sandbox. Omit for the existing auto-started " + "cpu-basic sandbox; choose GPU/cpu-upgrade only when needed." + ), + }, + "trackio_space_id": { + "type": "string", + "description": ( + "Optional. The HF Space hosting the trackio dashboard for runs in this sandbox " + "(e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as " + "TRACKIO_SPACE_ID secret and surfaced to the UI. The Space is auto-created and " + "seeded with the trackio dashboard β€” DO NOT pre-create it via hf_repo_git, " + "that produces an empty Space that breaks the embed." + ), + }, + "trackio_project": { + "type": "string", + "description": ( + "Optional. The trackio project name. Injected as TRACKIO_PROJECT secret and " + "used by the UI to filter the embedded dashboard to this project." + ), + }, + }, + }, +} + + +async def sandbox_create_handler( + args: dict[str, Any], session: Any = None, tool_call_id: str | None = None +) -> tuple[str, bool]: + """Handle sandbox_create tool calls.""" + hardware = args.get("hardware", DEFAULT_CPU_SANDBOX_HARDWARE) + trackio_space_id = args.get("trackio_space_id") or None + trackio_project = args.get("trackio_project") or None + + async def _emit_trackio_state(sb: Sandbox) -> None: + """Tell the frontend which trackio dashboard to embed for this sandbox.""" + if not (session and tool_call_id and trackio_space_id): + return + data: dict[str, Any] = { + "tool_call_id": tool_call_id, + "tool": "sandbox_create", + "state": "running", + "trackioSpaceId": trackio_space_id, + } + if trackio_project: + data["trackioProject"] = trackio_project + await session.send_event(Event(event_type="tool_state_change", data=data)) + + preload_task = getattr(session, "sandbox_preload_task", None) + if ( + session + and not getattr(session, "sandbox", None) + and preload_task + and not preload_task.done() + and hardware == DEFAULT_CPU_SANDBOX_HARDWARE + ): + sb, error = await get_active_or_preloaded_sandbox(session) + if error: + return error, False + if sb: + await _emit_trackio_state(sb) + return ( + f"Sandbox already active: {sb.space_id}\n" + f"URL: {sb.url}\n" + f"Hardware: {DEFAULT_CPU_SANDBOX_HARDWARE}\n" + f"Use bash/read/write/edit to interact with it." + ), True + + if ( + session + and not getattr(session, "sandbox", None) + and preload_task + and not preload_task.done() + and hardware != DEFAULT_CPU_SANDBOX_HARDWARE + ): + await cancel_sandbox_preload(session) + + # If sandbox already exists, return its info or replace the auto CPU sandbox + if session and getattr(session, "sandbox", None): + sb = session.sandbox + active_hardware = getattr(session, "sandbox_hardware", None) + if active_hardware == hardware: + await _emit_trackio_state(sb) + return ( + f"Sandbox already active: {sb.space_id}\n" + f"URL: {sb.url}\n" + f"Hardware: {active_hardware}\n" + f"Use bash/read/write/edit to interact with it." + ), True + + requested_hardware = args.get("hardware") + lockout_note = "" + if ( + active_hardware == DEFAULT_CPU_SANDBOX_HARDWARE + and hardware != DEFAULT_CPU_SANDBOX_HARDWARE + ): + await teardown_session_sandbox(session) + elif requested_hardware: + lockout_note = ( + f"\nRequested hardware: {requested_hardware}\n" + "Hardware cannot be changed by calling sandbox_create again. " + "Delete the existing sandbox first if you need a different tier." + ) + await _emit_trackio_state(sb) + return ( + f"Sandbox already active: {sb.space_id}\n" + f"URL: {sb.url}\n" + f"{lockout_note}\n" + f"Use bash/read/write/edit to interact with it." + ), True + else: + await _emit_trackio_state(sb) + return ( + f"Sandbox already active: {sb.space_id}\n" + f"URL: {sb.url}\n" + f"Hardware: {active_hardware or 'unknown'}\n" + f"Use bash/read/write/edit to interact with it." + ), True + + create_kwargs: dict[str, Any] = {} + + extra_secrets: dict[str, str] = {} + if trackio_space_id: + extra_secrets["TRACKIO_SPACE_ID"] = trackio_space_id + await _seed_trackio_dashboard_safe(session, trackio_space_id) + if trackio_project: + extra_secrets["TRACKIO_PROJECT"] = trackio_project + + try: + sb, error = await _ensure_sandbox( + session, + hardware=hardware, + extra_secrets=extra_secrets or None, + **create_kwargs, + ) + except Exception as e: + return f"Failed to create sandbox: {e}", False + + if error: + return error, False + + if session and tool_call_id and hardware != DEFAULT_CPU_SANDBOX_HARDWARE: + session._sandbox_yolo_reservation_id = tool_call_id + session._sandbox_yolo_finalized_cost_usd = 0.0 + _start_sandbox_yolo_renewal( + session, + hardware=hardware, + reservation_id=tool_call_id, + ) + + await _emit_trackio_state(sb) + + return ( + f"Sandbox created: {sb.space_id}\n" + f"URL: {sb.url}\n" + f"Hardware: {hardware}\n" + "Visibility: private\n" + f"Use bash/read/write/edit to interact with it." + ), True + + +def _make_tool_handler(sandbox_tool_name: str): + """Factory: create a handler for a sandbox operation tool.""" + + async def handler(args: dict[str, Any], session: Any = None) -> tuple[str, bool]: + sb, error = await get_active_or_preloaded_sandbox(session) + if error: + return error, False + if not sb: + return "Sandbox is still starting. Please retry shortly.", False + + try: + if sandbox_tool_name == "bash" and args.get("command"): + args = { + **args, + "command": wrap_shell_command_with_hub_artifact_bootstrap( + args["command"], + session, + ), + } + result = await asyncio.to_thread(sb.call_tool, sandbox_tool_name, args) + if result.success: + output = result.output or "(no output)" + return output, True + else: + error_msg = result.error or "Unknown error" + output = result.output + if output: + return f"{output}\n\nERROR: {error_msg}", False + return f"ERROR: {error_msg}", False + except Exception as e: + return f"Sandbox operation failed: {e}", False + + return handler + + +def get_sandbox_tools(): + """Return all 5 sandbox ToolSpecs (sandbox_create + 4 operation tools).""" + from agent.core.tools import ToolSpec + + tools = [] + + # sandbox_create (for GPU or other non-default hardware) + tools.append( + ToolSpec( + name=SANDBOX_CREATE_TOOL_SPEC["name"], + description=SANDBOX_CREATE_TOOL_SPEC["description"], + parameters=SANDBOX_CREATE_TOOL_SPEC["parameters"], + handler=sandbox_create_handler, + ) + ) + + # Operation tools (auto-execute, no approval needed) + for name in Sandbox.TOOLS.keys(): + spec = Sandbox.TOOLS[name] + description = ( + "Uses the session's active sandbox. A private cpu-basic sandbox is " + "started automatically for normal CPU work; call sandbox_create only " + "for GPU or other non-default hardware.\n\n" + spec["description"] + ) + tools.append( + ToolSpec( + name=name, + description=description, + parameters=spec["parameters"], + handler=_make_tool_handler(name), + ) + ) + + return tools diff --git a/agent/tools/trackio_seed.py b/agent/tools/trackio_seed.py new file mode 100644 index 0000000000000000000000000000000000000000..1062e1b5eda2701833aad7c1c895727d7fbd191e --- /dev/null +++ b/agent/tools/trackio_seed.py @@ -0,0 +1,205 @@ +"""Seed an HF Space with the trackio dashboard. + +Background: when the agent creates a Space via `hf_repo_git create_repo` (or +the user pre-creates one), it ships with no app.py β€” so the iframe shows the +default Gradio "Get started" template instead of charts. Trackio's `init()` +detects the existing Space but does NOT auto-bootstrap dashboard files into it, +so the dashboard never materializes. + +This helper writes the three files trackio's runtime expects (README.md, +requirements.txt, app.py) into the Space, idempotently, BEFORE the job that +will call `trackio.init()` runs. We deliberately omit `hf_oauth: true` from +the README so the embedded iframe in ml-intern renders without a login click β€” +per-user privacy is enforced by namespace ownership instead. + +Beyond the dashboard files, the helper also creates the metrics bucket and +mounts it on the Space at `/data` (with `TRACKIO_DIR` / `TRACKIO_BUCKET_ID` +Space variables). Without this, the running job writes metrics into a bucket +that the dashboard Space can't read, and the iframe shows "No projects". +""" + +from __future__ import annotations + +import io +from typing import Callable, Optional + +from huggingface_hub import ( + HfApi, + Volume, + add_space_variable, + create_bucket, + create_repo, +) +from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError + + +_README = """--- +title: Trackio Dashboard +emoji: πŸ“Š +colorFrom: pink +colorTo: gray +sdk: gradio +app_file: app.py +pinned: false +tags: + - trackio +--- + +Embedded trackio dashboard for ml-intern runs. +""" + +_REQUIREMENTS = "trackio\n" +_APP_PY = "import trackio\ntrackio.show()\n" + +# ml-intern brand mark surfaced inside the trackio dashboard. Trackio reads +# `TRACKIO_LOGO_LIGHT_URL` / `TRACKIO_LOGO_DARK_URL` from Space variables and +# renders them in place of its own logo. We point at the publicly-resolvable +# copy on the smolagents/ml-intern Space repo so any seeded dashboard inherits +# the ml-intern branding without each user having to host the asset. +_LOGO_URL = ( + "https://huggingface.co/spaces/smolagents/ml-intern/" + "resolve/main/frontend/public/smolagents.webp" +) + +_FILES = { + "README.md": _README, + "requirements.txt": _REQUIREMENTS, + "app.py": _APP_PY, +} + + +def _already_seeded(api: HfApi, space_id: str) -> bool: + """Cheap check: does the Space already have a trackio dashboard app.py? + + Avoids re-uploading the same three files on every job submission. We look + for the literal `trackio.show` call which is the load-bearing line β€” any + other app.py shape (the default gradio shell, a stale custom one) means + we should re-seed. + """ + try: + path = api.hf_hub_download( + repo_id=space_id, repo_type="space", filename="app.py" + ) + except (EntryNotFoundError, RepositoryNotFoundError, OSError): + return False + try: + with open(path, "r", encoding="utf-8") as f: + return "trackio.show" in f.read() + except OSError: + return False + + +def _get_space_volumes(api: HfApi, space_id: str) -> list: + """Return mounted volumes for a Space. + + `get_space_runtime()` doesn't always populate `volumes` even when the + mount exists; mirror trackio's fallback to `space_info().runtime.volumes`. + """ + runtime = api.get_space_runtime(space_id) + if getattr(runtime, "volumes", None): + return list(runtime.volumes) + info = api.space_info(space_id) + if info.runtime and getattr(info.runtime, "volumes", None): + return list(info.runtime.volumes) + return [] + + +def _ensure_bucket_mounted( + api: HfApi, + space_id: str, + bucket_id: str, + hf_token: str, + log: Optional[Callable[[str], None]] = None, +) -> None: + """Create the bucket if missing, mount it at `/data` on the Space, and + set the `TRACKIO_DIR` / `TRACKIO_BUCKET_ID` Space variables. Idempotent β€” + skips work that has already been done. + """ + create_bucket(bucket_id, private=True, exist_ok=True, token=hf_token) + + existing = _get_space_volumes(api, space_id) + already_mounted = any( + getattr(v, "type", None) == "bucket" + and getattr(v, "source", None) == bucket_id + and getattr(v, "mount_path", None) == "/data" + for v in existing + ) + if not already_mounted: + preserved = [ + v + for v in existing + if not ( + getattr(v, "type", None) == "bucket" + and ( + getattr(v, "source", None) == bucket_id + or getattr(v, "mount_path", None) == "/data" + ) + ) + ] + api.set_space_volumes( + space_id, + preserved + [Volume(type="bucket", source=bucket_id, mount_path="/data")], + ) + if log: + log(f"mounted bucket {bucket_id} at /data on {space_id}") + + variables = api.get_space_variables(space_id) + desired = { + "TRACKIO_DIR": "/data/trackio", + "TRACKIO_BUCKET_ID": bucket_id, + "TRACKIO_LOGO_LIGHT_URL": _LOGO_URL, + "TRACKIO_LOGO_DARK_URL": _LOGO_URL, + } + for key, value in desired.items(): + if getattr(variables.get(key), "value", None) != value: + add_space_variable(space_id, key, value, token=hf_token) + + +def ensure_trackio_dashboard( + space_id: str, + hf_token: str, + log: Optional[Callable[[str], None]] = None, +) -> bool: + """Make sure *space_id* is fully wired for trackio: + 1. Space exists with our dashboard files (README without `hf_oauth`, + `requirements.txt`, `app.py` calling `trackio.show`). + 2. Bucket `-bucket` exists, is mounted at `/data`, and the + Space has `TRACKIO_DIR` / `TRACKIO_BUCKET_ID` variables set. + + Idempotent β€” re-running is cheap. Returns True if any seeding happened + in step (1), False if the dashboard files were already in place. Bucket + mount is always re-checked. + """ + api = HfApi(token=hf_token) + + create_repo( + repo_id=space_id, + repo_type="space", + space_sdk="gradio", + exist_ok=True, + token=hf_token, + ) + + seeded_files = False + if _already_seeded(api, space_id): + if log: + log(f"trackio dashboard already seeded on {space_id}") + else: + if log: + log(f"seeding trackio dashboard files into {space_id}") + for path_in_repo, content in _FILES.items(): + api.upload_file( + path_or_fileobj=io.BytesIO(content.encode("utf-8")), + path_in_repo=path_in_repo, + repo_id=space_id, + repo_type="space", + commit_message=f"ml-intern: seed trackio dashboard ({path_in_repo})", + ) + seeded_files = True + + bucket_id = f"{space_id}-bucket" + _ensure_bucket_mounted(api, space_id, bucket_id, hf_token, log) + + if log: + log(f"trackio dashboard ready: https://huggingface.co/spaces/{space_id}") + return seeded_files diff --git a/agent/tools/types.py b/agent/tools/types.py new file mode 100644 index 0000000000000000000000000000000000000000..c968e35bdd667d04423295a412a53d10eda4b576 --- /dev/null +++ b/agent/tools/types.py @@ -0,0 +1,16 @@ +""" +Types for Hugging Face tools + +Ported from: hf-mcp-server/packages/mcp/src/types/ +""" + +from typing import TypedDict + + +class ToolResult(TypedDict, total=False): + """Result returned by HF tool operations""" + + formatted: str + totalResults: int + resultsShared: int + isError: bool diff --git a/agent/tools/utilities.py b/agent/tools/utilities.py new file mode 100644 index 0000000000000000000000000000000000000000..93b4229edabfe32a875be2bd728ce3edec74c168 --- /dev/null +++ b/agent/tools/utilities.py @@ -0,0 +1,142 @@ +""" +Utility functions for Hugging Face tools + +Ported from: hf-mcp-server/packages/mcp/src/jobs/formatters.ts +Includes GPU memory validation for job submissions +""" + +import json +from datetime import datetime +from typing import Any, Dict, List, Optional + + +def truncate(text: str, max_length: int) -> str: + """Truncate a string to a maximum length with ellipsis""" + if len(text) <= max_length: + return text + return text[: max_length - 3] + "..." + + +def format_date(date_str: Optional[str]) -> str: + """Format a date string to a readable format""" + if not date_str: + return "N/A" + try: + date = datetime.fromisoformat(date_str.replace("Z", "+00:00")) + return date.strftime("%Y-%m-%d %H:%M:%S") + except Exception: + return date_str + + +def format_command(command: Optional[List[str]]) -> str: + """Format command array as a single string""" + if not command or len(command) == 0: + return "N/A" + return " ".join(command) + + +def get_image_or_space(job: Dict[str, Any]) -> str: + """Get image/space identifier from job""" + if job.get("spaceId"): + return job["spaceId"] + if job.get("dockerImage"): + return job["dockerImage"] + return "N/A" + + +def format_jobs_table(jobs: List[Dict[str, Any]]) -> str: + """Format jobs as a markdown table""" + if len(jobs) == 0: + return "No jobs found." + + # Calculate dynamic ID column width + longest_id_length = max(len(job["id"]) for job in jobs) + id_column_width = max(longest_id_length, len("JOB ID")) + + # Define column widths + col_widths = { + "id": id_column_width, + "image": 20, + "command": 30, + "created": 19, + "status": 12, + } + + # Build header + header = f"| {'JOB ID'.ljust(col_widths['id'])} | {'IMAGE/SPACE'.ljust(col_widths['image'])} | {'COMMAND'.ljust(col_widths['command'])} | {'CREATED'.ljust(col_widths['created'])} | {'STATUS'.ljust(col_widths['status'])} |" + separator = f"|{'-' * (col_widths['id'] + 2)}|{'-' * (col_widths['image'] + 2)}|{'-' * (col_widths['command'] + 2)}|{'-' * (col_widths['created'] + 2)}|{'-' * (col_widths['status'] + 2)}|" + + # Build rows + rows = [] + for job in jobs: + job_id = job["id"] + image = truncate(get_image_or_space(job), col_widths["image"]) + command = truncate(format_command(job.get("command")), col_widths["command"]) + created = truncate(format_date(job.get("createdAt")), col_widths["created"]) + status = truncate(job["status"]["stage"], col_widths["status"]) + + rows.append( + f"| {job_id.ljust(col_widths['id'])} | {image.ljust(col_widths['image'])} | {command.ljust(col_widths['command'])} | {created.ljust(col_widths['created'])} | {status.ljust(col_widths['status'])} |" + ) + + return "\n".join([header, separator] + rows) + + +def format_scheduled_jobs_table(jobs: List[Dict[str, Any]]) -> str: + """Format scheduled jobs as a markdown table""" + if len(jobs) == 0: + return "No scheduled jobs found." + + # Calculate dynamic ID column width + longest_id_length = max(len(job["id"]) for job in jobs) + id_column_width = max(longest_id_length, len("ID")) + + # Define column widths + col_widths = { + "id": id_column_width, + "schedule": 12, + "image": 18, + "command": 25, + "lastRun": 19, + "nextRun": 19, + "suspend": 9, + } + + # Build header + header = f"| {'ID'.ljust(col_widths['id'])} | {'SCHEDULE'.ljust(col_widths['schedule'])} | {'IMAGE/SPACE'.ljust(col_widths['image'])} | {'COMMAND'.ljust(col_widths['command'])} | {'LAST RUN'.ljust(col_widths['lastRun'])} | {'NEXT RUN'.ljust(col_widths['nextRun'])} | {'SUSPENDED'.ljust(col_widths['suspend'])} |" + separator = f"|{'-' * (col_widths['id'] + 2)}|{'-' * (col_widths['schedule'] + 2)}|{'-' * (col_widths['image'] + 2)}|{'-' * (col_widths['command'] + 2)}|{'-' * (col_widths['lastRun'] + 2)}|{'-' * (col_widths['nextRun'] + 2)}|{'-' * (col_widths['suspend'] + 2)}|" + + # Build rows + rows = [] + for job in jobs: + job_id = job["id"] + schedule = truncate(job["schedule"], col_widths["schedule"]) + image = truncate(get_image_or_space(job["jobSpec"]), col_widths["image"]) + command = truncate( + format_command(job["jobSpec"].get("command")), col_widths["command"] + ) + last_run = truncate(format_date(job.get("lastRun")), col_widths["lastRun"]) + next_run = truncate(format_date(job.get("nextRun")), col_widths["nextRun"]) + suspend = "Yes" if job.get("suspend") else "No" + + rows.append( + f"| {job_id.ljust(col_widths['id'])} | {schedule.ljust(col_widths['schedule'])} | {image.ljust(col_widths['image'])} | {command.ljust(col_widths['command'])} | {last_run.ljust(col_widths['lastRun'])} | {next_run.ljust(col_widths['nextRun'])} | {suspend.ljust(col_widths['suspend'])} |" + ) + + return "\n".join([header, separator] + rows) + + +def format_job_details(jobs: Any) -> str: + """Format job details as JSON in a markdown code block""" + + job_array = jobs if isinstance(jobs, list) else [jobs] + json_str = json.dumps(job_array, indent=2) + return f"```json\n{json_str}\n```" + + +def format_scheduled_job_details(jobs: Any) -> str: + """Format scheduled job details as JSON in a markdown code block""" + + job_array = jobs if isinstance(jobs, list) else [jobs] + json_str = json.dumps(job_array, indent=2) + return f"```json\n{json_str}\n```" diff --git a/agent/tools/web_search_tool.py b/agent/tools/web_search_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..5c18410855bebdee305997d90de4c9e56f942461 --- /dev/null +++ b/agent/tools/web_search_tool.py @@ -0,0 +1,276 @@ +"""DuckDuckGo HTML web search tool. + +This mirrors Claw Code's Rust WebSearch behavior: fetch DuckDuckGo's HTML +endpoint, extract result links, optionally filter domains, and return a +JSON payload the model can cite. +""" + +from __future__ import annotations + +import asyncio +import html +import json +import os +import time +from dataclasses import dataclass +from html.parser import HTMLParser +from typing import Any +from urllib.parse import parse_qsl, parse_qs, urlencode, urlparse, urlunparse + +import requests + +DEFAULT_SEARCH_URL = "https://html.duckduckgo.com/html/" +WEB_SEARCH_BASE_URL_ENV = "CLAWD_WEB_SEARCH_BASE_URL" +USER_AGENT = "clawd-rust-tools/0.1" +REQUEST_TIMEOUT_SECONDS = 20 +MAX_RESULTS = 8 + + +@dataclass(frozen=True) +class SearchHit: + title: str + url: str + + def as_json(self) -> dict[str, str]: + return {"title": self.title, "url": self.url} + + +class _AnchorParser(HTMLParser): + def __init__(self, *, require_result_class: bool) -> None: + super().__init__(convert_charrefs=True) + self.require_result_class = require_result_class + self.hits: list[tuple[str, str]] = [] + self._active_href: str | None = None + self._active_text: list[str] = [] + + def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None: + if tag.lower() != "a": + return + attr_map = {key.lower(): value or "" for key, value in attrs} + href = attr_map.get("href") + if not href: + return + if self.require_result_class and "result__a" not in attr_map.get("class", ""): + return + self._active_href = href + self._active_text = [] + + def handle_data(self, data: str) -> None: + if self._active_href is not None: + self._active_text.append(data) + + def handle_entityref(self, name: str) -> None: + if self._active_href is not None: + self._active_text.append(f"&{name};") + + def handle_charref(self, name: str) -> None: + if self._active_href is not None: + self._active_text.append(f"&#{name};") + + def handle_endtag(self, tag: str) -> None: + if tag.lower() != "a" or self._active_href is None: + return + title = collapse_whitespace(html.unescape("".join(self._active_text))).strip() + self.hits.append((self._active_href, title)) + self._active_href = None + self._active_text = [] + + +def build_search_url(query: str) -> str: + base = os.environ.get(WEB_SEARCH_BASE_URL_ENV, DEFAULT_SEARCH_URL) + parsed = urlparse(base) + if parsed.scheme not in {"http", "https"} or not parsed.netloc: + raise ValueError(f"invalid search base URL: {base}") + + query_pairs = parse_qsl(parsed.query, keep_blank_values=True) + query_pairs.append(("q", query)) + return urlunparse(parsed._replace(query=urlencode(query_pairs))) + + +def collapse_whitespace(value: str) -> str: + return " ".join(value.split()) + + +def decode_duckduckgo_redirect(url: str) -> str | None: + if url.startswith("http://") or url.startswith("https://"): + return html.unescape(url) + if url.startswith("//"): + joined = f"https:{url}" + elif url.startswith("/"): + joined = f"https://duckduckgo.com{url}" + else: + return None + + parsed = urlparse(joined) + if parsed.path in {"/l", "/l/"}: + uddg = parse_qs(parsed.query).get("uddg", []) + if uddg: + return html.unescape(uddg[0]) + return joined + + +def _extract_links(search_html: str, *, require_result_class: bool) -> list[SearchHit]: + parser = _AnchorParser(require_result_class=require_result_class) + parser.feed(search_html) + + hits: list[SearchHit] = [] + for raw_url, title in parser.hits: + if not title: + continue + decoded_url = decode_duckduckgo_redirect(raw_url) + if decoded_url and ( + decoded_url.startswith("http://") or decoded_url.startswith("https://") + ): + hits.append(SearchHit(title=title, url=decoded_url)) + return hits + + +def extract_search_hits(search_html: str) -> list[SearchHit]: + return _extract_links(search_html, require_result_class=True) + + +def extract_search_hits_from_generic_links(search_html: str) -> list[SearchHit]: + return _extract_links(search_html, require_result_class=False) + + +def normalize_domain_filter(domain: str) -> str: + trimmed = domain.strip() + parsed = urlparse(trimmed) + candidate = parsed.hostname if parsed.scheme and parsed.hostname else trimmed + return candidate.strip().lstrip(".").rstrip("/").lower() + + +def host_matches_list(url: str, domains: list[str]) -> bool: + host = urlparse(url).hostname + if not host: + return False + normalized_host = host.lower() + for domain in domains: + normalized = normalize_domain_filter(domain) + if normalized and ( + normalized_host == normalized or normalized_host.endswith(f".{normalized}") + ): + return True + return False + + +def dedupe_hits(hits: list[SearchHit]) -> list[SearchHit]: + seen: set[str] = set() + deduped: list[SearchHit] = [] + for hit in hits: + if hit.url in seen: + continue + seen.add(hit.url) + deduped.append(hit) + return deduped + + +def execute_web_search( + query: str, + allowed_domains: list[str] | None = None, + blocked_domains: list[str] | None = None, + tool_use_id: str = "web_search_1", +) -> dict[str, Any]: + started = time.monotonic() + search_url = build_search_url(query) + response = requests.get( + search_url, + headers={"User-Agent": USER_AGENT}, + timeout=REQUEST_TIMEOUT_SECONDS, + allow_redirects=True, + ) + + hits = extract_search_hits(response.text) + if not hits and urlparse(response.url or search_url).hostname: + hits = extract_search_hits_from_generic_links(response.text) + + if allowed_domains is not None: + hits = [hit for hit in hits if host_matches_list(hit.url, allowed_domains)] + if blocked_domains is not None: + hits = [hit for hit in hits if not host_matches_list(hit.url, blocked_domains)] + + hits = dedupe_hits(hits)[:MAX_RESULTS] + rendered_hits = "\n".join(f"- [{hit.title}]({hit.url})" for hit in hits) + if hits: + summary = ( + f"Search results for {query!r}. Include a Sources section in the final answer.\n" + f"{rendered_hits}" + ) + else: + summary = f"No web search results matched the query {query!r}." + + return { + "query": query, + "results": [ + summary, + { + "tool_use_id": tool_use_id, + "content": [hit.as_json() for hit in hits], + }, + ], + "durationSeconds": time.monotonic() - started, + } + + +WEB_SEARCH_TOOL_SPEC = { + "name": "web_search", + "description": "Search the web for current information and return cited results.", + "parameters": { + "type": "object", + "properties": { + "query": {"type": "string", "minLength": 2}, + "allowed_domains": { + "type": "array", + "items": {"type": "string"}, + "description": "Optional allowlist of domains or URLs. Subdomains match.", + }, + "blocked_domains": { + "type": "array", + "items": {"type": "string"}, + "description": "Optional blocklist of domains or URLs. Subdomains match.", + }, + }, + "required": ["query"], + "additionalProperties": False, + }, +} + + +def _optional_string_list(arguments: dict[str, Any], key: str) -> list[str] | None: + value = arguments.get(key) + if value is None: + return None + if not isinstance(value, list) or not all(isinstance(item, str) for item in value): + raise ValueError(f"{key} must be an array of strings") + return value + + +async def web_search_handler( + arguments: dict[str, Any], + session: Any = None, + tool_call_id: str | None = None, + **_kw: Any, +) -> tuple[str, bool]: + query_value = arguments.get("query", "") + if not isinstance(query_value, str): + return ( + "Error: web_search requires a query string with at least 2 characters.", + False, + ) + + query = query_value.strip() + if len(query) < 2: + return "Error: web_search requires a query with at least 2 characters.", False + + try: + output = await asyncio.to_thread( + execute_web_search, + query=query, + allowed_domains=_optional_string_list(arguments, "allowed_domains"), + blocked_domains=_optional_string_list(arguments, "blocked_domains"), + tool_use_id=tool_call_id or "web_search_1", + ) + except Exception as exc: + return f"Error executing web search: {exc}", False + + return json.dumps(output, indent=2), True diff --git a/agent/utils/__init__.py b/agent/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d514f8cf784c6de04afd94182faaf2c059bff9a0 --- /dev/null +++ b/agent/utils/__init__.py @@ -0,0 +1,3 @@ +""" +Utility functions and helpers +""" diff --git a/agent/utils/boot_timing.py b/agent/utils/boot_timing.py new file mode 100644 index 0000000000000000000000000000000000000000..0c0884d03380f07a05a26c059247fa1b393552e9 --- /dev/null +++ b/agent/utils/boot_timing.py @@ -0,0 +1,15 @@ +"""Shared timing and color helpers for startup visual effects.""" + +import math + + +def settle_curve(progress: float, sharpness: float = 3.0) -> float: + """Return noise amount in range 1..0 for normalized progress 0..1.""" + t = max(0.0, min(1.0, progress)) + return math.exp(-sharpness * t) + + +def warm_gold_from_white(progress: float) -> tuple[int, int, int]: + """Interpolate from white to warm gold for progress 0..1.""" + t = max(0.0, min(1.0, progress)) + return 255, int(255 - 55 * t), int(255 - 175 * t) diff --git a/agent/utils/braille.py b/agent/utils/braille.py new file mode 100644 index 0000000000000000000000000000000000000000..4621b735b7cff25d453afbc93f443f2bae4e7e4b --- /dev/null +++ b/agent/utils/braille.py @@ -0,0 +1,121 @@ +"""Braille-character canvas for high-resolution terminal graphics. + +Each terminal cell maps to a 2x4 dot grid using Unicode braille characters +(U+2800–U+28FF), giving 2Γ— horizontal and 4Γ— vertical resolution. +""" + +# Braille dot positions: (0,0) (1,0) dots 1,4 +# (0,1) (1,1) dots 2,5 +# (0,2) (1,2) dots 3,6 +# (0,3) (1,3) dots 7,8 +_DOT_MAP = ( + (0x01, 0x08), + (0x02, 0x10), + (0x04, 0x20), + (0x40, 0x80), +) + + +class BrailleCanvas: + """A pixel canvas that renders to braille characters.""" + + def __init__(self, term_width: int, term_height: int): + self.term_width = term_width + self.term_height = term_height + self.pixel_width = term_width * 2 + self.pixel_height = term_height * 4 + self._buf = bytearray(term_width * term_height) + + def clear(self) -> None: + for i in range(len(self._buf)): + self._buf[i] = 0 + + def set_pixel(self, x: int, y: int) -> None: + if 0 <= x < self.pixel_width and 0 <= y < self.pixel_height: + cx, rx = divmod(x, 2) + cy, ry = divmod(y, 4) + self._buf[cy * self.term_width + cx] |= _DOT_MAP[ry][rx] + + def render(self) -> list[str]: + lines = [] + for row in range(self.term_height): + offset = row * self.term_width + line = "".join( + chr(0x2800 + self._buf[offset + col]) for col in range(self.term_width) + ) + lines.append(line) + return lines + + +# ── Bitmap font (5Γ—7 uppercase + digits) ────────────────────────────── + +_FONT: dict[str, list[str]] = {} + + +def _define_font() -> None: + """Define a simple 5Γ—7 bitmap font for uppercase ASCII.""" + glyphs = { + "A": [" ## ", "# #", "# #", "####", "# #", "# #", "# #"], + "B": ["### ", "# #", "# #", "### ", "# #", "# #", "### "], + "C": [" ## ", "# #", "# ", "# ", "# ", "# #", " ## "], + "D": ["### ", "# #", "# #", "# #", "# #", "# #", "### "], + "E": ["####", "# ", "# ", "### ", "# ", "# ", "####"], + "F": ["####", "# ", "# ", "### ", "# ", "# ", "# "], + "G": [" ## ", "# #", "# ", "# ##", "# #", "# #", " ###"], + "H": ["# #", "# #", "# #", "####", "# #", "# #", "# #"], + "I": ["###", " # ", " # ", " # ", " # ", " # ", "###"], + "J": [" ##", " # ", " # ", " # ", " # ", "# # ", " # "], + "K": ["# #", "# # ", "## ", "## ", "# # ", "# #", "# #"], + "L": ["# ", "# ", "# ", "# ", "# ", "# ", "####"], + "M": ["# #", "## ##", "# # #", "# # #", "# #", "# #", "# #"], + "N": ["# #", "## #", "## #", "# ##", "# ##", "# #", "# #"], + "O": [" ## ", "# #", "# #", "# #", "# #", "# #", " ## "], + "P": ["### ", "# #", "# #", "### ", "# ", "# ", "# "], + "Q": [" ## ", "# #", "# #", "# #", "# ##", "# #", " ## "], + "R": ["### ", "# #", "# #", "### ", "# # ", "# #", "# #"], + "S": [" ## ", "# #", "# ", " ## ", " #", "# #", " ## "], + "T": ["#####", " # ", " # ", " # ", " # ", " # ", " # "], + "U": ["# #", "# #", "# #", "# #", "# #", "# #", " ## "], + "V": ["# #", "# #", "# #", " # # ", " # # ", " # ", " # "], + "W": ["# #", "# #", "# #", "# # #", "# # #", "## ##", "# #"], + "X": ["# #", "# #", " ## ", " ## ", " ## ", "# #", "# #"], + "Y": ["# #", "# #", " # # ", " # ", " # ", " # ", " # "], + "Z": ["####", " #", " # ", " # ", "# ", "# ", "####"], + " ": [" ", " ", " ", " ", " ", " ", " "], + "0": [" ## ", "# #", "# #", "# #", "# #", "# #", " ## "], + "1": [" # ", "## ", " # ", " # ", " # ", " # ", "###"], + "2": [" ## ", "# #", " #", " # ", " # ", "# ", "####"], + "3": [" ## ", "# #", " #", " ## ", " #", "# #", " ## "], + "4": ["# #", "# #", "# #", "####", " #", " #", " #"], + "5": ["####", "# ", "### ", " #", " #", "# #", " ## "], + "6": [" ## ", "# ", "### ", "# #", "# #", "# #", " ## "], + "7": ["####", " #", " # ", " # ", " # ", " # ", " # "], + "8": [" ## ", "# #", "# #", " ## ", "# #", "# #", " ## "], + "9": [" ## ", "# #", "# #", " ###", " #", " #", " ## "], + } + _FONT.update(glyphs) + + +_define_font() + + +def text_to_pixels(text: str, scale: int = 1) -> list[tuple[int, int]]: + """Convert text string to a list of (x, y) pixel positions using bitmap font.""" + pixels = [] + cursor_x = 0 + for ch in text.upper(): + glyph = _FONT.get(ch) + if glyph is None: + cursor_x += 4 * scale + continue + for row_idx, row in enumerate(glyph): + for col_idx, cell in enumerate(row): + if cell == "#": + for sy in range(scale): + for sx in range(scale): + pixels.append( + (cursor_x + col_idx * scale + sx, row_idx * scale + sy) + ) + glyph_width = max(len(r) for r in glyph) + cursor_x += (glyph_width + 1) * scale + return pixels diff --git a/agent/utils/crt_boot.py b/agent/utils/crt_boot.py new file mode 100644 index 0000000000000000000000000000000000000000..da0867188961ff08952005c7d098879dfd2a4279 --- /dev/null +++ b/agent/utils/crt_boot.py @@ -0,0 +1,116 @@ +"""CRT / glitch boot sequence effect for CLI startup. + +Simulates an old CRT terminal booting up: text appearing character by character +with noise artifacts, then settling into a clean display. +""" + +import random +import time + +from rich.console import Console +from rich.text import Text +from rich.live import Live + +from agent.utils.boot_timing import settle_curve + + +def _glitch_text(text: str, intensity: float, rng: random.Random) -> str: + """Add random glitch characters to text.""" + glitch_chars = "β–ˆβ–“β–’β–‘β”ƒβ”«β”£β•‹β•β•Žβ”€β”β”…β”„" + result = list(text) + for i in range(len(result)): + if rng.random() < intensity: + result[i] = rng.choice(glitch_chars) + return "".join(result) + + +def run_boot_sequence(console: Console, boot_lines: list[tuple[str, str]]) -> None: + """Run the CRT boot sequence effect. + + Args: + console: Rich console instance. + boot_lines: List of (text, rich_style) tuples to display. + """ + term_height = min(console.height - 2, 40) + rng = random.Random(42) + + with Live(console=console, refresh_per_second=30, transient=True) as live: + displayed_lines: list[tuple[str, str]] = [] + + for line_text, line_style in boot_lines: + if not line_text: + displayed_lines.append(("", "")) + continue + + line_len = max(1, len(line_text)) + # Type out each character + for char_idx in range(len(line_text) + 1): + result = Text() + progress = char_idx / line_len + noise = settle_curve(progress) + prev_glitch_chance = 0.01 + 0.06 * noise + prev_glitch_intensity = 0.02 + 0.12 * noise + scanline_chance = 0.005 + 0.03 * noise + + # Render previously completed lines + for prev_text, prev_style in displayed_lines: + if rng.random() < prev_glitch_chance: + result.append( + _glitch_text(prev_text, prev_glitch_intensity, rng), + style=prev_style, + ) + else: + result.append(prev_text, style=prev_style) + result.append("\n") + + # Current line being typed + typed = line_text[:char_idx] + cursor = "β–ˆ" if char_idx < len(line_text) else "" + + # Noise after cursor + noise_tail = "" + if char_idx < len(line_text): + noise_len = rng.randint(0, int(1 + 5 * noise)) + noise_tail = "".join(rng.choice("β–‘β–’β–“") for _ in range(noise_len)) + + result.append(typed, style=line_style) + result.append(cursor, style="bold rgb(255,200,80)") + result.append(noise_tail, style="dim rgb(180,140,40)") + result.append("\n") + + # Faint scanlines in remaining space + remaining = term_height - len(displayed_lines) - 2 + for _ in range(max(0, remaining)): + if rng.random() < scanline_chance: + scan_len = rng.randint(5, 30) + result.append("─" * scan_len, style="dim rgb(180,140,40)") + result.append("\n") + + live.update(result) + + # Variable typing speed + if line_text[char_idx - 1 : char_idx] in " .": + time.sleep(0.025) + else: + time.sleep(0.010) + + displayed_lines.append((line_text, line_style)) + time.sleep(0.06) + + # Hold with blinking cursor + for frame in range(20): + result = Text() + for prev_text, prev_style in displayed_lines: + result.append(prev_text, style=prev_style) + result.append("\n") + if frame % 8 < 4: + result.append("β–ˆ", style="rgb(255,200,80)") + live.update(result) + time.sleep(0.05) + + # Print final clean frame + final = Text() + for prev_text, prev_style in displayed_lines: + final.append(prev_text, style=prev_style) + final.append("\n") + console.print(final) diff --git a/agent/utils/particle_logo.py b/agent/utils/particle_logo.py new file mode 100644 index 0000000000000000000000000000000000000000..eb0da59bd59f6ea73825d3377192c45a9eef45bd --- /dev/null +++ b/agent/utils/particle_logo.py @@ -0,0 +1,226 @@ +"""Particle coalesce effect for the HUGGING FACE ML INTERN logo. + +Random particles swirl in from the edges, converge to form the text +"HUGGING FACE / ML INTERN", hold briefly, then the final frame is printed. +Rendered with braille characters for high detail. + +Based on Leandro's particle_coalesce.py demo. +""" + +import math +import random +import time + +from rich.console import Console +from rich.text import Text +from rich.align import Align +from rich.live import Live + +from agent.utils.braille import BrailleCanvas, text_to_pixels +from agent.utils.boot_timing import settle_curve, warm_gold_from_white + + +class Particle: + __slots__ = ("x", "y", "target_x", "target_y", "vx", "vy", "phase", "delay") + + def __init__( + self, x: float, y: float, target_x: float, target_y: float, delay: float = 0 + ): + self.x = x + self.y = y + self.target_x = target_x + self.target_y = target_y + self.vx = 0.0 + self.vy = 0.0 + self.phase = random.uniform(0, math.pi * 2) + self.delay = delay + + def update_converge(self, t: float, strength: float = 0.08, damping: float = 0.92): + """Move toward target with spring-like physics.""" + if t < self.delay: + # Still in swirl phase + self.x += self.vx + self.y += self.vy + self.vx *= 0.99 + self.vy *= 0.99 + # Gentle spiral + angle = self.phase + t * 2 + self.vx += math.cos(angle) * 0.3 + self.vy += math.sin(angle) * 0.3 + return + + # Spring toward target + dx = self.target_x - self.x + dy = self.target_y - self.y + self.vx += dx * strength + self.vy += dy * strength + self.vx *= damping + self.vy *= damping + self.x += self.vx + self.y += self.vy + + +def run_particle_logo(console: Console, hold_seconds: float = 1.5) -> None: + """Run the particle coalesce effect.""" + term_width = min(console.width, 120) + term_height = min(console.height - 4, 35) + + canvas = BrailleCanvas(term_width, term_height) + + # Get target positions from text + text_pixels_line1 = text_to_pixels("HUGGING FACE", scale=2) + text_pixels_line2 = text_to_pixels("ML INTERN", scale=2) + + # Calculate dimensions for centering + def get_bounds(pixels): + if not pixels: + return 0, 0, 0, 0 + xs = [p[0] for p in pixels] + ys = [p[1] for p in pixels] + return min(xs), max(xs), min(ys), max(ys) + + min_x1, max_x1, min_y1, max_y1 = get_bounds(text_pixels_line1) + min_x2, max_x2, min_y2, max_y2 = get_bounds(text_pixels_line2) + + w1, h1 = max_x1 - min_x1 + 1, max_y1 - min_y1 + 1 + w2, h2 = max_x2 - min_x2 + 1, max_y2 - min_y2 + 1 + + total_h = h1 + 6 + h2 # gap between lines + start_y = (canvas.pixel_height - total_h) // 2 + + # Center line 1 + offset_x1 = (canvas.pixel_width - w1) // 2 - min_x1 + offset_y1 = start_y - min_y1 + targets_1 = [(p[0] + offset_x1, p[1] + offset_y1) for p in text_pixels_line1] + + # Center line 2 + offset_x2 = (canvas.pixel_width - w2) // 2 - min_x2 + offset_y2 = start_y + h1 + 6 - min_y2 + targets_2 = [(p[0] + offset_x2, p[1] + offset_y2) for p in text_pixels_line2] + + all_targets = targets_1 + targets_2 + + # Subsample for performance β€” take every Nth pixel + step = max(1, len(all_targets) // 1500) + sampled_targets = all_targets[::step] + + # Create particles at random edge positions + rng = random.Random(42) + particles = [] + pw, ph = canvas.pixel_width, canvas.pixel_height + + for i, (tx, ty) in enumerate(sampled_targets): + # Spawn from random edge + side = rng.choice(["top", "bottom", "left", "right"]) + if side == "top": + sx, sy = rng.uniform(0, pw), rng.uniform(-20, -5) + elif side == "bottom": + sx, sy = rng.uniform(0, pw), rng.uniform(ph + 5, ph + 20) + elif side == "left": + sx, sy = rng.uniform(-20, -5), rng.uniform(0, ph) + else: + sx, sy = rng.uniform(pw + 5, pw + 20), rng.uniform(0, ph) + + delay = rng.uniform(0, 0.4) # staggered start + p = Particle(sx, sy, tx, ty, delay=delay) + # Initial velocity β€” gentle swirl + angle = math.atan2(ph / 2 - sy, pw / 2 - sx) + rng.gauss(0, 0.8) + speed = rng.uniform(1.0, 2.5) + p.vx = math.cos(angle) * speed + p.vy = math.sin(angle) * speed + particles.append(p) + + # Also add some extra ambient particles that never converge + ambient = [] + for _ in range(200): + ax = rng.uniform(0, pw) + ay = rng.uniform(0, ph) + ap = Particle(ax, ay, ax, ay) + ap.vx = rng.gauss(0, 1) + ap.vy = rng.gauss(0, 1) + ambient.append(ap) + + # Timing: 1s converge + 2s hold = 3s total + fps = 24 + converge_frames = int(fps * 0.9) + hold_frames = int(fps * hold_seconds) + total_frames = converge_frames + hold_frames + + with Live(console=console, refresh_per_second=fps, transient=True) as live: + for frame in range(total_frames): + canvas.clear() + t = frame * 0.03 + + # Update ambient particles (always drifting) + for ap in ambient: + ap.x += ap.vx + math.sin(t + ap.phase) * 0.5 + ap.y += ap.vy + math.cos(t + ap.phase * 1.3) * 0.5 + # Wrap around + ap.x = ap.x % pw + ap.y = ap.y % ph + + # Fade out ambient during hold phase + if frame < converge_frames: + alpha = 0.3 + 0.2 * math.sin(t * 2 + ap.phase) + else: + fade = (frame - converge_frames) / hold_frames + alpha = (0.3 + 0.2 * math.sin(t * 2 + ap.phase)) * (1 - fade) + if alpha > 0.25: + canvas.set_pixel(int(ap.x), int(ap.y)) + + if frame < converge_frames: + # Converge phase + progress = frame / converge_frames + noise = settle_curve(progress) + for p in particles: + p.update_converge(t, strength=0.06, damping=0.90) + canvas.set_pixel(int(p.x), int(p.y)) + + # Trail effect + trail_scale = 0.2 + 0.5 * noise + trail_x = int(p.x - p.vx * trail_scale) + trail_y = int(p.y - p.vy * trail_scale) + canvas.set_pixel(trail_x, trail_y) + + # Color transitions from white to warm gold + r, g, b = warm_gold_from_white(progress) + else: + # Hold phase β€” settle into solid logo + settle_t = (frame - converge_frames) / hold_frames + for p in particles: + # Jitter decays to zero + jitter = (1 - settle_t) * 0.7 + jx = p.target_x + math.sin(t * 3 + p.phase) * jitter + jy = p.target_y + math.cos(t * 3 + p.phase * 1.5) * jitter + canvas.set_pixel(int(jx), int(jy)) + canvas.set_pixel(int(p.target_x), int(p.target_y)) + + r, g, b = 255, 200, 80 + + # Render with color + lines = canvas.render() + result = Text() + for line in lines: + for ch in line: + if ch == chr(0x2800): + result.append(ch) + else: + result.append(ch, style=f"rgb({r},{g},{b})") + result.append("\n") + + live.update(Align.center(result)) + time.sleep(1.0 / fps) + + # Print final settled frame + canvas.clear() + for p in particles: + canvas.set_pixel(int(p.target_x), int(p.target_y)) + final = Text() + for line in canvas.render(): + for ch in line: + if ch == chr(0x2800): + final.append(ch) + else: + final.append(ch, style="rgb(255,200,80)") + final.append("\n") + console.print(Align.center(final)) diff --git a/agent/utils/reliability_checks.py b/agent/utils/reliability_checks.py new file mode 100644 index 0000000000000000000000000000000000000000..3ed76d72b3517c077144d2c659add85f7caf547e --- /dev/null +++ b/agent/utils/reliability_checks.py @@ -0,0 +1,14 @@ +"""Reliability checks for job submissions and other operations""" + + +def check_training_script_save_pattern(script: str) -> str | None: + """Check if a training script properly saves models.""" + has_from_pretrained = "from_pretrained" in script + has_push_to_hub = "push_to_hub" in script + + if has_from_pretrained and not has_push_to_hub: + return "\n\033[91mWARNING: No model save detected in this script. Ensure this is intentional.\033[0m" + elif has_from_pretrained and has_push_to_hub: + return "\n\033[92mModel will be pushed to hub after training.\033[0m" + + return None diff --git a/agent/utils/terminal_display.py b/agent/utils/terminal_display.py new file mode 100644 index 0000000000000000000000000000000000000000..45850e893653253673a4f87a2132de6957fc8155 --- /dev/null +++ b/agent/utils/terminal_display.py @@ -0,0 +1,590 @@ +""" +Terminal display utilities β€” rich-powered CLI formatting. +""" + +import asyncio +import re + +from rich.console import Console +from rich.markup import escape +from rich.markdown import Heading, Markdown +from rich.panel import Panel +from rich.theme import Theme + + +class _LeftHeading(Heading): + """Rich's default Markdown renders h1/h2 centered via Align.center. + Yield the styled text directly so headings stay left-aligned.""" + + def __rich_console__(self, console, options): + self.text.justify = "left" + yield self.text + + +Markdown.elements["heading_open"] = _LeftHeading + + +_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]") + + +def _clip_to_width(s: str, width: int) -> str: + """Truncate a string to `width` visible columns, preserving ANSI styles. + + Needed for the sub-agent live redraw: cursor-up-and-erase assumes one + logical line == one terminal row. If a line wraps, cursor-up undershoots + and the next redraw corrupts the display. Truncating prevents wrap. + """ + if width <= 0: + return s + out: list[str] = [] + visible = 0 + i = 0 + # Reserve 1 char for the trailing ellipsis + limit = width - 1 + truncated = False + while i < len(s): + m = _ANSI_RE.match(s, i) + if m: + out.append(m.group()) + i = m.end() + continue + if visible >= limit: + truncated = True + break + out.append(s[i]) + visible += 1 + i += 1 + if truncated: + # Strip styles (so ellipsis isn't left hanging inside a style run) + out.append("\033[0m…") + return "".join(out) + + +_THEME = Theme( + { + "tool.name": "bold rgb(255,200,80)", + "tool.args": "dim", + "tool.ok": "dim green", + "tool.fail": "dim red", + "info": "dim", + "muted": "dim", + # Markdown emphasis colors + "markdown.strong": "bold rgb(255,200,80)", + "markdown.emphasis": "italic rgb(180,140,40)", + "markdown.code": "rgb(120,220,255)", + "markdown.code_block": "rgb(120,220,255)", + "markdown.link": "underline rgb(90,180,255)", + "markdown.h1": "bold rgb(255,200,80)", + "markdown.h2": "bold rgb(240,180,95)", + "markdown.h3": "bold rgb(220,165,100)", + } +) + +_console = Console(theme=_THEME, highlight=False) + +# Indent prefix for all agent output (aligns under the `>` prompt) +_I = " " + + +def get_console() -> Console: + return _console + + +# ── Banner ───────────────────────────────────────────────────────────── + + +def print_banner( + model: str | None = None, + hf_user: str | None = None, + tool_runtime: str | None = None, +) -> None: + """Print particle logo then CRT boot sequence with system info.""" + from agent.utils.particle_logo import run_particle_logo + from agent.utils.crt_boot import run_boot_sequence + + # Particle coalesce logo β€” 1.5s converge, 2s hold + run_particle_logo(_console, hold_seconds=2.0) + + # Clear screen for CRT boot β€” starts from top + _console.file.write("\033[2J\033[H") + _console.file.flush() + + model_label = model or "unknown" + user_label = hf_user or "not logged in" + + # Warm gold palette matching the shimmer highlight (255, 200, 80) + gold = "rgb(255,200,80)" + dim_gold = "rgb(180,140,40)" + + boot_lines = [ + (f"{_I}Initializing agent runtime...", gold), + (f"{_I} User: {user_label}", dim_gold), + (f"{_I} Model: {model_label}", dim_gold), + (f"{_I} Tool runtime: {tool_runtime or 'local filesystem'}", dim_gold), + (f"{_I} Tools: loading...", dim_gold), + ("", ""), + (f"{_I}/help for commands Β· /model to switch Β· /quit to exit", gold), + ] + + run_boot_sequence(_console, boot_lines) + + +# ── Init progress ────────────────────────────────────────────────────── + + +def print_init_done(tool_count: int = 0) -> None: + import time + + f = _console.file + # Overwrite the "Tools: loading..." line with actual count + f.write( + "\033[A\033[A\033[A\033[K" + ) # Move up 3 lines (blank + help + blank) then up to tools line + f.write("\033[A\033[K") + gold = "\033[38;2;180;140;40m" + reset = "\033[0m" + tool_text = f"{_I} Tools: {tool_count} loaded" + for ch in tool_text: + f.write(f"{gold}{ch}{reset}") + f.flush() + time.sleep(0.012) + f.write("\n\n") + # Reprint the help line + f.write( + f"{_I}\033[38;2;255;200;80m/help for commands Β· /model to switch Β· /quit to exit{reset}\n\n" + ) + # Ready message β€” minimal padding + f.write( + f"{_I}\033[38;2;255;200;80mReady. Let's build something impressive.{reset}\n" + ) + f.flush() + + +# ── Tool calls ───────────────────────────────────────────────────────── + + +def print_tool_call(tool_name: str, args_preview: str) -> None: + import time + + f = _console.file + # CRT-style: type out tool name in HF yellow + gold = "\033[38;2;255;200;80m" + reset = "\033[0m" + f.write(f"{_I}{gold}β–Έ ") + for ch in tool_name: + f.write(ch) + f.flush() + time.sleep(0.015) + f.write(f"{reset} \033[2m{args_preview}{reset}\n") + f.flush() + + +def print_tool_output(output: str, success: bool, truncate: bool = True) -> None: + if truncate: + output = _truncate(output, max_lines=10) + style = "tool.ok" if success else "tool.fail" + # Indent each line of tool output + indented = "\n".join(f"{_I} {line}" for line in output.split("\n")) + _console.print(f"[{style}]{indented}[/{style}]") + + +class SubAgentDisplayManager: + """Manages multiple concurrent sub-agent displays. + + Each agent gets its own stats and rolling tool-call log. + All agents are rendered together so terminal escape-code + erase/redraw stays consistent. + """ + + _MAX_VISIBLE = 4 # tool-call lines shown per agent + + def __init__(self): + self._agents: dict[str, dict] = {} # agent_id -> state dict + self._lines_on_screen = 0 + + def start(self, agent_id: str, label: str = "research") -> None: + import time + + self._agents[agent_id] = { + "label": label, + "calls": [], + "tool_count": 0, + "token_count": 0, + "start_time": time.monotonic(), + } + self._redraw() + + def set_tokens(self, agent_id: str, tokens: int) -> None: + if agent_id in self._agents: + self._agents[agent_id]["token_count"] = tokens + + def set_tool_count(self, agent_id: str, count: int) -> None: + if agent_id in self._agents: + self._agents[agent_id]["tool_count"] = count + + def add_call(self, agent_id: str, tool_desc: str) -> None: + if agent_id in self._agents: + self._agents[agent_id]["calls"].append(tool_desc) + self._redraw() + + def clear(self, agent_id: str) -> None: + # On completion: erase the live region, freeze a single-line summary + # for this agent ("βœ“ research: … (stats)") above the live region so + # the user sees each sub-agent finish cleanly without the tool-call + # noise, then redraw remaining live agents. + agent = self._agents.pop(agent_id, None) + self._erase() + if agent is not None: + width = max(10, _console.width) + line = _clip_to_width(self._render_completion_line(agent), width) + _console.file.write(line + "\n") + _console.file.flush() + self._lines_on_screen = 0 + if self._agents: + self._redraw() + + @staticmethod + def _render_completion_line(agent: dict) -> str: + stats = SubAgentDisplayManager._format_stats(agent) + label = agent["label"] + # dim green check + dim label; stats in parens + line = f"{_I}\033[38;2;120;200;140mβœ“\033[0m \033[2m{label}\033[0m" + if stats: + line += f" \033[2m({stats})\033[0m" + return line + + @staticmethod + def _format_stats(agent: dict) -> str: + import time + + start = agent["start_time"] + if start is None: + return "" + elapsed = time.monotonic() - start + if elapsed < 60: + time_str = f"{elapsed:.0f}s" + else: + time_str = f"{elapsed / 60:.0f}m {elapsed % 60:.0f}s" + tok = agent["token_count"] + tok_str = f"{tok / 1000:.1f}k" if tok >= 1000 else str(tok) + return f"{agent['tool_count']} tool uses Β· {tok_str} tokens Β· {time_str}" + + def _erase(self) -> None: + if self._lines_on_screen > 0: + f = _console.file + for _ in range(self._lines_on_screen): + f.write("\033[A\033[K") + f.flush() + + def _render_agent_lines(self, agent: dict, compact: bool = False) -> list[str]: + """Render one agent's block. + + compact=True β†’ single line (label + stats + most-recent tool name); + compact=False β†’ header + up to _MAX_VISIBLE rolling tool-call lines. + We use compact mode when multiple agents are live so the total live + region stays small enough to fit on one screen. Otherwise cursor-up + can't reach lines that have scrolled into scrollback, and every + redraw pollutes history with a stale copy. + """ + stats = self._format_stats(agent) + label = agent["label"] + header = f"{_I}\033[38;2;255;200;80mβ–Έ {label}\033[0m" + if stats: + header += f" \033[2m({stats})\033[0m" + if compact: + latest = agent["calls"][-1] if agent["calls"] else "" + if latest: + # Strip long json tails for the inline view + short = latest.split(" ")[0] if " " in latest else latest + header += f" \033[2mΒ·\033[0m \033[2m{short}\033[0m" + return [header] + lines = [header] + visible = agent["calls"][-self._MAX_VISIBLE :] + for desc in visible: + lines.append(f"{_I} \033[2m{desc}\033[0m") + return lines + + def _redraw(self) -> None: + f = _console.file + self._erase() + compact = len(self._agents) > 1 + width = max(10, _console.width) + lines: list[str] = [] + for agent in self._agents.values(): + for ln in self._render_agent_lines(agent, compact=compact): + lines.append(_clip_to_width(ln, width)) + for line in lines: + f.write(line + "\n") + f.flush() + self._lines_on_screen = len(lines) + + +_subagent_display = SubAgentDisplayManager() + + +def print_tool_log(tool: str, log: str, agent_id: str = "", label: str = "") -> None: + """Handle tool log events β€” sub-agent calls get the rolling display.""" + if tool == "research": + aid = agent_id or "research" + if log == "Starting research sub-agent...": + _subagent_display.start(aid, label or "research") + elif log == "Research complete.": + _subagent_display.clear(aid) + elif log.startswith("tokens:"): + _subagent_display.set_tokens(aid, int(log[7:])) + elif log.startswith("tools:"): + _subagent_display.set_tool_count(aid, int(log[6:])) + else: + _subagent_display.add_call(aid, log) + else: + _console.print(f"{_I}[dim]{tool}: {log}[/dim]") + + +# ── Messages ─────────────────────────────────────────────────────────── + + +async def print_markdown( + text: str, + cancel_event: "asyncio.Event | None" = None, + instant: bool = False, +) -> None: + import io + import random + from rich.padding import Padding + + _console.print() + + # Render markdown to a string buffer so we can type it out + buf = io.StringIO() + # Important: StringIO is not a TTY, so Rich would normally strip styles. + # Force terminal rendering so ANSI style codes are preserved for typewriter output. + buf_console = Console( + file=buf, + width=_console.width, + highlight=False, + theme=_THEME, + force_terminal=True, + color_system=_console.color_system or "truecolor", + ) + buf_console.print(Padding(Markdown(text), (0, 0, 0, 2))) + rendered = buf.getvalue() + + # Strip trailing whitespace from each line so we don't type across the full width + lines = rendered.split("\n") + rendered = "\n".join(line.rstrip() for line in lines) + + f = _console.file + + # Headless / non-interactive: dump the rendered markdown in one write. + if instant: + f.write(rendered) + f.write("\n") + f.flush() + return + + # CRT typewriter effect β€” async so the event loop can service signal + # handlers (Ctrl+C during streaming) between characters. If cancelled + # mid-type, stop cleanly: write an ANSI reset so half-open color state + # doesn't bleed onto the "interrupted" line, and return. + rng = random.Random(42) + cancelled = False + for ch in rendered: + if cancel_event is not None and cancel_event.is_set(): + cancelled = True + break + f.write(ch) + f.flush() + if ch == "\n": + await asyncio.sleep(0.002) + elif ch == " ": + await asyncio.sleep(0.002) + elif rng.random() < 0.03: + await asyncio.sleep(0.015) + else: + await asyncio.sleep(0.004) + f.write("\033[0m\n" if cancelled else "\n") + f.flush() + + +def print_error(message: str) -> None: + _console.print(f"\n{_I}[bold red]Error:[/bold red] {message}") + + +def print_turn_complete() -> None: + pass # no separator β€” clean output + + +def print_interrupted() -> None: + _console.print(f"\n{_I}[dim italic]interrupted[/dim italic]") + + +def print_compacted(old_tokens: int, new_tokens: int) -> None: + _console.print( + f"{_I}[dim]context compacted: {old_tokens:,} β†’ {new_tokens:,} tokens[/dim]" + ) + + +# ── Approval ─────────────────────────────────────────────────────────── + + +def print_approval_header(count: int) -> None: + label = f"Approval required β€” {count} item{'s' if count != 1 else ''}" + _console.print() + _console.print( + f"{_I}", + Panel( + f"[bold yellow]{label}[/bold yellow]", border_style="yellow", expand=False + ), + ) + + +def print_approval_item(index: int, total: int, tool_name: str, operation: str) -> None: + _console.print( + f"\n{_I}[bold]\\[{index}/{total}][/bold] [tool.name]{tool_name}[/tool.name] {operation}" + ) + + +def print_yolo_approve(count: int) -> None: + _console.print( + f"{_I}[bold yellow]yolo β†’[/bold yellow] auto-approved {count} item(s)" + ) + + +# ── Help ─────────────────────────────────────────────────────────────── + +HELP_ROWS: tuple[tuple[str, str, str], ...] = ( + ("/help", "", "Show this help"), + ("/new", "", "Start a fresh chat"), + ("/clear", "", "Clear terminal and start fresh"), + ("/undo", "", "Undo last turn"), + ("/compact", "", "Compact context window"), + ("/resume", "[index|id|path]", "Pick up from ./session_logs"), + ("/model", "[id]", "Show available models or switch"), + ( + "/effort", + "[level]", + "Set reasoning effort preference", + ), + ("/yolo", "", "Toggle auto-approve mode"), + ("/status", "", "Current model & turn count"), + ( + "/share-traces", + "[public|private]", + "Show or change HF trace visibility", + ), + ("/quit", "", "Exit"), +) + + +def _help_column_widths( + rows: tuple[tuple[str, str, str], ...], +) -> tuple[int, int]: + return ( + max(len(command) for command, _, _ in rows), + max(len(args) for _, args, _ in rows), + ) + + +def _format_help_row( + command: str, + args: str, + description: str, + command_width: int, + args_width: int, +) -> str: + command_gap = " " * (command_width - len(command) + 2) + args_gap = " " * (args_width - len(args) + 2) + command_markup = f"[cyan]{escape(command)}[/cyan]" + args_markup = f"[muted]{escape(args)}[/muted]" if args else "" + return f"{_I} {command_markup}{command_gap}{args_markup}{args_gap}{description}" + + +def format_help_text(rows: tuple[tuple[str, str, str], ...] | None = None) -> str: + help_rows = HELP_ROWS if rows is None else rows + command_width, args_width = _help_column_widths(help_rows) + return "\n".join( + [f"{_I}[bold]Commands[/bold]"] + + [ + _format_help_row( + command, + args, + description, + command_width, + args_width, + ) + for command, args, description in help_rows + ] + ) + + +def print_help() -> None: + _console.print() + _console.print(format_help_text()) + _console.print() + + +# ── Plan display ─────────────────────────────────────────────────────── + + +def format_plan_display() -> str: + """Format the current plan for display.""" + from agent.tools.plan_tool import get_current_plan + + plan = get_current_plan() + if not plan: + return "" + + completed = [t for t in plan if t["status"] == "completed"] + in_progress = [t for t in plan if t["status"] == "in_progress"] + pending = [t for t in plan if t["status"] == "pending"] + + lines = [] + for t in completed: + lines.append(f"{_I}[green]βœ“[/green] [dim]{t['content']}[/dim]") + for t in in_progress: + lines.append(f"{_I}[yellow]β–Έ[/yellow] {t['content']}") + for t in pending: + lines.append(f"{_I}[dim]β—‹ {t['content']}[/dim]") + + summary = f"[dim]{len(completed)}/{len(plan)} done[/dim]" + lines.append(f"{_I}{summary}") + return "\n".join(lines) + + +def print_plan() -> None: + plan_str = format_plan_display() + if plan_str: + _console.print(plan_str) + + +# ── Formatting for plan_tool output (used by plan_tool handler) ──────── + + +def format_plan_tool_output(todos: list) -> str: + if not todos: + return "Plan is empty." + + lines = ["Plan updated:", ""] + completed = [t for t in todos if t["status"] == "completed"] + in_progress = [t for t in todos if t["status"] == "in_progress"] + pending = [t for t in todos if t["status"] == "pending"] + + for t in completed: + lines.append(f" [x] {t['id']}. {t['content']}") + for t in in_progress: + lines.append(f" [~] {t['id']}. {t['content']}") + for t in pending: + lines.append(f" [ ] {t['id']}. {t['content']}") + + lines.append(f"\n{len(completed)}/{len(todos)} done") + return "\n".join(lines) + + +# ── Internal helpers ─────────────────────────────────────────────────── + + +def _truncate(text: str, max_lines: int = 6) -> str: + lines = text.split("\n") + if len(lines) <= max_lines: + return text + return "\n".join(lines[:max_lines]) + f"\n... ({len(lines) - max_lines} more lines)" diff --git a/api-docs/index.html b/api-docs/index.html new file mode 100644 index 0000000000000000000000000000000000000000..dcc36c724f4cb239f2dcd008a0f7c229ad8f7ca6 --- /dev/null +++ b/api-docs/index.html @@ -0,0 +1,691 @@ + + + + + +ML Intern API β€” an ML intern you can hire over HTTP + + + + + + + + + +

+
+ + smolagents + ML InternAPI + + +
+
+ +
+ + +
+
+ live Β· OpenAI Responses-compatible +

An ML intern you can hire over HTTP.

+

+ Send a task with your Hugging Face token. The agent researches, writes code, + launches HF Jobs under your namespace, and streams everything back β€” + including trackio dashboards, job URLs and trained models β€” over resumable SSE. + Runs take seconds or hours; background: true has you covered. +

+
+ POST + …/v1/responses + +
+
+ Get started in 60s + GitHub β†— +
+
+ + +
+ + +
+
01

Three calls, end to end

+
+
+ AUTH +

Bring your HF token

+

Pass any Hugging Face user access token as + Authorization: Bearer hf_…. Inference, jobs and repos are + authenticated and billed as you β€” the API never pools compute.

+
+
+ CREATE +

POST a task

+

One response = one agent turn. Use background: true for + long runs, stream: true for live SSE, and + previous_response_id to chain follow-ups with full context.

+
+
+ WATCH +

Stream or poll

+

Reconnect any time with ?starting_after=<seq> β€” every event + is numbered and replayable. Polling survives server restarts; HF Jobs keep + running on HF infra regardless.

+
+
+
+ + +
+
02

Quickstart

+
+ + + + +
+ +
+ + 
# 1. kick off a long-running task
+RID=$(curl -s -X POST …/v1/responses \
+  -H "Authorization: Bearer $HF_TOKEN" \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "input": "Fine-tune a small model on imdb as an HF job and push it to my namespace",
+    "background": true,
+    "max_cost_usd": 5.0
+  }' | jq -r .id)
+
+# 2. poll status + artifacts whenever you like
+curl -s …/v1/responses/$RID \
+  -H "Authorization: Bearer $HF_TOKEN" | jq '{status, artifacts}'
+
+ + + + + + +
+ + +
+
03

Endpoints

+
+
+ POST + /v1/responses +

Create a run. Modes: synchronous (waits up to wait_timeout_seconds), stream: true (SSE), background: true (returns immediately).

+
+
+ GET + /v1/responses/{id} +

Poll the full response object: status, reconstructed output[], usage, and aggregated artifacts[]. Works even after a server restart.

+
+
+ GET + /v1/responses/{id}/events +

Resumable SSE. Replays persisted events after ?starting_after=<seq> (or Last-Event-ID), then streams live until the turn ends or pauses.

+
+
+ POST + /v1/responses/{id}/cancel +

Interrupt the run. Idempotent β€” finished responses return their current snapshot.

+
+
+ POST + /v1/responses/{id}/approvals +

Resume a paused run: {"approve": bool, "new_max_cost_usd"?: number, "feedback"?: string}. The same response id continues streaming.

+
+
+ +
+
+ + + + + + + + + + + + +
Request fieldTypeDescription
inputstring | message[]The task. With a message list, all but the last become context; the last is submitted.
modelstring optionalOne of the app's supported models; defaults follow your HF plan.
backgroundboolean default falseReturn immediately with status: "queued"; the run continues server-side.
streamboolean default falseStream the turn as SSE from this request.
previous_response_idstring optionalChain this turn onto the same session as an earlier response.
max_cost_usdnumber default 5.0Session-cumulative auto-approval cap. The run pauses instead of exceeding it.
instructionsstring optionalDeveloper guidance prefixed to the task.
wait_timeout_secondsnumber default 900Synchronous mode only: how long to wait before returning the in-progress object.
metadataobject optionalYour tags, echoed back on the response object.
+
+
+ + +
+
04

The event stream

+

Every SSE frame carries id: <seq> β€” pass the last one you saw to + ?starting_after= and the stream picks up exactly where it left off.

+
+ + + + + + + + + + + + +
eventmeaning
response.createdStream opened (synthetic first frame on POST streams).
response.in_progressThe turn started.
response.output_text.delta / .doneAssistant text, token by token.
response.output_item.added / .doneTool call started / finished (with output).
response.tool_logIncremental tool logs β€” training logs stream here.
response.tool_state.changedTool runtime state, e.g. an HF Job entering running.
response.artifact.createdAn artifact was detected: job, trackio dashboard, repo…
response.approval_requiredPaused on the cost cap β€” stream ends, resume via /approvals.
response.completed / .failed / .cancelledTerminal β€” the stream closes.
+ +
+ queued→ + in_progress→ + completed + · + incomplete (approval_required)→ + in_progress + · + cancelled / failed +
+
+ + +
+
05

Artifacts, first-class

+
+
+

Everything the intern produces is surfaced twice: streamed live as + response.artifact.created the moment it exists, and aggregated on the + response object under artifacts[] β€” including repos created + inside HF Jobs, recovered from the session's Hub collection.

+
+ hf_jobtrackio_dashboardmodel + datasetspacecollection +
+

Embed the trackio dashboard URL in your own UI for live training + curves, or hand the job URL to teammates β€” these are plain Hugging Face links + under your namespace.

+
+
+ + 
"artifacts": [
+  { "type": "hf_job",
+    "id": "6843a1…",
+    "url": "https://huggingface.co/jobs/you/6843a1…" },
+  { "type": "trackio_dashboard",
+    "space_id": "you/trackio",
+    "project": "imdb-finetune",
+    "url": "https://huggingface.co/spaces/you/trackio" },
+  { "type": "model",
+    "repo_id": "you/distilbert-imdb",
+    "url": "https://huggingface.co/you/distilbert-imdb" }
+]
+
+
+
+ + +
+
06

Spend caps, not surprises

+

API runs execute unattended, so tool calls auto-approve under a + session-cumulative cost cap (max_cost_usd, default $5). When the next + action would blow the budget β€” say, an 8Γ—A100 job β€” the run pauses and emits + response.approval_required instead of spending. Approve, raise the cap, or + deny with feedback; the same response resumes mid-turn.

+
+ Heads-up: chained responses (via previous_response_id) share one + session and therefore one budget β€” the most recent request's cap wins. Inference and + job costs are billed to the HF account behind your token; check + your billing page. +
+
+ +
+ + + + + + diff --git a/backend/__init__.py b/backend/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c448d7bc45e6a03a3c4cb23553e1d51681abb5a9 --- /dev/null +++ b/backend/__init__.py @@ -0,0 +1 @@ +# Backend package for HF Agent web interface diff --git a/backend/dataset_uploads.py b/backend/dataset_uploads.py new file mode 100644 index 0000000000000000000000000000000000000000..94c0839e02b9478521093090b493f9d17de55375 --- /dev/null +++ b/backend/dataset_uploads.py @@ -0,0 +1,305 @@ +"""Helpers for session-scoped dataset uploads to the Hugging Face Hub.""" + +import asyncio +import os +import re +import uuid +from dataclasses import dataclass +from urllib.parse import quote + +from fastapi import HTTPException, UploadFile +from huggingface_hub import HfApi + +MAX_DATASET_UPLOAD_BYTES = 100 * 1024 * 1024 +ALLOWED_DATASET_EXTENSIONS = {"csv", "json", "jsonl"} +_SAFE_FILENAME_RE = re.compile(r"[^A-Za-z0-9._-]+") +_SAFE_NAMESPACE_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,95}$") + + +@dataclass(frozen=True) +class DatasetUpload: + session_id: str + repo_id: str + repo_type: str + private: bool + upload_id: str + config_name: str + filename: str + original_filename: str + path_in_repo: str + size_bytes: int + format: str + hub_url: str + load_dataset_snippet: str + + def response_payload(self) -> dict[str, str | int | bool]: + return { + "session_id": self.session_id, + "repo_id": self.repo_id, + "repo_type": self.repo_type, + "private": self.private, + "upload_id": self.upload_id, + "config_name": self.config_name, + "filename": self.filename, + "path_in_repo": self.path_in_repo, + "size_bytes": self.size_bytes, + "format": self.format, + "hub_url": self.hub_url, + "load_dataset_snippet": self.load_dataset_snippet, + } + + +def sanitize_dataset_filename(filename: str | None) -> str: + """Return a Hub-safe basename while preserving the extension.""" + raw = os.path.basename(filename or "").strip() + if not raw: + raw = "dataset.csv" + + safe = _SAFE_FILENAME_RE.sub("-", raw).strip(".-_") + if not safe: + safe = "dataset.csv" + + stem, ext = os.path.splitext(safe) + if not stem: + stem = "dataset" + if not ext: + ext = ".csv" + + max_stem_len = 96 - len(ext) + stem = stem[:max_stem_len].strip(".-_") or "dataset" + return f"{stem}{ext.lower()}" + + +def display_filename(filename: str | None, fallback: str) -> str: + raw = os.path.basename(filename or "").strip() + if not raw: + return fallback + cleaned = "".join(char for char in raw if ord(char) >= 32) + return cleaned[:160] or fallback + + +def dataset_format_from_filename(filename: str) -> str: + ext = os.path.splitext(filename)[1].lower().lstrip(".") + if ext not in ALLOWED_DATASET_EXTENSIONS: + raise HTTPException( + status_code=400, + detail="Only .csv, .json, and .jsonl dataset files are supported.", + ) + return ext + + +def session_dataset_repo_id(hf_username: str | None, session_id: str) -> str: + namespace = (hf_username or "").strip() + if not namespace or not _SAFE_NAMESPACE_RE.fullmatch(namespace): + raise HTTPException( + status_code=400, + detail="Could not determine a valid Hugging Face namespace.", + ) + + safe_session_id = re.sub(r"[^A-Za-z0-9]+", "-", session_id).strip("-") + if not safe_session_id: + safe_session_id = uuid.uuid4().hex[:8] + return f"{namespace}/ml-intern-{safe_session_id[:8]}-datasets" + + +async def upload_size_bytes(upload: UploadFile) -> int: + await asyncio.to_thread(upload.file.seek, 0, os.SEEK_END) + size = await asyncio.to_thread(upload.file.tell) + await asyncio.to_thread(upload.file.seek, 0) + return int(size) + + +async def validate_dataset_upload(upload: UploadFile) -> tuple[str, str, int]: + dataset_format = dataset_format_from_filename(upload.filename or "") + safe_filename = sanitize_dataset_filename(upload.filename) + size = await upload_size_bytes(upload) + if size <= 0: + raise HTTPException(status_code=400, detail="Uploaded dataset file is empty.") + if size > MAX_DATASET_UPLOAD_BYTES: + raise HTTPException( + status_code=413, + detail="Dataset upload exceeds the 100 MB limit.", + ) + return safe_filename, dataset_format, size + + +def dataset_hub_url(repo_id: str, path_in_repo: str) -> str: + quoted_path = quote(path_in_repo, safe="/") + return f"https://huggingface.co/datasets/{repo_id}/blob/main/{quoted_path}" + + +def dataset_config_name(upload_id: str) -> str: + safe_upload_id = re.sub(r"[^A-Za-z0-9]+", "_", upload_id).strip("_").lower() + if not safe_upload_id: + safe_upload_id = "dataset" + return f"upload_{safe_upload_id[:32]}" + + +def dataset_config_name_from_path(path_in_repo: str) -> str: + parts = path_in_repo.split("/") + if len(parts) >= 3 and parts[0] == "uploads": + return dataset_config_name(parts[1]) + stem = os.path.splitext(os.path.basename(path_in_repo))[0] + return dataset_config_name(stem) + + +def is_dataset_upload_path(path_in_repo: str) -> bool: + parts = path_in_repo.split("/") + if len(parts) != 3 or parts[0] != "uploads" or not parts[1] or not parts[2]: + return False + extension = os.path.splitext(path_in_repo)[1].lower().lstrip(".") + return extension in ALLOWED_DATASET_EXTENSIONS + + +def unique_dataset_upload_paths(paths: list[str]) -> list[str]: + seen = set() + upload_paths = [] + for path in paths: + if not is_dataset_upload_path(path) or path in seen: + continue + seen.add(path) + upload_paths.append(path) + return upload_paths + + +def load_dataset_snippet(repo_id: str, config_name: str) -> str: + return ( + "from datasets import load_dataset\n\n" + f'dataset = load_dataset("{repo_id}", "{config_name}", ' + 'split="train", token=True)' + ) + + +def dataset_repo_card(repo_id: str, upload_paths: list[str]) -> bytes: + config_lines = [] + unique_upload_paths = unique_dataset_upload_paths(upload_paths) + if unique_upload_paths: + config_lines.append("configs:") + for path in unique_upload_paths: + config_lines.extend( + [ + f"- config_name: {dataset_config_name_from_path(path)}", + " data_files:", + " - split: train", + f' path: "{path}"', + ] + ) + + configs = "\n".join(config_lines) + if configs: + configs = f"{configs}\n" + + content = f"""--- +tags: +- ml-intern +- uploaded-dataset +{configs}--- + +# {repo_id} + +Private dataset files uploaded through ML Intern. + +Files are stored under `uploads//` and are attached to the +corresponding ML Intern session context by Hub reference, not by copying file +contents into the chat. + +Each uploaded file is exposed as its own dataset config so files with different +schemas can coexist in the same session repo. +""" + return content.encode("utf-8") + + +def dataset_context_note(upload: DatasetUpload) -> str: + return f"""[SYSTEM: The user uploaded a dataset file for this session. + +Use this Hugging Face Hub dataset reference when the task needs the uploaded data. +Do not look for the uploaded file on local disk and do not ask the user to +upload it again unless this Hub reference fails. + +- Repo ID: {upload.repo_id} +- Repo type: dataset +- Dataset config: {upload.config_name} +- File in repo: {upload.path_in_repo} +- Original filename: {upload.original_filename} +- Stored filename: {upload.filename} +- Format: {upload.format} +- Size: {upload.size_bytes} bytes +- Hub URL: {upload.hub_url} + +Load it with: +```python +{upload.load_dataset_snippet} +``` +]""" + + +async def push_dataset_upload_to_hub( + *, + upload: UploadFile, + session_id: str, + hf_username: str, + hf_token: str, +) -> DatasetUpload: + safe_filename, dataset_format, size = await validate_dataset_upload(upload) + original_filename = display_filename(upload.filename, safe_filename) + upload_id = uuid.uuid4().hex[:12] + config_name = dataset_config_name(upload_id) + repo_id = session_dataset_repo_id(hf_username, session_id) + path_in_repo = f"uploads/{upload_id}/{safe_filename}" + hub_url = dataset_hub_url(repo_id, path_in_repo) + snippet = load_dataset_snippet(repo_id, config_name) + api = HfApi(token=hf_token) + + await asyncio.to_thread( + api.create_repo, + repo_id=repo_id, + repo_type="dataset", + private=True, + exist_ok=True, + ) + await asyncio.to_thread( + api.update_repo_settings, + repo_id=repo_id, + repo_type="dataset", + private=True, + ) + repo_files = await asyncio.to_thread( + api.list_repo_files, + repo_id=repo_id, + repo_type="dataset", + ) + upload_paths = unique_dataset_upload_paths([*repo_files, path_in_repo]) + await asyncio.to_thread(upload.file.seek, 0) + file_bytes = await asyncio.to_thread(upload.file.read) + await asyncio.to_thread( + api.upload_file, + path_or_fileobj=file_bytes, + path_in_repo=path_in_repo, + repo_id=repo_id, + repo_type="dataset", + commit_message=f"Upload dataset file {safe_filename}", + ) + await asyncio.to_thread( + api.upload_file, + path_or_fileobj=dataset_repo_card(repo_id, upload_paths), + path_in_repo="README.md", + repo_id=repo_id, + repo_type="dataset", + commit_message="Update ML Intern dataset upload configs", + ) + + return DatasetUpload( + session_id=session_id, + repo_id=repo_id, + repo_type="dataset", + private=True, + upload_id=upload_id, + config_name=config_name, + filename=safe_filename, + original_filename=original_filename, + path_in_repo=path_in_repo, + size_bytes=size, + format=dataset_format, + hub_url=hub_url, + load_dataset_snippet=snippet, + ) diff --git a/backend/dependencies.py b/backend/dependencies.py new file mode 100644 index 0000000000000000000000000000000000000000..5c348ac582a9a8f611484c8a6989dcde93c49ed4 --- /dev/null +++ b/backend/dependencies.py @@ -0,0 +1,325 @@ +"""Authentication dependencies for FastAPI routes. + +- In dev mode (OAUTH_CLIENT_ID not set): auth is bypassed, returns a default "dev" user. +- In production: validates Bearer tokens or cookies against HF OAuth. +""" + +import logging +import os +import time +from collections.abc import Iterable +from hashlib import sha256 +from typing import Any + +import httpx +from fastapi import HTTPException, Request, status + +from openai_compat import V1APIError + +from agent.core.hf_tokens import bearer_token_from_header, clean_hf_token + +from agent.core.hf_access import fetch_whoami_v2, normalize_hf_user_plan + +logger = logging.getLogger(__name__) + +OPENID_PROVIDER_URL = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface.co") +# Auth is on when HF OAuth is configured (the web Space) OR when explicitly +# forced (REQUIRE_API_AUTH=1, set by the API-only Space image, which has no +# OAuth app but must never fall back to the dev-mode identity). +AUTH_ENABLED = bool(os.environ.get("OAUTH_CLIENT_ID", "")) or os.environ.get( + "REQUIRE_API_AUTH", "" +) not in ("", "0", "false") + +# Simple in-memory token cache: token -> (user_info, expiry_time) +_token_cache: dict[str, tuple[dict[str, Any], float]] = {} +TOKEN_CACHE_TTL = 300 # 5 minutes + +DEV_USER: dict[str, Any] = { + "user_id": "dev", + "username": "dev", + "authenticated": True, + "plan": "pro", # Dev uses the Pro web default model. +} + +INTERNAL_HF_TOKEN_KEY = "_hf_token" +OAUTH_SCOPE_COOKIE = "hf_oauth_scope_hash" +REQUIRED_OAUTH_SCOPES: tuple[str, ...] = ( + "openid", + "profile", + "read-billing", + "read-repos", + "write-repos", + "contribute-repos", + "manage-repos", + "write-collections", + "inference-api", + "jobs", + "write-discussions", +) + +# Log the whoami-v2 shape once at DEBUG so we can confirm the production Pro +# signal without hammering the HF API. +_WHOAMI_SHAPE_LOGGED = False + + +def normalize_oauth_scopes(scopes: Iterable[str]) -> tuple[str, ...]: + """Return stable, de-duplicated OAuth scopes preserving declaration order.""" + seen: set[str] = set() + normalized: list[str] = [] + for scope in scopes: + value = str(scope).strip() + if not value or value in seen: + continue + seen.add(value) + normalized.append(value) + return tuple(normalized) + + +def configured_oauth_scopes() -> tuple[str, ...]: + """Return the scopes this backend should request from HF OAuth. + + Spaces expose README ``hf_oauth_scopes`` through ``OAUTH_SCOPES``. Unioning + that value with the app-required scopes keeps the local request and Space + metadata in sync while ensuring new required scopes are never omitted. + """ + env_scopes = os.environ.get("OAUTH_SCOPES", "").split() + return normalize_oauth_scopes((*env_scopes, *REQUIRED_OAUTH_SCOPES)) + + +def oauth_scope_fingerprint(scopes: Iterable[str] | None = None) -> str: + """Return a non-secret fingerprint for the current OAuth scope contract.""" + scope_list = configured_oauth_scopes() if scopes is None else scopes + payload = " ".join(sorted(normalize_oauth_scopes(scope_list))) + return sha256(payload.encode("utf-8")).hexdigest()[:16] + + +def _cookie_has_current_oauth_scope_marker(request: Request) -> bool: + return request.cookies.get(OAUTH_SCOPE_COOKIE) == oauth_scope_fingerprint() + + +async def _validate_token(token: str) -> dict[str, Any] | None: + """Validate a token against HF OAuth userinfo endpoint. + + Results are cached for TOKEN_CACHE_TTL seconds to avoid excessive API calls. + """ + now = time.time() + + # Check cache + if token in _token_cache: + user_info, expiry = _token_cache[token] + if now < expiry: + return user_info + del _token_cache[token] + + # Validate against HF + async with httpx.AsyncClient(timeout=10.0) as client: + try: + response = await client.get( + f"{OPENID_PROVIDER_URL}/oauth/userinfo", + headers={"Authorization": f"Bearer {token}"}, + ) + if response.status_code != 200: + logger.debug("Token validation failed: status %d", response.status_code) + return None + user_info = response.json() + _token_cache[token] = (user_info, now + TOKEN_CACHE_TTL) + return user_info + except httpx.HTTPError as e: + logger.warning("Token validation error: %s", e) + return None + + +def _user_from_info(user_info: dict[str, Any]) -> dict[str, Any]: + """Build a normalized user dict from HF userinfo response.""" + return { + "user_id": user_info.get("sub", user_info.get("preferred_username", "unknown")), + "username": user_info.get("preferred_username", "unknown"), + "name": user_info.get("name"), + "picture": user_info.get("picture"), + "authenticated": True, + } + + +def _normalize_user_plan(whoami: Any) -> str: + """Normalize a whoami-v2 payload to the app's supported plan tiers.""" + return normalize_hf_user_plan(whoami) or "free" + + +async def _fetch_user_plan(token: str) -> str: + """Look up the user's HF plan via /api/whoami-v2. + + Returns 'free' | 'pro'. Non-200, network errors, or an unknown + payload shape all collapse to 'free' β€” safe default; we'd rather avoid + selecting the Pro default on bad data. + """ + global _WHOAMI_SHAPE_LOGGED + whoami = await fetch_whoami_v2(token) + if whoami is None: + return "free" + + if not _WHOAMI_SHAPE_LOGGED: + _WHOAMI_SHAPE_LOGGED = True + logger.debug( + "whoami-v2 payload keys: %s (sample values: isPro=%r)", + sorted(whoami.keys()) + if isinstance(whoami, dict) + else type(whoami).__name__, + whoami.get("isPro") if isinstance(whoami, dict) else None, + ) + + return _normalize_user_plan(whoami) + + +async def _extract_user_from_token(token: str) -> dict[str, Any] | None: + """Validate a token and return a user dict, or None.""" + user_info = await _validate_token(token) + if user_info is None: + return None + user = _user_from_info(user_info) + user["plan"] = await _fetch_user_plan(token) + user[INTERNAL_HF_TOKEN_KEY] = clean_hf_token(token) + return user + + +async def _dev_user_from_env() -> dict[str, Any]: + """Use HF_TOKEN as the dev identity when available. + + Local dev often runs without OAuth, but session trace uploads still need a + real HF namespace. Deriving the dev user from HF_TOKEN keeps local uploads + pointed at the token owner's dataset instead of dev/ml-intern-sessions. + """ + token = clean_hf_token(os.environ.get("HF_TOKEN", "")) + if not token: + return dict(DEV_USER) + + whoami = await fetch_whoami_v2(token) + if not isinstance(whoami, dict): + return dict(DEV_USER) + + username = None + for key in ("name", "user", "preferred_username"): + value = whoami.get(key) + if isinstance(value, str) and value: + username = value + break + if not username: + return dict(DEV_USER) + + return { + "user_id": username, + "username": username, + "authenticated": True, + "plan": await _fetch_user_plan(token), + INTERNAL_HF_TOKEN_KEY: token, + } + + +async def get_current_user(request: Request) -> dict[str, Any]: + """FastAPI dependency: extract and validate the current user. + + Checks (in order): + 1. Authorization: Bearer header + 2. hf_access_token cookie + + In dev mode (AUTH_ENABLED=False), uses HF_TOKEN as the user when possible. + """ + if not AUTH_ENABLED: + return await _dev_user_from_env() + + # Bearer callers manage token lifecycle themselves; only browser cookie + # auth is forced through the scope-freshness marker below. + token = bearer_token_from_header(request.headers.get("Authorization", "")) + if token: + user = await _extract_user_from_token(token) + if user: + return user + + # Try cookie + token = request.cookies.get("hf_access_token") + if token: + if not _cookie_has_current_oauth_scope_marker(request): + logger.info( + "Rejecting stale HF OAuth cookie; current scopes require refresh." + ) + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Authentication scopes changed. Please log in again.", + headers={"WWW-Authenticate": "Bearer"}, + ) + user = await _extract_user_from_token(token) + if user: + return user + + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Not authenticated. Please log in via /auth/login.", + headers={"WWW-Authenticate": "Bearer"}, + ) + + +# ── /v1 developer-API auth ─────────────────────────────────────────── +# The /v1 surface accepts plain `hf_...` user access tokens (not just OAuth +# access tokens), validated against /api/whoami-v2 which accepts both kinds. + +_api_token_cache: dict[str, tuple[dict[str, Any], float]] = {} + + +def _api_auth_error(message: str) -> V1APIError: + return V1APIError( + 401, + message, + code="invalid_api_key", + error_type="authentication_error", + ) + + +async def get_api_user(request: Request) -> dict[str, Any]: + """FastAPI dependency for /v1 routes: Bearer-token-only authentication. + + Validates the token via whoami-v2 so plain user access tokens work. No + cookie path β€” developer API callers manage tokens themselves. In dev mode + (AUTH_ENABLED=False) falls back to the HF_TOKEN-derived dev identity. + """ + if not AUTH_ENABLED: + return await _dev_user_from_env() + + token = bearer_token_from_header(request.headers.get("Authorization", "")) + if not token: + raise _api_auth_error( + "Missing Authorization header. Pass your Hugging Face token as " + "'Authorization: Bearer hf_...'." + ) + + now = time.time() + cached = _api_token_cache.get(token) + if cached and now < cached[1]: + return dict(cached[0]) + + whoami = await fetch_whoami_v2(token) + if not isinstance(whoami, dict): + raise _api_auth_error( + "Invalid Hugging Face token (whoami-v2 validation failed)." + ) + if whoami.get("type") not in (None, "user"): + raise _api_auth_error( + "Organization tokens are not supported; use a user access token." + ) + username = None + for key in ("name", "user", "preferred_username"): + value = whoami.get(key) + if isinstance(value, str) and value: + username = value + break + if not username: + raise _api_auth_error("Could not resolve a username for this token.") + + user: dict[str, Any] = { + "user_id": str(whoami.get("id") or username), + "username": username, + "name": whoami.get("fullname"), + "authenticated": True, + "plan": normalize_hf_user_plan(whoami) or "free", + INTERNAL_HF_TOKEN_KEY: clean_hf_token(token), + } + _api_token_cache[token] = (user, now + TOKEN_CACHE_TTL) + return dict(user) diff --git a/backend/kpis_scheduler.py b/backend/kpis_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..9b2199c69151118762ed2cfaddde579fb5a694d3 --- /dev/null +++ b/backend/kpis_scheduler.py @@ -0,0 +1,148 @@ +"""In-process hourly KPI rollup, owned by the backend Space lifespan. + +Replaces an external GitHub Actions cron so the rollup lives next to the data +and reuses the Space's existing HF token β€” no production secrets on the +public source repo. See ``scripts/build_kpis.py`` for the data-flow diagram +and metric definitions. + +Behaviour:: + + lifespan startup β†’ start APScheduler with cron("5 * * * *", UTC) + β†’ fire a best-effort 6-hour backfill (fire-and-forget) + each :05 β†’ run ``build_kpis.run_for_hour`` for the just-completed hour + lifespan shutdown β†’ scheduler.shutdown(wait=False) + +Environment:: + + HF_KPI_WRITE_TOKEN | HF_SESSION_UPLOAD_TOKEN | HF_TOKEN | HF_ADMIN_TOKEN + First one found is used. Least-privilege first. + KPI_SOURCE_REPO default smolagents/ml-intern-sessions + KPI_TARGET_REPO default smolagents/ml-intern-kpis + ML_INTERN_KPIS_DISABLED if truthy, the scheduler is not started +""" + +from __future__ import annotations + +import asyncio +import importlib.util +import logging +import os +from datetime import datetime, timedelta, timezone +from pathlib import Path +from typing import Optional + +logger = logging.getLogger(__name__) + +_PROJECT_ROOT = Path(__file__).resolve().parent.parent + +# Hold strong refs to backfill tasks so asyncio doesn't GC them mid-run. +_background_tasks: set[asyncio.Task] = set() + +_scheduler = None # AsyncIOScheduler instance (lazy import) + + +def _resolve_token() -> Optional[str]: + """Pick the first available HF token. Least-privilege first.""" + for var in ( + "HF_KPI_WRITE_TOKEN", + "HF_SESSION_UPLOAD_TOKEN", + "HF_TOKEN", + "HF_ADMIN_TOKEN", + ): + val = os.environ.get(var) + if val: + return val + return None + + +def _load_build_kpis(): + """Import ``scripts/build_kpis.py`` without putting ``scripts/`` on sys.path.""" + spec = importlib.util.spec_from_file_location( + "build_kpis", + _PROJECT_ROOT / "scripts" / "build_kpis.py", + ) + mod = importlib.util.module_from_spec(spec) + assert spec.loader is not None + spec.loader.exec_module(mod) + return mod + + +async def _run_hour(hour_dt: datetime) -> None: + """Run one hourly rollup off the event loop. Best-effort, never raises.""" + token = _resolve_token() + if not token: + logger.warning("kpis_scheduler: no HF token available, skipping %s", hour_dt) + return + try: + mod = _load_build_kpis() + from huggingface_hub import HfApi + + api = HfApi() + source = os.environ.get("KPI_SOURCE_REPO", "smolagents/ml-intern-sessions") + target = os.environ.get("KPI_TARGET_REPO", "smolagents/ml-intern-kpis") + await asyncio.to_thread(mod.run_for_hour, api, source, target, hour_dt, token) + except Exception as e: + logger.warning("kpis_scheduler: rollup for %s failed: %s", hour_dt, e) + + +async def run_last_completed_hour() -> None: + """The scheduled-at-:05 job. Rolls up the previous whole hour.""" + now = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0) + await _run_hour(now - timedelta(hours=1)) + + +async def backfill(hours: int = 6) -> None: + """Catch-up pass for hours the Space was down. Idempotent (overwrites).""" + now = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0) + for i in range(1, hours + 1): + await _run_hour(now - timedelta(hours=i)) + + +def start(backfill_hours: int = 6) -> None: + """Called from FastAPI lifespan startup.""" + global _scheduler + if os.environ.get("ML_INTERN_KPIS_DISABLED"): + logger.info("kpis_scheduler: disabled via ML_INTERN_KPIS_DISABLED") + return + if _scheduler is not None: + return + + try: + from apscheduler.schedulers.asyncio import AsyncIOScheduler + from apscheduler.triggers.cron import CronTrigger + except ImportError: + logger.warning("kpis_scheduler: apscheduler not installed, skipping") + return + + _scheduler = AsyncIOScheduler(timezone="UTC") + _scheduler.add_job( + run_last_completed_hour, + CronTrigger(minute=5), + id="kpis_hourly", + misfire_grace_time=600, # tolerate a 10-min misfire window + coalesce=True, # collapse multiple missed fires into one + max_instances=1, + replace_existing=True, + ) + _scheduler.start() + logger.info("kpis_scheduler: started (cron '5 * * * *' UTC)") + + # Non-blocking backfill. Hold a strong ref until done so asyncio doesn't + # GC the task before it finishes. + try: + task = asyncio.get_running_loop().create_task(backfill(backfill_hours)) + _background_tasks.add(task) + task.add_done_callback(_background_tasks.discard) + except RuntimeError: + # Not in an event loop (tests); skip backfill. + pass + + +async def shutdown() -> None: + """Called from FastAPI lifespan shutdown.""" + global _scheduler + if _scheduler is None: + return + _scheduler.shutdown(wait=False) + _scheduler = None + logger.info("kpis_scheduler: stopped") diff --git a/backend/main.py b/backend/main.py new file mode 100644 index 0000000000000000000000000000000000000000..d97517987eb01be9276ca82c80b8b1bfe3f65bb5 --- /dev/null +++ b/backend/main.py @@ -0,0 +1,154 @@ +"""FastAPI application for HF Agent web interface.""" + +import asyncio +import logging +import os +from contextlib import asynccontextmanager +from pathlib import Path + +from dotenv import load_dotenv +from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware +from fastapi.staticfiles import StaticFiles + +# Load .env before importing routes/session_manager so persistence and model +# modules see local settings during startup. +load_dotenv(Path(__file__).parent.parent / ".env") + +from openai_compat import V1APIError # noqa: E402 +from routes.agent import router as agent_router # noqa: E402 +from routes.auth import router as auth_router # noqa: E402 +from routes.v1_responses import router as v1_router # noqa: E402 +from session_manager import session_manager # noqa: E402 + +# Configure logging +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", +) +logger = logging.getLogger(__name__) +SHUTDOWN_USAGE_REFRESH_CONCURRENCY = 32 + + +async def _flush_session_on_shutdown(sid: str, agent_session, semaphore) -> None: + sess = agent_session.session + if not sess.config.save_sessions: + return + try: + async with semaphore: + await session_manager.refresh_session_usage_metrics( + agent_session, + error_code="lifespan_billing_snapshot_error", + ) + sess.save_and_upload_detached(sess.config.session_dataset_repo) + logger.info("Flushed session %s on shutdown", sid) + except Exception as e: + logger.warning("Failed to flush session %s: %s", sid, e) + + +@asynccontextmanager +async def lifespan(app: FastAPI): + """Application lifespan handler.""" + logger.info("Starting HF Agent backend...") + await session_manager.start() + # Start in-process hourly KPI rollup. Replaces an external cron so the + # rollup lives next to the data and reuses the Space's HF token. + try: + import kpis_scheduler + + kpis_scheduler.start() + except Exception as e: + logger.warning("KPI scheduler failed to start: %s", e) + yield + + logger.info("Shutting down HF Agent backend...") + try: + import kpis_scheduler + + await kpis_scheduler.shutdown() + except Exception as e: + logger.warning("KPI scheduler shutdown failed: %s", e) + + # Final-flush: save every still-active session so we don't lose traces on + # server restart. Billing refreshes are timeboxed and bounded; uploads are + # detached subprocesses. + try: + semaphore = asyncio.Semaphore(SHUTDOWN_USAGE_REFRESH_CONCURRENCY) + await asyncio.gather( + *( + _flush_session_on_shutdown(sid, agent_session, semaphore) + for sid, agent_session in list(session_manager.sessions.items()) + ) + ) + except Exception as e: + logger.warning("Lifespan final-flush skipped: %s", e) + await session_manager.close() + + +# Disable FastAPI auto-docs when running on HF Spaces (SPACE_ID is set by the +# platform) to avoid exposing the full API surface to anonymous visitors. Local +# dev keeps /docs and /redoc available. +_DOCS_DISABLED = os.environ.get("SPACE_ID") is not None + +app = FastAPI( + title="HF Agent", + description="ML Engineering Assistant API", + version="1.0.0", + lifespan=lifespan, + docs_url=None if _DOCS_DISABLED else "/docs", + redoc_url=None if _DOCS_DISABLED else "/redoc", + openapi_url=None if _DOCS_DISABLED else "/openapi.json", +) + +# CORS middleware for development +app.add_middleware( + CORSMiddleware, + allow_origins=[ + "http://localhost:5173", # Vite dev server + "http://localhost:3000", + "http://127.0.0.1:5173", + "http://127.0.0.1:3000", + ], + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + +# Include routers (must come before the static mount at "/" below β€” Starlette +# matches in registration order and the mount swallows everything after it) +app.include_router(agent_router) +app.include_router(auth_router) +app.include_router(v1_router) + + +@app.exception_handler(V1APIError) +async def v1_api_error_handler(request, exc: V1APIError): + """OpenAI-shaped error bodies for the /v1 developer API.""" + from fastapi.responses import JSONResponse + + return JSONResponse(status_code=exc.status_code, content=exc.body()) + +# Serve static files (frontend build) in production +static_path = Path(__file__).parent.parent / "static" +if static_path.exists(): + app.mount("/", StaticFiles(directory=str(static_path), html=True), name="static") + logger.info(f"Serving static files from {static_path}") +else: + logger.info("No static directory found, running in API-only mode") + + +@app.get("/api") +async def api_root(): + """API root endpoint.""" + return { + "name": "HF Agent API", + "version": "1.0.0", + "docs": "/docs", + } + + +if __name__ == "__main__": + import uvicorn + + port = int(os.environ.get("PORT", 7860)) + uvicorn.run(app, host="0.0.0.0", port=port) diff --git a/backend/models.py b/backend/models.py new file mode 100644 index 0000000000000000000000000000000000000000..76edd312833e28081efadccd081f345ca99101de --- /dev/null +++ b/backend/models.py @@ -0,0 +1,259 @@ +"""Pydantic models for API requests and responses.""" + +from enum import Enum +from typing import Any, Literal + +from pydantic import BaseModel, Field + + +class OpType(str, Enum): + """Operation types matching agent/core/agent_loop.py.""" + + USER_INPUT = "user_input" + EXEC_APPROVAL = "exec_approval" + UNDO = "undo" + COMPACT = "compact" + SHUTDOWN = "shutdown" + + +class Operation(BaseModel): + """Operation to be submitted to the agent.""" + + op_type: OpType + data: dict[str, Any] | None = None + + +class Submission(BaseModel): + """Submission wrapper with ID and operation.""" + + id: str + operation: Operation + + +class ToolApproval(BaseModel): + """Approval decision for a single tool call.""" + + tool_call_id: str + approved: bool + feedback: str | None = None + edited_script: str | None = None + namespace: str | None = None + + +class ApprovalRequest(BaseModel): + """Request to approve/reject tool calls.""" + + session_id: str + approvals: list[ToolApproval] + + +class SubmitRequest(BaseModel): + """Request to submit user input.""" + + session_id: str + # Cap text size to prevent context-bloat / cost-amplification: a malicious + # or runaway client could otherwise attach megabytes that then ride along + # in every subsequent turn until /api/compact is called. + text: str = Field(..., min_length=1, max_length=100_000) + + +class TruncateRequest(BaseModel): + """Request to truncate conversation history to before a specific user message.""" + + user_message_index: int + + +class SessionResponse(BaseModel): + """Response when creating a new session.""" + + session_id: str + ready: bool = True + model: str | None = None + + +class PendingApprovalTool(BaseModel): + """A tool waiting for user approval.""" + + tool: str + tool_call_id: str + arguments: dict[str, Any] = {} + + +class SessionAutoApprovalInfo(BaseModel): + """Per-session auto-approval budget state.""" + + enabled: bool = False + cost_cap_usd: float | None = None + estimated_spend_usd: float = 0.0 + remaining_usd: float | None = None + + +class SessionInfo(BaseModel): + """Session metadata.""" + + session_id: str + created_at: str + usage_window_started_at: str | None = None + is_active: bool + is_processing: bool = False + message_count: int + user_id: str = "dev" + pending_approval: list[PendingApprovalTool] | None = None + model: str | None = None + title: str | None = None + notification_destinations: list[str] = Field(default_factory=list) + auto_approval: SessionAutoApprovalInfo = Field( + default_factory=SessionAutoApprovalInfo + ) + + +class SessionNotificationsRequest(BaseModel): + """Replace the session's auto-notification destinations.""" + + destinations: list[str] + + +class SessionYoloRequest(BaseModel): + """Update a session's auto-approval policy.""" + + enabled: bool + cost_cap_usd: float | None = Field(default=None, ge=0) + + +class UsageBucket(BaseModel): + """App-attributed usage totals for a session.""" + + session_id: str | None = None + total_usd: float = 0.0 + inference_usd: float = 0.0 + hf_jobs_estimated_usd: float = 0.0 + sandbox_estimated_usd: float = 0.0 + llm_calls: int = 0 + hf_jobs_count: int = 0 + sandbox_count: int = 0 + prompt_tokens: int = 0 + completion_tokens: int = 0 + cache_read_tokens: int = 0 + cache_creation_tokens: int = 0 + total_tokens: int = 0 + hf_jobs_billable_seconds_estimate: int = 0 + sandbox_billable_seconds_estimate: int = 0 + + +class HfAccountUsageBucket(BaseModel): + """HF account billing usage for a time window.""" + + window_start: str | None = None + window_end: str | None = None + timezone: str | None = None + total_usd: float = 0.0 + inference_providers_usd: float = 0.0 + hf_jobs_usd: float = 0.0 + inference_provider_requests: int = 0 + hf_jobs_minutes: float = 0.0 + + +class HfInferenceProvidersCredits(BaseModel): + """Included and configured Inference Providers account credits.""" + + included_usd: float = 0.0 + used_usd: float = 0.0 + remaining_included_usd: float = 0.0 + limit_usd: float = 0.0 + remaining_limit_usd: float = 0.0 + num_requests: int = 0 + period_start: str | None = None + period_end: str | None = None + + +class HfAccountUsage(BaseModel): + """Authoritative HF account billing usage from the signed-in token.""" + + source: Literal["hf_billing"] + available: bool = False + error: str | None = None + current_session: HfAccountUsageBucket | None = None + month: HfAccountUsageBucket | None = None + inference_providers_credits: HfInferenceProvidersCredits | None = None + + +class UsageResponse(BaseModel): + """Current-user app-attributed usage response.""" + + source: Literal["app_telemetry"] + currency: Literal["USD"] + generated_at: str + timezone: str + session: UsageBucket | None = None + hf_account: HfAccountUsage | None = None + auto_approval: SessionAutoApprovalInfo | None = None + links: dict[str, str] = Field(default_factory=dict) + + +class DatasetUploadResponse(BaseModel): + """Response for a dataset file uploaded to the Hub.""" + + session_id: str + repo_id: str + repo_type: Literal["dataset"] = "dataset" + private: bool = True + upload_id: str + config_name: str + filename: str + path_in_repo: str + size_bytes: int + format: Literal["csv", "json", "jsonl"] + hub_url: str + load_dataset_snippet: str + + +class V1InputMessage(BaseModel): + """One message in a /v1/responses structured input list.""" + + role: Literal["user", "assistant", "system", "developer"] = "user" + content: str = Field(..., min_length=1, max_length=100_000) + + +class V1CreateResponseRequest(BaseModel): + """Body for POST /v1/responses (OpenAI Responses-API style).""" + + model: str | None = None + input: str | list[V1InputMessage] = Field(..., max_length=100_000) + instructions: str | None = Field(default=None, max_length=20_000) + background: bool = False + stream: bool = False + previous_response_id: str | None = None + # Session-cumulative YOLO auto-approval cap. None falls back to the + # server default (DEFAULT_YOLO_COST_CAP_USD). + max_cost_usd: float | None = Field(default=None, gt=0, le=500) + # How long a synchronous (non-stream, non-background) call waits for the + # turn to finish before returning the in-progress response object. + wait_timeout_seconds: float = Field(default=900, ge=1, le=3600) + metadata: dict[str, str] | None = None + + +class V1ApprovalDecisionRequest(BaseModel): + """Body for POST /v1/responses/{id}/approvals.""" + + approve: bool + new_max_cost_usd: float | None = Field(default=None, gt=0, le=500) + feedback: str | None = Field(default=None, max_length=10_000) + + +class HealthResponse(BaseModel): + """Health check response.""" + + status: str = "ok" + active_sessions: int = 0 + max_sessions: int = 0 + + +class LLMHealthResponse(BaseModel): + """LLM provider health check response.""" + + status: str # "ok" | "error" | "skipped" + model: str + error: str | None = None + error_type: str | None = ( + None # "auth" | "credits" | "rate_limit" | "network" | "unknown" + ) diff --git a/backend/openai_compat.py b/backend/openai_compat.py new file mode 100644 index 0000000000000000000000000000000000000000..be99659868083d285d75456cc94ba72a4304e4b6 --- /dev/null +++ b/backend/openai_compat.py @@ -0,0 +1,478 @@ +"""OpenAI Responses-API compatibility layer for the /v1 developer API. + +Pure translation between ml-intern's internal session events and an +OpenAI-Responses-style wire format: SSE event names, the response object, +terminal-status derivation, and artifact extraction. No I/O here β€” routes +in routes/v1_responses.py own all store/session access. + +Internal events arrive either as live broadcaster messages +(``{"event_type", "data", "seq"}``) or persisted Mongo docs (same keys plus +``_id``/``created_at``) β€” both shapes are accepted everywhere below. +""" + +import json +import re +import uuid +from datetime import UTC, datetime +from typing import Any + +RESPONSE_ID_PREFIX = "resp_" +MAX_TOOL_OUTPUT_CHARS = 4096 + +# Internal terminal event β†’ response status. ``approval_required`` is handled +# separately: it pauses the response (resumable) rather than ending it. +HARD_TERMINAL_STATUS: dict[str, str] = { + "turn_complete": "completed", + "error": "failed", + "interrupted": "cancelled", + "shutdown": "failed", +} +APPROVAL_EVENT = "approval_required" +TERMINAL_RESPONSE_STATUSES = {"completed", "failed", "cancelled"} + +# HF job URLs look like https://huggingface.co/jobs// +_JOB_URL_ID_RE = re.compile(r"/jobs/[^/?#]+/([^/?#]+)/?(?:[?#]|$)") + + +class V1APIError(Exception): + """OpenAI-shaped API error: ``{"error": {message, type, code}}``.""" + + def __init__( + self, + status_code: int, + message: str, + *, + code: str | None = None, + error_type: str = "invalid_request_error", + ) -> None: + super().__init__(message) + self.status_code = status_code + self.message = message + self.code = code + self.error_type = error_type + + def body(self) -> dict[str, Any]: + return { + "error": { + "message": self.message, + "type": self.error_type, + "code": self.code, + } + } + + +def new_response_id() -> str: + return f"{RESPONSE_ID_PREFIX}{uuid.uuid4().hex}" + + +def _timestamp(value: Any) -> int | None: + if isinstance(value, datetime): + if value.tzinfo is None: + value = value.replace(tzinfo=UTC) + return int(value.timestamp()) + if isinstance(value, (int, float)): + return int(value) + return None + + +# --------------------------------------------------------------------------- +# Artifacts +# --------------------------------------------------------------------------- + + +def _job_id_from_url(url: str) -> str | None: + match = _JOB_URL_ID_RE.search(url or "") + return match.group(1) if match else None + + +def artifact_key(artifact: dict[str, Any]) -> str: + ident = ( + artifact.get("id") + or artifact.get("repo_id") + or artifact.get("space_id") + or artifact.get("slug") + or artifact.get("url") + or "" + ) + return f"{artifact.get('type')}:{ident}" + + +def artifacts_from_event(event_type: str, data: dict[str, Any]) -> list[dict[str, Any]]: + """Structured artifacts carried by a single internal event, if any.""" + artifacts: list[dict[str, Any]] = [] + data = data or {} + if event_type == "tool_state_change": + job_url = data.get("jobUrl") + if isinstance(job_url, str) and job_url: + artifacts.append( + { + "type": "hf_job", + "id": _job_id_from_url(job_url), + "url": job_url, + } + ) + space_id = data.get("trackioSpaceId") + if isinstance(space_id, str) and space_id: + artifact: dict[str, Any] = { + "type": "trackio_dashboard", + "space_id": space_id, + "url": f"https://huggingface.co/spaces/{space_id}", + } + project = data.get("trackioProject") + if isinstance(project, str) and project: + artifact["project"] = project + artifacts.append(artifact) + elif event_type == "hub_artifact": + repo_id = data.get("repo_id") + repo_type = data.get("repo_type") or "model" + if isinstance(repo_id, str) and repo_id: + prefix = {"model": "", "dataset": "datasets/", "space": "spaces/"}.get( + repo_type, "" + ) + artifacts.append( + { + "type": repo_type, + "repo_id": repo_id, + "url": f"https://huggingface.co/{prefix}{repo_id}", + } + ) + return artifacts + + +def merge_artifacts( + existing: list[dict[str, Any]] | None, + new: list[dict[str, Any]] | None, +) -> list[dict[str, Any]]: + merged: list[dict[str, Any]] = [] + seen: set[str] = set() + for artifact in [*(existing or []), *(new or [])]: + if not isinstance(artifact, dict) or not artifact.get("type"): + continue + key = artifact_key(artifact) + if key in seen: + continue + seen.add(key) + merged.append(artifact) + return merged + + +def extract_artifacts(events: list[dict[str, Any]]) -> list[dict[str, Any]]: + found: list[dict[str, Any]] = [] + for event in events or []: + found.extend( + artifacts_from_event( + str(event.get("event_type") or ""), event.get("data") or {} + ) + ) + return merge_artifacts([], found) + + +# --------------------------------------------------------------------------- +# Turn state (event-sourced status derivation) +# --------------------------------------------------------------------------- + + +def derive_turn_state(events: list[dict[str, Any]]) -> dict[str, Any] | None: + """Derive the response status from a turn's event slice. + + Returns None when no verdict can be drawn from the events alone (turn + still running β€” or the server restarted mid-run; callers disambiguate by + checking the live session). ``approval_required`` only counts as a pause + if nothing ran after it (a resumed turn keeps appending events). + """ + last_event: dict[str, Any] | None = None + for event in events or []: + event_type = str(event.get("event_type") or "") + status = HARD_TERMINAL_STATUS.get(event_type) + if status is not None: + data = event.get("data") or {} + error = None + if status == "failed": + error = { + "code": ( + "session_shutdown" + if event_type == "shutdown" + else "agent_error" + ), + "message": str(data.get("error") or event_type), + } + return { + "status": status, + "terminal_event_type": event_type, + "end_seq": event.get("seq"), + "error": error, + "incomplete_details": None, + "final_response": data.get("final_response"), + } + last_event = event + if last_event and str(last_event.get("event_type")) == APPROVAL_EVENT: + return { + "status": "incomplete", + "terminal_event_type": APPROVAL_EVENT, + "end_seq": None, + "error": None, + "incomplete_details": { + "reason": "approval_required", + "approval": last_event.get("data") or {}, + }, + "final_response": None, + } + return None + + +# --------------------------------------------------------------------------- +# Output reconstruction +# --------------------------------------------------------------------------- + + +def _truncate(text: str, limit: int = MAX_TOOL_OUTPUT_CHARS) -> str: + if len(text) <= limit: + return text + return text[:limit] + f"… [truncated {len(text) - limit} chars]" + + +def build_output_items(events: list[dict[str, Any]]) -> list[dict[str, Any]]: + """Rebuild OpenAI-style output items from a turn's event slice.""" + items: list[dict[str, Any]] = [] + tool_items: dict[str, dict[str, Any]] = {} + text_parts: list[str] = [] + final_response: str | None = None + + def flush_text() -> None: + nonlocal text_parts + text = "".join(text_parts) + text_parts = [] + if text.strip(): + items.append( + { + "type": "message", + "id": f"msg_{len(items)}", + "role": "assistant", + "status": "completed", + "content": [{"type": "output_text", "text": text}], + } + ) + + for event in events or []: + event_type = str(event.get("event_type") or "") + data = event.get("data") or {} + if event_type == "assistant_chunk": + content = data.get("content") + if isinstance(content, str): + text_parts.append(content) + elif event_type == "assistant_message": + # Non-streamed full message replaces any partial chunk state. + content = data.get("content") + if isinstance(content, str): + text_parts = [content] + flush_text() + elif event_type == "assistant_stream_end": + flush_text() + elif event_type == "tool_call": + flush_text() + tool_call_id = str(data.get("tool_call_id") or f"call_{len(items)}") + item = { + "type": "custom_tool_call", + "id": tool_call_id, + "name": data.get("tool"), + "input": json.dumps(data.get("arguments") or {}), + "output": None, + "status": "in_progress", + } + tool_items[tool_call_id] = item + items.append(item) + elif event_type == "tool_output": + tool_call_id = str(data.get("tool_call_id") or "") + item = tool_items.get(tool_call_id) + output = data.get("output") + if item is not None: + item["output"] = _truncate(str(output)) if output is not None else None + item["status"] = ( + "completed" if data.get("success", True) else "incomplete" + ) + elif event_type == "turn_complete": + response_text = data.get("final_response") + if isinstance(response_text, str): + final_response = response_text + flush_text() + + # turn_complete.final_response is authoritative for the last message: if + # the chunk-reconstructed tail diverges (or is missing), replace it. + if final_response and final_response.strip(): + last = items[-1] if items else None + if ( + last is not None + and last.get("type") == "message" + and last["content"][0]["text"].strip() == final_response.strip() + ): + pass + else: + items.append( + { + "type": "message", + "id": f"msg_{len(items)}", + "role": "assistant", + "status": "completed", + "content": [{"type": "output_text", "text": final_response}], + } + ) + return items + + +# --------------------------------------------------------------------------- +# Response object +# --------------------------------------------------------------------------- + + +def build_response_object( + doc: dict[str, Any], + *, + output: list[dict[str, Any]] | None = None, + artifacts: list[dict[str, Any]] | None = None, + usage: dict[str, Any] | None = None, +) -> dict[str, Any]: + return { + "id": doc.get("_id"), + "object": "response", + "created_at": _timestamp(doc.get("created_at")), + "completed_at": _timestamp(doc.get("completed_at")), + "status": doc.get("status") or "queued", + "model": doc.get("model"), + "background": bool(doc.get("background")), + "previous_response_id": doc.get("previous_response_id"), + "session_id": doc.get("session_id"), + "max_cost_usd": doc.get("max_cost_usd"), + "instructions": doc.get("instructions"), + "output": output if output is not None else (doc.get("output") or []), + "error": doc.get("error"), + "incomplete_details": doc.get("incomplete_details"), + "usage": usage if usage is not None else doc.get("usage"), + "artifacts": ( + artifacts if artifacts is not None else (doc.get("artifacts") or []) + ), + "metadata": doc.get("metadata") or {}, + } + + +# --------------------------------------------------------------------------- +# SSE translation +# --------------------------------------------------------------------------- + +_DROPPED_EVENTS = { + "ready", + "compacted", + "new_complete", + "resume_complete", + "undo_complete", + "session_terminated", +} + + +def translate_event( + msg: dict[str, Any], response_id: str +) -> list[tuple[str, dict[str, Any]]]: + """Translate one internal event into zero or more (name, payload) SSE frames. + + Terminal frames (``response.completed`` etc.) carry only a light payload + here; the streaming routes merge in the full response snapshot they have + been accumulating. + """ + event_type = str(msg.get("event_type") or "") + data = msg.get("data") or {} + seq = msg.get("seq") + base: dict[str, Any] = {"response_id": response_id} + if seq is not None: + base["sequence_number"] = seq + + if event_type in _DROPPED_EVENTS: + return [] + if event_type == "processing": + return [("response.in_progress", base)] + if event_type == "assistant_chunk": + return [("response.output_text.delta", {**base, "delta": data.get("content")})] + if event_type == "assistant_message": + return [("response.output_text.done", {**base, "text": data.get("content")})] + if event_type == "assistant_stream_end": + return [("response.output_text.done", base)] + if event_type == "tool_call": + return [ + ( + "response.output_item.added", + { + **base, + "item": { + "type": "custom_tool_call", + "id": data.get("tool_call_id"), + "name": data.get("tool"), + "input": json.dumps(data.get("arguments") or {}), + "status": "in_progress", + }, + }, + ) + ] + if event_type == "tool_output": + output = data.get("output") + return [ + ( + "response.output_item.done", + { + **base, + "item": { + "type": "custom_tool_call", + "id": data.get("tool_call_id"), + "name": data.get("tool"), + "output": ( + _truncate(str(output)) if output is not None else None + ), + "status": ( + "completed" if data.get("success", True) else "incomplete" + ), + }, + }, + ) + ] + if event_type == "tool_log": + return [("response.tool_log", {**base, **data})] + if event_type == "tool_state_change": + frames: list[tuple[str, dict[str, Any]]] = [ + ("response.tool_state.changed", {**base, **data}) + ] + for artifact in artifacts_from_event(event_type, data): + frames.append(("response.artifact.created", {**base, "artifact": artifact})) + return frames + if event_type == "hub_artifact": + return [ + ("response.artifact.created", {**base, "artifact": artifact}) + for artifact in artifacts_from_event(event_type, data) + ] + if event_type == APPROVAL_EVENT: + return [("response.approval_required", {**base, **data})] + if event_type == "turn_complete": + return [ + ( + "response.completed", + {**base, "final_response": data.get("final_response")}, + ) + ] + if event_type == "error": + return [("response.failed", {**base, "error": data.get("error")})] + if event_type == "interrupted": + return [("response.cancelled", base)] + if event_type == "shutdown": + return [ + ( + "response.failed", + {**base, "error": {"code": "session_shutdown"}}, + ) + ] + # Unknown event types pass through under a generic name so new internal + # events are visible to API consumers without a translator change. + return [(f"response.{event_type}", {**base, **data})] + + +def format_v1_sse(event_name: str, payload: dict[str, Any]) -> str: + seq = payload.get("sequence_number") + body = json.dumps({"type": event_name, **payload}) + if isinstance(seq, int): + return f"id: {seq}\nevent: {event_name}\ndata: {body}\n\n" + return f"event: {event_name}\ndata: {body}\n\n" diff --git a/backend/routes/__init__.py b/backend/routes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d212dab603147209ac855bcc695bf0a3e23636c1 --- /dev/null +++ b/backend/routes/__init__.py @@ -0,0 +1 @@ +# Routes package diff --git a/backend/routes/agent.py b/backend/routes/agent.py new file mode 100644 index 0000000000000000000000000000000000000000..79d33986d065d8a478ddf430f33bb099a0f7e0f0 --- /dev/null +++ b/backend/routes/agent.py @@ -0,0 +1,1194 @@ +"""Agent API routes β€” REST + SSE endpoints. + +All routes (except /health) require authentication via the get_current_user +dependency. In dev mode (no OAUTH_CLIENT_ID), auth is bypassed automatically. +""" + +import asyncio +import json +import logging +from datetime import datetime +from typing import Any + +from dependencies import ( + INTERNAL_HF_TOKEN_KEY, + get_current_user, +) +from fastapi import ( + APIRouter, + Depends, + HTTPException, + Request, +) +from fastapi.exceptions import RequestValidationError +from fastapi.responses import StreamingResponse +from huggingface_hub.errors import HfHubHTTPError +from litellm import Message, acompletion +from pydantic import ValidationError +from starlette.datastructures import FormData, UploadFile +from dataset_uploads import ( + MAX_DATASET_UPLOAD_BYTES, + dataset_context_note, + push_dataset_upload_to_hub, +) +from models import ( + ApprovalRequest, + DatasetUploadResponse, + HealthResponse, + LLMHealthResponse, + SessionInfo, + SessionNotificationsRequest, + SessionResponse, + SessionYoloRequest, + SubmitRequest, + TruncateRequest, + UsageResponse, +) +from session_manager import ( + MAX_SESSIONS, + AgentSession, + SessionCapacityError, + session_manager, +) + +from agent.core.hf_access import get_jobs_access +from agent.core.hf_tokens import resolve_hf_request_token +from agent.core.local_models import local_model_provider +from agent.core.llm_params import _resolve_llm_params +from agent.core.model_ids import ( + CLAUDE_OPUS_48_MODEL_ID, + DEEPSEEK_V4_PRO_MODEL_ID, + GLM_51_MODEL_ID, + GPT_55_MODEL_ID, + KIMI_K26_MODEL_ID, + MINIMAX_M27_MODEL_ID, + strip_huggingface_model_prefix, +) +from agent.core.prompt_caching import with_prompt_cache_params +from usage import build_usage_response + +logger = logging.getLogger(__name__) + +router = APIRouter(prefix="/api", tags=["agent"]) +_background_route_tasks: set[asyncio.Task] = set() + +DEFAULT_OPUS_MODEL_ID = CLAUDE_OPUS_48_MODEL_ID +DEFAULT_GPT_MODEL_ID = GPT_55_MODEL_ID +DEFAULT_FREE_MODEL_ID = KIMI_K26_MODEL_ID +DATASET_UPLOAD_MULTIPART_SLACK_BYTES = 1024 * 1024 + + +async def _reset_usage_window(session_id: str) -> dict[str, Any] | None: + return await session_manager.reset_session_usage_window( + session_id, + started_at=datetime.utcnow(), + ) + + +async def _refresh_usage_and_upload( + agent_session: AgentSession, + *, + error_code: str, +) -> None: + session = agent_session.session + try: + await session_manager.refresh_session_usage_metrics( + agent_session, + error_code=error_code, + ) + session.save_and_upload_detached(session.config.session_dataset_repo) + except Exception as e: + logger.warning( + "Background usage refresh/upload failed for %s: %s", + agent_session.session_id, + e, + ) + + +def _schedule_usage_refresh_and_upload( + agent_session: AgentSession, + *, + error_code: str, +) -> None: + task = asyncio.create_task( + _refresh_usage_and_upload(agent_session, error_code=error_code) + ) + _background_route_tasks.add(task) + task.add_done_callback(_background_route_tasks.discard) + + +def _available_models() -> list[dict[str, Any]]: + models = [ + { + "id": DEFAULT_OPUS_MODEL_ID, + "label": "Claude Opus 4.8", + "provider": "huggingface", + "recommended": True, + }, + { + "id": DEFAULT_GPT_MODEL_ID, + "label": "GPT-5.5", + "provider": "huggingface", + }, + { + "id": DEFAULT_FREE_MODEL_ID, + "label": "Kimi K2.6", + "provider": "huggingface", + }, + { + "id": MINIMAX_M27_MODEL_ID, + "label": "MiniMax M2.7", + "provider": "huggingface", + }, + { + "id": GLM_51_MODEL_ID, + "label": "GLM 5.1", + "provider": "huggingface", + }, + { + "id": DEEPSEEK_V4_PRO_MODEL_ID, + "label": "DeepSeek V4 Pro", + "provider": "huggingface", + }, + ] + return models + + +AVAILABLE_MODELS = _available_models() + + +def _valid_model_ids() -> set[str]: + return {m["id"] for m in AVAILABLE_MODELS} + + +def _validate_model_id(model_id: str | None) -> None: + if not model_id or model_id in _valid_model_ids(): + return + raise HTTPException(status_code=400, detail=f"Unknown model: {model_id}") + + +def _default_model_for_user(user: dict[str, Any]) -> str: + return DEFAULT_OPUS_MODEL_ID if user.get("plan") == "pro" else DEFAULT_FREE_MODEL_ID + + +async def _model_override_for_new_session( + requested_model: str | None, + user: dict[str, Any], +) -> str | None: + """Return the model override to use when creating a new session. + + Explicit model requests are honored. Empty web requests default to Kimi for + non-Pro users and Opus for Pro users. + """ + return requested_model or _default_model_for_user(user) + + +def _user_hf_token(user: dict[str, Any] | None) -> str | None: + if not isinstance(user, dict): + return None + return user.get(INTERNAL_HF_TOKEN_KEY) + + +def _model_requires_hf_router_token(model_id: str | None) -> bool: + normalized = strip_huggingface_model_prefix(model_id) or model_id or "" + return local_model_provider(normalized) is None + + +def _reject_oversize_dataset_upload(request: Request) -> None: + raw_content_length = request.headers.get("content-length") + if raw_content_length is None: + return + try: + content_length = int(raw_content_length) + except (TypeError, ValueError): + return + if content_length > MAX_DATASET_UPLOAD_BYTES + DATASET_UPLOAD_MULTIPART_SLACK_BYTES: + raise HTTPException( + status_code=413, + detail="Dataset upload exceeds the 100 MB limit.", + ) + + +def _dataset_upload_file_from_form(form: FormData) -> UploadFile: + uploaded_files = [ + (key, value) + for key, value in form.multi_items() + if isinstance(value, UploadFile) + ] + if len(uploaded_files) != 1: + raise HTTPException( + status_code=400, + detail="Upload exactly one dataset file.", + ) + field_name, upload = uploaded_files[0] + if field_name != "file": + raise HTTPException( + status_code=400, + detail="Missing 'file' upload field.", + ) + return upload + + +def _dataset_upload_hub_http_exception(error: HfHubHTTPError) -> HTTPException: + status_code = getattr(error.response, "status_code", None) + if status_code == 401: + detail = "Hugging Face rejected the token used for the dataset upload." + return HTTPException(status_code=401, detail=detail) + if status_code == 403: + detail = ( + "Hugging Face denied permission to create or write to the dataset repo." + ) + return HTTPException(status_code=403, detail=detail) + if status_code == 404: + detail = "Could not find the Hugging Face namespace or dataset repo." + return HTTPException(status_code=404, detail=detail) + if status_code == 429: + detail = "Hugging Face Hub rate limit reached while uploading the dataset." + return HTTPException(status_code=429, detail=detail) + return HTTPException( + status_code=502, + detail="Hugging Face Hub upload failed. Please try again.", + ) + + +async def _check_session_access( + session_id: str, + user: dict[str, Any], + request: Request | None = None, + preload_sandbox: bool = True, +) -> AgentSession: + """Verify and lazily load the user's session. Raises 403 or 404.""" + hf_token = ( + resolve_hf_request_token(request) + if request is not None + else _user_hf_token(user) + ) + agent_session = await session_manager.ensure_session_loaded( + session_id, + user["user_id"], + hf_token=hf_token, + hf_username=user.get("username"), + user_plan=user.get("plan"), + preload_sandbox=preload_sandbox, + ) + if not agent_session: + raise HTTPException(status_code=404, detail="Session not found") + if user["user_id"] != "dev" and agent_session.user_id not in { + user["user_id"], + "dev", + }: + raise HTTPException(status_code=403, detail="Access denied to this session") + return agent_session + + +@router.get("/health", response_model=HealthResponse) +async def health_check() -> HealthResponse: + """Health check endpoint.""" + return HealthResponse( + status="ok", + active_sessions=session_manager.active_session_count, + max_sessions=MAX_SESSIONS, + ) + + +@router.get("/health/llm", response_model=LLMHealthResponse) +async def llm_health_check(request: Request) -> LLMHealthResponse: + """Check if the LLM provider is reachable and the API key is valid. + + Makes a minimal 1-token completion call when a token is available. For + token-less HF Router requests, returns ``status="skipped"`` instead of + making an unauthenticated probe. Catches common errors: + - 401 β†’ invalid API key + - 402/insufficient_quota β†’ out of credits + - 429 β†’ rate limited + - timeout / network β†’ provider unreachable + """ + model = session_manager.config.model_name + hf_token = resolve_hf_request_token(request) + if _model_requires_hf_router_token(model) and not hf_token: + return LLMHealthResponse(status="skipped", model=model) + + try: + llm_params = _resolve_llm_params( + model, + hf_token, + reasoning_effort="high", + ) + await acompletion( + messages=[{"role": "user", "content": "hi"}], + max_tokens=1, + timeout=10, + **llm_params, + ) + return LLMHealthResponse(status="ok", model=model) + except Exception as e: + err_str = str(e).lower() + error_type = "unknown" + + if ( + "401" in err_str + or "auth" in err_str + or "invalid" in err_str + or "api key" in err_str + ): + error_type = "auth" + elif ( + "402" in err_str + or "credit" in err_str + or "quota" in err_str + or "insufficient" in err_str + or "billing" in err_str + ): + error_type = "credits" + elif "429" in err_str or "rate" in err_str: + error_type = "rate_limit" + elif "timeout" in err_str or "connect" in err_str or "network" in err_str: + error_type = "network" + + logger.warning(f"LLM health check failed ({error_type}): {e}") + return LLMHealthResponse( + status="error", + model=model, + error=str(e)[:500], + error_type=error_type, + ) + + +@router.get("/config/model") +async def get_model() -> dict: + """Get current model and available models. No auth required.""" + return { + "current": session_manager.config.model_name, + "available": AVAILABLE_MODELS, + } + + +_TITLE_STRIP_CHARS = str.maketrans("", "", "`*_~#[]()") + + +@router.post("/title") +async def generate_title( + request: SubmitRequest, user: dict = Depends(get_current_user) +) -> dict: + """Generate a short title for a chat session based on the first user message. + + Always uses gpt-oss-120b via Cerebras on the HF router. The tab headline + renders as plain text, so the model is told to avoid markdown and any + stray formatting characters are stripped before returning. gpt-oss is a + reasoning model β€” reasoning_effort=low keeps the reasoning budget small + so the 60-token output budget isn't consumed before the title is written. + """ + try: + await _check_session_access(request.session_id, user) + llm_params = _resolve_llm_params( + "openai/gpt-oss-120b:cerebras", + _user_hf_token(user), + reasoning_effort="low", + ) + llm_params = with_prompt_cache_params(llm_params) + response = await acompletion( + messages=[ + { + "role": "system", + "content": ( + "Generate a very short title (max 6 words) for a chat conversation " + "that starts with the following user message. " + "Reply with ONLY the title in plain text. " + "Do NOT use markdown, backticks, asterisks, quotes, brackets, or any " + "formatting characters. No punctuation at the end." + ), + }, + {"role": "user", "content": request.text[:500]}, + ], + max_tokens=60, + temperature=0.3, + timeout=10, + **llm_params, + ) + title = response.choices[0].message.content.strip().strip('"').strip("'") + title = title.translate(_TITLE_STRIP_CHARS).strip() + if len(title) > 50: + title = title[:50].rstrip() + "…" + try: + await session_manager.update_session_title(request.session_id, title) + except Exception: + logger.debug( + "Skipping title persistence for missing session %s", request.session_id + ) + return {"title": title} + except Exception as e: + logger.warning(f"Title generation failed: {e}") + fallback = request.text.strip() + title = fallback[:40].rstrip() + "…" if len(fallback) > 40 else fallback + try: + await _check_session_access(request.session_id, user) + await session_manager.update_session_title(request.session_id, title) + except Exception: + logger.debug( + "Skipping fallback title persistence for missing session %s", + request.session_id, + ) + return {"title": title} + + +@router.post("/session", response_model=SessionResponse) +async def create_session( + request: Request, user: dict = Depends(get_current_user) +) -> SessionResponse: + """Create a new agent session bound to the authenticated user. + + The user's HF access token is extracted from the Authorization header + and stored in the session so that tools (e.g. hf_jobs) can act on + behalf of the user. + + Optional body ``{"model"?: }`` selects the session's LLM; unknown + ids are rejected (400). Empty requests use the plan-aware web default. + + Returns 503 if the server or user has reached the session limit. + """ + # Extract the user's HF token (Bearer header, HttpOnly cookie, or env var) + hf_token = resolve_hf_request_token(request) + + # Optional model override. Empty body falls back to the config default. + model: str | None = None + try: + body = await request.json() + except Exception: + body = None + if isinstance(body, dict): + model = body.get("model") + + _validate_model_id(model) + + # Empty requests use the plan-aware web default. + model = await _model_override_for_new_session(model, user) + + try: + session_id = await session_manager.create_session( + user_id=user["user_id"], + hf_username=user.get("username"), + hf_token=hf_token, + user_plan=user.get("plan"), + model=model, + is_pro=user.get("plan") == "pro", + ) + except SessionCapacityError as e: + raise HTTPException(status_code=503, detail=str(e)) + + await _reset_usage_window(session_id) + + return SessionResponse( + session_id=session_id, + ready=True, + model=model, + ) + + +@router.post("/session/restore-summary", response_model=SessionResponse) +async def restore_session_summary( + request: Request, body: dict, user: dict = Depends(get_current_user) +) -> SessionResponse: + """Create a new session seeded with a summary of the caller's prior + conversation. The client sends its cached messages; we run the standard + summarization prompt on them and drop the result into the new + session's context as a user-role system note. + + Optional ``"model"`` in the body overrides the session's LLM; otherwise + the new session uses the plan-aware web default. + """ + messages = body.get("messages") + if not isinstance(messages, list) or not messages: + raise HTTPException(status_code=400, detail="Missing 'messages' array") + + hf_token = resolve_hf_request_token(request) + + model = body.get("model") + _validate_model_id(model) + + model = await _model_override_for_new_session(model, user) + + try: + session_id = await session_manager.create_session( + user_id=user["user_id"], + hf_username=user.get("username"), + hf_token=hf_token, + user_plan=user.get("plan"), + model=model, + is_pro=user.get("plan") == "pro", + ) + except SessionCapacityError as e: + raise HTTPException(status_code=503, detail=str(e)) + + await _reset_usage_window(session_id) + + await _check_session_access( + session_id, + user, + request, + preload_sandbox=False, + ) + try: + summarized = await session_manager.seed_from_summary(session_id, messages) + except ValueError as e: + raise HTTPException(status_code=500, detail=str(e)) + except Exception as e: + logger.exception("seed_from_summary failed") + raise HTTPException(status_code=500, detail=f"Summary failed: {e}") + + logger.info( + f"Seeded session {session_id} for {user.get('username', 'unknown')} " + f"(summary of {summarized} messages)" + ) + return SessionResponse( + session_id=session_id, + ready=True, + model=model, + ) + + +@router.get("/session/{session_id}", response_model=SessionInfo) +async def get_session( + session_id: str, user: dict = Depends(get_current_user) +) -> SessionInfo: + """Get session information. Only accessible by the session owner.""" + await _check_session_access(session_id, user) + info = session_manager.get_session_info(session_id) + return SessionInfo(**info) + + +@router.post("/session/{session_id}/activate", response_model=SessionInfo) +async def activate_session( + session_id: str, + request: Request, + user: dict = Depends(get_current_user), +) -> SessionInfo: + """Mark a session as actively revisited and reset its usage meter window.""" + await _check_session_access(session_id, user, request) + info = await _reset_usage_window(session_id) + if not info: + raise HTTPException(status_code=404, detail="Session not found") + return SessionInfo(**info) + + +@router.post("/session/{session_id}/model") +async def set_session_model( + session_id: str, + body: dict, + request: Request, + user: dict = Depends(get_current_user), +) -> dict: + """Switch the active model for a single session (tab-scoped). + + Takes effect on the next LLM call in that session β€” other sessions + (including other browser tabs) are unaffected. + """ + agent_session = await _check_session_access(session_id, user, request) + model_id = body.get("model") + if not model_id: + raise HTTPException(status_code=400, detail="Missing 'model' field") + _validate_model_id(model_id) + if not agent_session: + raise HTTPException(status_code=404, detail="Session not found") + await session_manager.update_session_model(session_id, model_id) + logger.info( + f"Session {session_id} model β†’ {model_id} " + f"(by {user.get('username', 'unknown')})" + ) + return {"session_id": session_id, "model": model_id} + + +@router.post("/session/{session_id}/notifications") +async def set_session_notifications( + session_id: str, + body: SessionNotificationsRequest, + user: dict = Depends(get_current_user), +) -> dict: + """Replace the session's auto-notification destinations.""" + agent_session = await _check_session_access(session_id, user) + try: + destinations = session_manager.set_notification_destinations( + session_id, body.destinations + ) + except ValueError as e: + raise HTTPException(status_code=400, detail=str(e)) + await session_manager.persist_session_snapshot(agent_session) + return { + "session_id": session_id, + "notification_destinations": destinations, + } + + +@router.post("/session/{session_id}/datasets", response_model=DatasetUploadResponse) +async def upload_session_dataset( + session_id: str, + request: Request, + user: dict = Depends(get_current_user), +) -> DatasetUploadResponse: + """Upload a CSV/JSON dataset file to a private Hub dataset for this session.""" + file: UploadFile | None = None + try: + _reject_oversize_dataset_upload(request) + agent_session = await _check_session_access(session_id, user, request) + if not agent_session or not agent_session.is_active: + raise HTTPException(status_code=404, detail="Session not found") + if agent_session.is_processing: + raise HTTPException( + status_code=409, + detail="Cannot upload a dataset while the agent is processing.", + ) + if agent_session.session.pending_approval: + raise HTTPException( + status_code=409, + detail="Resolve pending approvals before uploading a dataset.", + ) + + hf_token = ( + resolve_hf_request_token(request, include_env_fallback=False) + or _user_hf_token(user) + or resolve_hf_request_token(request) + ) + if not hf_token: + raise HTTPException( + status_code=401, + detail="A Hugging Face token is required to upload datasets.", + ) + + form = await request.form( + max_files=1, + max_fields=1, + max_part_size=MAX_DATASET_UPLOAD_BYTES, + ) + file = _dataset_upload_file_from_form(form) + hf_username = user.get("username") or agent_session.hf_username + uploaded = await push_dataset_upload_to_hub( + upload=file, + session_id=session_id, + hf_username=hf_username, + hf_token=hf_token, + ) + agent_session.session.context_manager.add_message( + Message(role="user", content=dataset_context_note(uploaded)) + ) + session_manager._touch(agent_session) + await session_manager.persist_session_snapshot(agent_session) + logger.info( + "Uploaded dataset file %s to %s for session %s", + uploaded.filename, + uploaded.repo_id, + session_id, + ) + return DatasetUploadResponse(**uploaded.response_payload()) + except HTTPException: + raise + except HfHubHTTPError as e: + logger.warning( + "Hub rejected dataset upload for session %s: status=%s request_id=%s", + session_id, + getattr(e.response, "status_code", None), + getattr(e, "request_id", None), + ) + raise _dataset_upload_hub_http_exception(e) + except Exception: + logger.exception("Dataset upload failed for session %s", session_id) + raise HTTPException( + status_code=502, + detail="Dataset upload failed. Please try again.", + ) + finally: + if file is not None: + await file.close() + + +@router.patch("/session/{session_id}/yolo") +async def set_session_yolo( + session_id: str, + body: SessionYoloRequest, + user: dict = Depends(get_current_user), +) -> dict: + """Update the session-scoped auto-approval policy.""" + await _check_session_access(session_id, user) + try: + summary = await session_manager.update_session_auto_approval( + session_id, + enabled=body.enabled, + cost_cap_usd=body.cost_cap_usd, + cap_provided="cost_cap_usd" in body.model_fields_set, + ) + except ValueError as e: + raise HTTPException(status_code=400, detail=str(e)) + return {"session_id": session_id, **summary} + + +@router.get("/user/jobs-access") +async def get_jobs_access_info( + request: Request, user: dict = Depends(get_current_user) +) -> dict: + """Return the namespaces the current token can run HF Jobs under. + + Credits are enforced by the HF API at job-creation time, not here β€” + the response only describes which wallets the caller is allowed to + pick from. Pro is irrelevant. + """ + token = resolve_hf_request_token(request) + + access = await get_jobs_access(token or "") + return { + "eligible_namespaces": access.eligible_namespaces if access else [], + "default_namespace": access.default_namespace if access else None, + "billing_url": "https://huggingface.co/settings/billing", + } + + +@router.get("/usage", response_model=UsageResponse) +async def get_usage( + request: Request, + session_id: str | None = None, + tz: str | None = None, + user: dict = Depends(get_current_user), +) -> dict: + """Return app-attributed usage for the current user.""" + if session_id: + await _check_session_access( + session_id, + user, + request, + preload_sandbox=False, + ) + usage = await build_usage_response( + session_manager, + user_id=user["user_id"], + hf_token=( + resolve_hf_request_token(request, include_env_fallback=False) + or _user_hf_token(user) + or resolve_hf_request_token(request) + ), + session_id=session_id, + timezone_name=tz, + ) + if session_id: + auto_approval = ( + await session_manager.reconcile_session_auto_approval_from_usage( + session_id, + usage, + ) + ) + if auto_approval is not None: + usage["auto_approval"] = auto_approval + return usage + + +@router.get("/sessions", response_model=list[SessionInfo]) +async def list_sessions(user: dict = Depends(get_current_user)) -> list[SessionInfo]: + """List sessions belonging to the authenticated user.""" + sessions = await session_manager.list_sessions(user_id=user["user_id"]) + return [SessionInfo(**s) for s in sessions] + + +@router.post("/session/{session_id}/sandbox/teardown") +async def teardown_session_sandbox( + session_id: str, user: dict = Depends(get_current_user) +) -> dict: + """Best-effort sandbox teardown that preserves durable chat history.""" + await _check_session_access(session_id, user, preload_sandbox=False) + task = asyncio.create_task(session_manager.teardown_sandbox(session_id)) + _background_route_tasks.add(task) + task.add_done_callback(_background_route_tasks.discard) + return {"status": "teardown_requested", "session_id": session_id} + + +@router.delete("/session/{session_id}") +async def delete_session( + session_id: str, user: dict = Depends(get_current_user) +) -> dict: + """Delete a session. Only accessible by the session owner.""" + await _check_session_access(session_id, user, preload_sandbox=False) + success = await session_manager.delete_session(session_id) + if not success: + raise HTTPException(status_code=404, detail="Session not found") + return {"status": "deleted", "session_id": session_id} + + +@router.post("/submit") +async def submit_input( + request: Request, user: dict = Depends(get_current_user) +) -> dict: + """Submit user input to a session. Only accessible by the session owner.""" + # Parse the body manually so session ownership can be checked before the + # text-length constraints fire β€” otherwise a non-owner sending an empty + # or oversized text gets a 422 leaking the constraint instead of the 404 + # they'd get for any other access to a session they don't own. + try: + payload = await request.json() + except (json.JSONDecodeError, TypeError) as exc: + raise HTTPException(status_code=422, detail=str(exc)) + if not isinstance(payload, dict): + raise HTTPException(status_code=422, detail="Body must be a JSON object") + raw_session_id = payload.get("session_id") + if not isinstance(raw_session_id, str) or not raw_session_id: + raise RequestValidationError( + [ + { + "type": "missing", + "loc": ("body", "session_id"), + "msg": "Field required", + "input": payload, + } + ] + ) + await _check_session_access(raw_session_id, user) + try: + body = SubmitRequest(**payload) + except ValidationError as exc: + raise RequestValidationError(exc.errors()) from exc + success = await session_manager.submit_user_input(body.session_id, body.text) + if not success: + raise HTTPException(status_code=404, detail="Session not found or inactive") + return {"status": "submitted", "session_id": body.session_id} + + +@router.post("/approve") +async def submit_approval( + request: ApprovalRequest, user: dict = Depends(get_current_user) +) -> dict: + """Submit tool approvals to a session. Only accessible by the session owner.""" + await _check_session_access(request.session_id, user) + approvals = [ + { + "tool_call_id": a.tool_call_id, + "approved": a.approved, + "feedback": a.feedback, + "edited_script": a.edited_script, + "namespace": a.namespace, + } + for a in request.approvals + ] + success = await session_manager.submit_approval(request.session_id, approvals) + if not success: + raise HTTPException(status_code=404, detail="Session not found or inactive") + return {"status": "submitted", "session_id": request.session_id} + + +@router.post("/chat/{session_id}") +async def chat_sse( + session_id: str, + request: Request, + user: dict = Depends(get_current_user), +) -> StreamingResponse: + """SSE endpoint: submit input or approval, then stream events until turn ends.""" + agent_session = await _check_session_access(session_id, user, request) + if not agent_session or not agent_session.is_active: + raise HTTPException(status_code=404, detail="Session not found or inactive") + + # Parse body + body = await request.json() + + # Subscribe BEFORE submitting so we never miss events β€” even if the + # agent loop processes the submission before this coroutine continues. + broadcaster = agent_session.broadcaster + sub_id, event_queue = broadcaster.subscribe() + + # Submit the operation + text = body.get("text") + approvals = body.get("approvals") + + try: + if approvals: + formatted = [ + { + "tool_call_id": a["tool_call_id"], + "approved": a["approved"], + "feedback": a.get("feedback"), + "edited_script": a.get("edited_script"), + "namespace": a.get("namespace"), + } + for a in approvals + ] + success = await session_manager.submit_approval(session_id, formatted) + elif text is not None: + success = await session_manager.submit_user_input(session_id, text) + else: + broadcaster.unsubscribe(sub_id) + raise HTTPException( + status_code=400, detail="Must provide 'text' or 'approvals'" + ) + + if not success: + broadcaster.unsubscribe(sub_id) + raise HTTPException(status_code=404, detail="Session not found or inactive") + except HTTPException: + broadcaster.unsubscribe(sub_id) + raise + except Exception: + broadcaster.unsubscribe(sub_id) + raise + + return _sse_response(broadcaster, event_queue, sub_id) + + +@router.post("/pro-click/{session_id}") +async def record_pro_click( + session_id: str, + body: dict, + user: dict = Depends(get_current_user), +) -> dict: + """Record a click on a Pro upgrade CTA shown from inside a session.""" + agent_session = await _check_session_access(session_id, user) + + from agent.core import telemetry + + await telemetry.record_pro_cta_click( + agent_session.session, + source=str(body.get("source") or "unknown"), + target=str(body.get("target") or "pro_pricing"), + ) + if agent_session.session.config.save_sessions: + _schedule_usage_refresh_and_upload( + agent_session, + error_code="pro_click_billing_snapshot_error", + ) + return {"status": "ok"} + + +# --------------------------------------------------------------------------- +# Shared SSE helpers +# --------------------------------------------------------------------------- +_TERMINAL_EVENTS = { + "turn_complete", + "approval_required", + "error", + "interrupted", + "shutdown", +} +_SSE_KEEPALIVE_SECONDS = 15 + + +def _last_event_seq(request: Request) -> int: + raw = ( + request.headers.get("last-event-id") or request.query_params.get("after") or "0" + ) + try: + return max(0, int(raw)) + except (TypeError, ValueError): + return 0 + + +def _format_sse(msg: dict[str, Any]) -> str: + seq = msg.get("seq") + body = {"event_type": msg.get("event_type"), "data": msg.get("data") or {}} + if seq is not None: + body["seq"] = seq + return f"id: {seq}\ndata: {json.dumps(body)}\n\n" + return f"data: {json.dumps(body)}\n\n" + + +def _event_doc_to_msg(doc: dict[str, Any]) -> dict[str, Any]: + return { + "event_type": doc.get("event_type"), + "data": doc.get("data") or {}, + "seq": doc.get("seq"), + } + + +def _sse_response( + broadcaster, + event_queue, + sub_id, + *, + replay_events: list[dict[str, Any]] | None = None, + after_seq: int = 0, +) -> StreamingResponse: + """Build a StreamingResponse that drains *event_queue* as SSE, + sending keepalive comments every 15 s to prevent proxy timeouts.""" + + async def event_generator(): + try: + for doc in replay_events or []: + msg = _event_doc_to_msg(doc) + seq = msg.get("seq") + if isinstance(seq, int) and seq <= after_seq: + continue + yield _format_sse(msg) + if msg.get("event_type", "") in _TERMINAL_EVENTS: + return + + while True: + try: + msg = await asyncio.wait_for( + event_queue.get(), timeout=_SSE_KEEPALIVE_SECONDS + ) + except asyncio.TimeoutError: + # SSE comment β€” ignored by parsers, keeps connection alive + yield ": keepalive\n\n" + continue + event_type = msg.get("event_type", "") + yield _format_sse(msg) + if event_type in _TERMINAL_EVENTS: + break + finally: + broadcaster.unsubscribe(sub_id) + + return StreamingResponse( + event_generator(), + media_type="text/event-stream", + headers={ + "Cache-Control": "no-cache", + "Connection": "keep-alive", + "X-Accel-Buffering": "no", + }, + ) + + +@router.get("/events/{session_id}") +async def subscribe_events( + session_id: str, + request: Request, + user: dict = Depends(get_current_user), +) -> StreamingResponse: + """Subscribe to events for a running session without submitting new input. + + Used by the frontend to re-attach after a connection drop (e.g. screen + sleep). Returns 404 if the session isn't active or isn't processing. + """ + agent_session = await _check_session_access(session_id, user, request) + if not agent_session or not agent_session.is_active: + raise HTTPException(status_code=404, detail="Session not found or inactive") + + after_seq = _last_event_seq(request) + replay_events = await session_manager._store().load_events_after( + session_id, after_seq + ) + broadcaster = agent_session.broadcaster + sub_id, event_queue = broadcaster.subscribe() + return _sse_response( + broadcaster, + event_queue, + sub_id, + replay_events=replay_events, + after_seq=after_seq, + ) + + +@router.post("/interrupt/{session_id}") +async def interrupt_session( + session_id: str, user: dict = Depends(get_current_user) +) -> dict: + """Interrupt the current operation in a session.""" + await _check_session_access(session_id, user) + success = await session_manager.interrupt(session_id) + if not success: + raise HTTPException(status_code=404, detail="Session not found or inactive") + return {"status": "interrupted", "session_id": session_id} + + +@router.get("/session/{session_id}/messages") +async def get_session_messages( + session_id: str, user: dict = Depends(get_current_user) +) -> list[dict]: + """Return the session's message history from memory.""" + agent_session = await _check_session_access(session_id, user) + if not agent_session or not agent_session.is_active: + raise HTTPException(status_code=404, detail="Session not found or inactive") + return [ + msg.model_dump(mode="json") + for msg in agent_session.session.context_manager.items + ] + + +@router.post("/undo/{session_id}") +async def undo_session(session_id: str, user: dict = Depends(get_current_user)) -> dict: + """Undo the last turn in a session.""" + await _check_session_access(session_id, user) + success = await session_manager.undo(session_id) + if not success: + raise HTTPException(status_code=404, detail="Session not found or inactive") + return {"status": "undo_requested", "session_id": session_id} + + +@router.post("/truncate/{session_id}") +async def truncate_session( + session_id: str, + request: Request, + user: dict = Depends(get_current_user), +) -> dict: + """Truncate conversation to before a specific user message.""" + # Check session ownership before parsing the request body so a 404 on a + # non-existent / non-owned session_id beats the 422 schema-validation error + # (otherwise the response leaks the required field name to non-owners). + await _check_session_access(session_id, user) + try: + body = TruncateRequest(**(await request.json())) + except ValidationError as exc: + # Re-raise as RequestValidationError so FastAPI returns its standard + # structured 422 schema (`{"detail": [{"type":..., "loc":..., ...}]}`) + # instead of a string-stringified Pydantic dump. + raise RequestValidationError(exc.errors()) from exc + except (json.JSONDecodeError, TypeError) as exc: + raise HTTPException(status_code=422, detail=str(exc)) + success = await session_manager.truncate(session_id, body.user_message_index) + if not success: + raise HTTPException( + status_code=404, + detail="Session not found, inactive, or message index out of range", + ) + return {"status": "truncated", "session_id": session_id} + + +@router.post("/compact/{session_id}") +async def compact_session( + session_id: str, user: dict = Depends(get_current_user) +) -> dict: + """Compact the context in a session.""" + await _check_session_access(session_id, user) + success = await session_manager.compact(session_id) + if not success: + raise HTTPException(status_code=404, detail="Session not found or inactive") + return {"status": "compact_requested", "session_id": session_id} + + +@router.post("/shutdown/{session_id}") +async def shutdown_session( + session_id: str, user: dict = Depends(get_current_user) +) -> dict: + """Shutdown a session.""" + await _check_session_access(session_id, user) + success = await session_manager.shutdown_session(session_id) + if not success: + raise HTTPException(status_code=404, detail="Session not found or inactive") + return {"status": "shutdown_requested", "session_id": session_id} + + +@router.post("/feedback/{session_id}") +async def submit_feedback( + session_id: str, + body: dict, + user: dict = Depends(get_current_user), +) -> dict: + """Attach a user feedback signal to a session's event log. + + Body: {rating: "up"|"down"|"outcome_success"|"outcome_fail", + turn_index?: int, comment?: str, message_id?: str} + Appended as a `feedback` event and saved with the session trajectory. + """ + agent_session = await _check_session_access(session_id, user) + + rating = body.get("rating") + if rating not in {"up", "down", "outcome_success", "outcome_fail"}: + raise HTTPException(status_code=400, detail="invalid rating") + + from agent.core import telemetry + + await telemetry.record_feedback( + agent_session.session, + rating=rating, + turn_index=body.get("turn_index"), + message_id=body.get("message_id"), + comment=body.get("comment"), + ) + # Fire-and-forget save so feedback reaches the dataset even if the user + # closes the tab right after clicking. + if agent_session.session.config.save_sessions: + _schedule_usage_refresh_and_upload( + agent_session, + error_code="feedback_billing_snapshot_error", + ) + return {"status": "ok"} diff --git a/backend/routes/auth.py b/backend/routes/auth.py new file mode 100644 index 0000000000000000000000000000000000000000..d736deff1841dcc89594f2abb8728bc7306741f5 --- /dev/null +++ b/backend/routes/auth.py @@ -0,0 +1,208 @@ +"""Authentication routes for HF OAuth. + +Handles the OAuth 2.0 authorization code flow with HF as provider. +After successful auth, sets an HttpOnly cookie with the access token. +""" + +import logging +import os +import secrets +import time +from urllib.parse import urlencode + +import httpx +from dependencies import ( + AUTH_ENABLED, + OAUTH_SCOPE_COOKIE, + REQUIRED_OAUTH_SCOPES, + configured_oauth_scopes, + get_current_user, + oauth_scope_fingerprint, +) +from fastapi import APIRouter, Depends, HTTPException, Request +from fastapi.responses import RedirectResponse + +router = APIRouter(prefix="/auth", tags=["auth"]) +logger = logging.getLogger(__name__) + +# OAuth configuration from environment +OAUTH_CLIENT_ID = os.environ.get("OAUTH_CLIENT_ID", "") +OAUTH_CLIENT_SECRET = os.environ.get("OAUTH_CLIENT_SECRET", "") +OPENID_PROVIDER_URL = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface.co") +OAUTH_SCOPES = configured_oauth_scopes() + +# In-memory OAuth state store with expiry (5 min TTL) +_OAUTH_STATE_TTL = 300 +oauth_states: dict[str, dict] = {} + + +def _missing_required_scopes(token_data: dict) -> set[str]: + raw_scopes = token_data.get("scope") + if not isinstance(raw_scopes, str) or not raw_scopes.strip(): + logger.debug("OAuth token response omitted a usable scope field") + return set() + granted = set(raw_scopes.split()) + return set(REQUIRED_OAUTH_SCOPES) - granted + + +def _cleanup_expired_states() -> None: + """Remove expired OAuth states to prevent memory growth.""" + now = time.time() + expired = [k for k, v in oauth_states.items() if now > v.get("expires_at", 0)] + for k in expired: + del oauth_states[k] + + +def get_redirect_uri(request: Request) -> str: + """Get the OAuth callback redirect URI.""" + # In HF Spaces, use the SPACE_HOST if available + space_host = os.environ.get("SPACE_HOST") + if space_host: + return f"https://{space_host}/auth/callback" + # Otherwise construct from request + return str(request.url_for("oauth_callback")) + + +@router.get("/login") +async def oauth_login(request: Request) -> RedirectResponse: + """Initiate OAuth login flow.""" + if not OAUTH_CLIENT_ID: + raise HTTPException( + status_code=500, + detail="OAuth not configured. Set OAUTH_CLIENT_ID environment variable.", + ) + + # Clean up expired states to prevent memory growth + _cleanup_expired_states() + + # Generate state for CSRF protection + state = secrets.token_urlsafe(32) + oauth_states[state] = { + "redirect_uri": get_redirect_uri(request), + "expires_at": time.time() + _OAUTH_STATE_TTL, + } + + # Build authorization URL. We no longer suggest a default `orgIds` β€” + # users no longer need to join the ML Agent Explorers org to use the + # app, and HF Jobs are billed per-namespace via credits. + params = { + "client_id": OAUTH_CLIENT_ID, + "redirect_uri": get_redirect_uri(request), + "scope": " ".join(OAUTH_SCOPES), + "response_type": "code", + "state": state, + } + auth_url = f"{OPENID_PROVIDER_URL}/oauth/authorize?{urlencode(params)}" + + return RedirectResponse(url=auth_url) + + +@router.get("/callback") +async def oauth_callback( + request: Request, code: str = "", state: str = "" +) -> RedirectResponse: + """Handle OAuth callback.""" + # Verify state + if state not in oauth_states: + raise HTTPException(status_code=400, detail="Invalid state parameter") + + stored_state = oauth_states.pop(state) + redirect_uri = stored_state["redirect_uri"] + + if not code: + raise HTTPException(status_code=400, detail="No authorization code provided") + + # Exchange code for token + token_url = f"{OPENID_PROVIDER_URL}/oauth/token" + async with httpx.AsyncClient() as client: + try: + response = await client.post( + token_url, + data={ + "grant_type": "authorization_code", + "code": code, + "redirect_uri": redirect_uri, + "client_id": OAUTH_CLIENT_ID, + "client_secret": OAUTH_CLIENT_SECRET, + }, + ) + response.raise_for_status() + token_data = response.json() + except httpx.HTTPError as e: + raise HTTPException(status_code=500, detail=f"Token exchange failed: {e}") + + # Get user info + access_token = token_data.get("access_token") + if not access_token: + raise HTTPException( + status_code=500, + detail="Token exchange succeeded but no access_token was returned.", + ) + missing_scopes = _missing_required_scopes(token_data) + if missing_scopes: + raise HTTPException( + status_code=403, + detail=( + "OAuth token is missing required scopes: " + + ", ".join(sorted(missing_scopes)) + ), + ) + + # Fetch user info (optional β€” failure is not fatal) + async with httpx.AsyncClient() as client: + try: + userinfo_response = await client.get( + f"{OPENID_PROVIDER_URL}/oauth/userinfo", + headers={"Authorization": f"Bearer {access_token}"}, + ) + userinfo_response.raise_for_status() + except httpx.HTTPError: + pass # user_info not required for auth flow + + # Set access token as HttpOnly cookie (not in URL β€” avoids leaks via + # Referrer headers, browser history, and server logs) + is_production = bool(os.environ.get("SPACE_HOST")) + response = RedirectResponse(url="/", status_code=302) + response.set_cookie( + key="hf_access_token", + value=access_token, + httponly=True, + secure=is_production, # Secure flag only in production (HTTPS) + samesite="lax", + max_age=3600 * 24 * 7, # 7 days + path="/", + ) + response.set_cookie( + key=OAUTH_SCOPE_COOKIE, + value=oauth_scope_fingerprint(OAUTH_SCOPES), + httponly=True, + secure=is_production, + samesite="lax", + max_age=3600 * 24 * 7, + path="/", + ) + return response + + +@router.get("/logout") +async def logout() -> RedirectResponse: + """Log out the user by clearing the auth cookie.""" + response = RedirectResponse(url="/") + response.delete_cookie(key="hf_access_token", path="/") + response.delete_cookie(key=OAUTH_SCOPE_COOKIE, path="/") + return response + + +@router.get("/status") +async def auth_status() -> dict: + """Check if OAuth is enabled on this instance.""" + return {"auth_enabled": AUTH_ENABLED} + + +@router.get("/me") +async def get_me(user: dict = Depends(get_current_user)) -> dict: + """Get current user info. Returns the authenticated user or dev user. + + Uses the shared auth dependency which handles cookie + Bearer token. + """ + return {key: value for key, value in user.items() if not key.startswith("_")} diff --git a/backend/routes/v1_responses.py b/backend/routes/v1_responses.py new file mode 100644 index 0000000000000000000000000000000000000000..ba5885f6ed574d90a35a7c9bd50b6616831dc1a7 --- /dev/null +++ b/backend/routes/v1_responses.py @@ -0,0 +1,858 @@ +"""OpenAI Responses-API-compatible developer API. + +POST /v1/responses create a run (sync, stream, or background) +GET /v1/responses/{id} poll status/output/artifacts +GET /v1/responses/{id}/events resumable SSE event stream +POST /v1/responses/{id}/cancel interrupt +POST /v1/responses/{id}/approvals resume a paused (cost-cap/tool) run + +One response = one agent turn. ``previous_response_id`` chains turns onto the +same underlying session. Auth: ``Authorization: Bearer `` (plain +user access tokens accepted). Runs auto-approve tools under a session- +cumulative ``max_cost_usd`` YOLO cap; when the cap would be exceeded the run +pauses with ``status="incomplete"`` until /approvals is called. +""" + +import asyncio +import logging +import time +from datetime import UTC, datetime +from typing import Any + +from dependencies import get_api_user +from fastapi import APIRouter, Depends, Request +from fastapi.responses import JSONResponse, StreamingResponse +from litellm import Message + +from models import V1ApprovalDecisionRequest, V1CreateResponseRequest +from openai_compat import ( + APPROVAL_EVENT, + HARD_TERMINAL_STATUS, + TERMINAL_RESPONSE_STATUSES, + V1APIError, + artifacts_from_event, + build_output_items, + build_response_object, + derive_turn_state, + extract_artifacts, + format_v1_sse, + merge_artifacts, + new_response_id, + translate_event, +) +from session_manager import ( + DEFAULT_YOLO_COST_CAP_USD, + AgentSession, + SessionCapacityError, + session_manager, +) +from usage import build_usage_response + +from agent.core.hf_tokens import resolve_hf_request_token + +logger = logging.getLogger(__name__) + +router = APIRouter(prefix="/v1", tags=["v1"]) + +_SSE_KEEPALIVE_SECONDS = 15 +_COLLECTION_FETCH_TIMEOUT_SECONDS = 10.0 +_background_v1_tasks: set[asyncio.Task] = set() + + +def _spawn(coro) -> None: + task = asyncio.create_task(coro) + _background_v1_tasks.add(task) + task.add_done_callback(_background_v1_tasks.discard) + + +def _store(): + return session_manager._store() + + +def _now() -> datetime: + return datetime.now(UTC) + + +# --------------------------------------------------------------------------- +# Shared helpers +# --------------------------------------------------------------------------- + + +async def _await_broadcaster(agent_session: AgentSession, timeout: float = 5.0): + """Wait for the session's broadcaster to come up. + + It is assigned inside the _run_session task, which may not have been + scheduled yet when create_session/ensure_session_loaded returns. + """ + deadline = time.monotonic() + timeout + while agent_session.broadcaster is None: + if time.monotonic() > deadline: + raise V1APIError( + 503, + "Session runtime failed to start. Please retry.", + code="session_unavailable", + error_type="server_error", + ) + await asyncio.sleep(0.01) + return agent_session.broadcaster + + +async def _load_owned_response( + response_id: str, user: dict[str, Any] +) -> dict[str, Any]: + doc = await _store().load_api_response(response_id) + if not doc: + raise V1APIError( + 404, + f"No response found with id '{response_id}'.", + code="response_not_found", + ) + owner = str(doc.get("user_id") or "") + if user["user_id"] != "dev" and owner not in {user["user_id"], "dev"}: + # Same 404 as missing so response ids can't be probed. + raise V1APIError( + 404, + f"No response found with id '{response_id}'.", + code="response_not_found", + ) + return doc + + +async def _load_session_for_doc( + doc: dict[str, Any], + user: dict[str, Any], + hf_token: str | None, + *, + preload_sandbox: bool = True, +) -> AgentSession | None: + return await session_manager.ensure_session_loaded( + str(doc.get("session_id")), + user["user_id"], + hf_token=hf_token, + hf_username=user.get("username"), + user_plan=user.get("plan"), + preload_sandbox=preload_sandbox, + ) + + +async def _collection_artifacts(agent_session: AgentSession) -> list[dict[str, Any]]: + """Artifacts registered on the session's Hub collection (best-effort). + + Catches repos created *inside* HF Jobs, which never produce in-process + events β€” the sitecustomize hooks register them on the Hub collection only. + """ + session = agent_session.session + slug = getattr(session, "_ml_intern_artifact_collection_slug", None) + if not slug: + return [] + token = agent_session.hf_token + + def _fetch() -> list[dict[str, Any]]: + from huggingface_hub import HfApi + + collection = HfApi(token=token).get_collection(slug) + found: list[dict[str, Any]] = [] + for item in getattr(collection, "items", None) or []: + item_type = getattr(item, "item_type", None) + item_id = getattr(item, "item_id", None) + if item_type in {"model", "dataset", "space"} and item_id: + prefix = {"model": "", "dataset": "datasets/", "space": "spaces/"}[ + item_type + ] + found.append( + { + "type": item_type, + "repo_id": item_id, + "url": f"https://huggingface.co/{prefix}{item_id}", + } + ) + found.append( + { + "type": "collection", + "slug": slug, + "url": f"https://huggingface.co/collections/{slug}", + } + ) + return found + + try: + return await asyncio.wait_for( + asyncio.to_thread(_fetch), timeout=_COLLECTION_FETCH_TIMEOUT_SECONDS + ) + except Exception as e: + logger.debug("Collection artifact fetch failed for %s: %s", slug, e) + return [] + + +async def _watch_response( + response_id: str, + agent_session: AgentSession, + sub_id: int, + queue: asyncio.Queue, +) -> None: + """Follow a turn to its terminal event and finalize the response doc. + + Subscribed before the submission, so it sees the full turn. Accumulates + the turn's events in memory and writes output/artifacts onto the doc at + terminal time β€” this keeps GET working even without Mongo (NoopStore). + The lazy derivation in GET is the fallback when this task dies (restart). + """ + store = _store() + broadcaster = agent_session.broadcaster + turn_events: list[dict[str, Any]] = [] + try: + while True: + msg = await queue.get() + event_type = str(msg.get("event_type") or "") + turn_events.append(msg) + if event_type == "processing": + await store.update_api_response_fields( + response_id, status="in_progress" + ) + continue + if event_type == APPROVAL_EVENT: + await store.update_api_response_fields( + response_id, + status="incomplete", + incomplete_details={ + "reason": "approval_required", + "approval": msg.get("data") or {}, + }, + output=build_output_items(turn_events), + artifacts=await _merged_doc_artifacts( + response_id, turn_events, agent_session=None + ), + ) + return + status = HARD_TERMINAL_STATUS.get(event_type) + if status is None: + continue + data = msg.get("data") or {} + fields: dict[str, Any] = { + "status": status, + "end_seq": msg.get("seq"), + "completed_at": _now(), + "incomplete_details": None, + "output": build_output_items(turn_events), + } + if status == "failed": + fields["error"] = { + "code": ( + "session_shutdown" + if event_type == "shutdown" + else "agent_error" + ), + "message": str(data.get("error") or event_type), + } + fields["artifacts"] = await _merged_doc_artifacts( + response_id, turn_events, agent_session=agent_session + ) + await store.update_api_response_fields(response_id, **fields) + return + except asyncio.CancelledError: + raise + except Exception as e: + logger.warning("Response watcher failed for %s: %s", response_id, e) + finally: + broadcaster.unsubscribe(sub_id) + + +async def _merged_doc_artifacts( + response_id: str, + turn_events: list[dict[str, Any]], + *, + agent_session: AgentSession | None, +) -> list[dict[str, Any]]: + artifacts = extract_artifacts(turn_events) + if agent_session is not None: + artifacts = merge_artifacts( + artifacts, await _collection_artifacts(agent_session) + ) + doc = await _store().load_api_response(response_id) + return merge_artifacts((doc or {}).get("artifacts"), artifacts) + + +def _events_in_range( + events: list[dict[str, Any]], doc: dict[str, Any] +) -> list[dict[str, Any]]: + """Clamp persisted events to the doc's turn (never leak a later turn).""" + end_seq = doc.get("end_seq") + if not isinstance(end_seq, int): + return events + return [ + e for e in events if not isinstance(e.get("seq"), int) or e["seq"] <= end_seq + ] + + +async def _session_usage( + doc: dict[str, Any], user: dict[str, Any], hf_token: str | None +) -> dict[str, Any] | None: + try: + usage = await build_usage_response( + session_manager, + user_id=user["user_id"], + hf_token=hf_token, + session_id=str(doc.get("session_id")), + ) + return usage.get("session") + except Exception as e: + logger.debug("Usage lookup failed for %s: %s", doc.get("_id"), e) + return None + + +async def _build_full_response( + doc: dict[str, Any], user: dict[str, Any], hf_token: str | None +) -> dict[str, Any]: + """Build the complete response object, lazily finalizing status. + + Pure event-log read β€” works without a live runtime session, so polling + survives Space restarts (HF Jobs keep running on HF infra regardless). + """ + store = _store() + session_id = str(doc.get("session_id")) + response_id = str(doc.get("_id")) + events = _events_in_range( + await store.load_events_after(session_id, int(doc.get("start_seq") or 0)), + doc, + ) + + status = doc.get("status") or "queued" + if status not in TERMINAL_RESPONSE_STATUSES: + state = derive_turn_state(events) + if state is not None: + updates: dict[str, Any] = { + "status": state["status"], + "error": state["error"], + "incomplete_details": state["incomplete_details"], + } + if state["status"] in TERMINAL_RESPONSE_STATUSES: + updates["end_seq"] = state["end_seq"] + if not doc.get("completed_at"): + updates["completed_at"] = _now() + doc = {**doc, **updates} + status = state["status"] + await store.update_api_response_fields(response_id, **updates) + elif getattr(store, "enabled", False): + # Mongo is on but the turn has no terminal event: either the run + # is live, or a restart killed it mid-turn. + agent_session = session_manager.sessions.get(session_id) + if agent_session is not None and agent_session.is_active: + if agent_session.session.pending_approval: + status = "incomplete" + elif agent_session.is_processing: + status = "in_progress" + # else keep the stored status (likely still "queued") + else: + updates = { + "status": "incomplete", + "incomplete_details": {"reason": "server_restart"}, + } + doc = {**doc, **updates} + status = "incomplete" + await store.update_api_response_fields(response_id, **updates) + # NoopStore: no events to derive from β€” trust the watcher-written doc. + + output = build_output_items(events) if events else None + artifacts = ( + merge_artifacts(doc.get("artifacts"), extract_artifacts(events)) + if events + else None + ) + usage = await _session_usage(doc, user, hf_token) + return build_response_object( + {**doc, "status": status}, + output=output, + artifacts=artifacts, + usage=usage, + ) + + +# --------------------------------------------------------------------------- +# SSE generators +# --------------------------------------------------------------------------- + + +def _is_stream_terminal(event_type: str) -> bool: + return event_type in HARD_TERMINAL_STATUS or event_type == APPROVAL_EVENT + + +def _sse_headers() -> dict[str, str]: + return { + "Cache-Control": "no-cache", + "Connection": "keep-alive", + "X-Accel-Buffering": "no", + } + + +def _translated_frames( + msg: dict[str, Any], + response_id: str, + artifacts_acc: list[dict[str, Any]], +) -> list[str]: + """Translate one internal event, accumulating artifacts as we go and + enriching terminal frames with everything collected so far.""" + event_type = str(msg.get("event_type") or "") + artifacts_acc.extend(artifacts_from_event(event_type, msg.get("data") or {})) + frames: list[str] = [] + for name, payload in translate_event(msg, response_id): + if _is_stream_terminal(event_type): + payload = {**payload, "artifacts": merge_artifacts([], artifacts_acc)} + frames.append(format_v1_sse(name, payload)) + return frames + + +def _live_stream_response( + response_id: str, + broadcaster, + queue: asyncio.Queue, + sub_id: int, + *, + created_payload: dict[str, Any] | None = None, + replay: list[dict[str, Any]] | None = None, + after_seq: int = 0, + attach_live: bool = True, +) -> StreamingResponse: + async def generator(): + artifacts_acc: list[dict[str, Any]] = [] + last_seq = after_seq + try: + if created_payload is not None: + yield format_v1_sse("response.created", created_payload) + for doc_event in replay or []: + seq = doc_event.get("seq") + if isinstance(seq, int): + if seq <= after_seq: + continue + last_seq = max(last_seq, seq) + msg = { + "event_type": doc_event.get("event_type"), + "data": doc_event.get("data") or {}, + "seq": seq, + } + for frame in _translated_frames(msg, response_id, artifacts_acc): + yield frame + if HARD_TERMINAL_STATUS.get(str(msg["event_type"])): + return + if not attach_live: + return + while True: + try: + msg = await asyncio.wait_for( + queue.get(), timeout=_SSE_KEEPALIVE_SECONDS + ) + except asyncio.TimeoutError: + yield ": keepalive\n\n" + continue + seq = msg.get("seq") + if isinstance(seq, int) and seq <= last_seq: + continue # already replayed from the persisted log + for frame in _translated_frames(msg, response_id, artifacts_acc): + yield frame + if _is_stream_terminal(str(msg.get("event_type") or "")): + return + finally: + broadcaster.unsubscribe(sub_id) + + return StreamingResponse( + generator(), media_type="text/event-stream", headers=_sse_headers() + ) + + +# --------------------------------------------------------------------------- +# POST /v1/responses +# --------------------------------------------------------------------------- + + +async def _resolve_session_for_create( + body: V1CreateResponseRequest, + user: dict[str, Any], + hf_token: str | None, +) -> tuple[str, AgentSession]: + if body.previous_response_id: + prev = await _load_owned_response(body.previous_response_id, user) + agent_session = await _load_session_for_doc(prev, user, hf_token) + if agent_session is None or not agent_session.is_active: + raise V1APIError( + 404, + "The session behind previous_response_id is no longer available.", + code="previous_response_unavailable", + ) + return str(prev["session_id"]), agent_session + + # Model validation mirrors the web API (routes/agent.py owns the list). + from routes.agent import _default_model_for_user, _validate_model_id + + try: + _validate_model_id(body.model) + except Exception: + raise V1APIError(400, f"Unknown model: {body.model}", code="model_not_found") + model = body.model or _default_model_for_user(user) + try: + session_id = await session_manager.create_session( + user_id=user["user_id"], + hf_username=user.get("username"), + hf_token=hf_token, + user_plan=user.get("plan"), + model=model, + is_pro=user.get("plan") == "pro", + surface="api", + ) + except SessionCapacityError as e: + status_code = 429 if e.error_type == "per_user" else 503 + raise V1APIError( + status_code, str(e), code="capacity_exceeded", error_type="rate_limit_error" + ) + await session_manager.reset_session_usage_window( + session_id, started_at=datetime.utcnow() + ) + agent_session = session_manager.sessions[session_id] + return session_id, agent_session + + +def _submission_text(body: V1CreateResponseRequest, session) -> str: + if isinstance(body.input, str): + text = body.input + else: + if not body.input: + raise V1APIError( + 400, "input must not be an empty list.", code="empty_input" + ) + # All-but-last messages become context; the last is the submission. + for message in body.input[:-1]: + role = message.role + content = message.content + if role in {"system", "developer"}: + role, content = "user", f"[Developer note] {content}" + session.context_manager.add_message(Message(role=role, content=content)) + text = body.input[-1].content + if body.instructions: + text = f"[Developer instructions for this task: {body.instructions}]\n\n{text}" + return text + + +async def _wait_for_stream_terminal( + queue: asyncio.Queue, timeout_seconds: float +) -> None: + """Wait until the turn pauses/ends or the timeout elapses (sync mode).""" + deadline = time.monotonic() + timeout_seconds + while True: + remaining = deadline - time.monotonic() + if remaining <= 0: + return + try: + msg = await asyncio.wait_for(queue.get(), timeout=remaining) + except asyncio.TimeoutError: + return + if _is_stream_terminal(str(msg.get("event_type") or "")): + return + + +@router.post("/responses") +async def create_response( + body: V1CreateResponseRequest, + request: Request, + user: dict = Depends(get_api_user), +): + hf_token = resolve_hf_request_token(request) + session_id, agent_session = await _resolve_session_for_create(body, user, hf_token) + + if agent_session.is_processing: + raise V1APIError( + 409, + "The previous response on this session is still running. Wait for " + "it to finish (poll GET /v1/responses/{id}) before chaining.", + code="previous_response_still_running", + ) + if agent_session.session.pending_approval: + raise V1APIError( + 409, + "This session is paused on an approval. Resolve it via " + "POST /v1/responses/{id}/approvals on the paused response first.", + code="approval_pending", + ) + + # Headless approval policy: YOLO auto-approval under a cumulative cap. + cap_provided = "max_cost_usd" in body.model_fields_set + try: + approval_summary = await session_manager.update_session_auto_approval( + session_id, + enabled=True, + cost_cap_usd=body.max_cost_usd, + cap_provided=cap_provided, + ) + except ValueError as e: + raise V1APIError(409, str(e), code="session_unavailable") + effective_cap = approval_summary.get("cost_cap_usd", DEFAULT_YOLO_COST_CAP_USD) + + text = _submission_text(body, agent_session.session) + + store = _store() + start_seq = await store.current_event_seq(session_id) + response_id = new_response_id() + doc: dict[str, Any] = { + "_id": response_id, + "session_id": session_id, + "user_id": user["user_id"], + "model": agent_session.session.config.model_name, + "background": body.background, + "max_cost_usd": effective_cap, + "instructions": body.instructions, + "previous_response_id": body.previous_response_id, + "input_preview": text[:500], + "status": "queued", + "start_seq": start_seq, + "end_seq": None, + "error": None, + "incomplete_details": None, + "metadata": body.metadata or {}, + "created_at": _now(), + "completed_at": None, + } + await store.upsert_api_response(doc) + + # Subscribe BEFORE submitting so neither the watcher nor the stream can + # miss events (same pattern as the web chat SSE route). + broadcaster = await _await_broadcaster(agent_session) + watch_sub_id, watch_queue = broadcaster.subscribe() + stream_sub_id: int | None = None + stream_queue: asyncio.Queue | None = None + if body.stream or not body.background: + stream_sub_id, stream_queue = broadcaster.subscribe() + + success = await session_manager.submit_user_input(session_id, text) + if not success: + broadcaster.unsubscribe(watch_sub_id) + if stream_sub_id is not None: + broadcaster.unsubscribe(stream_sub_id) + await store.update_api_response_fields( + response_id, + status="failed", + error={"code": "submit_failed", "message": "Session not found or inactive"}, + ) + raise V1APIError( + 409, "Session not found or inactive.", code="session_unavailable" + ) + + _spawn(_watch_response(response_id, agent_session, watch_sub_id, watch_queue)) + + if body.stream: + return _live_stream_response( + response_id, + broadcaster, + stream_queue, + stream_sub_id, + created_payload={"response": build_response_object(doc)}, + ) + + if body.background: + return JSONResponse(build_response_object(doc)) + + # Synchronous mode: wait (bounded) for the turn to end, then return the + # full response object. On timeout the run keeps going server-side and + # the caller falls back to polling. + try: + await _wait_for_stream_terminal(stream_queue, body.wait_timeout_seconds) + finally: + broadcaster.unsubscribe(stream_sub_id) + # The watcher runs on its own subscription; give it a beat to finalize the + # doc so the synchronous return reflects the terminal state (matters for + # the NoopStore, where there is no event log to lazily derive from). + fresh = doc + for _ in range(20): + fresh = await store.load_api_response(response_id) or doc + if fresh.get("status") in TERMINAL_RESPONSE_STATUSES or fresh.get( + "incomplete_details" + ): + break + await asyncio.sleep(0.1) + return JSONResponse(await _build_full_response(fresh, user, hf_token)) + + +# --------------------------------------------------------------------------- +# GET /v1/responses/{response_id} +# --------------------------------------------------------------------------- + + +@router.get("/responses/{response_id}") +async def get_response( + response_id: str, + request: Request, + user: dict = Depends(get_api_user), +): + doc = await _load_owned_response(response_id, user) + hf_token = resolve_hf_request_token(request) + return JSONResponse(await _build_full_response(doc, user, hf_token)) + + +# --------------------------------------------------------------------------- +# GET /v1/responses/{response_id}/events +# --------------------------------------------------------------------------- + + +def _starting_after(request: Request, doc: dict[str, Any]) -> int: + raw = ( + request.query_params.get("starting_after") + or request.headers.get("last-event-id") + or "0" + ) + try: + requested = max(0, int(raw)) + except (TypeError, ValueError): + requested = 0 + return max(int(doc.get("start_seq") or 0), requested) + + +@router.get("/responses/{response_id}/events") +async def stream_response_events( + response_id: str, + request: Request, + user: dict = Depends(get_api_user), +): + doc = await _load_owned_response(response_id, user) + session_id = str(doc.get("session_id")) + after_seq = _starting_after(request, doc) + + finished = doc.get("status") in TERMINAL_RESPONSE_STATUSES + + # Live attach (subscribe BEFORE loading the replay so no gap can form; + # the generator dedupes overlap by seq). + broadcaster = None + sub_id: int | None = None + queue: asyncio.Queue | None = None + if not finished: + agent_session = session_manager.sessions.get(session_id) + if agent_session is not None and agent_session.is_active: + broadcaster = await _await_broadcaster(agent_session) + sub_id, queue = broadcaster.subscribe() + + replay = _events_in_range( + await _store().load_events_after(session_id, after_seq), doc + ) + + if broadcaster is None: + # No live session: replay whatever is persisted and close. + class _NoopBroadcaster: + def unsubscribe(self, _sub_id) -> None: + return None + + return _live_stream_response( + response_id, + _NoopBroadcaster(), + asyncio.Queue(), + 0, + replay=replay, + after_seq=after_seq, + attach_live=False, + ) + + return _live_stream_response( + response_id, + broadcaster, + queue, + sub_id, + replay=replay, + after_seq=after_seq, + attach_live=True, + ) + + +# --------------------------------------------------------------------------- +# POST /v1/responses/{response_id}/cancel +# --------------------------------------------------------------------------- + + +@router.post("/responses/{response_id}/cancel") +async def cancel_response( + response_id: str, + request: Request, + user: dict = Depends(get_api_user), +): + doc = await _load_owned_response(response_id, user) + hf_token = resolve_hf_request_token(request) + if doc.get("status") not in TERMINAL_RESPONSE_STATUSES: + await session_manager.interrupt(str(doc.get("session_id"))) + # Snapshot semantics match OpenAI: status may still read in_progress for + # a moment until the interrupted event lands. + return JSONResponse(await _build_full_response(doc, user, hf_token)) + + +# --------------------------------------------------------------------------- +# POST /v1/responses/{response_id}/approvals +# --------------------------------------------------------------------------- + + +@router.post("/responses/{response_id}/approvals") +async def submit_response_approval( + response_id: str, + body: V1ApprovalDecisionRequest, + request: Request, + user: dict = Depends(get_api_user), +): + doc = await _load_owned_response(response_id, user) + hf_token = resolve_hf_request_token(request) + agent_session = await _load_session_for_doc(doc, user, hf_token) + if agent_session is None or not agent_session.is_active: + raise V1APIError( + 404, + "The session behind this response is no longer available.", + code="session_unavailable", + ) + session = agent_session.session + if not session.pending_approval: + raise V1APIError( + 409, "No approval is pending for this response.", code="no_pending_approval" + ) + + session_id = str(doc.get("session_id")) + + # Raise the cap BEFORE submitting: yolo_budget_can_resume re-checks the + # remaining cap, so approving without headroom would immediately re-pause. + if body.new_max_cost_usd is not None: + try: + await session_manager.update_session_auto_approval( + session_id, + enabled=True, + cost_cap_usd=body.new_max_cost_usd, + cap_provided=True, + ) + except ValueError as e: + raise V1APIError(409, str(e), code="session_unavailable") + await _store().update_api_response_fields( + response_id, max_cost_usd=body.new_max_cost_usd + ) + + # Headless callers approve/deny the whole pending batch with one flag. + pending_tools = session_manager._pending_tools_for_api(session) or [] + approvals = [ + { + "tool_call_id": tool.get("tool_call_id"), + "approved": body.approve, + "feedback": body.feedback, + "edited_script": None, + "namespace": None, + } + for tool in pending_tools + if tool.get("tool_call_id") + ] + if not approvals: + raise V1APIError( + 409, "No approvable tool calls are pending.", code="no_pending_approval" + ) + + broadcaster = await _await_broadcaster(agent_session) + sub_id, queue = broadcaster.subscribe() + success = await session_manager.submit_approval(session_id, approvals) + if not success: + broadcaster.unsubscribe(sub_id) + raise V1APIError( + 409, "Session not found or inactive.", code="session_unavailable" + ) + + await _store().update_api_response_fields( + response_id, status="in_progress", incomplete_details=None + ) + # Re-arm the watcher: the resumed turn keeps the same response_id. + _spawn(_watch_response(response_id, agent_session, sub_id, queue)) + + fresh = await _store().load_api_response(response_id) or doc + return JSONResponse(await _build_full_response(fresh, user, hf_token)) diff --git a/backend/session_logs/session_567854d5-3516-4007-a794-656d3122f652_20260612_122736.json b/backend/session_logs/session_567854d5-3516-4007-a794-656d3122f652_20260612_122736.json new file mode 100644 index 0000000000000000000000000000000000000000..ccc164919c7595f4622ce062735945ce24ca587d --- /dev/null +++ b/backend/session_logs/session_567854d5-3516-4007-a794-656d3122f652_20260612_122736.json @@ -0,0 +1,1273 @@ +{ + "session_id": "567854d5-3516-4007-a794-656d3122f652", + "user_id": "608b8bb39d7c9519b4adae19", + "hf_username": "abidlabs", + "session_start_time": "2026-06-12T12:27:24.748351-07:00", + "session_end_time": "2026-06-12T12:27:36.007338", + "model_name": "anthropic/claude-opus-4.8:fal-ai", + "total_cost_usd": 0, + "usage_metrics": { + "version": 1, + "session_id": "567854d5-3516-4007-a794-656d3122f652", + "billing_scope": "account_window_delta", + "total_usd": 0.0, + "total_usd_source": "hf_billing_plus_sandbox_estimate", + "app_total_usd": 0.0, + "hf_billing_total_usd": 0.0, + "app_telemetry": { + "session_id": "567854d5-3516-4007-a794-656d3122f652", + "total_usd": 0.0, + "inference_usd": 0.0, + "hf_jobs_estimated_usd": 0.0, + "sandbox_estimated_usd": 0.0, + "llm_calls": 0, + "hf_jobs_count": 0, + "sandbox_count": 0, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0, + "hf_jobs_billable_seconds_estimate": 0, + "sandbox_billable_seconds_estimate": 0 + }, + "hf_billing": { + "source": "hf_billing_usage_v2", + "available": true, + "error": null, + "current_session": { + "window_start": "2026-06-12T19:27:24.748902Z", + "window_end": "2026-06-12T19:27:35.259379Z", + "timezone": "UTC", + "total_usd": 0.0, + "inference_providers_usd": 0.0, + "hf_jobs_usd": 0.0, + "inference_provider_requests": 0, + "hf_jobs_minutes": 0.0 + } + }, + "llm": { + "calls": 0, + "calls_by_kind": {}, + "calls_by_model": {}, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0 + }, + "turns": { + "turn_complete_count": 0, + "assistant_stream_end_count": 0 + }, + "hf_jobs": { + "submits": 0, + "status_snapshots": 0, + "statuses": {}, + "flavors": {}, + "submit_flavors": {}, + "status_snapshot_flavors": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0, + "snapshots_with_estimated_cost": 0, + "snapshots_with_nonzero_estimated_cost": 0 + }, + "sandboxes": { + "creates": 0, + "destroys": 0, + "matched_pairs": 0, + "unpaired_creates": 0, + "unpaired_destroys": 0, + "hardware": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0 + }, + "data_quality": { + "event_count": 3, + "events_without_timestamp": 0, + "llm_calls_with_cost_usd": 0, + "llm_calls_with_nonzero_cost_usd": 0, + "job_snapshots_with_estimated_cost": 0, + "job_snapshots_missing_estimated_cost": 0 + } + }, + "messages": [ + { + "content": "You are ML Intern, an ML engineering assistant with 19 tools for training, fine-tuning, data processing, inference, and evaluation on the Hugging Face (HF) ecosystem.\n\nYour goal is to complete what the user requested with zero errors. You are fully autonomous \u2014 research, validate, implement, and deliver results without asking for unnecessary confirmation.\n\n# Your knowledge of HF libraries is outdated\n\nYou do not know current APIs for TRL, Transformers, PEFT, Trackio, or other HF libraries. Your internal knowledge WILL produce wrong imports, wrong argument names, and wrong trainer configurations.\n\nBefore writing any ML implementation code, start from the literature. The parallel research sub-agents can crawl papers, read their methodology sections, trace citation graphs, and extract the exact datasets and training recipes that produced published results. This is your primary advantage \u2014 use it.\n\nYour default workflow for any ML task:\n1. Find the landmark paper(s) for the task or domain\n2. Crawl their citation graphs to find recent downstream work\n3. Read methodology sections (not abstracts) of the most promising papers \u2014 especially recent ones with strong results, lot of citations, and publications in high-impact conferences\n4. Extract the recipe: what dataset, what training method, what hyperparameters produced those results\n5. Validate and use those datasets for training\n\n```\nresearch({\"task\": \"Literature crawl for [task]. Start from [paper/topic]. Crawl citation graph for recent downstream papers. Read their methodology sections (3, 4, 5) \u2014 extract the exact datasets, training methods, and hyperparameters that produced their best results. Attribute every finding to a specific result (e.g. 'Dataset X + method Y \u2192 85.3% on benchmark Z'). Also find working code examples using current TRL/Transformers APIs.\", \"context\": \"User wants to [goal]. We need the best training recipe backed by published results.\"})\n```\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, and hf_papers (with citation_graph, read_paper, snippet_search, find_datasets). Be specific in your task description \u2014 name anchor papers or arxiv IDs when you have them.\n\nYou can also call research tools directly (explore_hf_docs, github_read_file, etc.) for quick lookups.\n\nSkip research only for trivial non-code operations.\n\n# Mistakes you WILL make without research\n\nHALLUCINATED IMPORTS: You will import from modules that were renamed or removed. Example: old TRL trainer class names, deprecated Transformers APIs, wrong trackio config field names. Fix: read a current example script first.\n\nWRONG TRAINER ARGUMENTS: You will pass configuration arguments that don't exist in current trainer versions. Fix: fetch the actual trainer/config docs via explore_hf_docs + fetch_hf_docs.\n\nWRONG DATASET FORMAT: You will assume column names without checking. Training fails with KeyError. Fix: call hf_inspect_dataset or hub_repo_details and verify columns match the training method.\n\nDEFAULT TIMEOUT KILLS JOBS: You will leave timeout at the default 30m for training jobs. Training takes hours. The job gets killed and all progress is lost. Fix: set timeout based on model size (minimum 2h for any training).\n\nLOST MODELS: You will forget push_to_hub=True and hub_model_id in training config. Job storage is ephemeral \u2014 the filesystem is deleted when the job ends. Without push_to_hub, the trained model is permanently lost.\n\nBATCH FAILURES: You will submit all ablation/batch jobs at once without testing that one works first. All will fail for the same bug. Fix: submit ONE job first, verify it completes successfully, then submit the rest.\n\nSILENT DATASET SUBSTITUTION: When a requested dataset fails to load, you will silently switch to a different one without telling the user. Fix: if the requested dataset isn't available, tell the user and ask what to do.\n\nPREFER HUB KERNELS OVER COMPILING ATTENTION: Do NOT pip install 'flash-attn' to enable flash_attention_2 building from source can take many minutes to hours and often fails on the job's CUDA/PyTorch combo. Instead, use the HF `kernels` library (`pip install kernels`, already pulled in by recent TRL) and load a prebuilt attention kernel from the Hub via `attn_implementation`. Examples: `AutoModelForCausalLM.from_pretrained(..., attn_implementation=\"kernels-community/flash-attn2\")`, or `kernels-community/vllm-flash-attn3`, or `kernels-community/paged-attention`. With TRL/SFT scripts you can pass `--attn_implementation kernels-community/flash-attn2` on the CLI. Search additional kernels at https://huggingface.co/models?other=kernel. Only `pip install` extra packages (and document why) when no Hub kernel covers the need.\n\nSCOPE-CHANGING FIXES: Avoid at all costs! When you hit an error (especially OOM), you will try \"creative\" workarounds that change what the user asked for and/or change the training task itself \u2014 switching full SFT to LoRA on OOM, reducing max_length (silently truncates training data and changes what the model learns), disabling monitoring instead of fixing it. Do not do this. Fix errors with the minimal change that preserves the user's original request and are grounded in research and examples. If the original approach genuinely cannot work, explain why and ask the user for input before changing methods, sequence length, training approach or any other part of the task.\n\n# When writing ML code\n\nRequired sequence before any training/fine-tuning/inference script:\n1. Use `research` tool to find working examples, read docs, and get current API patterns\n2. Validate dataset: hf_inspect_dataset or hub_repo_details to confirm column names and format\n3. Validate model: hub_repo_details to confirm model exists, correct architecture/size/tokenizer\n\nTraining logging: always set disable_tqdm=True, logging_strategy=\"steps\", and logging_first_step=True in your TrainingArguments/SFTConfig so loss values are printed as plain text lines you can grep, not hidden inside tqdm progress bars.\n\nDataset format requirements by training method:\n SFT: \"messages\", \"text\", or \"prompt\"/\"completion\"\n DPO: \"prompt\", \"chosen\", \"rejected\"\n GRPO: \"prompt\"\n\n# Trackio\n\nTrackio is natively integrated with Transformers Trainer and all TRL trainers \u2014 the built-in TrackioCallback handles init/log/finish. In TrainingArguments/SFTConfig/DPOConfig/GRPOConfig set:\n report_to=\"trackio\"\n run_name=\"\" # e.g. \"sft_qwen3-4b_lr2e-5_bs128\"\n project=\"\" # keeps related runs grouped so you can compare them\n trackio_space_id=\"/ml-intern-<8-char-id>\" # creates a public dashboard Space\n`project` and `trackio_space_id` can also be set via TRACKIO_PROJECT / TRACKIO_SPACE_ID env vars.\n\nAlerts are how iterations decide what to change. Use trackio.alert(title, text, level) at every decision point in training. Levels:\n ERROR \u2014 stop and change approach (divergence, NaN, OOM)\n WARN \u2014 tweak hyperparameters (overfitting, early stopping, KL spike, reward collapse, slow convergence)\n INFO \u2014 milestones (training complete, target reached, checkpoint saved)\nAlways include numeric values and an actionable suggestion in `text`, e.g. \"loss=12.4 at step 200 \u2014 lr likely too high, try \u00d70.1\". A future call must be able to parse it and act on it.\n\nTo add alerts under Trainer/SFTTrainer/GRPOTrainer, pass a custom TrainerCallback via `callbacks=[...]` that calls trackio.alert() inside `on_log` (training metrics like loss, reward, kl) and `on_evaluate` (eval metrics \u2014 only available here, not in `on_log`). Keep each `if` simple: one metric, one threshold. Conditions stay easy to adjust between runs.\n\nRead alerts back between runs instead of parsing thousands of metric values. CLI \u2014 always use --json:\n trackio get alerts --project

--run --json\n trackio get alerts --project

--since --json # incremental polling\n trackio get run --project

--run --json\n trackio get metric --project

--run --metric --json\n trackio list runs --project

--json\nPython: api = trackio.Api(); api.alerts(

, run=, since=); api.runs(

) (each run has .name, .config, .alerts()).\n\nDrive the next config from prior alerts:\n diverged \u2192 lr \u00d7 0.1\n overfitting \u2192 weight_decay \u00d7 10 or reduce capacity\n early stopping \u2192 lr \u00d7 0.5 or adjust schedule\n high accuracy \u2192 refine around current config\nRead prior config via api.runs(...).config and only mutate keys the alerts justify changing.\n\n# Data audit\n\nBefore working with any dataset, audit it first. Do not assume you know what the data looks like \u2014 inspect it.\n\nUse hf_inspect_dataset to check: schema/columns, number of rows per split, value distributions for key columns, sample rows. Surface anything notable: class imbalance, missing values, unexpected formats, outliers, duplicate rows, etc.\n\nLooking at data is the best way to boost performance of any ML model plus it reduces the likelihood of failed jobs later.\n\n# When submitting a training job\n\nNever pass a local machine path to hf_jobs.script, such as /Users/..., /home/..., /fsx/..., or a repo checkout path. HF Jobs runs in a fresh cloud environment where local files do not exist. For hf_jobs.script, use exactly one of:\n - inline Python source code\n - a file already written in the session sandbox, e.g. /app/train.py, ./train.py, or train.py\n - a public/raw URL\nIf you wrote or tested a script locally, read the file content and submit it inline, or write it into the sandbox first.\n\nGPU preflight is mandatory before hf_jobs when the job will run on GPU, or when the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile. First create a GPU sandbox with sandbox_create (t4-small minimum; choose larger hardware when VRAM requires it), run a tiny smoke test there using the same imports, model-loading path, training entrypoint, and a tiny dataset/subset, then fix failures before submitting. If you skip GPU sandbox preflight, state why before calling hf_jobs.\n\nBefore calling hf_jobs, output a pre-flight check:\n - Reference implementation: [which example you based this on]\n - Dataset format verified: [columns confirmed via hf_inspect_dataset/hub_repo_details]\n - GPU sandbox smoke test: [hardware and result, or explicitly not applicable because ...]\n - push_to_hub=True and hub_model_id set\n - timeout: [value] (based on: [model size] on [hardware])\n - Trackio monitoring included and deploying metrics to a public Space\n\nIf you cannot fill in all items, stop and complete the missing steps first.\n\nFor batch/ablation jobs: submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once.\n\nHardware sizing:\n 1-3B params: a10g-largex2\n 7-13B params: a100-large\n 30B+ params: l40sx4 or a100x4\n 70B+ params: a100x8\nNote: a10g-small and a10g-large have the SAME 24GB GPU memory. The difference is CPU/RAM only.\n\n# Sandbox-first development\n\nA private cpu-basic sandbox is already available for normal code execution in each session. For non-trivial scripts, develop and test there before launching via hf_jobs:\n write script \u2192 pip install \u2192 test with small run using bash/read/write/edit \u2192 fix errors \u2192 launch via hf_jobs at scale\n\nDo NOT call sandbox_create before normal CPU work. Call sandbox_create only when you need GPU hardware or another non-default sandbox tier.\n\nThe sandbox filesystem does not survive session resumption. If a session is resumed, any files, installed packages, or running processes from earlier are gone \u2014 recreate what you need before relying on the sandbox.\n\nUse a GPU sandbox (t4-small minimum) when testing code that uses CUDA, bf16/fp16, quantization, flash attention, torch.compile, or model loading. CPU sandboxes cannot test GPU code paths. If the available sandbox tiers cannot fit the full model path, test the largest useful smoke path, state what was not covered, and submit one HF job first.\n\n\n# When a task has 3+ steps\n\nUse plan_tool to track progress. One task in_progress at a time. Mark completed immediately after finishing. Update frequently to show the user what you're doing.\n\n# Error recovery\n\nWhen something fails:\n- Diagnose the actual error. Read the full error message and logs.\n- Do not retry the exact same thing. Identify what needs to change.\n- If an API/import error: check documentation for the correct API.\n- If an OOM error: (1) reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally to keep effective batch size identical, (2) enable gradient_checkpointing=True, (3) upgrade to larger GPU (a10gx4\u2192a100\u2192a100x4\u2192a100x8). Do NOT switch training methods (e.g. SFT\u2192LoRA) or reduce max_length \u2014 those change what the user gets. If OOM happens in sandbox, create a new sandbox with larger GPU hardware.\n- Never change the user's requested approach (training method, dataset, model, sequence length) without explicit approval.\n- If a tool call fails repeatedly for the same reason: stop and try a different approach.\n- Never silently substitute resources (datasets, models) \u2014 tell the user if something isn't available.\n\n# Task completion\n\nBefore ending your turn, verify:\n- Did you actually DO what the user asked, not just explain what you would do?\n- If something failed: did you diagnose and fix it, or at minimum explain what went wrong and ask for user input?\n- For training jobs: did you include a working Trackio dashboard URL?\n\nDo not stop after describing what you plan to do. Continue calling tools until the task is verifiably done.\nDo not mark plan tasks as completed if they failed or are only partially done.\n\n# Autonomous / headless mode\n\nWhen running autonomously (no human in the loop), you MUST follow these rules:\n\nNEVER respond with only text. Every response MUST include at least one tool call. If you have nothing to do, check the plan, verify outputs or plan ahead. A text-only response ends the agent loop permanently \u2014 there is no human to re-prompt you.\n\nNEVER STOP WORKING. Do NOT decide you are \"done\" while time remains. The human is not watching \u2014 they expect you to use the ENTIRE time budget productively. Do NOT ask \"should I continue?\" or \"is this a good stopping point?\" \u2014 there is nobody to answer. You run until the timer expires or you are manually killed.\n\nYour workflow is a loop, not a checklist. Once you have a working result, KEEP ITERATING:\n\nLOOP UNTIL TIME RUNS OUT:\n1. Research the approach (read docs, find examples, check current APIs)\n2. Implement the solution (write code, set up training)\n3. Train and evaluate\n4. Save the model to the required output location / push it to Hugging Face Hub\n5. Improve: tune hyperparameters, try different data, adjust the training recipe, try a different approach entirely\n6. Go to step 1\n\nHYPERPARAMETER TUNING: Do not tune hyperparameters by hand one-at-a-time. Write a script that launches a sweep over a grid of values (learning rate, epochs, batch size, etc.) and evaluates each run automatically. One well-designed sweep script beats ten manual experiments.\n\nIf you run out of ideas: go back to the literature. Crawl citation graphs deeper \u2014 find papers you haven't read yet, read their methodology sections, extract new datasets or training tricks. Look for papers that cite your current approach and improved on it. Try combining recipes from different papers. Re-read the task prompt for angles you missed. Re-read the training logs for clues. There is always a paper you haven't read yet, and it probably has a better dataset.\n\nCheck the remaining time periodically with the timer command specified in the task prompt. Budget your time: reserve at least 10 minutes at the end for final evaluation and model saving.\n\nThe task is NOT done until:\n- The required output exists (e.g. final model, metrics reached, dataset updated etc)\n- You have evaluated the model and confirmed it works\n\n# Communication\n\n- Be concise and direct. No filler, no restating what the user said.\n- One-word answers when appropriate for simple questions.\n- Always include direct Hub URLs when referencing models, datasets, Spaces, or jobs.\n- For errors: state what went wrong, why, and what you're doing to fix it.\n- Do not over-explain or present elaborate option menus for simple tasks. When the user's intent is clear, act on it. Present options only when there's genuine ambiguity.\n- Use the `notify` tool only when the user explicitly asked for out-of-band notifications or when the task clearly requires reporting to a configured messaging destination. Do not use it for routine chat updates.\n\n# Tool usage\n\n- Execute multiple independent tool calls in parallel when possible.\n- HF_TOKEN is automatically available in job secrets \u2014 no need to include it extra.\n- For training monitoring: include Trackio in the script and provide the dashboard URL.\n- For private/gated datasets: HF_TOKEN is needed \u2014 it's auto-loaded into job secrets.\n\n[Session context: Date=12-06-2026, Time=21:27:24.185, Timezone=CEST (UTC+02:00), User=abidlabs, Tools=19]", + "role": "system", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "reply with just ok", + "role": "user", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + } + ], + "events": [ + { + "timestamp": "2026-06-12T12:27:25.022776-07:00", + "event_type": "tool_log", + "data": { + "tool": "sandbox", + "log": "Auto-creating sandbox for abidlabs (cpu-basic)..." + } + }, + { + "timestamp": "2026-06-12T12:27:34.937855-07:00", + "event_type": "ready", + "data": { + "message": "Agent initialized" + } + }, + { + "timestamp": "2026-06-12T12:27:34.938006-07:00", + "event_type": "processing", + "data": { + "message": "Processing user input" + } + } + ], + "tools": [ + { + "type": "function", + "function": { + "name": "sandbox_create", + "description": "Create or replace the session sandbox when non-default hardware is needed.\n\nA private cpu-basic sandbox is already started automatically for each session. For normal CPU code execution, call bash/read/write/edit directly; do NOT call sandbox_create first.\n\nUse sandbox_create when: you need GPU hardware, cpu-upgrade, or Trackio secrets before running code. The active sandbox persists across tool calls within the session. pip install works out of the box. Sandboxes are always created as private HF Spaces.\n\nFor ML code that uses CUDA, bf16, or model loading: use GPU hardware (t4-small minimum). CPU sandboxes cannot run GPU code paths \u2014 your test will not catch GPU-related errors.\n\nBefore choosing hardware, estimate your VRAM needs (models you run, training data size). Rule of thumb: bf16/fp16 \u2248 2 bytes/param, fp32 \u2248 4 bytes/param, plus ~20% overhead for optimizer states during training.\nCommon picks: t4-small (16GB VRAM, fits \u22641-3B), a10g-small (24GB, \u22647B), a100-large (80GB, \u226430B). If the model won't fit, pick larger hardware upfront \u2014 OOM on a sandbox wastes time.\n\nIf you intend to run a training script in this sandbox that uses report_to='trackio', pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` so they are set as TRACKIO_SPACE_ID/TRACKIO_PROJECT secrets in the sandbox and the UI can embed the live dashboard.\n\nHardware: cpu-basic, cpu-upgrade, cpu-performance, cpu-xl, sprx8, zero-a10g, t4-small, t4-medium, l4x1, l4x4, l40sx1, l40sx4, l40sx8, a10g-small, a10g-large, a10g-largex2, a10g-largex4, a100-large, a100x4, a100x8, h200, h200x2, h200x4, h200x8, inf2x6.\n", + "parameters": { + "type": "object", + "required": [], + "additionalProperties": false, + "properties": { + "hardware": { + "type": "string", + "enum": [ + "cpu-basic", + "cpu-upgrade", + "cpu-performance", + "cpu-xl", + "sprx8", + "zero-a10g", + "t4-small", + "t4-medium", + "l4x1", + "l4x4", + "l40sx1", + "l40sx4", + "l40sx8", + "a10g-small", + "a10g-large", + "a10g-largex2", + "a10g-largex4", + "a100-large", + "a100x4", + "a100x8", + "h200", + "h200x2", + "h200x4", + "h200x8", + "inf2x6" + ], + "description": "Hardware tier for the sandbox. Omit for the existing auto-started cpu-basic sandbox; choose GPU/cpu-upgrade only when needed." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for runs in this sandbox (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID secret and surfaced to the UI. The Space is auto-created and seeded with the trackio dashboard \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name. Injected as TRACKIO_PROJECT secret and used by the UI to filter the embedded dashboard to this project." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "bash", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nRun a shell command in the remote sandbox and return stdout/stderr.\n\nIMPORTANT: Do NOT use bash for file operations \u2014 use the dedicated tools instead:\n- To read files: use read (not cat/head/tail)\n- To edit files: use edit (not sed/awk)\n- To write files: use write (not echo/cat < > /app/output.log 2>&1 & echo $!\nThen check status:\n kill -0 2>/dev/null && echo 'running' || echo 'done'\n tail -n 50 /app/output.log\n\nTimeout default 240s, max 1200s.", + "parameters": { + "type": "object", + "required": [ + "command" + ], + "additionalProperties": false, + "properties": { + "command": { + "type": "string", + "description": "The shell command to execute." + }, + "description": { + "type": "string", + "description": "Short description (5-10 words, active voice)." + }, + "work_dir": { + "type": "string", + "description": "Working directory (default: /app)." + }, + "timeout": { + "type": "integer", + "description": "Optional timeout in seconds (default: 240, max: 1200)." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "read", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nReads a file from the sandbox filesystem. Returns contents with line numbers (cat -n format).\n\nUsage:\n- By default, reads up to 2000 lines from the beginning of the file.\n- You can optionally specify offset and limit for large files, but prefer reading the whole file first.\n- Lines longer than 4000 chars are truncated.\n- Cannot read directories \u2014 use bash with 'ls' instead.\n- You should read multiple potentially useful files in parallel when possible.\n- IMPORTANT: Always read a file before editing or overwriting it. The edit and write tools will reject operations on files you haven't read.", + "parameters": { + "type": "object", + "required": [ + "path" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to read." + }, + "offset": { + "type": "integer", + "description": "The line number to start reading from (1-based). Only provide if the file is too large to read at once." + }, + "limit": { + "type": "integer", + "description": "The number of lines to read. Only provide if the file is too large to read at once." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "write", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nWrites a file to the sandbox filesystem. Overwrites the existing file if one exists at the path.\n\n- If this is an existing file, you MUST use the read tool first. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files with the edit tool over overwriting with write.\n- Creates parent directories as needed.", + "parameters": { + "type": "object", + "required": [ + "path", + "content" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to write." + }, + "content": { + "type": "string", + "description": "The complete file content to write." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "edit", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nPerforms string replacements in files. Supports exact matching with fuzzy fallback.\n\nUsage:\n- You must read the file at least once before editing. This tool will error if you attempt an edit without reading the file.\n- The edit will FAIL if old_str is not unique in the file. Either provide a larger string with more surrounding context to make it unique, or set replace_all to true.\n- old_str and new_str must differ.\n- Preserve indentation exactly as it appears in the file.\n- Do NOT include line number prefixes from read output in old_str or new_str.\n- To delete code, set new_str to empty string.\n- Use replace_all for renaming variables or strings across the file.\n\nModes:\n- replace (default): replace first occurrence of old_str with new_str.\n- append_after: insert new_str immediately after old_str (old_str is kept).\n- prepend_before: insert new_str immediately before old_str (old_str is kept).", + "parameters": { + "type": "object", + "required": [ + "path", + "old_str", + "new_str" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to edit." + }, + "old_str": { + "type": "string", + "description": "The text to find in the file. Must match exactly (fuzzy matching is used as fallback)." + }, + "new_str": { + "type": "string", + "description": "The replacement text. For append_after/prepend_before modes, the text to insert." + }, + "replace_all": { + "type": "boolean", + "description": "Replace all occurrences of old_str (default: false).", + "default": false + }, + "mode": { + "type": "string", + "enum": [ + "replace", + "append_after", + "prepend_before" + ], + "description": "Edit mode (default: replace).", + "default": "replace" + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "research", + "description": "Spawn a research sub-agent to explore documentation, codebases, or repos WITHOUT polluting the main conversation context. The sub-agent gets its own independent context window with read-only research tools and returns a concise summary of findings.\n\nUse this for:\n- Researching current API usage before implementing ML tasks (find examples + read docs)\n- Exploring HF docs, reading papers, analyzing GitHub repos\n- Any research where raw tool outputs would be too verbose\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, hf_papers, etc. Just describe what you need researched.", + "parameters": { + "type": "object", + "properties": { + "task": { + "type": "string", + "description": "Detailed description of what to research. Be specific: include library names, trainer types, dataset names, repo names, or doc pages to explore. Example: 'Research current TRL SFTTrainer usage: find working example scripts, read the SFT documentation, and check SFTConfig parameters. Also validate that dataset HuggingFaceH4/ultrachat_200k has the right format for SFT.'" + }, + "context": { + "type": "string", + "description": "Optional context from the current conversation that the research agent needs (e.g., what the user wants to build, constraints, what's been tried)." + } + }, + "required": [ + "task" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "explore_hf_docs", + "description": "Browse HF documentation structure \u2014 discover all available documentation with 200-char previews.\n\nUse this to find relevant documentation and/or examples with detailed parameter docs and API reference. To be used together with github_find_examples and github_read_file to find working examples and documentation.\n\nPattern: explore_hf_docs (find relevant pages) \u2192 fetch_hf_docs (get full content).\n\nFor training tasks: fetch the trainer config docs (SFTConfig, DPOConfig, GRPOConfig) to verify parameter names. Returns top 20 results by default; set max_results (max 50) to adjust.", + "parameters": { + "type": "object", + "properties": { + "endpoint": { + "type": "string", + "enum": [ + "hub", + "transformers", + "diffusers", + "datasets", + "gradio", + "trackio", + "smolagents", + "huggingface_hub", + "huggingface.js", + "transformers.js", + "inference-providers", + "inference-endpoints", + "peft", + "accelerate", + "optimum", + "tokenizers", + "courses", + "evaluate", + "tasks", + "dataset-viewer", + "trl", + "simulate", + "sagemaker", + "timm", + "safetensors", + "tgi", + "setfit", + "lerobot", + "autotrain", + "tei", + "bitsandbytes", + "sentence_transformers", + "chat-ui", + "leaderboards", + "lighteval", + "argilla", + "distilabel", + "microsoft-azure", + "kernels", + "google-cloud" + ], + "description": "The documentation endpoint to explore. Each endpoint corresponds to a major section of the Hugging Face documentation:\n\n\u2022 courses \u2014 All Hugging Face courses (LLM, robotics, MCP, smol (llm training), agents, deep RL, computer vision, games, diffusion, 3D, audio) and the cookbook recipes. Probably the best place for examples.\n\u2022 hub \u2014 Find answers to questions about models/datasets/spaces, auth, versioning, metadata.\n\u2022 transformers \u2014 Core model library: architectures, configs, tokenizers, training & inference APIs.\n\u2022 diffusers \u2014 Diffusion pipelines, schedulers, fine-tuning, training, and deployment patterns.\n\u2022 datasets \u2014 Dataset loading, streaming, processing, Arrow format, Hub integration.\n\u2022 gradio \u2014 UI components and demos for ML models. Uses Gradio's native API: without query returns full docs (llms.txt), with query uses embedding search for precise results.\n\u2022 trackio \u2014 Experiment tracking, metrics logging, and run comparison.\n\u2022 smolagents \u2014 Lightweight agent abstractions and tool-using patterns.\n\u2022 huggingface_hub \u2014 Python client for Hub operations (auth, upload/download, repo management).\n\u2022 huggingface.js \u2014 JS/TS client for Hub APIs in browser and Node.\n\u2022 transformers.js \u2014 Run Transformer models in browser/Node via WebGPU/WASM.\n\u2022 inference-providers \u2014 Unified interface for third-party inference backends.\n\u2022 inference-endpoints \u2014 Managed, scalable model deployments on HF infrastructure.\n\u2022 peft \u2014 Parameter-efficient fine-tuning methods (LoRA, adapters, etc.).\n\u2022 accelerate \u2014 Hardware-agnostic, distributed and mixed-precision training orchestration.\n\u2022 optimum \u2014 Hardware-aware optimization and model export tooling, including Habana, Neuron, Intel, ExecuTorch, and TPU variants.\n\u2022 tokenizers \u2014 Fast tokenizer internals, training, and low-level APIs.\n\u2022 evaluate \u2014 Metrics, evaluation workflows, and training-loop integration.\n\u2022 tasks \u2014 Canonical task definitions and model categorization.\n\u2022 dataset-viewer \u2014 Dataset preview, streaming views, and viewer internals.\n\u2022 trl \u2014 RLHF, DPO, PPO, and SFT utilities for LLMs.\n\u2022 simulate \u2014 Experimental simulation tools and workflows.\n\u2022 sagemaker \u2014 Deploying Hugging Face models on AWS SageMaker.\n\u2022 timm \u2014 Image model zoo and utilities via HF integrations.\n\u2022 safetensors \u2014 Safe, fast tensor serialization format.\n\u2022 tgi \u2014 High-throughput text generation server for LLMs.\n\u2022 setfit \u2014 Few-shot text classification via sentence embeddings.\n\u2022 lerobot \u2014 Robotics datasets, policies, and learning workflows.\n\u2022 autotrain \u2014 No/low-code model training on Hugging Face.\n\u2022 tei \u2014 Optimized inference server for embedding workloads.\n\u2022 bitsandbytes \u2014 Quantization and memory-efficient optimizers.\n\u2022 sentence_transformers \u2014 Embedding models, training recipes, similarity/search workflows.\n\u2022 chat-ui \u2014 Reference chat interfaces for LLM deployment.\n\u2022 leaderboards \u2014 Evaluation leaderboards and submission mechanics.\n\u2022 lighteval \u2014 Lightweight, reproducible LLM evaluation framework.\n\u2022 argilla \u2014 Data annotation, feedback, and human-in-the-loop workflows.\n\u2022 distilabel \u2014 Synthetic data generation and distillation pipelines.\n\u2022 microsoft-azure \u2014 Azure deployment and integration guides.\n\u2022 kernels \u2014 Load prebuilt compute kernels (E.g. flash-attn2) from the Hub via `attn_implementation`; avoids compiling flash-attn from source.\n\u2022 google-cloud \u2014 GCP deployment and serving workflows.\n" + }, + "query": { + "type": "string", + "description": "Optional keyword query to rank and filter documentation pages. For Gradio, use concise queries like 'how to use the image component' or 'audio component demo'." + }, + "max_results": { + "type": "integer", + "description": "Max results (default 20, max 50). Ignored for Gradio.", + "minimum": 1, + "maximum": 50 + } + }, + "required": [ + "endpoint" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "fetch_hf_docs", + "description": "Fetch full markdown content of an HF documentation page. Use after explore_hf_docs.\n\nCritical for finding documentation e.g. current trainer configuration parameters (SFTConfig, DPOConfig, etc.) Use for researching solutions and before writing training scripts. Your internal knowledge is outdated.\n\nProvide the full URL from explore_hf_docs results. The .md extension is added automatically.", + "parameters": { + "type": "object", + "properties": { + "url": { + "type": "string", + "description": "The full URL to the documentation page. Example: 'https://huggingface.co/docs/trl/dpo_trainer' The .md extension will be added automatically if not present." + } + }, + "required": [ + "url" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_papers", + "description": "Discover ML research papers, analyze citations, search paper contents, and find linked resources.\n\nCombines HuggingFace Hub, arXiv, and Semantic Scholar. Use for exploring research areas, finding datasets for a task, tracing citation chains, or implementing a paper's approach.\n\nTypical flows:\n search \u2192 read_paper \u2192 find_all_resources \u2192 hf_inspect_dataset\n search \u2192 paper_details \u2192 citation_graph \u2192 read_paper (trace influence)\n snippet_search \u2192 paper_details \u2192 read_paper (find specific claims)\n\nOperations:\n- trending: Get trending daily papers, optionally filter by topic keyword\n- search: Search papers. Uses HF by default (ML-tuned). Add date_from/min_citations/categories to use Semantic Scholar with filters\n- paper_details: Metadata, abstract, AI summary, github link\n- read_paper: Read paper contents \u2014 without section: abstract + TOC; with section: full text\n- citation_graph: Get references and citations for a paper with influence flags and citation intents\n- snippet_search: Semantic search over full-text passages from 12M+ papers\n- recommend: Find similar papers (single paper or positive/negative examples)\n- find_datasets: Find datasets linked to a paper\n- find_models: Find models linked to a paper\n- find_collections: Find collections that include a paper\n- find_all_resources: Parallel fetch of datasets + models + collections for a paper", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "trending", + "search", + "paper_details", + "read_paper", + "citation_graph", + "snippet_search", + "recommend", + "find_datasets", + "find_models", + "find_collections", + "find_all_resources" + ], + "description": "Operation to execute." + }, + "query": { + "type": "string", + "description": "Search query. Required for: search, snippet_search. Optional for: trending (filters by keyword). Supports boolean syntax for Semantic Scholar: '\"exact phrase\" term1 | term2'." + }, + "arxiv_id": { + "type": "string", + "description": "ArXiv paper ID (e.g. '2305.18290'). Required for: paper_details, read_paper, citation_graph, find_datasets, find_models, find_collections, find_all_resources. Optional for: recommend (single-paper recs). Get IDs from search results first." + }, + "section": { + "type": "string", + "description": "Section name or number to read (e.g. '3', 'Experiments', '4.2'). Optional for: read_paper. Without this, returns abstract + TOC." + }, + "direction": { + "type": "string", + "enum": [ + "citations", + "references", + "both" + ], + "description": "Direction for citation_graph. Default: both." + }, + "date": { + "type": "string", + "description": "Date in YYYY-MM-DD format. Optional for: trending (defaults to recent papers)." + }, + "date_from": { + "type": "string", + "description": "Start date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "date_to": { + "type": "string", + "description": "End date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "categories": { + "type": "string", + "description": "Field of study filter (e.g. 'Computer Science'). Triggers Semantic Scholar search." + }, + "min_citations": { + "type": "integer", + "description": "Minimum citation count filter. Triggers Semantic Scholar search." + }, + "sort_by": { + "type": "string", + "enum": [ + "relevance", + "citationCount", + "publicationDate" + ], + "description": "Sort order for Semantic Scholar search. Default: relevance." + }, + "positive_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs for multi-paper recommendations. For: recommend." + }, + "negative_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs as negative examples. For: recommend." + }, + "sort": { + "type": "string", + "enum": [ + "downloads", + "likes", + "trending" + ], + "description": "Sort order for find_datasets and find_models. Default: downloads." + }, + "limit": { + "type": "integer", + "description": "Maximum results to return (default: 10, max: 50)." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "web_search", + "description": "Search the web for current information and return cited results.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "minLength": 2 + }, + "allowed_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional allowlist of domains or URLs. Subdomains match." + }, + "blocked_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional blocklist of domains or URLs. Subdomains match." + } + }, + "required": [ + "query" + ], + "additionalProperties": false + } + } + }, + { + "type": "function", + "function": { + "name": "hf_inspect_dataset", + "description": "Inspect a HF dataset in one call: status, configs/splits, schema, sample rows, parquet info.\n\nREQUIRED before any training job to verify dataset format matches training method:\n SFT: needs 'messages', 'text', or 'prompt'/'completion'\n DPO: needs 'prompt', 'chosen', 'rejected'\n GRPO: needs 'prompt'\nAll datasets used for training have to be in conversational ChatML format to be compatible with HF libraries.'\nTraining will fail with KeyError if columns don't match.\n\nAlso use to get example datapoints, understand column names, data types, and available splits before writing any data loading code. Supports private/gated datasets when HF_TOKEN is set.", + "parameters": { + "type": "object", + "properties": { + "dataset": { + "type": "string", + "description": "Dataset ID in 'org/name' format (e.g., 'stanfordnlp/imdb')" + }, + "config": { + "type": "string", + "description": "Config/subset name. Auto-detected if not specified." + }, + "split": { + "type": "string", + "description": "Split for sample rows. Auto-detected if not specified." + }, + "sample_rows": { + "type": "integer", + "description": "Number of sample rows to show (default: 3, max: 10)", + "default": 3 + } + }, + "required": [ + "dataset" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "plan_tool", + "description": "Track progress on multi-step tasks with a todo list (pending/in_progress/completed).\n\nUse for tasks with 3+ steps. Each call replaces the entire plan (send full list).\n\nRules: exactly ONE task in_progress at a time. Mark completed immediately after finishing. Only mark completed when the task fully succeeded \u2014 keep in_progress if there are errors. Update frequently so the user sees progress.", + "parameters": { + "type": "object", + "properties": { + "todos": { + "type": "array", + "description": "List of todo items", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "Unique identifier for the todo" + }, + "content": { + "type": "string", + "description": "Description of the todo task" + }, + "status": { + "type": "string", + "enum": [ + "pending", + "in_progress", + "completed" + ], + "description": "Current status of the todo" + } + }, + "required": [ + "id", + "content", + "status" + ] + } + } + }, + "required": [ + "todos" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "notify", + "description": "Send an out-of-band notification to configured messaging destinations. Use this only when the user explicitly asked for proactive notifications or when the task requires reporting progress outside the chat. Destinations must be named server-side configs such as 'slack.ops'.", + "parameters": { + "type": "object", + "properties": { + "destinations": { + "type": "array", + "description": "Named messaging destinations to notify.", + "items": { + "type": "string" + }, + "minItems": 1 + }, + "message": { + "type": "string", + "description": "Main notification body." + }, + "title": { + "type": "string", + "description": "Optional short title line." + }, + "severity": { + "type": "string", + "enum": [ + "info", + "success", + "warning", + "error" + ], + "description": "Notification severity label." + } + }, + "required": [ + "destinations", + "message" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_jobs", + "description": "Execute Python scripts or Docker containers on HF cloud infrastructure.\n\nTwo modes (mutually exclusive): Python mode (script + dependencies) or Docker mode (command + image). Provide exactly ONE of 'script' or 'command'.\n\nBEFORE submitting training/fine-tuning jobs:\n- You MUST have called github_find_examples + github_read_file to find a working reference implementation. Scripts based on your internal knowledge WILL use outdated APIs and fail.\n- You MUST have validated dataset format via hf_inspect_dataset or hub_repo_details.\n- If the job runs on GPU, or the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile, you MUST create a GPU sandbox with sandbox_create first, run a tiny smoke test there, and fix failures before submitting. If skipped, state why before calling hf_jobs.\n- Training config MUST include push_to_hub=True and hub_model_id. Job storage is EPHEMERAL \u2014 all files are deleted when the job ends. Without push_to_hub, trained models are lost permanently.\n- Include trackio monitoring and provide the dashboard URL to the user. When the script uses report_to='trackio', also pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` as tool args \u2014 they are injected as TRACKIO_SPACE_ID/TRACKIO_PROJECT env vars and let the UI embed the live dashboard.\n\nBATCH/ABLATION JOBS: Submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once \u2014 if there's a bug, all jobs fail.\n\nOperations: run, ps, logs, inspect, cancel, scheduled run/ps/inspect/delete/suspend/resume.\n\nHardware: CPU: cpu-basic(2vCPU/16GB), cpu-upgrade(8vCPU/32GB). GPU: t4-small(4vCPU/15GB/GPU 16GB), t4-medium(8vCPU/30GB/GPU 16GB), a10g-small(4vCPU/15GB/GPU 24GB), a10g-large(12vCPU/46GB/GPU 24GB), a10g-largex2(24vCPU/92GB/GPU 48GB), a10g-largex4(48vCPU/184GB/GPU 96GB), a100-large(12vCPU/142GB/GPU 80GB), a100x4(48vCPU/568GB/GPU 320GB), a100x8(96vCPU/1136GB/GPU 640GB), l4x1(8vCPU/30GB/GPU 24GB), l4x4(48vCPU/186GB/GPU 96GB), l40sx1(8vCPU/62GB/GPU 48GB), l40sx4(48vCPU/382GB/GPU 192GB), l40sx8(192vCPU/1534GB/GPU 384GB).\nCommon picks: t4-small ($0.60/hr, 1-3B), a10g-large ($2/hr, 7-13B), a100-large ($4/hr, 30B+), h100 ($6/hr, 70B+). Note: a10g-small and a10g-large have the SAME 24GB GPU \u2014 the difference is CPU/RAM only.\n\nOOM RECOVERY: When a training job fails with CUDA OOM:\n1. Reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally (keep effective batch size identical)\n2. Enable gradient_checkpointing=True\n3. Upgrade to larger GPU (a10g\u2192a100\u2192h100)\nDo NOT switch training methods (e.g. full SFT to LoRA) or reduce max_length \u2014 those change what the user gets and require explicit approval.\n\nExamples:\nTraining: {'operation': 'run', 'script': '/app/train.py', 'dependencies': ['transformers', 'trl', 'torch', 'datasets', 'trackio'], 'hardware_flavor': 'a100-large', 'timeout': '8h'}\nMonitor: {'operation': 'ps'}, {'operation': 'logs', 'job_id': 'xxx'}, {'operation': 'cancel', 'job_id': 'xxx'}Docker: {'operation': 'run', 'command': ['duckdb', '-c', 'select 1 + 2'], 'image': 'duckdb/duckdb', 'hardware_flavor': 'cpu-basic', 'timeout': '1h'}\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "run", + "ps", + "logs", + "inspect", + "cancel", + "scheduled run", + "scheduled ps", + "scheduled inspect", + "scheduled delete", + "scheduled suspend", + "scheduled resume" + ], + "description": "Operation to execute." + }, + "script": { + "type": "string", + "description": "Python code, sandbox file path (e.g. '/app/train.py', './train.py', or bare 'train.py'), or URL. Triggers Python mode. For ML training: base this on a working example found via github_find_examples, not on internal knowledge. For GPU/model-loading training scripts, smoke-test in a GPU sandbox before submission. Mutually exclusive with 'command'." + }, + "dependencies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Pip packages to install. Include ALL required packages. Common training set: ['transformers', 'trl', 'torch', 'datasets', 'trackio', 'accelerate']. Only used with 'script'." + }, + "image": { + "type": "string", + "description": "Docker image. Optional \u2014 auto-selected if not provided. Use with 'command'." + }, + "command": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Command to execute as list. Triggers Docker mode. Mutually exclusive with 'script'." + }, + "hardware_flavor": { + "type": "string", + "description": "Hardware type. Sizing guide: 1-3B params \u2192 t4-small/a10g-small, 7-13B \u2192 a10g-large, 30B+ \u2192 a100-large, 70B+ \u2192 h100/h100x8. All options: CPU: ['cpu-basic', 'cpu-upgrade']. GPU: ['t4-small', 't4-medium', 'a10g-small', 'a10g-large', 'a10g-largex2', 'a10g-largex4', 'a100-large', 'a100x4', 'a100x8', 'l4x1', 'l4x4', 'l40sx1', 'l40sx4', 'l40sx8']." + }, + "timeout": { + "type": "string", + "description": "Maximum job runtime. MUST be >2h for any training job \u2014 default 30m kills training mid-run. Guidelines: 1-3B models: 3-4h, 7-13B: 6-8h, 30B+: 12-24h. Use 30m-1h only for quick data processing or inference tasks. Default: '30m'." + }, + "env": { + "type": "object", + "description": "Environment variables {'KEY': 'VALUE'}. HF_TOKEN is auto-included." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for this run (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID env var and used by the UI to embed the live dashboard. Set this whenever the script uses report_to='trackio'. The Space is auto-created and seeded with the trackio dashboard before the job starts \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name to log this run under. Injected as TRACKIO_PROJECT env var and used by the UI to filter the embedded dashboard to this project." + }, + "namespace": { + "type": "string", + "description": "Optional namespace to run the job under. Must be the caller's own account or an org they belong to. If omitted, defaults to the caller's personal account. Credits are billed against this namespace." + }, + "job_id": { + "type": "string", + "description": "Job ID. Required for: logs, inspect, cancel." + }, + "scheduled_job_id": { + "type": "string", + "description": "Scheduled job ID. Required for: scheduled inspect/delete/suspend/resume." + }, + "schedule": { + "type": "string", + "description": "Cron schedule or preset (@hourly, @daily, @weekly, @monthly). Required for: scheduled run." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_files", + "description": "Read and write files in HF repos (models/datasets/spaces).\n\n## Operations\n- **list**: List files with sizes and structure\n- **read**: Read file content (text files only)\n- **upload**: Upload content to repo (can create PR)\n- **delete**: Delete files/folders (supports wildcards like *.tmp)\n\n## Use when\n- Need to see what files exist in a repo\n- Want to read config.json, README.md, or other text files\n- Uploading training scripts, configs, or results to a repo\n- Cleaning up temporary files from a repo\n\n## Examples\n{\"operation\": \"list\", \"repo_id\": \"meta-llama/Llama-2-7b\"}\n{\"operation\": \"read\", \"repo_id\": \"gpt2\", \"path\": \"config.json\"}\n{\"operation\": \"upload\", \"repo_id\": \"my-model\", \"path\": \"README.md\", \"content\": \"# My Model\"}\n{\"operation\": \"upload\", \"repo_id\": \"org/model\", \"path\": \"fix.py\", \"content\": \"...\", \"create_pr\": true}\n{\"operation\": \"delete\", \"repo_id\": \"my-model\", \"patterns\": [\"*.tmp\", \"logs/\"]}\n\n## Notes\n- For binary files (safetensors, bin), use list to see them but can't read content\n- upload/delete require approval (can overwrite/destroy data)\n- Use create_pr=true to propose changes instead of direct commit\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "list", + "read", + "upload", + "delete" + ], + "description": "Operation: list, read, upload, delete" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "revision": { + "type": "string", + "description": "Branch/tag/commit (default: main)" + }, + "path": { + "type": "string", + "description": "File path for read/upload" + }, + "content": { + "type": "string", + "description": "File content for upload" + }, + "patterns": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Patterns to delete (e.g., ['*.tmp', 'logs/'])" + }, + "create_pr": { + "type": "boolean", + "description": "Create PR instead of direct commit" + }, + "commit_message": { + "type": "string", + "description": "Custom commit message" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_git", + "description": "Git-like operations on HF repos: branches, tags, PRs, and repo management.\n\n## Operations\n**Branches:** create_branch, delete_branch, list_refs\n**Tags:** create_tag, delete_tag\n**PRs:** create_pr, list_prs, get_pr, merge_pr, close_pr, comment_pr, change_pr_status\n**Repo:** create_repo, update_repo\n\n## Use when\n- Creating feature branches for experiments\n- Tagging model versions (v1.0, v2.0)\n- Opening PRs to contribute to repos you don't own\n- Reviewing and merging PRs on your repos\n- Creating new model/dataset/space repos\n- Changing repo visibility (public/private) or gated access\n\n## Examples\n{\"operation\": \"list_refs\", \"repo_id\": \"my-model\"}\n{\"operation\": \"create_branch\", \"repo_id\": \"my-model\", \"branch\": \"experiment-v2\"}\n{\"operation\": \"create_tag\", \"repo_id\": \"my-model\", \"tag\": \"v1.0\", \"revision\": \"main\"}\n{\"operation\": \"create_pr\", \"repo_id\": \"org/model\", \"title\": \"Fix tokenizer config\"}\n{\"operation\": \"change_pr_status\", \"repo_id\": \"my-model\", \"pr_num\": 1, \"new_status\": \"open\"}\n{\"operation\": \"merge_pr\", \"repo_id\": \"my-model\", \"pr_num\": 3}\n{\"operation\": \"create_repo\", \"repo_id\": \"my-new-model\", \"private\": true}\n{\"operation\": \"update_repo\", \"repo_id\": \"my-model\", \"gated\": \"auto\"}\n\n## PR Workflow\n1. create_pr \u2192 creates draft PR (empty by default)\n2. Upload files with revision='refs/pr/N' to add commits\n3. change_pr_status with new_status='open' to publish (convert draft to open)\n4. merge_pr when ready\n\n## Notes\n- PR status: draft (default), open, merged, closed\n- delete_branch, delete_tag, merge_pr, create_repo, update_repo require approval\n- For spaces, create_repo needs space_sdk (gradio/streamlit/docker/static)\n- gated options: 'auto' (instant), 'manual' (review), false (open)\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "create_branch", + "delete_branch", + "create_tag", + "delete_tag", + "list_refs", + "create_pr", + "list_prs", + "get_pr", + "merge_pr", + "close_pr", + "comment_pr", + "change_pr_status", + "create_repo", + "update_repo" + ], + "description": "Operation to execute" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "branch": { + "type": "string", + "description": "Branch name (create_branch, delete_branch)" + }, + "from_rev": { + "type": "string", + "description": "Create branch from this revision (default: main)" + }, + "tag": { + "type": "string", + "description": "Tag name (create_tag, delete_tag)" + }, + "revision": { + "type": "string", + "description": "Revision for tag (default: main)" + }, + "tag_message": { + "type": "string", + "description": "Tag description" + }, + "title": { + "type": "string", + "description": "PR title (create_pr)" + }, + "description": { + "type": "string", + "description": "PR description (create_pr)" + }, + "pr_num": { + "type": "integer", + "description": "PR/discussion number" + }, + "comment": { + "type": "string", + "description": "Comment text" + }, + "status": { + "type": "string", + "enum": [ + "open", + "closed", + "all" + ], + "description": "Filter PRs by status (list_prs)" + }, + "new_status": { + "type": "string", + "enum": [ + "open", + "closed" + ], + "description": "New status for PR/discussion (change_pr_status)" + }, + "private": { + "type": "boolean", + "description": "Make repo private (create_repo, update_repo)" + }, + "gated": { + "type": "string", + "enum": [ + "auto", + "manual", + "false" + ], + "description": "Gated access setting (update_repo)" + }, + "space_sdk": { + "type": "string", + "enum": [ + "gradio", + "streamlit", + "docker", + "static" + ], + "description": "Space SDK (required for create_repo with space)" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_find_examples", + "description": "Find working example scripts in GitHub repositories (from a list of predetermined directories e.g. examples/, scripts/, tutorials/, etc.). Uses fuzzy keyword matching.\n\nMANDATORY before writing any ML training, fine-tuning, or inference code. Your internal knowledge of library APIs is outdated \u2014 working examples show current API patterns.\n\nSequence: github_find_examples \u2192 github_read_file (study the example) \u2192 implement based on what you found.\n\nSkip this only for: simple data queries, status checks, non-code tasks.\n\nExamples:\n {keyword: 'sft', repo: 'trl'} \u2192 finds examples/scripts/sft.py\n {keyword: 'grpo', repo: 'trl'} \u2192 finds GRPO training examples\n {repo: 'trl', max_results: 20} \u2192 lists all available training method examples", + "parameters": { + "type": "object", + "properties": { + "keyword": { + "type": "string", + "description": "Keyword to fuzzy match against file paths (e.g., 'grpo', 'sft')." + }, + "repo": { + "type": "string", + "description": "Repository name (e.g., 'trl', 'transformers'). Required." + }, + "org": { + "type": "string", + "description": "GitHub organization or username. Default: 'huggingface'." + }, + "max_results": { + "type": "integer", + "description": "Maximum number of results to return. Default: 50." + }, + "min_score": { + "type": "integer", + "description": "Minimum fuzzy match score (0-100). Default: 60." + } + }, + "required": [ + "repo" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_list_repos", + "description": "List and discover repositories for GitHub organizations or users with flexible sorting. **Use when:** (1) Exploring what libraries exist for a task, (2) Finding the right library to use, (3) Discovering popular or active projects, (4) Checking recently updated repos for latest features, (5) Finding alternative libraries in an organization. **Pattern:** github_list_repos (discover libraries) \u2192 github_find_examples (find usage examples) \u2192 implement. Returns: Comprehensive repository information (stars, forks, language, topics, URLs), sorted by preference. **Then:** Use github_find_examples on selected repo to discover example code. Sorts by: stars (popularity), forks (community), updated (activity), created (age).\n\n## When to use this tool\n\n- When you need to find libraries to use in your implementation\n- When exploring what repositories exist for a task or domain\n- When debugging an error and looking up if others have similar issues in repos\n- When finding the most popular or actively maintained projects for a user/org\n## Examples\n\n\n// ML Workflow Step: Discover HF libraries for RLHF/alignment\n// Use case: Find the right library for training with human feedback\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'stars',\n limit: 10\n}\n// Returns: transformers, trl, peft, accelerate, diffusers...\n\n\n\n// ML Workflow Step: Check for recently updated HF repos\n// Use case: Find actively maintained libraries with latest features\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'updated',\n order: 'desc',\n limit: 15\n}\n// Helps identify which repos have recent improvements/fixes\n", + "parameters": { + "type": "object", + "properties": { + "owner": { + "type": "string", + "description": "GitHub username or organization name. Required." + }, + "owner_type": { + "type": "string", + "enum": [ + "user", + "org" + ], + "description": "Whether the owner is a 'user' or 'org'. Default: 'org'." + }, + "sort": { + "type": "string", + "enum": [ + "stars", + "forks", + "updated", + "created" + ], + "description": "Sort field. Options: 'stars', 'forks', 'updated', 'created'. Default: 'stars'." + }, + "order": { + "type": "string", + "enum": [ + "asc", + "desc" + ], + "description": "Sort order. Options: 'asc', 'desc'. Default: 'desc'." + }, + "limit": { + "type": "integer", + "description": "Maximum number of repositories to return. No limit if not specified. Default: 30." + } + }, + "required": [ + "owner" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_read_file", + "description": "Read file contents from GitHub repositories. Returns first 300 lines by default. Auto-converts Jupyter notebooks to markdown.\n\nUse AFTER github_find_examples to study the working implementation. The purpose is to learn current API patterns \u2014 imports, trainer configs, dataset handling \u2014 so your implementation uses correct, up-to-date code.\n\nUse line_start/line_end for large files (>300 lines) to read specific sections.\n\nWhen NOT to use: when you don't know the file path (use github_find_examples first).", + "parameters": { + "type": "object", + "properties": { + "repo": { + "type": "string", + "description": "Repository in format 'owner/repo' (e.g., 'github/github-mcp-server'). Required." + }, + "path": { + "type": "string", + "description": "Path to file in repository (e.g., 'src/index.js'). Required." + }, + "ref": { + "type": "string", + "description": "Git reference - branch name, tag, or commit SHA. Default: 'HEAD'." + }, + "line_start": { + "type": "integer", + "description": "Starting line number (1-indexed, inclusive). Optional." + }, + "line_end": { + "type": "integer", + "description": "Ending line number (1-indexed, inclusive). Optional." + } + }, + "required": [ + "repo", + "path" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "space_search", + "description": "Find Hugging Face Spaces using semantic search. IMPORTANT Only MCP Servers can be used with the dynamic_space toolInclude links to the Space when presenting the results.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "minLength": 1, + "maxLength": 100, + "description": "Semantic Search Query" + }, + "limit": { + "type": "number", + "default": 10, + "description": "Number of results to return" + }, + "mcp": { + "type": "boolean", + "default": false, + "description": "Only return MCP Server enabled Spaces" + } + }, + "required": [ + "query" + ], + "additionalProperties": false, + "$schema": "http://json-schema.org/draft-07/schema#" + } + } + }, + { + "type": "function", + "function": { + "name": "paper_search", + "description": "Find Machine Learning research papers on the Hugging Face hub. Include 'Link to paper' When presenting the results. Consider whether tabulating results matches user intent.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "minLength": 3, + "maxLength": 200, + "description": "Semantic Search query" + }, + "results_limit": { + "type": "number", + "default": 12, + "description": "Number of results to return" + }, + "concise_only": { + "type": "boolean", + "default": false, + "description": "Return a 2 sentence summary of the abstract. Use for broad search terms which may return a lot of results. Check with User if unsure." + } + }, + "required": [ + "query" + ], + "additionalProperties": false, + "$schema": "http://json-schema.org/draft-07/schema#" + } + } + }, + { + "type": "function", + "function": { + "name": "hub_repo_details", + "description": "Get details for one or more Hugging Face repos (model, dataset, or space). Auto-detects type unless specified. For datasets, use operations: overview, dataset_structure, dataset_preview. Use dataset_structure first to discover configs, splits, sizes, and schema. Use dataset_preview only when config and split are known, unless the dataset has a single config/split.", + "parameters": { + "type": "object", + "properties": { + "repo_ids": { + "type": "array", + "items": { + "type": "string", + "minLength": 1 + }, + "minItems": 1, + "maxItems": 10, + "description": "Repo IDs for (models|dataset/space) - usually in author/name format (e.g. openai/gpt-oss-120b)" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Specify lookup type; otherwise auto-detects" + }, + "operations": { + "type": "array", + "items": { + "type": "string", + "enum": [ + "overview", + "dataset_structure", + "dataset_preview" + ] + }, + "description": "Details to return. Defaults to [\"overview\"]. For datasets, prefer [\"overview\", \"dataset_structure\"] first; then call [\"dataset_preview\"] with config and split." + }, + "config": { + "type": "string", + "description": "Dataset Viewer config. Required for dataset_preview when the dataset has multiple config/split options. Discover via dataset_structure." + }, + "split": { + "type": "string", + "description": "Dataset Viewer split. Required for dataset_preview when the dataset has multiple config/split options. Discover via dataset_structure." + }, + "offset": { + "type": "integer", + "minimum": 0, + "description": "Row offset for dataset_preview. Defaults to 0." + }, + "limit": { + "type": "integer", + "description": "Row count for dataset_preview. Defaults to 5 and is clamped to 1-100." + } + }, + "required": [ + "repo_ids" + ], + "additionalProperties": false, + "$schema": "http://json-schema.org/draft-07/schema#" + } + } + }, + { + "type": "function", + "function": { + "name": "find_hf_api", + "description": "Find HuggingFace Hub REST API endpoints to make HTTP requests. Returns curl examples with authentication. \u26a0\ufe0f USE THIS TOOL when you need to call the HF Hub API directly - for operations like: uploading/downloading files, managing repos, listing models/datasets, getting user info, managing webhooks, collections, discussions, or any Hub interaction not covered by other tools. **Use cases:** (1) 'Stream Space logs' \u2192 query='space logs', (2) 'Get Space metrics/Zero-GPU usage' \u2192 query='space metrics', (3) 'List organization members' \u2192 query='organization members', (4) 'Generate repo access token' \u2192 query='jwt token', (5) 'Check repo security scan' \u2192 query='security scan'. **Search modes:** Use 'query' for keyword search, 'tag' to browse a category, or both. If query finds no results, falls back to showing all endpoints in the tag. **Output:** Full endpoint details with method, path, parameters, curl command, and response schema.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "Keyword search across endpoint summaries, descriptions, and operation IDs. Examples: 'upload file', 'create repository', 'list user models', 'delete branch', 'webhook', 'collection', 'discussion comments'. Supports stemming (upload/uploading both work)." + }, + "tag": { + "type": "string", + "enum": [ + "agentic-provisioning", + "agents", + "auth", + "buckets", + "collections", + "container", + "datasets", + "discussions", + "docs", + "inference-endpoints", + "inference-providers", + "jobs", + "kernels", + "mcp", + "models", + "notifications", + "oauth", + "orgs", + "papers", + "repo-search", + "repos", + "resource-groups", + "scim", + "service-accounts", + "spaces", + "sql-console", + "users", + "webhooks" + ], + "description": "Filter by API category. Use alone to browse all endpoints in a category, or combine with 'query' to search within a category." + } + }, + "required": [] + } + } + } + ], + "upload_status": "pending", + "upload_url": null, + "last_save_time": "2026-06-12T12:27:36.014883" +} \ No newline at end of file diff --git a/backend/session_logs/session_691e5dca-699d-41ab-b416-8f0c51d2df1e_20260612_113914.json b/backend/session_logs/session_691e5dca-699d-41ab-b416-8f0c51d2df1e_20260612_113914.json new file mode 100644 index 0000000000000000000000000000000000000000..7be4b7d5f0db0126fe924f10b6d188bd08e251e2 --- /dev/null +++ b/backend/session_logs/session_691e5dca-699d-41ab-b416-8f0c51d2df1e_20260612_113914.json @@ -0,0 +1,1237 @@ +{ + "session_id": "691e5dca-699d-41ab-b416-8f0c51d2df1e", + "user_id": "dev", + "hf_username": "dev", + "session_start_time": "2026-06-12T11:39:09.524456-07:00", + "session_end_time": "2026-06-12T11:40:49.999354", + "model_name": "anthropic/claude-opus-4.8:fal-ai", + "total_cost_usd": 0.0, + "usage_metrics": { + "version": 1, + "session_id": "691e5dca-699d-41ab-b416-8f0c51d2df1e", + "billing_scope": "account_window_delta", + "total_usd": 0.0, + "total_usd_source": "app_telemetry_fallback", + "app_total_usd": 0.0, + "hf_billing_total_usd": null, + "app_telemetry": { + "session_id": "691e5dca-699d-41ab-b416-8f0c51d2df1e", + "total_usd": 0.0, + "inference_usd": 0.0, + "hf_jobs_estimated_usd": 0.0, + "sandbox_estimated_usd": 0.0, + "llm_calls": 2, + "hf_jobs_count": 0, + "sandbox_count": 0, + "prompt_tokens": 46576, + "completion_tokens": 9, + "cache_read_tokens": 23279, + "cache_creation_tokens": 23293, + "total_tokens": 46585, + "hf_jobs_billable_seconds_estimate": 0, + "sandbox_billable_seconds_estimate": 0 + }, + "hf_billing": { + "source": "hf_billing_usage_v2", + "available": false, + "error": "missing_hf_token", + "current_session": null + }, + "llm": { + "calls": 2, + "calls_by_kind": { + "main": 2 + }, + "calls_by_model": { + "openai/anthropic/claude-opus-4.8:fal-ai": 2 + }, + "prompt_tokens": 46576, + "completion_tokens": 9, + "cache_read_tokens": 23279, + "cache_creation_tokens": 23293, + "total_tokens": 46585 + }, + "turns": { + "turn_complete_count": 2, + "assistant_stream_end_count": 2 + }, + "hf_jobs": { + "submits": 0, + "status_snapshots": 0, + "statuses": {}, + "flavors": {}, + "submit_flavors": {}, + "status_snapshot_flavors": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0, + "snapshots_with_estimated_cost": 0, + "snapshots_with_nonzero_estimated_cost": 0 + }, + "sandboxes": { + "creates": 0, + "destroys": 0, + "matched_pairs": 0, + "unpaired_creates": 0, + "unpaired_destroys": 0, + "hardware": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0 + }, + "data_quality": { + "event_count": 12, + "events_without_timestamp": 0, + "llm_calls_with_cost_usd": 2, + "llm_calls_with_nonzero_cost_usd": 0, + "job_snapshots_with_estimated_cost": 0, + "job_snapshots_missing_estimated_cost": 0 + } + }, + "messages": [ + { + "content": "You are ML Intern, an ML engineering assistant with 19 tools for training, fine-tuning, data processing, inference, and evaluation on the Hugging Face (HF) ecosystem.\n\nYour goal is to complete what the user requested with zero errors. You are fully autonomous \u2014 research, validate, implement, and deliver results without asking for unnecessary confirmation.\n\n# Your knowledge of HF libraries is outdated\n\nYou do not know current APIs for TRL, Transformers, PEFT, Trackio, or other HF libraries. Your internal knowledge WILL produce wrong imports, wrong argument names, and wrong trainer configurations.\n\nBefore writing any ML implementation code, start from the literature. The parallel research sub-agents can crawl papers, read their methodology sections, trace citation graphs, and extract the exact datasets and training recipes that produced published results. This is your primary advantage \u2014 use it.\n\nYour default workflow for any ML task:\n1. Find the landmark paper(s) for the task or domain\n2. Crawl their citation graphs to find recent downstream work\n3. Read methodology sections (not abstracts) of the most promising papers \u2014 especially recent ones with strong results, lot of citations, and publications in high-impact conferences\n4. Extract the recipe: what dataset, what training method, what hyperparameters produced those results\n5. Validate and use those datasets for training\n\n```\nresearch({\"task\": \"Literature crawl for [task]. Start from [paper/topic]. Crawl citation graph for recent downstream papers. Read their methodology sections (3, 4, 5) \u2014 extract the exact datasets, training methods, and hyperparameters that produced their best results. Attribute every finding to a specific result (e.g. 'Dataset X + method Y \u2192 85.3% on benchmark Z'). Also find working code examples using current TRL/Transformers APIs.\", \"context\": \"User wants to [goal]. We need the best training recipe backed by published results.\"})\n```\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, and hf_papers (with citation_graph, read_paper, snippet_search, find_datasets). Be specific in your task description \u2014 name anchor papers or arxiv IDs when you have them.\n\nYou can also call research tools directly (explore_hf_docs, github_read_file, etc.) for quick lookups.\n\nSkip research only for trivial non-code operations.\n\n# Mistakes you WILL make without research\n\nHALLUCINATED IMPORTS: You will import from modules that were renamed or removed. Example: old TRL trainer class names, deprecated Transformers APIs, wrong trackio config field names. Fix: read a current example script first.\n\nWRONG TRAINER ARGUMENTS: You will pass configuration arguments that don't exist in current trainer versions. Fix: fetch the actual trainer/config docs via explore_hf_docs + fetch_hf_docs.\n\nWRONG DATASET FORMAT: You will assume column names without checking. Training fails with KeyError. Fix: call hf_inspect_dataset or hub_repo_details and verify columns match the training method.\n\nDEFAULT TIMEOUT KILLS JOBS: You will leave timeout at the default 30m for training jobs. Training takes hours. The job gets killed and all progress is lost. Fix: set timeout based on model size (minimum 2h for any training).\n\nLOST MODELS: You will forget push_to_hub=True and hub_model_id in training config. Job storage is ephemeral \u2014 the filesystem is deleted when the job ends. Without push_to_hub, the trained model is permanently lost.\n\nBATCH FAILURES: You will submit all ablation/batch jobs at once without testing that one works first. All will fail for the same bug. Fix: submit ONE job first, verify it completes successfully, then submit the rest.\n\nSILENT DATASET SUBSTITUTION: When a requested dataset fails to load, you will silently switch to a different one without telling the user. Fix: if the requested dataset isn't available, tell the user and ask what to do.\n\nPREFER HUB KERNELS OVER COMPILING ATTENTION: Do NOT pip install 'flash-attn' to enable flash_attention_2 building from source can take many minutes to hours and often fails on the job's CUDA/PyTorch combo. Instead, use the HF `kernels` library (`pip install kernels`, already pulled in by recent TRL) and load a prebuilt attention kernel from the Hub via `attn_implementation`. Examples: `AutoModelForCausalLM.from_pretrained(..., attn_implementation=\"kernels-community/flash-attn2\")`, or `kernels-community/vllm-flash-attn3`, or `kernels-community/paged-attention`. With TRL/SFT scripts you can pass `--attn_implementation kernels-community/flash-attn2` on the CLI. Search additional kernels at https://huggingface.co/models?other=kernel. Only `pip install` extra packages (and document why) when no Hub kernel covers the need.\n\nSCOPE-CHANGING FIXES: Avoid at all costs! When you hit an error (especially OOM), you will try \"creative\" workarounds that change what the user asked for and/or change the training task itself \u2014 switching full SFT to LoRA on OOM, reducing max_length (silently truncates training data and changes what the model learns), disabling monitoring instead of fixing it. Do not do this. Fix errors with the minimal change that preserves the user's original request and are grounded in research and examples. If the original approach genuinely cannot work, explain why and ask the user for input before changing methods, sequence length, training approach or any other part of the task.\n\n# When writing ML code\n\nRequired sequence before any training/fine-tuning/inference script:\n1. Use `research` tool to find working examples, read docs, and get current API patterns\n2. Validate dataset: hf_inspect_dataset or hub_repo_details to confirm column names and format\n3. Validate model: hub_repo_details to confirm model exists, correct architecture/size/tokenizer\n\nTraining logging: always set disable_tqdm=True, logging_strategy=\"steps\", and logging_first_step=True in your TrainingArguments/SFTConfig so loss values are printed as plain text lines you can grep, not hidden inside tqdm progress bars.\n\nDataset format requirements by training method:\n SFT: \"messages\", \"text\", or \"prompt\"/\"completion\"\n DPO: \"prompt\", \"chosen\", \"rejected\"\n GRPO: \"prompt\"\n\n# Trackio\n\nTrackio is natively integrated with Transformers Trainer and all TRL trainers \u2014 the built-in TrackioCallback handles init/log/finish. In TrainingArguments/SFTConfig/DPOConfig/GRPOConfig set:\n report_to=\"trackio\"\n run_name=\"\" # e.g. \"sft_qwen3-4b_lr2e-5_bs128\"\n project=\"\" # keeps related runs grouped so you can compare them\n trackio_space_id=\"/ml-intern-<8-char-id>\" # creates a public dashboard Space\n`project` and `trackio_space_id` can also be set via TRACKIO_PROJECT / TRACKIO_SPACE_ID env vars.\n\nAlerts are how iterations decide what to change. Use trackio.alert(title, text, level) at every decision point in training. Levels:\n ERROR \u2014 stop and change approach (divergence, NaN, OOM)\n WARN \u2014 tweak hyperparameters (overfitting, early stopping, KL spike, reward collapse, slow convergence)\n INFO \u2014 milestones (training complete, target reached, checkpoint saved)\nAlways include numeric values and an actionable suggestion in `text`, e.g. \"loss=12.4 at step 200 \u2014 lr likely too high, try \u00d70.1\". A future call must be able to parse it and act on it.\n\nTo add alerts under Trainer/SFTTrainer/GRPOTrainer, pass a custom TrainerCallback via `callbacks=[...]` that calls trackio.alert() inside `on_log` (training metrics like loss, reward, kl) and `on_evaluate` (eval metrics \u2014 only available here, not in `on_log`). Keep each `if` simple: one metric, one threshold. Conditions stay easy to adjust between runs.\n\nRead alerts back between runs instead of parsing thousands of metric values. CLI \u2014 always use --json:\n trackio get alerts --project

--run --json\n trackio get alerts --project

--since --json # incremental polling\n trackio get run --project

--run --json\n trackio get metric --project

--run --metric --json\n trackio list runs --project

--json\nPython: api = trackio.Api(); api.alerts(

, run=, since=); api.runs(

) (each run has .name, .config, .alerts()).\n\nDrive the next config from prior alerts:\n diverged \u2192 lr \u00d7 0.1\n overfitting \u2192 weight_decay \u00d7 10 or reduce capacity\n early stopping \u2192 lr \u00d7 0.5 or adjust schedule\n high accuracy \u2192 refine around current config\nRead prior config via api.runs(...).config and only mutate keys the alerts justify changing.\n\n# Data audit\n\nBefore working with any dataset, audit it first. Do not assume you know what the data looks like \u2014 inspect it.\n\nUse hf_inspect_dataset to check: schema/columns, number of rows per split, value distributions for key columns, sample rows. Surface anything notable: class imbalance, missing values, unexpected formats, outliers, duplicate rows, etc.\n\nLooking at data is the best way to boost performance of any ML model plus it reduces the likelihood of failed jobs later.\n\n# When submitting a training job\n\nNever pass a local machine path to hf_jobs.script, such as /Users/..., /home/..., /fsx/..., or a repo checkout path. HF Jobs runs in a fresh cloud environment where local files do not exist. For hf_jobs.script, use exactly one of:\n - inline Python source code\n - a file already written in the session sandbox, e.g. /app/train.py, ./train.py, or train.py\n - a public/raw URL\nIf you wrote or tested a script locally, read the file content and submit it inline, or write it into the sandbox first.\n\nGPU preflight is mandatory before hf_jobs when the job will run on GPU, or when the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile. First create a GPU sandbox with sandbox_create (t4-small minimum; choose larger hardware when VRAM requires it), run a tiny smoke test there using the same imports, model-loading path, training entrypoint, and a tiny dataset/subset, then fix failures before submitting. If you skip GPU sandbox preflight, state why before calling hf_jobs.\n\nBefore calling hf_jobs, output a pre-flight check:\n - Reference implementation: [which example you based this on]\n - Dataset format verified: [columns confirmed via hf_inspect_dataset/hub_repo_details]\n - GPU sandbox smoke test: [hardware and result, or explicitly not applicable because ...]\n - push_to_hub=True and hub_model_id set\n - timeout: [value] (based on: [model size] on [hardware])\n - Trackio monitoring included and deploying metrics to a public Space\n\nIf you cannot fill in all items, stop and complete the missing steps first.\n\nFor batch/ablation jobs: submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once.\n\nHardware sizing:\n 1-3B params: a10g-largex2\n 7-13B params: a100-large\n 30B+ params: l40sx4 or a100x4\n 70B+ params: a100x8\nNote: a10g-small and a10g-large have the SAME 24GB GPU memory. The difference is CPU/RAM only.\n\n# Sandbox-first development\n\nA private cpu-basic sandbox is already available for normal code execution in each session. For non-trivial scripts, develop and test there before launching via hf_jobs:\n write script \u2192 pip install \u2192 test with small run using bash/read/write/edit \u2192 fix errors \u2192 launch via hf_jobs at scale\n\nDo NOT call sandbox_create before normal CPU work. Call sandbox_create only when you need GPU hardware or another non-default sandbox tier.\n\nThe sandbox filesystem does not survive session resumption. If a session is resumed, any files, installed packages, or running processes from earlier are gone \u2014 recreate what you need before relying on the sandbox.\n\nUse a GPU sandbox (t4-small minimum) when testing code that uses CUDA, bf16/fp16, quantization, flash attention, torch.compile, or model loading. CPU sandboxes cannot test GPU code paths. If the available sandbox tiers cannot fit the full model path, test the largest useful smoke path, state what was not covered, and submit one HF job first.\n\n\n# When a task has 3+ steps\n\nUse plan_tool to track progress. One task in_progress at a time. Mark completed immediately after finishing. Update frequently to show the user what you're doing.\n\n# Error recovery\n\nWhen something fails:\n- Diagnose the actual error. Read the full error message and logs.\n- Do not retry the exact same thing. Identify what needs to change.\n- If an API/import error: check documentation for the correct API.\n- If an OOM error: (1) reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally to keep effective batch size identical, (2) enable gradient_checkpointing=True, (3) upgrade to larger GPU (a10gx4\u2192a100\u2192a100x4\u2192a100x8). Do NOT switch training methods (e.g. SFT\u2192LoRA) or reduce max_length \u2014 those change what the user gets. If OOM happens in sandbox, create a new sandbox with larger GPU hardware.\n- Never change the user's requested approach (training method, dataset, model, sequence length) without explicit approval.\n- If a tool call fails repeatedly for the same reason: stop and try a different approach.\n- Never silently substitute resources (datasets, models) \u2014 tell the user if something isn't available.\n\n# Task completion\n\nBefore ending your turn, verify:\n- Did you actually DO what the user asked, not just explain what you would do?\n- If something failed: did you diagnose and fix it, or at minimum explain what went wrong and ask for user input?\n- For training jobs: did you include a working Trackio dashboard URL?\n\nDo not stop after describing what you plan to do. Continue calling tools until the task is verifiably done.\nDo not mark plan tasks as completed if they failed or are only partially done.\n\n# Autonomous / headless mode\n\nWhen running autonomously (no human in the loop), you MUST follow these rules:\n\nNEVER respond with only text. Every response MUST include at least one tool call. If you have nothing to do, check the plan, verify outputs or plan ahead. A text-only response ends the agent loop permanently \u2014 there is no human to re-prompt you.\n\nNEVER STOP WORKING. Do NOT decide you are \"done\" while time remains. The human is not watching \u2014 they expect you to use the ENTIRE time budget productively. Do NOT ask \"should I continue?\" or \"is this a good stopping point?\" \u2014 there is nobody to answer. You run until the timer expires or you are manually killed.\n\nYour workflow is a loop, not a checklist. Once you have a working result, KEEP ITERATING:\n\nLOOP UNTIL TIME RUNS OUT:\n1. Research the approach (read docs, find examples, check current APIs)\n2. Implement the solution (write code, set up training)\n3. Train and evaluate\n4. Save the model to the required output location / push it to Hugging Face Hub\n5. Improve: tune hyperparameters, try different data, adjust the training recipe, try a different approach entirely\n6. Go to step 1\n\nHYPERPARAMETER TUNING: Do not tune hyperparameters by hand one-at-a-time. Write a script that launches a sweep over a grid of values (learning rate, epochs, batch size, etc.) and evaluates each run automatically. One well-designed sweep script beats ten manual experiments.\n\nIf you run out of ideas: go back to the literature. Crawl citation graphs deeper \u2014 find papers you haven't read yet, read their methodology sections, extract new datasets or training tricks. Look for papers that cite your current approach and improved on it. Try combining recipes from different papers. Re-read the task prompt for angles you missed. Re-read the training logs for clues. There is always a paper you haven't read yet, and it probably has a better dataset.\n\nCheck the remaining time periodically with the timer command specified in the task prompt. Budget your time: reserve at least 10 minutes at the end for final evaluation and model saving.\n\nThe task is NOT done until:\n- The required output exists (e.g. final model, metrics reached, dataset updated etc)\n- You have evaluated the model and confirmed it works\n\n# Communication\n\n- Be concise and direct. No filler, no restating what the user said.\n- One-word answers when appropriate for simple questions.\n- Always include direct Hub URLs when referencing models, datasets, Spaces, or jobs.\n- For errors: state what went wrong, why, and what you're doing to fix it.\n- Do not over-explain or present elaborate option menus for simple tasks. When the user's intent is clear, act on it. Present options only when there's genuine ambiguity.\n- Use the `notify` tool only when the user explicitly asked for out-of-band notifications or when the task clearly requires reporting to a configured messaging destination. Do not use it for routine chat updates.\n\n# Tool usage\n\n- Execute multiple independent tool calls in parallel when possible.\n- HF_TOKEN is automatically available in job secrets \u2014 no need to include it extra.\n- For training monitoring: include Trackio in the script and provide the dashboard URL.\n- For private/gated datasets: HF_TOKEN is needed \u2014 it's auto-loaded into job secrets.\n\n[Session context: Date=12-06-2026, Time=20:39:09.520, Timezone=CEST (UTC+02:00), User=unknown, Tools=19]", + "role": "system", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "say ok", + "role": "user", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "Ok", + "role": "assistant", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "reply with just: hi", + "role": "user", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "hi", + "role": "assistant", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + } + ], + "events": [ + { + "timestamp": "2026-06-12T11:39:10.299933-07:00", + "event_type": "ready", + "data": { + "message": "Agent initialized" + } + }, + { + "timestamp": "2026-06-12T11:39:10.300123-07:00", + "event_type": "processing", + "data": { + "message": "Processing user input" + } + }, + { + "timestamp": "2026-06-12T11:39:13.797047-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "Ok" + } + }, + { + "timestamp": "2026-06-12T11:39:13.999362-07:00", + "event_type": "llm_call", + "data": { + "model": "openai/anthropic/claude-opus-4.8:fal-ai", + "latency_ms": 3698, + "finish_reason": "stop", + "cost_usd": 0.0, + "kind": "main", + "prompt_tokens": 23281, + "completion_tokens": 5, + "total_tokens": 23286, + "cache_read_tokens": 0, + "cache_creation_tokens": 23279 + } + }, + { + "timestamp": "2026-06-12T11:39:13.999397-07:00", + "event_type": "assistant_stream_end", + "data": {} + }, + { + "timestamp": "2026-06-12T11:39:13.999577-07:00", + "event_type": "turn_complete", + "data": { + "history_size": 3, + "final_response": "Ok" + } + }, + { + "timestamp": "2026-06-12T11:39:39.057733-07:00", + "event_type": "processing", + "data": { + "message": "Processing user input" + } + }, + { + "timestamp": "2026-06-12T11:39:44.519178-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "h" + } + }, + { + "timestamp": "2026-06-12T11:39:44.578396-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "i" + } + }, + { + "timestamp": "2026-06-12T11:39:44.632961-07:00", + "event_type": "llm_call", + "data": { + "model": "openai/anthropic/claude-opus-4.8:fal-ai", + "latency_ms": 5574, + "finish_reason": "stop", + "cost_usd": 0.0, + "kind": "main", + "prompt_tokens": 23295, + "completion_tokens": 4, + "total_tokens": 23299, + "cache_read_tokens": 23279, + "cache_creation_tokens": 14 + } + }, + { + "timestamp": "2026-06-12T11:39:44.632992-07:00", + "event_type": "assistant_stream_end", + "data": {} + }, + { + "timestamp": "2026-06-12T11:39:44.633114-07:00", + "event_type": "turn_complete", + "data": { + "history_size": 5, + "final_response": "hi" + } + } + ], + "tools": [ + { + "type": "function", + "function": { + "name": "sandbox_create", + "description": "Create or replace the session sandbox when non-default hardware is needed.\n\nA private cpu-basic sandbox is already started automatically for each session. For normal CPU code execution, call bash/read/write/edit directly; do NOT call sandbox_create first.\n\nUse sandbox_create when: you need GPU hardware, cpu-upgrade, or Trackio secrets before running code. The active sandbox persists across tool calls within the session. pip install works out of the box. Sandboxes are always created as private HF Spaces.\n\nFor ML code that uses CUDA, bf16, or model loading: use GPU hardware (t4-small minimum). CPU sandboxes cannot run GPU code paths \u2014 your test will not catch GPU-related errors.\n\nBefore choosing hardware, estimate your VRAM needs (models you run, training data size). Rule of thumb: bf16/fp16 \u2248 2 bytes/param, fp32 \u2248 4 bytes/param, plus ~20% overhead for optimizer states during training.\nCommon picks: t4-small (16GB VRAM, fits \u22641-3B), a10g-small (24GB, \u22647B), a100-large (80GB, \u226430B). If the model won't fit, pick larger hardware upfront \u2014 OOM on a sandbox wastes time.\n\nIf you intend to run a training script in this sandbox that uses report_to='trackio', pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` so they are set as TRACKIO_SPACE_ID/TRACKIO_PROJECT secrets in the sandbox and the UI can embed the live dashboard.\n\nHardware: cpu-basic, cpu-upgrade, cpu-performance, cpu-xl, sprx8, zero-a10g, t4-small, t4-medium, l4x1, l4x4, l40sx1, l40sx4, l40sx8, a10g-small, a10g-large, a10g-largex2, a10g-largex4, a100-large, a100x4, a100x8, h200, h200x2, h200x4, h200x8, inf2x6.\n", + "parameters": { + "type": "object", + "required": [], + "additionalProperties": false, + "properties": { + "hardware": { + "type": "string", + "enum": [ + "cpu-basic", + "cpu-upgrade", + "cpu-performance", + "cpu-xl", + "sprx8", + "zero-a10g", + "t4-small", + "t4-medium", + "l4x1", + "l4x4", + "l40sx1", + "l40sx4", + "l40sx8", + "a10g-small", + "a10g-large", + "a10g-largex2", + "a10g-largex4", + "a100-large", + "a100x4", + "a100x8", + "h200", + "h200x2", + "h200x4", + "h200x8", + "inf2x6" + ], + "description": "Hardware tier for the sandbox. Omit for the existing auto-started cpu-basic sandbox; choose GPU/cpu-upgrade only when needed." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for runs in this sandbox (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID secret and surfaced to the UI. The Space is auto-created and seeded with the trackio dashboard \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name. Injected as TRACKIO_PROJECT secret and used by the UI to filter the embedded dashboard to this project." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "bash", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nRun a shell command in the remote sandbox and return stdout/stderr.\n\nIMPORTANT: Do NOT use bash for file operations \u2014 use the dedicated tools instead:\n- To read files: use read (not cat/head/tail)\n- To edit files: use edit (not sed/awk)\n- To write files: use write (not echo/cat < > /app/output.log 2>&1 & echo $!\nThen check status:\n kill -0 2>/dev/null && echo 'running' || echo 'done'\n tail -n 50 /app/output.log\n\nTimeout default 240s, max 1200s.", + "parameters": { + "type": "object", + "required": [ + "command" + ], + "additionalProperties": false, + "properties": { + "command": { + "type": "string", + "description": "The shell command to execute." + }, + "description": { + "type": "string", + "description": "Short description (5-10 words, active voice)." + }, + "work_dir": { + "type": "string", + "description": "Working directory (default: /app)." + }, + "timeout": { + "type": "integer", + "description": "Optional timeout in seconds (default: 240, max: 1200)." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "read", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nReads a file from the sandbox filesystem. Returns contents with line numbers (cat -n format).\n\nUsage:\n- By default, reads up to 2000 lines from the beginning of the file.\n- You can optionally specify offset and limit for large files, but prefer reading the whole file first.\n- Lines longer than 4000 chars are truncated.\n- Cannot read directories \u2014 use bash with 'ls' instead.\n- You should read multiple potentially useful files in parallel when possible.\n- IMPORTANT: Always read a file before editing or overwriting it. The edit and write tools will reject operations on files you haven't read.", + "parameters": { + "type": "object", + "required": [ + "path" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to read." + }, + "offset": { + "type": "integer", + "description": "The line number to start reading from (1-based). Only provide if the file is too large to read at once." + }, + "limit": { + "type": "integer", + "description": "The number of lines to read. Only provide if the file is too large to read at once." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "write", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nWrites a file to the sandbox filesystem. Overwrites the existing file if one exists at the path.\n\n- If this is an existing file, you MUST use the read tool first. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files with the edit tool over overwriting with write.\n- Creates parent directories as needed.", + "parameters": { + "type": "object", + "required": [ + "path", + "content" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to write." + }, + "content": { + "type": "string", + "description": "The complete file content to write." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "edit", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nPerforms string replacements in files. Supports exact matching with fuzzy fallback.\n\nUsage:\n- You must read the file at least once before editing. This tool will error if you attempt an edit without reading the file.\n- The edit will FAIL if old_str is not unique in the file. Either provide a larger string with more surrounding context to make it unique, or set replace_all to true.\n- old_str and new_str must differ.\n- Preserve indentation exactly as it appears in the file.\n- Do NOT include line number prefixes from read output in old_str or new_str.\n- To delete code, set new_str to empty string.\n- Use replace_all for renaming variables or strings across the file.\n\nModes:\n- replace (default): replace first occurrence of old_str with new_str.\n- append_after: insert new_str immediately after old_str (old_str is kept).\n- prepend_before: insert new_str immediately before old_str (old_str is kept).", + "parameters": { + "type": "object", + "required": [ + "path", + "old_str", + "new_str" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to edit." + }, + "old_str": { + "type": "string", + "description": "The text to find in the file. Must match exactly (fuzzy matching is used as fallback)." + }, + "new_str": { + "type": "string", + "description": "The replacement text. For append_after/prepend_before modes, the text to insert." + }, + "replace_all": { + "type": "boolean", + "description": "Replace all occurrences of old_str (default: false).", + "default": false + }, + "mode": { + "type": "string", + "enum": [ + "replace", + "append_after", + "prepend_before" + ], + "description": "Edit mode (default: replace).", + "default": "replace" + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "research", + "description": "Spawn a research sub-agent to explore documentation, codebases, or repos WITHOUT polluting the main conversation context. The sub-agent gets its own independent context window with read-only research tools and returns a concise summary of findings.\n\nUse this for:\n- Researching current API usage before implementing ML tasks (find examples + read docs)\n- Exploring HF docs, reading papers, analyzing GitHub repos\n- Any research where raw tool outputs would be too verbose\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, hf_papers, etc. Just describe what you need researched.", + "parameters": { + "type": "object", + "properties": { + "task": { + "type": "string", + "description": "Detailed description of what to research. Be specific: include library names, trainer types, dataset names, repo names, or doc pages to explore. Example: 'Research current TRL SFTTrainer usage: find working example scripts, read the SFT documentation, and check SFTConfig parameters. Also validate that dataset HuggingFaceH4/ultrachat_200k has the right format for SFT.'" + }, + "context": { + "type": "string", + "description": "Optional context from the current conversation that the research agent needs (e.g., what the user wants to build, constraints, what's been tried)." + } + }, + "required": [ + "task" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "explore_hf_docs", + "description": "Browse HF documentation structure \u2014 discover all available documentation with 200-char previews.\n\nUse this to find relevant documentation and/or examples with detailed parameter docs and API reference. To be used together with github_find_examples and github_read_file to find working examples and documentation.\n\nPattern: explore_hf_docs (find relevant pages) \u2192 fetch_hf_docs (get full content).\n\nFor training tasks: fetch the trainer config docs (SFTConfig, DPOConfig, GRPOConfig) to verify parameter names. Returns top 20 results by default; set max_results (max 50) to adjust.", + "parameters": { + "type": "object", + "properties": { + "endpoint": { + "type": "string", + "enum": [ + "hub", + "transformers", + "diffusers", + "datasets", + "gradio", + "trackio", + "smolagents", + "huggingface_hub", + "huggingface.js", + "transformers.js", + "inference-providers", + "inference-endpoints", + "peft", + "accelerate", + "optimum", + "tokenizers", + "courses", + "evaluate", + "tasks", + "dataset-viewer", + "trl", + "simulate", + "sagemaker", + "timm", + "safetensors", + "tgi", + "setfit", + "lerobot", + "autotrain", + "tei", + "bitsandbytes", + "sentence_transformers", + "chat-ui", + "leaderboards", + "lighteval", + "argilla", + "distilabel", + "microsoft-azure", + "kernels", + "google-cloud" + ], + "description": "The documentation endpoint to explore. Each endpoint corresponds to a major section of the Hugging Face documentation:\n\n\u2022 courses \u2014 All Hugging Face courses (LLM, robotics, MCP, smol (llm training), agents, deep RL, computer vision, games, diffusion, 3D, audio) and the cookbook recipes. Probably the best place for examples.\n\u2022 hub \u2014 Find answers to questions about models/datasets/spaces, auth, versioning, metadata.\n\u2022 transformers \u2014 Core model library: architectures, configs, tokenizers, training & inference APIs.\n\u2022 diffusers \u2014 Diffusion pipelines, schedulers, fine-tuning, training, and deployment patterns.\n\u2022 datasets \u2014 Dataset loading, streaming, processing, Arrow format, Hub integration.\n\u2022 gradio \u2014 UI components and demos for ML models. Uses Gradio's native API: without query returns full docs (llms.txt), with query uses embedding search for precise results.\n\u2022 trackio \u2014 Experiment tracking, metrics logging, and run comparison.\n\u2022 smolagents \u2014 Lightweight agent abstractions and tool-using patterns.\n\u2022 huggingface_hub \u2014 Python client for Hub operations (auth, upload/download, repo management).\n\u2022 huggingface.js \u2014 JS/TS client for Hub APIs in browser and Node.\n\u2022 transformers.js \u2014 Run Transformer models in browser/Node via WebGPU/WASM.\n\u2022 inference-providers \u2014 Unified interface for third-party inference backends.\n\u2022 inference-endpoints \u2014 Managed, scalable model deployments on HF infrastructure.\n\u2022 peft \u2014 Parameter-efficient fine-tuning methods (LoRA, adapters, etc.).\n\u2022 accelerate \u2014 Hardware-agnostic, distributed and mixed-precision training orchestration.\n\u2022 optimum \u2014 Hardware-aware optimization and model export tooling, including Habana, Neuron, Intel, ExecuTorch, and TPU variants.\n\u2022 tokenizers \u2014 Fast tokenizer internals, training, and low-level APIs.\n\u2022 evaluate \u2014 Metrics, evaluation workflows, and training-loop integration.\n\u2022 tasks \u2014 Canonical task definitions and model categorization.\n\u2022 dataset-viewer \u2014 Dataset preview, streaming views, and viewer internals.\n\u2022 trl \u2014 RLHF, DPO, PPO, and SFT utilities for LLMs.\n\u2022 simulate \u2014 Experimental simulation tools and workflows.\n\u2022 sagemaker \u2014 Deploying Hugging Face models on AWS SageMaker.\n\u2022 timm \u2014 Image model zoo and utilities via HF integrations.\n\u2022 safetensors \u2014 Safe, fast tensor serialization format.\n\u2022 tgi \u2014 High-throughput text generation server for LLMs.\n\u2022 setfit \u2014 Few-shot text classification via sentence embeddings.\n\u2022 lerobot \u2014 Robotics datasets, policies, and learning workflows.\n\u2022 autotrain \u2014 No/low-code model training on Hugging Face.\n\u2022 tei \u2014 Optimized inference server for embedding workloads.\n\u2022 bitsandbytes \u2014 Quantization and memory-efficient optimizers.\n\u2022 sentence_transformers \u2014 Embedding models, training recipes, similarity/search workflows.\n\u2022 chat-ui \u2014 Reference chat interfaces for LLM deployment.\n\u2022 leaderboards \u2014 Evaluation leaderboards and submission mechanics.\n\u2022 lighteval \u2014 Lightweight, reproducible LLM evaluation framework.\n\u2022 argilla \u2014 Data annotation, feedback, and human-in-the-loop workflows.\n\u2022 distilabel \u2014 Synthetic data generation and distillation pipelines.\n\u2022 microsoft-azure \u2014 Azure deployment and integration guides.\n\u2022 kernels \u2014 Load prebuilt compute kernels (E.g. flash-attn2) from the Hub via `attn_implementation`; avoids compiling flash-attn from source.\n\u2022 google-cloud \u2014 GCP deployment and serving workflows.\n" + }, + "query": { + "type": "string", + "description": "Optional keyword query to rank and filter documentation pages. For Gradio, use concise queries like 'how to use the image component' or 'audio component demo'." + }, + "max_results": { + "type": "integer", + "description": "Max results (default 20, max 50). Ignored for Gradio.", + "minimum": 1, + "maximum": 50 + } + }, + "required": [ + "endpoint" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "fetch_hf_docs", + "description": "Fetch full markdown content of an HF documentation page. Use after explore_hf_docs.\n\nCritical for finding documentation e.g. current trainer configuration parameters (SFTConfig, DPOConfig, etc.) Use for researching solutions and before writing training scripts. Your internal knowledge is outdated.\n\nProvide the full URL from explore_hf_docs results. The .md extension is added automatically.", + "parameters": { + "type": "object", + "properties": { + "url": { + "type": "string", + "description": "The full URL to the documentation page. Example: 'https://huggingface.co/docs/trl/dpo_trainer' The .md extension will be added automatically if not present." + } + }, + "required": [ + "url" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_papers", + "description": "Discover ML research papers, analyze citations, search paper contents, and find linked resources.\n\nCombines HuggingFace Hub, arXiv, and Semantic Scholar. Use for exploring research areas, finding datasets for a task, tracing citation chains, or implementing a paper's approach.\n\nTypical flows:\n search \u2192 read_paper \u2192 find_all_resources \u2192 hf_inspect_dataset\n search \u2192 paper_details \u2192 citation_graph \u2192 read_paper (trace influence)\n snippet_search \u2192 paper_details \u2192 read_paper (find specific claims)\n\nOperations:\n- trending: Get trending daily papers, optionally filter by topic keyword\n- search: Search papers. Uses HF by default (ML-tuned). Add date_from/min_citations/categories to use Semantic Scholar with filters\n- paper_details: Metadata, abstract, AI summary, github link\n- read_paper: Read paper contents \u2014 without section: abstract + TOC; with section: full text\n- citation_graph: Get references and citations for a paper with influence flags and citation intents\n- snippet_search: Semantic search over full-text passages from 12M+ papers\n- recommend: Find similar papers (single paper or positive/negative examples)\n- find_datasets: Find datasets linked to a paper\n- find_models: Find models linked to a paper\n- find_collections: Find collections that include a paper\n- find_all_resources: Parallel fetch of datasets + models + collections for a paper", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "trending", + "search", + "paper_details", + "read_paper", + "citation_graph", + "snippet_search", + "recommend", + "find_datasets", + "find_models", + "find_collections", + "find_all_resources" + ], + "description": "Operation to execute." + }, + "query": { + "type": "string", + "description": "Search query. Required for: search, snippet_search. Optional for: trending (filters by keyword). Supports boolean syntax for Semantic Scholar: '\"exact phrase\" term1 | term2'." + }, + "arxiv_id": { + "type": "string", + "description": "ArXiv paper ID (e.g. '2305.18290'). Required for: paper_details, read_paper, citation_graph, find_datasets, find_models, find_collections, find_all_resources. Optional for: recommend (single-paper recs). Get IDs from search results first." + }, + "section": { + "type": "string", + "description": "Section name or number to read (e.g. '3', 'Experiments', '4.2'). Optional for: read_paper. Without this, returns abstract + TOC." + }, + "direction": { + "type": "string", + "enum": [ + "citations", + "references", + "both" + ], + "description": "Direction for citation_graph. Default: both." + }, + "date": { + "type": "string", + "description": "Date in YYYY-MM-DD format. Optional for: trending (defaults to recent papers)." + }, + "date_from": { + "type": "string", + "description": "Start date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "date_to": { + "type": "string", + "description": "End date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "categories": { + "type": "string", + "description": "Field of study filter (e.g. 'Computer Science'). Triggers Semantic Scholar search." + }, + "min_citations": { + "type": "integer", + "description": "Minimum citation count filter. Triggers Semantic Scholar search." + }, + "sort_by": { + "type": "string", + "enum": [ + "relevance", + "citationCount", + "publicationDate" + ], + "description": "Sort order for Semantic Scholar search. Default: relevance." + }, + "positive_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs for multi-paper recommendations. For: recommend." + }, + "negative_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs as negative examples. For: recommend." + }, + "sort": { + "type": "string", + "enum": [ + "downloads", + "likes", + "trending" + ], + "description": "Sort order for find_datasets and find_models. Default: downloads." + }, + "limit": { + "type": "integer", + "description": "Maximum results to return (default: 10, max: 50)." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "web_search", + "description": "Search the web for current information and return cited results.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "minLength": 2 + }, + "allowed_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional allowlist of domains or URLs. Subdomains match." + }, + "blocked_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional blocklist of domains or URLs. Subdomains match." + } + }, + "required": [ + "query" + ], + "additionalProperties": false + } + } + }, + { + "type": "function", + "function": { + "name": "hf_inspect_dataset", + "description": "Inspect a HF dataset in one call: status, configs/splits, schema, sample rows, parquet info.\n\nREQUIRED before any training job to verify dataset format matches training method:\n SFT: needs 'messages', 'text', or 'prompt'/'completion'\n DPO: needs 'prompt', 'chosen', 'rejected'\n GRPO: needs 'prompt'\nAll datasets used for training have to be in conversational ChatML format to be compatible with HF libraries.'\nTraining will fail with KeyError if columns don't match.\n\nAlso use to get example datapoints, understand column names, data types, and available splits before writing any data loading code. Supports private/gated datasets when HF_TOKEN is set.", + "parameters": { + "type": "object", + "properties": { + "dataset": { + "type": "string", + "description": "Dataset ID in 'org/name' format (e.g., 'stanfordnlp/imdb')" + }, + "config": { + "type": "string", + "description": "Config/subset name. Auto-detected if not specified." + }, + "split": { + "type": "string", + "description": "Split for sample rows. Auto-detected if not specified." + }, + "sample_rows": { + "type": "integer", + "description": "Number of sample rows to show (default: 3, max: 10)", + "default": 3 + } + }, + "required": [ + "dataset" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "plan_tool", + "description": "Track progress on multi-step tasks with a todo list (pending/in_progress/completed).\n\nUse for tasks with 3+ steps. Each call replaces the entire plan (send full list).\n\nRules: exactly ONE task in_progress at a time. Mark completed immediately after finishing. Only mark completed when the task fully succeeded \u2014 keep in_progress if there are errors. Update frequently so the user sees progress.", + "parameters": { + "type": "object", + "properties": { + "todos": { + "type": "array", + "description": "List of todo items", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "Unique identifier for the todo" + }, + "content": { + "type": "string", + "description": "Description of the todo task" + }, + "status": { + "type": "string", + "enum": [ + "pending", + "in_progress", + "completed" + ], + "description": "Current status of the todo" + } + }, + "required": [ + "id", + "content", + "status" + ] + } + } + }, + "required": [ + "todos" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "notify", + "description": "Send an out-of-band notification to configured messaging destinations. Use this only when the user explicitly asked for proactive notifications or when the task requires reporting progress outside the chat. Destinations must be named server-side configs such as 'slack.ops'.", + "parameters": { + "type": "object", + "properties": { + "destinations": { + "type": "array", + "description": "Named messaging destinations to notify.", + "items": { + "type": "string" + }, + "minItems": 1 + }, + "message": { + "type": "string", + "description": "Main notification body." + }, + "title": { + "type": "string", + "description": "Optional short title line." + }, + "severity": { + "type": "string", + "enum": [ + "info", + "success", + "warning", + "error" + ], + "description": "Notification severity label." + } + }, + "required": [ + "destinations", + "message" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_jobs", + "description": "Execute Python scripts or Docker containers on HF cloud infrastructure.\n\nTwo modes (mutually exclusive): Python mode (script + dependencies) or Docker mode (command + image). Provide exactly ONE of 'script' or 'command'.\n\nBEFORE submitting training/fine-tuning jobs:\n- You MUST have called github_find_examples + github_read_file to find a working reference implementation. Scripts based on your internal knowledge WILL use outdated APIs and fail.\n- You MUST have validated dataset format via hf_inspect_dataset or hub_repo_details.\n- If the job runs on GPU, or the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile, you MUST create a GPU sandbox with sandbox_create first, run a tiny smoke test there, and fix failures before submitting. If skipped, state why before calling hf_jobs.\n- Training config MUST include push_to_hub=True and hub_model_id. Job storage is EPHEMERAL \u2014 all files are deleted when the job ends. Without push_to_hub, trained models are lost permanently.\n- Include trackio monitoring and provide the dashboard URL to the user. When the script uses report_to='trackio', also pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` as tool args \u2014 they are injected as TRACKIO_SPACE_ID/TRACKIO_PROJECT env vars and let the UI embed the live dashboard.\n\nBATCH/ABLATION JOBS: Submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once \u2014 if there's a bug, all jobs fail.\n\nOperations: run, ps, logs, inspect, cancel, scheduled run/ps/inspect/delete/suspend/resume.\n\nHardware: CPU: cpu-basic(2vCPU/16GB), cpu-upgrade(8vCPU/32GB). GPU: t4-small(4vCPU/15GB/GPU 16GB), t4-medium(8vCPU/30GB/GPU 16GB), a10g-small(4vCPU/15GB/GPU 24GB), a10g-large(12vCPU/46GB/GPU 24GB), a10g-largex2(24vCPU/92GB/GPU 48GB), a10g-largex4(48vCPU/184GB/GPU 96GB), a100-large(12vCPU/142GB/GPU 80GB), a100x4(48vCPU/568GB/GPU 320GB), a100x8(96vCPU/1136GB/GPU 640GB), l4x1(8vCPU/30GB/GPU 24GB), l4x4(48vCPU/186GB/GPU 96GB), l40sx1(8vCPU/62GB/GPU 48GB), l40sx4(48vCPU/382GB/GPU 192GB), l40sx8(192vCPU/1534GB/GPU 384GB).\nCommon picks: t4-small ($0.60/hr, 1-3B), a10g-large ($2/hr, 7-13B), a100-large ($4/hr, 30B+), h100 ($6/hr, 70B+). Note: a10g-small and a10g-large have the SAME 24GB GPU \u2014 the difference is CPU/RAM only.\n\nOOM RECOVERY: When a training job fails with CUDA OOM:\n1. Reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally (keep effective batch size identical)\n2. Enable gradient_checkpointing=True\n3. Upgrade to larger GPU (a10g\u2192a100\u2192h100)\nDo NOT switch training methods (e.g. full SFT to LoRA) or reduce max_length \u2014 those change what the user gets and require explicit approval.\n\nExamples:\nTraining: {'operation': 'run', 'script': '/app/train.py', 'dependencies': ['transformers', 'trl', 'torch', 'datasets', 'trackio'], 'hardware_flavor': 'a100-large', 'timeout': '8h'}\nMonitor: {'operation': 'ps'}, {'operation': 'logs', 'job_id': 'xxx'}, {'operation': 'cancel', 'job_id': 'xxx'}Docker: {'operation': 'run', 'command': ['duckdb', '-c', 'select 1 + 2'], 'image': 'duckdb/duckdb', 'hardware_flavor': 'cpu-basic', 'timeout': '1h'}\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "run", + "ps", + "logs", + "inspect", + "cancel", + "scheduled run", + "scheduled ps", + "scheduled inspect", + "scheduled delete", + "scheduled suspend", + "scheduled resume" + ], + "description": "Operation to execute." + }, + "script": { + "type": "string", + "description": "Python code, sandbox file path (e.g. '/app/train.py', './train.py', or bare 'train.py'), or URL. Triggers Python mode. For ML training: base this on a working example found via github_find_examples, not on internal knowledge. For GPU/model-loading training scripts, smoke-test in a GPU sandbox before submission. Mutually exclusive with 'command'." + }, + "dependencies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Pip packages to install. Include ALL required packages. Common training set: ['transformers', 'trl', 'torch', 'datasets', 'trackio', 'accelerate']. Only used with 'script'." + }, + "image": { + "type": "string", + "description": "Docker image. Optional \u2014 auto-selected if not provided. Use with 'command'." + }, + "command": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Command to execute as list. Triggers Docker mode. Mutually exclusive with 'script'." + }, + "hardware_flavor": { + "type": "string", + "description": "Hardware type. Sizing guide: 1-3B params \u2192 t4-small/a10g-small, 7-13B \u2192 a10g-large, 30B+ \u2192 a100-large, 70B+ \u2192 h100/h100x8. All options: CPU: ['cpu-basic', 'cpu-upgrade']. GPU: ['t4-small', 't4-medium', 'a10g-small', 'a10g-large', 'a10g-largex2', 'a10g-largex4', 'a100-large', 'a100x4', 'a100x8', 'l4x1', 'l4x4', 'l40sx1', 'l40sx4', 'l40sx8']." + }, + "timeout": { + "type": "string", + "description": "Maximum job runtime. MUST be >2h for any training job \u2014 default 30m kills training mid-run. Guidelines: 1-3B models: 3-4h, 7-13B: 6-8h, 30B+: 12-24h. Use 30m-1h only for quick data processing or inference tasks. Default: '30m'." + }, + "env": { + "type": "object", + "description": "Environment variables {'KEY': 'VALUE'}. HF_TOKEN is auto-included." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for this run (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID env var and used by the UI to embed the live dashboard. Set this whenever the script uses report_to='trackio'. The Space is auto-created and seeded with the trackio dashboard before the job starts \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name to log this run under. Injected as TRACKIO_PROJECT env var and used by the UI to filter the embedded dashboard to this project." + }, + "namespace": { + "type": "string", + "description": "Optional namespace to run the job under. Must be the caller's own account or an org they belong to. If omitted, defaults to the caller's personal account. Credits are billed against this namespace." + }, + "job_id": { + "type": "string", + "description": "Job ID. Required for: logs, inspect, cancel." + }, + "scheduled_job_id": { + "type": "string", + "description": "Scheduled job ID. Required for: scheduled inspect/delete/suspend/resume." + }, + "schedule": { + "type": "string", + "description": "Cron schedule or preset (@hourly, @daily, @weekly, @monthly). Required for: scheduled run." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_files", + "description": "Read and write files in HF repos (models/datasets/spaces).\n\n## Operations\n- **list**: List files with sizes and structure\n- **read**: Read file content (text files only)\n- **upload**: Upload content to repo (can create PR)\n- **delete**: Delete files/folders (supports wildcards like *.tmp)\n\n## Use when\n- Need to see what files exist in a repo\n- Want to read config.json, README.md, or other text files\n- Uploading training scripts, configs, or results to a repo\n- Cleaning up temporary files from a repo\n\n## Examples\n{\"operation\": \"list\", \"repo_id\": \"meta-llama/Llama-2-7b\"}\n{\"operation\": \"read\", \"repo_id\": \"gpt2\", \"path\": \"config.json\"}\n{\"operation\": \"upload\", \"repo_id\": \"my-model\", \"path\": \"README.md\", \"content\": \"# My Model\"}\n{\"operation\": \"upload\", \"repo_id\": \"org/model\", \"path\": \"fix.py\", \"content\": \"...\", \"create_pr\": true}\n{\"operation\": \"delete\", \"repo_id\": \"my-model\", \"patterns\": [\"*.tmp\", \"logs/\"]}\n\n## Notes\n- For binary files (safetensors, bin), use list to see them but can't read content\n- upload/delete require approval (can overwrite/destroy data)\n- Use create_pr=true to propose changes instead of direct commit\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "list", + "read", + "upload", + "delete" + ], + "description": "Operation: list, read, upload, delete" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "revision": { + "type": "string", + "description": "Branch/tag/commit (default: main)" + }, + "path": { + "type": "string", + "description": "File path for read/upload" + }, + "content": { + "type": "string", + "description": "File content for upload" + }, + "patterns": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Patterns to delete (e.g., ['*.tmp', 'logs/'])" + }, + "create_pr": { + "type": "boolean", + "description": "Create PR instead of direct commit" + }, + "commit_message": { + "type": "string", + "description": "Custom commit message" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_git", + "description": "Git-like operations on HF repos: branches, tags, PRs, and repo management.\n\n## Operations\n**Branches:** create_branch, delete_branch, list_refs\n**Tags:** create_tag, delete_tag\n**PRs:** create_pr, list_prs, get_pr, merge_pr, close_pr, comment_pr, change_pr_status\n**Repo:** create_repo, update_repo\n\n## Use when\n- Creating feature branches for experiments\n- Tagging model versions (v1.0, v2.0)\n- Opening PRs to contribute to repos you don't own\n- Reviewing and merging PRs on your repos\n- Creating new model/dataset/space repos\n- Changing repo visibility (public/private) or gated access\n\n## Examples\n{\"operation\": \"list_refs\", \"repo_id\": \"my-model\"}\n{\"operation\": \"create_branch\", \"repo_id\": \"my-model\", \"branch\": \"experiment-v2\"}\n{\"operation\": \"create_tag\", \"repo_id\": \"my-model\", \"tag\": \"v1.0\", \"revision\": \"main\"}\n{\"operation\": \"create_pr\", \"repo_id\": \"org/model\", \"title\": \"Fix tokenizer config\"}\n{\"operation\": \"change_pr_status\", \"repo_id\": \"my-model\", \"pr_num\": 1, \"new_status\": \"open\"}\n{\"operation\": \"merge_pr\", \"repo_id\": \"my-model\", \"pr_num\": 3}\n{\"operation\": \"create_repo\", \"repo_id\": \"my-new-model\", \"private\": true}\n{\"operation\": \"update_repo\", \"repo_id\": \"my-model\", \"gated\": \"auto\"}\n\n## PR Workflow\n1. create_pr \u2192 creates draft PR (empty by default)\n2. Upload files with revision='refs/pr/N' to add commits\n3. change_pr_status with new_status='open' to publish (convert draft to open)\n4. merge_pr when ready\n\n## Notes\n- PR status: draft (default), open, merged, closed\n- delete_branch, delete_tag, merge_pr, create_repo, update_repo require approval\n- For spaces, create_repo needs space_sdk (gradio/streamlit/docker/static)\n- gated options: 'auto' (instant), 'manual' (review), false (open)\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "create_branch", + "delete_branch", + "create_tag", + "delete_tag", + "list_refs", + "create_pr", + "list_prs", + "get_pr", + "merge_pr", + "close_pr", + "comment_pr", + "change_pr_status", + "create_repo", + "update_repo" + ], + "description": "Operation to execute" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "branch": { + "type": "string", + "description": "Branch name (create_branch, delete_branch)" + }, + "from_rev": { + "type": "string", + "description": "Create branch from this revision (default: main)" + }, + "tag": { + "type": "string", + "description": "Tag name (create_tag, delete_tag)" + }, + "revision": { + "type": "string", + "description": "Revision for tag (default: main)" + }, + "tag_message": { + "type": "string", + "description": "Tag description" + }, + "title": { + "type": "string", + "description": "PR title (create_pr)" + }, + "description": { + "type": "string", + "description": "PR description (create_pr)" + }, + "pr_num": { + "type": "integer", + "description": "PR/discussion number" + }, + "comment": { + "type": "string", + "description": "Comment text" + }, + "status": { + "type": "string", + "enum": [ + "open", + "closed", + "all" + ], + "description": "Filter PRs by status (list_prs)" + }, + "new_status": { + "type": "string", + "enum": [ + "open", + "closed" + ], + "description": "New status for PR/discussion (change_pr_status)" + }, + "private": { + "type": "boolean", + "description": "Make repo private (create_repo, update_repo)" + }, + "gated": { + "type": "string", + "enum": [ + "auto", + "manual", + "false" + ], + "description": "Gated access setting (update_repo)" + }, + "space_sdk": { + "type": "string", + "enum": [ + "gradio", + "streamlit", + "docker", + "static" + ], + "description": "Space SDK (required for create_repo with space)" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_find_examples", + "description": "Find working example scripts in GitHub repositories (from a list of predetermined directories e.g. examples/, scripts/, tutorials/, etc.). Uses fuzzy keyword matching.\n\nMANDATORY before writing any ML training, fine-tuning, or inference code. Your internal knowledge of library APIs is outdated \u2014 working examples show current API patterns.\n\nSequence: github_find_examples \u2192 github_read_file (study the example) \u2192 implement based on what you found.\n\nSkip this only for: simple data queries, status checks, non-code tasks.\n\nExamples:\n {keyword: 'sft', repo: 'trl'} \u2192 finds examples/scripts/sft.py\n {keyword: 'grpo', repo: 'trl'} \u2192 finds GRPO training examples\n {repo: 'trl', max_results: 20} \u2192 lists all available training method examples", + "parameters": { + "type": "object", + "properties": { + "keyword": { + "type": "string", + "description": "Keyword to fuzzy match against file paths (e.g., 'grpo', 'sft')." + }, + "repo": { + "type": "string", + "description": "Repository name (e.g., 'trl', 'transformers'). Required." + }, + "org": { + "type": "string", + "description": "GitHub organization or username. Default: 'huggingface'." + }, + "max_results": { + "type": "integer", + "description": "Maximum number of results to return. Default: 50." + }, + "min_score": { + "type": "integer", + "description": "Minimum fuzzy match score (0-100). Default: 60." + } + }, + "required": [ + "repo" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_list_repos", + "description": "List and discover repositories for GitHub organizations or users with flexible sorting. **Use when:** (1) Exploring what libraries exist for a task, (2) Finding the right library to use, (3) Discovering popular or active projects, (4) Checking recently updated repos for latest features, (5) Finding alternative libraries in an organization. **Pattern:** github_list_repos (discover libraries) \u2192 github_find_examples (find usage examples) \u2192 implement. Returns: Comprehensive repository information (stars, forks, language, topics, URLs), sorted by preference. **Then:** Use github_find_examples on selected repo to discover example code. Sorts by: stars (popularity), forks (community), updated (activity), created (age).\n\n## When to use this tool\n\n- When you need to find libraries to use in your implementation\n- When exploring what repositories exist for a task or domain\n- When debugging an error and looking up if others have similar issues in repos\n- When finding the most popular or actively maintained projects for a user/org\n## Examples\n\n\n// ML Workflow Step: Discover HF libraries for RLHF/alignment\n// Use case: Find the right library for training with human feedback\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'stars',\n limit: 10\n}\n// Returns: transformers, trl, peft, accelerate, diffusers...\n\n\n\n// ML Workflow Step: Check for recently updated HF repos\n// Use case: Find actively maintained libraries with latest features\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'updated',\n order: 'desc',\n limit: 15\n}\n// Helps identify which repos have recent improvements/fixes\n", + "parameters": { + "type": "object", + "properties": { + "owner": { + "type": "string", + "description": "GitHub username or organization name. Required." + }, + "owner_type": { + "type": "string", + "enum": [ + "user", + "org" + ], + "description": "Whether the owner is a 'user' or 'org'. Default: 'org'." + }, + "sort": { + "type": "string", + "enum": [ + "stars", + "forks", + "updated", + "created" + ], + "description": "Sort field. Options: 'stars', 'forks', 'updated', 'created'. Default: 'stars'." + }, + "order": { + "type": "string", + "enum": [ + "asc", + "desc" + ], + "description": "Sort order. Options: 'asc', 'desc'. Default: 'desc'." + }, + "limit": { + "type": "integer", + "description": "Maximum number of repositories to return. No limit if not specified. Default: 30." + } + }, + "required": [ + "owner" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_read_file", + "description": "Read file contents from GitHub repositories. Returns first 300 lines by default. Auto-converts Jupyter notebooks to markdown.\n\nUse AFTER github_find_examples to study the working implementation. The purpose is to learn current API patterns \u2014 imports, trainer configs, dataset handling \u2014 so your implementation uses correct, up-to-date code.\n\nUse line_start/line_end for large files (>300 lines) to read specific sections.\n\nWhen NOT to use: when you don't know the file path (use github_find_examples first).", + "parameters": { + "type": "object", + "properties": { + "repo": { + "type": "string", + "description": "Repository in format 'owner/repo' (e.g., 'github/github-mcp-server'). Required." + }, + "path": { + "type": "string", + "description": "Path to file in repository (e.g., 'src/index.js'). Required." + }, + "ref": { + "type": "string", + "description": "Git reference - branch name, tag, or commit SHA. Default: 'HEAD'." + }, + "line_start": { + "type": "integer", + "description": "Starting line number (1-indexed, inclusive). Optional." + }, + "line_end": { + "type": "integer", + "description": "Ending line number (1-indexed, inclusive). Optional." + } + }, + "required": [ + "repo", + "path" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "find_hf_api", + "description": "Find HuggingFace Hub REST API endpoints to make HTTP requests. Returns curl examples with authentication. \u26a0\ufe0f USE THIS TOOL when you need to call the HF Hub API directly - for operations like: uploading/downloading files, managing repos, listing models/datasets, getting user info, managing webhooks, collections, discussions, or any Hub interaction not covered by other tools. **Use cases:** (1) 'Stream Space logs' \u2192 query='space logs', (2) 'Get Space metrics/Zero-GPU usage' \u2192 query='space metrics', (3) 'List organization members' \u2192 query='organization members', (4) 'Generate repo access token' \u2192 query='jwt token', (5) 'Check repo security scan' \u2192 query='security scan'. **Search modes:** Use 'query' for keyword search, 'tag' to browse a category, or both. If query finds no results, falls back to showing all endpoints in the tag. **Output:** Full endpoint details with method, path, parameters, curl command, and response schema.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "Keyword search across endpoint summaries, descriptions, and operation IDs. Examples: 'upload file', 'create repository', 'list user models', 'delete branch', 'webhook', 'collection', 'discussion comments'. Supports stemming (upload/uploading both work)." + }, + "tag": { + "type": "string", + "enum": [ + "agentic-provisioning", + "agents", + "auth", + "buckets", + "collections", + "container", + "datasets", + "discussions", + "docs", + "inference-endpoints", + "inference-providers", + "jobs", + "kernels", + "mcp", + "models", + "notifications", + "oauth", + "orgs", + "papers", + "repo-search", + "repos", + "resource-groups", + "scim", + "service-accounts", + "spaces", + "sql-console", + "users", + "webhooks" + ], + "description": "Filter by API category. Use alone to browse all endpoints in a category, or combine with 'query' to search within a category." + } + }, + "required": [] + } + } + } + ], + "upload_status": "failed", + "upload_url": null, + "last_save_time": "2026-06-12T11:41:01.383118", + "personal_upload_status": "failed" +} \ No newline at end of file diff --git a/backend/session_logs/session_b08dc56b-d1bc-4bde-afb5-e43e3705f93c_20260612_114011.json b/backend/session_logs/session_b08dc56b-d1bc-4bde-afb5-e43e3705f93c_20260612_114011.json new file mode 100644 index 0000000000000000000000000000000000000000..e2942d026ff421e06a44033bc58fde1c80636679 --- /dev/null +++ b/backend/session_logs/session_b08dc56b-d1bc-4bde-afb5-e43e3705f93c_20260612_114011.json @@ -0,0 +1,1229 @@ +{ + "session_id": "b08dc56b-d1bc-4bde-afb5-e43e3705f93c", + "user_id": "dev", + "hf_username": "dev", + "session_start_time": "2026-06-12T11:39:59.522971-07:00", + "session_end_time": "2026-06-12T11:40:50.010596", + "model_name": "anthropic/claude-opus-4.8:fal-ai", + "total_cost_usd": 0.0, + "usage_metrics": { + "version": 1, + "session_id": "b08dc56b-d1bc-4bde-afb5-e43e3705f93c", + "billing_scope": "account_window_delta", + "total_usd": 0.0, + "total_usd_source": "app_telemetry_fallback", + "app_total_usd": 0.0, + "hf_billing_total_usd": null, + "app_telemetry": { + "session_id": "b08dc56b-d1bc-4bde-afb5-e43e3705f93c", + "total_usd": 0.0, + "inference_usd": 0.0, + "hf_jobs_estimated_usd": 0.0, + "sandbox_estimated_usd": 0.0, + "llm_calls": 1, + "hf_jobs_count": 0, + "sandbox_count": 0, + "prompt_tokens": 23292, + "completion_tokens": 745, + "cache_read_tokens": 0, + "cache_creation_tokens": 23290, + "total_tokens": 24037, + "hf_jobs_billable_seconds_estimate": 0, + "sandbox_billable_seconds_estimate": 0 + }, + "hf_billing": { + "source": "hf_billing_usage_v2", + "available": false, + "error": "missing_hf_token", + "current_session": null + }, + "llm": { + "calls": 1, + "calls_by_kind": { + "main": 1 + }, + "calls_by_model": { + "openai/anthropic/claude-opus-4.8:fal-ai": 1 + }, + "prompt_tokens": 23292, + "completion_tokens": 745, + "cache_read_tokens": 0, + "cache_creation_tokens": 23290, + "total_tokens": 24037 + }, + "turns": { + "turn_complete_count": 1, + "assistant_stream_end_count": 1 + }, + "hf_jobs": { + "submits": 0, + "status_snapshots": 0, + "statuses": {}, + "flavors": {}, + "submit_flavors": {}, + "status_snapshot_flavors": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0, + "snapshots_with_estimated_cost": 0, + "snapshots_with_nonzero_estimated_cost": 0 + }, + "sandboxes": { + "creates": 0, + "destroys": 0, + "matched_pairs": 0, + "unpaired_creates": 0, + "unpaired_destroys": 0, + "hardware": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0 + }, + "data_quality": { + "event_count": 14, + "events_without_timestamp": 0, + "llm_calls_with_cost_usd": 1, + "llm_calls_with_nonzero_cost_usd": 0, + "job_snapshots_with_estimated_cost": 0, + "job_snapshots_missing_estimated_cost": 0 + } + }, + "messages": [ + { + "content": "You are ML Intern, an ML engineering assistant with 19 tools for training, fine-tuning, data processing, inference, and evaluation on the Hugging Face (HF) ecosystem.\n\nYour goal is to complete what the user requested with zero errors. You are fully autonomous \u2014 research, validate, implement, and deliver results without asking for unnecessary confirmation.\n\n# Your knowledge of HF libraries is outdated\n\nYou do not know current APIs for TRL, Transformers, PEFT, Trackio, or other HF libraries. Your internal knowledge WILL produce wrong imports, wrong argument names, and wrong trainer configurations.\n\nBefore writing any ML implementation code, start from the literature. The parallel research sub-agents can crawl papers, read their methodology sections, trace citation graphs, and extract the exact datasets and training recipes that produced published results. This is your primary advantage \u2014 use it.\n\nYour default workflow for any ML task:\n1. Find the landmark paper(s) for the task or domain\n2. Crawl their citation graphs to find recent downstream work\n3. Read methodology sections (not abstracts) of the most promising papers \u2014 especially recent ones with strong results, lot of citations, and publications in high-impact conferences\n4. Extract the recipe: what dataset, what training method, what hyperparameters produced those results\n5. Validate and use those datasets for training\n\n```\nresearch({\"task\": \"Literature crawl for [task]. Start from [paper/topic]. Crawl citation graph for recent downstream papers. Read their methodology sections (3, 4, 5) \u2014 extract the exact datasets, training methods, and hyperparameters that produced their best results. Attribute every finding to a specific result (e.g. 'Dataset X + method Y \u2192 85.3% on benchmark Z'). Also find working code examples using current TRL/Transformers APIs.\", \"context\": \"User wants to [goal]. We need the best training recipe backed by published results.\"})\n```\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, and hf_papers (with citation_graph, read_paper, snippet_search, find_datasets). Be specific in your task description \u2014 name anchor papers or arxiv IDs when you have them.\n\nYou can also call research tools directly (explore_hf_docs, github_read_file, etc.) for quick lookups.\n\nSkip research only for trivial non-code operations.\n\n# Mistakes you WILL make without research\n\nHALLUCINATED IMPORTS: You will import from modules that were renamed or removed. Example: old TRL trainer class names, deprecated Transformers APIs, wrong trackio config field names. Fix: read a current example script first.\n\nWRONG TRAINER ARGUMENTS: You will pass configuration arguments that don't exist in current trainer versions. Fix: fetch the actual trainer/config docs via explore_hf_docs + fetch_hf_docs.\n\nWRONG DATASET FORMAT: You will assume column names without checking. Training fails with KeyError. Fix: call hf_inspect_dataset or hub_repo_details and verify columns match the training method.\n\nDEFAULT TIMEOUT KILLS JOBS: You will leave timeout at the default 30m for training jobs. Training takes hours. The job gets killed and all progress is lost. Fix: set timeout based on model size (minimum 2h for any training).\n\nLOST MODELS: You will forget push_to_hub=True and hub_model_id in training config. Job storage is ephemeral \u2014 the filesystem is deleted when the job ends. Without push_to_hub, the trained model is permanently lost.\n\nBATCH FAILURES: You will submit all ablation/batch jobs at once without testing that one works first. All will fail for the same bug. Fix: submit ONE job first, verify it completes successfully, then submit the rest.\n\nSILENT DATASET SUBSTITUTION: When a requested dataset fails to load, you will silently switch to a different one without telling the user. Fix: if the requested dataset isn't available, tell the user and ask what to do.\n\nPREFER HUB KERNELS OVER COMPILING ATTENTION: Do NOT pip install 'flash-attn' to enable flash_attention_2 building from source can take many minutes to hours and often fails on the job's CUDA/PyTorch combo. Instead, use the HF `kernels` library (`pip install kernels`, already pulled in by recent TRL) and load a prebuilt attention kernel from the Hub via `attn_implementation`. Examples: `AutoModelForCausalLM.from_pretrained(..., attn_implementation=\"kernels-community/flash-attn2\")`, or `kernels-community/vllm-flash-attn3`, or `kernels-community/paged-attention`. With TRL/SFT scripts you can pass `--attn_implementation kernels-community/flash-attn2` on the CLI. Search additional kernels at https://huggingface.co/models?other=kernel. Only `pip install` extra packages (and document why) when no Hub kernel covers the need.\n\nSCOPE-CHANGING FIXES: Avoid at all costs! When you hit an error (especially OOM), you will try \"creative\" workarounds that change what the user asked for and/or change the training task itself \u2014 switching full SFT to LoRA on OOM, reducing max_length (silently truncates training data and changes what the model learns), disabling monitoring instead of fixing it. Do not do this. Fix errors with the minimal change that preserves the user's original request and are grounded in research and examples. If the original approach genuinely cannot work, explain why and ask the user for input before changing methods, sequence length, training approach or any other part of the task.\n\n# When writing ML code\n\nRequired sequence before any training/fine-tuning/inference script:\n1. Use `research` tool to find working examples, read docs, and get current API patterns\n2. Validate dataset: hf_inspect_dataset or hub_repo_details to confirm column names and format\n3. Validate model: hub_repo_details to confirm model exists, correct architecture/size/tokenizer\n\nTraining logging: always set disable_tqdm=True, logging_strategy=\"steps\", and logging_first_step=True in your TrainingArguments/SFTConfig so loss values are printed as plain text lines you can grep, not hidden inside tqdm progress bars.\n\nDataset format requirements by training method:\n SFT: \"messages\", \"text\", or \"prompt\"/\"completion\"\n DPO: \"prompt\", \"chosen\", \"rejected\"\n GRPO: \"prompt\"\n\n# Trackio\n\nTrackio is natively integrated with Transformers Trainer and all TRL trainers \u2014 the built-in TrackioCallback handles init/log/finish. In TrainingArguments/SFTConfig/DPOConfig/GRPOConfig set:\n report_to=\"trackio\"\n run_name=\"\" # e.g. \"sft_qwen3-4b_lr2e-5_bs128\"\n project=\"\" # keeps related runs grouped so you can compare them\n trackio_space_id=\"/ml-intern-<8-char-id>\" # creates a public dashboard Space\n`project` and `trackio_space_id` can also be set via TRACKIO_PROJECT / TRACKIO_SPACE_ID env vars.\n\nAlerts are how iterations decide what to change. Use trackio.alert(title, text, level) at every decision point in training. Levels:\n ERROR \u2014 stop and change approach (divergence, NaN, OOM)\n WARN \u2014 tweak hyperparameters (overfitting, early stopping, KL spike, reward collapse, slow convergence)\n INFO \u2014 milestones (training complete, target reached, checkpoint saved)\nAlways include numeric values and an actionable suggestion in `text`, e.g. \"loss=12.4 at step 200 \u2014 lr likely too high, try \u00d70.1\". A future call must be able to parse it and act on it.\n\nTo add alerts under Trainer/SFTTrainer/GRPOTrainer, pass a custom TrainerCallback via `callbacks=[...]` that calls trackio.alert() inside `on_log` (training metrics like loss, reward, kl) and `on_evaluate` (eval metrics \u2014 only available here, not in `on_log`). Keep each `if` simple: one metric, one threshold. Conditions stay easy to adjust between runs.\n\nRead alerts back between runs instead of parsing thousands of metric values. CLI \u2014 always use --json:\n trackio get alerts --project

--run --json\n trackio get alerts --project

--since --json # incremental polling\n trackio get run --project

--run --json\n trackio get metric --project

--run --metric --json\n trackio list runs --project

--json\nPython: api = trackio.Api(); api.alerts(

, run=, since=); api.runs(

) (each run has .name, .config, .alerts()).\n\nDrive the next config from prior alerts:\n diverged \u2192 lr \u00d7 0.1\n overfitting \u2192 weight_decay \u00d7 10 or reduce capacity\n early stopping \u2192 lr \u00d7 0.5 or adjust schedule\n high accuracy \u2192 refine around current config\nRead prior config via api.runs(...).config and only mutate keys the alerts justify changing.\n\n# Data audit\n\nBefore working with any dataset, audit it first. Do not assume you know what the data looks like \u2014 inspect it.\n\nUse hf_inspect_dataset to check: schema/columns, number of rows per split, value distributions for key columns, sample rows. Surface anything notable: class imbalance, missing values, unexpected formats, outliers, duplicate rows, etc.\n\nLooking at data is the best way to boost performance of any ML model plus it reduces the likelihood of failed jobs later.\n\n# When submitting a training job\n\nNever pass a local machine path to hf_jobs.script, such as /Users/..., /home/..., /fsx/..., or a repo checkout path. HF Jobs runs in a fresh cloud environment where local files do not exist. For hf_jobs.script, use exactly one of:\n - inline Python source code\n - a file already written in the session sandbox, e.g. /app/train.py, ./train.py, or train.py\n - a public/raw URL\nIf you wrote or tested a script locally, read the file content and submit it inline, or write it into the sandbox first.\n\nGPU preflight is mandatory before hf_jobs when the job will run on GPU, or when the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile. First create a GPU sandbox with sandbox_create (t4-small minimum; choose larger hardware when VRAM requires it), run a tiny smoke test there using the same imports, model-loading path, training entrypoint, and a tiny dataset/subset, then fix failures before submitting. If you skip GPU sandbox preflight, state why before calling hf_jobs.\n\nBefore calling hf_jobs, output a pre-flight check:\n - Reference implementation: [which example you based this on]\n - Dataset format verified: [columns confirmed via hf_inspect_dataset/hub_repo_details]\n - GPU sandbox smoke test: [hardware and result, or explicitly not applicable because ...]\n - push_to_hub=True and hub_model_id set\n - timeout: [value] (based on: [model size] on [hardware])\n - Trackio monitoring included and deploying metrics to a public Space\n\nIf you cannot fill in all items, stop and complete the missing steps first.\n\nFor batch/ablation jobs: submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once.\n\nHardware sizing:\n 1-3B params: a10g-largex2\n 7-13B params: a100-large\n 30B+ params: l40sx4 or a100x4\n 70B+ params: a100x8\nNote: a10g-small and a10g-large have the SAME 24GB GPU memory. The difference is CPU/RAM only.\n\n# Sandbox-first development\n\nA private cpu-basic sandbox is already available for normal code execution in each session. For non-trivial scripts, develop and test there before launching via hf_jobs:\n write script \u2192 pip install \u2192 test with small run using bash/read/write/edit \u2192 fix errors \u2192 launch via hf_jobs at scale\n\nDo NOT call sandbox_create before normal CPU work. Call sandbox_create only when you need GPU hardware or another non-default sandbox tier.\n\nThe sandbox filesystem does not survive session resumption. If a session is resumed, any files, installed packages, or running processes from earlier are gone \u2014 recreate what you need before relying on the sandbox.\n\nUse a GPU sandbox (t4-small minimum) when testing code that uses CUDA, bf16/fp16, quantization, flash attention, torch.compile, or model loading. CPU sandboxes cannot test GPU code paths. If the available sandbox tiers cannot fit the full model path, test the largest useful smoke path, state what was not covered, and submit one HF job first.\n\n\n# When a task has 3+ steps\n\nUse plan_tool to track progress. One task in_progress at a time. Mark completed immediately after finishing. Update frequently to show the user what you're doing.\n\n# Error recovery\n\nWhen something fails:\n- Diagnose the actual error. Read the full error message and logs.\n- Do not retry the exact same thing. Identify what needs to change.\n- If an API/import error: check documentation for the correct API.\n- If an OOM error: (1) reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally to keep effective batch size identical, (2) enable gradient_checkpointing=True, (3) upgrade to larger GPU (a10gx4\u2192a100\u2192a100x4\u2192a100x8). Do NOT switch training methods (e.g. SFT\u2192LoRA) or reduce max_length \u2014 those change what the user gets. If OOM happens in sandbox, create a new sandbox with larger GPU hardware.\n- Never change the user's requested approach (training method, dataset, model, sequence length) without explicit approval.\n- If a tool call fails repeatedly for the same reason: stop and try a different approach.\n- Never silently substitute resources (datasets, models) \u2014 tell the user if something isn't available.\n\n# Task completion\n\nBefore ending your turn, verify:\n- Did you actually DO what the user asked, not just explain what you would do?\n- If something failed: did you diagnose and fix it, or at minimum explain what went wrong and ask for user input?\n- For training jobs: did you include a working Trackio dashboard URL?\n\nDo not stop after describing what you plan to do. Continue calling tools until the task is verifiably done.\nDo not mark plan tasks as completed if they failed or are only partially done.\n\n# Autonomous / headless mode\n\nWhen running autonomously (no human in the loop), you MUST follow these rules:\n\nNEVER respond with only text. Every response MUST include at least one tool call. If you have nothing to do, check the plan, verify outputs or plan ahead. A text-only response ends the agent loop permanently \u2014 there is no human to re-prompt you.\n\nNEVER STOP WORKING. Do NOT decide you are \"done\" while time remains. The human is not watching \u2014 they expect you to use the ENTIRE time budget productively. Do NOT ask \"should I continue?\" or \"is this a good stopping point?\" \u2014 there is nobody to answer. You run until the timer expires or you are manually killed.\n\nYour workflow is a loop, not a checklist. Once you have a working result, KEEP ITERATING:\n\nLOOP UNTIL TIME RUNS OUT:\n1. Research the approach (read docs, find examples, check current APIs)\n2. Implement the solution (write code, set up training)\n3. Train and evaluate\n4. Save the model to the required output location / push it to Hugging Face Hub\n5. Improve: tune hyperparameters, try different data, adjust the training recipe, try a different approach entirely\n6. Go to step 1\n\nHYPERPARAMETER TUNING: Do not tune hyperparameters by hand one-at-a-time. Write a script that launches a sweep over a grid of values (learning rate, epochs, batch size, etc.) and evaluates each run automatically. One well-designed sweep script beats ten manual experiments.\n\nIf you run out of ideas: go back to the literature. Crawl citation graphs deeper \u2014 find papers you haven't read yet, read their methodology sections, extract new datasets or training tricks. Look for papers that cite your current approach and improved on it. Try combining recipes from different papers. Re-read the task prompt for angles you missed. Re-read the training logs for clues. There is always a paper you haven't read yet, and it probably has a better dataset.\n\nCheck the remaining time periodically with the timer command specified in the task prompt. Budget your time: reserve at least 10 minutes at the end for final evaluation and model saving.\n\nThe task is NOT done until:\n- The required output exists (e.g. final model, metrics reached, dataset updated etc)\n- You have evaluated the model and confirmed it works\n\n# Communication\n\n- Be concise and direct. No filler, no restating what the user said.\n- One-word answers when appropriate for simple questions.\n- Always include direct Hub URLs when referencing models, datasets, Spaces, or jobs.\n- For errors: state what went wrong, why, and what you're doing to fix it.\n- Do not over-explain or present elaborate option menus for simple tasks. When the user's intent is clear, act on it. Present options only when there's genuine ambiguity.\n- Use the `notify` tool only when the user explicitly asked for out-of-band notifications or when the task clearly requires reporting to a configured messaging destination. Do not use it for routine chat updates.\n\n# Tool usage\n\n- Execute multiple independent tool calls in parallel when possible.\n- HF_TOKEN is automatically available in job secrets \u2014 no need to include it extra.\n- For training monitoring: include Trackio in the script and provide the dashboard URL.\n- For private/gated datasets: HF_TOKEN is needed \u2014 it's auto-loaded into job secrets.\n\n[Session context: Date=12-06-2026, Time=20:39:59.521, Timezone=CEST (UTC+02:00), User=unknown, Tools=19]", + "role": "system", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "count slowly from 1 to 100 in words", + "role": "user", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "One, two, three, four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen, fourteen, fifteen, sixteen, seventeen, eighteen, nineteen, twenty, twenty-one, twenty-two, twenty-three, twenty-four, twenty-five, twenty-six, twenty-seven, twenty-eight, twenty-nine, thirty, thirty-one, thirty-two, thirty-three, thirty-four, thirty-five, thirty-six, thirty-seven, thirty-eight, thirty-nine, forty, forty-one, forty-two, forty-three, forty-four, forty-five, forty-six, forty-seven, forty-eight, forty-nine, fifty, fifty-one, fifty-two, fifty-three, fifty-four, fifty-five, fifty-six, fifty-seven, fifty-eight, fifty-nine, sixty, sixty-one, sixty-two, sixty-three, sixty-four, sixty-five, sixty-six, sixty-seven, sixty-eight, sixty-nine, seventy, seventy-one, seventy-two, seventy-three, seventy-four, seventy-five, seventy-six, seventy-seven, seventy-eight, seventy-nine, eighty, eighty-one, eighty-two, eighty-three, eighty-four, eighty-five, eighty-six, eighty-seven, eighty-eight, eighty-nine, ninety, ninety-one, ninety-two, ninety-three, ninety-four, ninety-five, ninety-six, ninety-seven, ninety-eight, ninety-nine, one hundred.", + "role": "assistant", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + } + ], + "events": [ + { + "timestamp": "2026-06-12T11:40:01.755837-07:00", + "event_type": "ready", + "data": { + "message": "Agent initialized" + } + }, + { + "timestamp": "2026-06-12T11:40:01.755974-07:00", + "event_type": "processing", + "data": { + "message": "Processing user input" + } + }, + { + "timestamp": "2026-06-12T11:40:09.638450-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "One, two, three, four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen, fourteen, fifteen, sixteen, seventeen" + } + }, + { + "timestamp": "2026-06-12T11:40:09.638621-07:00", + "event_type": "assistant_chunk", + "data": { + "content": ", eighteen, nineteen, twenty, twenty-one, twenty-two, twenty-three, twenty-four, twenty-five, twenty-six, twenty-seven, twenty-eight" + } + }, + { + "timestamp": "2026-06-12T11:40:09.673541-07:00", + "event_type": "assistant_chunk", + "data": { + "content": ", twenty-nine, thirty, thirty-one, thirty-two, thirty-three, thirty-four, thirty-five, thirty-six, thirty-seven, thirty-eight, thir" + } + }, + { + "timestamp": "2026-06-12T11:40:09.673707-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "ty-nine, forty, forty-one, forty-two, forty-three, forty-four, forty-five, forty-six, forty-seven, forty-eight, forty-nine, fifty, fif" + } + }, + { + "timestamp": "2026-06-12T11:40:10.102950-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "ty-one, fifty-two, fifty-three, fifty-four, fifty-five, fifty-six, fifty-seven, fifty-eight, fifty-nine, sixty, sixty-one" + } + }, + { + "timestamp": "2026-06-12T11:40:10.564547-07:00", + "event_type": "assistant_chunk", + "data": { + "content": ", sixty-two, sixty-three, sixty-four, sixty-five, sixty-six, sixty-seven, sixty-eight, sixty-nine, seventy, seventy-one, sevent" + } + }, + { + "timestamp": "2026-06-12T11:40:11.037791-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "y-two, seventy-three, seventy-four, seventy-five, seventy-six, seventy-seven, seventy-eight, seventy-nine, eighty, eighty-one, eighty-two" + } + }, + { + "timestamp": "2026-06-12T11:40:11.509237-07:00", + "event_type": "assistant_chunk", + "data": { + "content": ", eighty-three, eighty-four, eighty-five, eighty-six, eighty-seven, eighty-eight, eighty-nine, ninety, ninety-one, ninety-two, nin" + } + }, + { + "timestamp": "2026-06-12T11:40:11.931704-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "ety-three, ninety-four, ninety-five, ninety-six, ninety-seven, ninety-eight, ninety-nine, one hundred." + } + }, + { + "timestamp": "2026-06-12T11:40:11.971581-07:00", + "event_type": "llm_call", + "data": { + "model": "openai/anthropic/claude-opus-4.8:fal-ai", + "latency_ms": 10215, + "finish_reason": "stop", + "cost_usd": 0.0, + "kind": "main", + "prompt_tokens": 23292, + "completion_tokens": 745, + "total_tokens": 24037, + "cache_read_tokens": 0, + "cache_creation_tokens": 23290 + } + }, + { + "timestamp": "2026-06-12T11:40:11.971608-07:00", + "event_type": "assistant_stream_end", + "data": {} + }, + { + "timestamp": "2026-06-12T11:40:11.971716-07:00", + "event_type": "turn_complete", + "data": { + "history_size": 3, + "final_response": "One, two, three, four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen, fourteen, fifteen, sixteen, seventeen, eighteen, nineteen, twenty, twenty-one, twenty-two, twenty-three, twenty-four, twenty-five, twenty-six, twenty-seven, twenty-eight, twenty-nine, thirty, thirty-one, thirty-two, thirty-three, thirty-four, thirty-five, thirty-six, thirty-seven, thirty-eight, thirty-nine, forty, forty-one, forty-two, forty-three, forty-four, forty-five, forty-six, forty-seven, forty-eight, forty-nine, fifty, fifty-one, fifty-two, fifty-three, fifty-four, fifty-five, fifty-six, fifty-seven, fifty-eight, fifty-nine, sixty, sixty-one, sixty-two, sixty-three, sixty-four, sixty-five, sixty-six, sixty-seven, sixty-eight, sixty-nine, seventy, seventy-one, seventy-two, seventy-three, seventy-four, seventy-five, seventy-six, seventy-seven, seventy-eight, seventy-nine, eighty, eighty-one, eighty-two, eighty-three, eighty-four, eighty-five, eighty-six, eighty-seven, eighty-eight, eighty-nine, ninety, ninety-one, ninety-two, ninety-three, ninety-four, ninety-five, ninety-six, ninety-seven, ninety-eight, ninety-nine, one hundred." + } + } + ], + "tools": [ + { + "type": "function", + "function": { + "name": "sandbox_create", + "description": "Create or replace the session sandbox when non-default hardware is needed.\n\nA private cpu-basic sandbox is already started automatically for each session. For normal CPU code execution, call bash/read/write/edit directly; do NOT call sandbox_create first.\n\nUse sandbox_create when: you need GPU hardware, cpu-upgrade, or Trackio secrets before running code. The active sandbox persists across tool calls within the session. pip install works out of the box. Sandboxes are always created as private HF Spaces.\n\nFor ML code that uses CUDA, bf16, or model loading: use GPU hardware (t4-small minimum). CPU sandboxes cannot run GPU code paths \u2014 your test will not catch GPU-related errors.\n\nBefore choosing hardware, estimate your VRAM needs (models you run, training data size). Rule of thumb: bf16/fp16 \u2248 2 bytes/param, fp32 \u2248 4 bytes/param, plus ~20% overhead for optimizer states during training.\nCommon picks: t4-small (16GB VRAM, fits \u22641-3B), a10g-small (24GB, \u22647B), a100-large (80GB, \u226430B). If the model won't fit, pick larger hardware upfront \u2014 OOM on a sandbox wastes time.\n\nIf you intend to run a training script in this sandbox that uses report_to='trackio', pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` so they are set as TRACKIO_SPACE_ID/TRACKIO_PROJECT secrets in the sandbox and the UI can embed the live dashboard.\n\nHardware: cpu-basic, cpu-upgrade, cpu-performance, cpu-xl, sprx8, zero-a10g, t4-small, t4-medium, l4x1, l4x4, l40sx1, l40sx4, l40sx8, a10g-small, a10g-large, a10g-largex2, a10g-largex4, a100-large, a100x4, a100x8, h200, h200x2, h200x4, h200x8, inf2x6.\n", + "parameters": { + "type": "object", + "required": [], + "additionalProperties": false, + "properties": { + "hardware": { + "type": "string", + "enum": [ + "cpu-basic", + "cpu-upgrade", + "cpu-performance", + "cpu-xl", + "sprx8", + "zero-a10g", + "t4-small", + "t4-medium", + "l4x1", + "l4x4", + "l40sx1", + "l40sx4", + "l40sx8", + "a10g-small", + "a10g-large", + "a10g-largex2", + "a10g-largex4", + "a100-large", + "a100x4", + "a100x8", + "h200", + "h200x2", + "h200x4", + "h200x8", + "inf2x6" + ], + "description": "Hardware tier for the sandbox. Omit for the existing auto-started cpu-basic sandbox; choose GPU/cpu-upgrade only when needed." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for runs in this sandbox (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID secret and surfaced to the UI. The Space is auto-created and seeded with the trackio dashboard \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name. Injected as TRACKIO_PROJECT secret and used by the UI to filter the embedded dashboard to this project." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "bash", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nRun a shell command in the remote sandbox and return stdout/stderr.\n\nIMPORTANT: Do NOT use bash for file operations \u2014 use the dedicated tools instead:\n- To read files: use read (not cat/head/tail)\n- To edit files: use edit (not sed/awk)\n- To write files: use write (not echo/cat < > /app/output.log 2>&1 & echo $!\nThen check status:\n kill -0 2>/dev/null && echo 'running' || echo 'done'\n tail -n 50 /app/output.log\n\nTimeout default 240s, max 1200s.", + "parameters": { + "type": "object", + "required": [ + "command" + ], + "additionalProperties": false, + "properties": { + "command": { + "type": "string", + "description": "The shell command to execute." + }, + "description": { + "type": "string", + "description": "Short description (5-10 words, active voice)." + }, + "work_dir": { + "type": "string", + "description": "Working directory (default: /app)." + }, + "timeout": { + "type": "integer", + "description": "Optional timeout in seconds (default: 240, max: 1200)." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "read", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nReads a file from the sandbox filesystem. Returns contents with line numbers (cat -n format).\n\nUsage:\n- By default, reads up to 2000 lines from the beginning of the file.\n- You can optionally specify offset and limit for large files, but prefer reading the whole file first.\n- Lines longer than 4000 chars are truncated.\n- Cannot read directories \u2014 use bash with 'ls' instead.\n- You should read multiple potentially useful files in parallel when possible.\n- IMPORTANT: Always read a file before editing or overwriting it. The edit and write tools will reject operations on files you haven't read.", + "parameters": { + "type": "object", + "required": [ + "path" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to read." + }, + "offset": { + "type": "integer", + "description": "The line number to start reading from (1-based). Only provide if the file is too large to read at once." + }, + "limit": { + "type": "integer", + "description": "The number of lines to read. Only provide if the file is too large to read at once." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "write", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nWrites a file to the sandbox filesystem. Overwrites the existing file if one exists at the path.\n\n- If this is an existing file, you MUST use the read tool first. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files with the edit tool over overwriting with write.\n- Creates parent directories as needed.", + "parameters": { + "type": "object", + "required": [ + "path", + "content" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to write." + }, + "content": { + "type": "string", + "description": "The complete file content to write." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "edit", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nPerforms string replacements in files. Supports exact matching with fuzzy fallback.\n\nUsage:\n- You must read the file at least once before editing. This tool will error if you attempt an edit without reading the file.\n- The edit will FAIL if old_str is not unique in the file. Either provide a larger string with more surrounding context to make it unique, or set replace_all to true.\n- old_str and new_str must differ.\n- Preserve indentation exactly as it appears in the file.\n- Do NOT include line number prefixes from read output in old_str or new_str.\n- To delete code, set new_str to empty string.\n- Use replace_all for renaming variables or strings across the file.\n\nModes:\n- replace (default): replace first occurrence of old_str with new_str.\n- append_after: insert new_str immediately after old_str (old_str is kept).\n- prepend_before: insert new_str immediately before old_str (old_str is kept).", + "parameters": { + "type": "object", + "required": [ + "path", + "old_str", + "new_str" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to edit." + }, + "old_str": { + "type": "string", + "description": "The text to find in the file. Must match exactly (fuzzy matching is used as fallback)." + }, + "new_str": { + "type": "string", + "description": "The replacement text. For append_after/prepend_before modes, the text to insert." + }, + "replace_all": { + "type": "boolean", + "description": "Replace all occurrences of old_str (default: false).", + "default": false + }, + "mode": { + "type": "string", + "enum": [ + "replace", + "append_after", + "prepend_before" + ], + "description": "Edit mode (default: replace).", + "default": "replace" + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "research", + "description": "Spawn a research sub-agent to explore documentation, codebases, or repos WITHOUT polluting the main conversation context. The sub-agent gets its own independent context window with read-only research tools and returns a concise summary of findings.\n\nUse this for:\n- Researching current API usage before implementing ML tasks (find examples + read docs)\n- Exploring HF docs, reading papers, analyzing GitHub repos\n- Any research where raw tool outputs would be too verbose\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, hf_papers, etc. Just describe what you need researched.", + "parameters": { + "type": "object", + "properties": { + "task": { + "type": "string", + "description": "Detailed description of what to research. Be specific: include library names, trainer types, dataset names, repo names, or doc pages to explore. Example: 'Research current TRL SFTTrainer usage: find working example scripts, read the SFT documentation, and check SFTConfig parameters. Also validate that dataset HuggingFaceH4/ultrachat_200k has the right format for SFT.'" + }, + "context": { + "type": "string", + "description": "Optional context from the current conversation that the research agent needs (e.g., what the user wants to build, constraints, what's been tried)." + } + }, + "required": [ + "task" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "explore_hf_docs", + "description": "Browse HF documentation structure \u2014 discover all available documentation with 200-char previews.\n\nUse this to find relevant documentation and/or examples with detailed parameter docs and API reference. To be used together with github_find_examples and github_read_file to find working examples and documentation.\n\nPattern: explore_hf_docs (find relevant pages) \u2192 fetch_hf_docs (get full content).\n\nFor training tasks: fetch the trainer config docs (SFTConfig, DPOConfig, GRPOConfig) to verify parameter names. Returns top 20 results by default; set max_results (max 50) to adjust.", + "parameters": { + "type": "object", + "properties": { + "endpoint": { + "type": "string", + "enum": [ + "hub", + "transformers", + "diffusers", + "datasets", + "gradio", + "trackio", + "smolagents", + "huggingface_hub", + "huggingface.js", + "transformers.js", + "inference-providers", + "inference-endpoints", + "peft", + "accelerate", + "optimum", + "tokenizers", + "courses", + "evaluate", + "tasks", + "dataset-viewer", + "trl", + "simulate", + "sagemaker", + "timm", + "safetensors", + "tgi", + "setfit", + "lerobot", + "autotrain", + "tei", + "bitsandbytes", + "sentence_transformers", + "chat-ui", + "leaderboards", + "lighteval", + "argilla", + "distilabel", + "microsoft-azure", + "kernels", + "google-cloud" + ], + "description": "The documentation endpoint to explore. Each endpoint corresponds to a major section of the Hugging Face documentation:\n\n\u2022 courses \u2014 All Hugging Face courses (LLM, robotics, MCP, smol (llm training), agents, deep RL, computer vision, games, diffusion, 3D, audio) and the cookbook recipes. Probably the best place for examples.\n\u2022 hub \u2014 Find answers to questions about models/datasets/spaces, auth, versioning, metadata.\n\u2022 transformers \u2014 Core model library: architectures, configs, tokenizers, training & inference APIs.\n\u2022 diffusers \u2014 Diffusion pipelines, schedulers, fine-tuning, training, and deployment patterns.\n\u2022 datasets \u2014 Dataset loading, streaming, processing, Arrow format, Hub integration.\n\u2022 gradio \u2014 UI components and demos for ML models. Uses Gradio's native API: without query returns full docs (llms.txt), with query uses embedding search for precise results.\n\u2022 trackio \u2014 Experiment tracking, metrics logging, and run comparison.\n\u2022 smolagents \u2014 Lightweight agent abstractions and tool-using patterns.\n\u2022 huggingface_hub \u2014 Python client for Hub operations (auth, upload/download, repo management).\n\u2022 huggingface.js \u2014 JS/TS client for Hub APIs in browser and Node.\n\u2022 transformers.js \u2014 Run Transformer models in browser/Node via WebGPU/WASM.\n\u2022 inference-providers \u2014 Unified interface for third-party inference backends.\n\u2022 inference-endpoints \u2014 Managed, scalable model deployments on HF infrastructure.\n\u2022 peft \u2014 Parameter-efficient fine-tuning methods (LoRA, adapters, etc.).\n\u2022 accelerate \u2014 Hardware-agnostic, distributed and mixed-precision training orchestration.\n\u2022 optimum \u2014 Hardware-aware optimization and model export tooling, including Habana, Neuron, Intel, ExecuTorch, and TPU variants.\n\u2022 tokenizers \u2014 Fast tokenizer internals, training, and low-level APIs.\n\u2022 evaluate \u2014 Metrics, evaluation workflows, and training-loop integration.\n\u2022 tasks \u2014 Canonical task definitions and model categorization.\n\u2022 dataset-viewer \u2014 Dataset preview, streaming views, and viewer internals.\n\u2022 trl \u2014 RLHF, DPO, PPO, and SFT utilities for LLMs.\n\u2022 simulate \u2014 Experimental simulation tools and workflows.\n\u2022 sagemaker \u2014 Deploying Hugging Face models on AWS SageMaker.\n\u2022 timm \u2014 Image model zoo and utilities via HF integrations.\n\u2022 safetensors \u2014 Safe, fast tensor serialization format.\n\u2022 tgi \u2014 High-throughput text generation server for LLMs.\n\u2022 setfit \u2014 Few-shot text classification via sentence embeddings.\n\u2022 lerobot \u2014 Robotics datasets, policies, and learning workflows.\n\u2022 autotrain \u2014 No/low-code model training on Hugging Face.\n\u2022 tei \u2014 Optimized inference server for embedding workloads.\n\u2022 bitsandbytes \u2014 Quantization and memory-efficient optimizers.\n\u2022 sentence_transformers \u2014 Embedding models, training recipes, similarity/search workflows.\n\u2022 chat-ui \u2014 Reference chat interfaces for LLM deployment.\n\u2022 leaderboards \u2014 Evaluation leaderboards and submission mechanics.\n\u2022 lighteval \u2014 Lightweight, reproducible LLM evaluation framework.\n\u2022 argilla \u2014 Data annotation, feedback, and human-in-the-loop workflows.\n\u2022 distilabel \u2014 Synthetic data generation and distillation pipelines.\n\u2022 microsoft-azure \u2014 Azure deployment and integration guides.\n\u2022 kernels \u2014 Load prebuilt compute kernels (E.g. flash-attn2) from the Hub via `attn_implementation`; avoids compiling flash-attn from source.\n\u2022 google-cloud \u2014 GCP deployment and serving workflows.\n" + }, + "query": { + "type": "string", + "description": "Optional keyword query to rank and filter documentation pages. For Gradio, use concise queries like 'how to use the image component' or 'audio component demo'." + }, + "max_results": { + "type": "integer", + "description": "Max results (default 20, max 50). Ignored for Gradio.", + "minimum": 1, + "maximum": 50 + } + }, + "required": [ + "endpoint" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "fetch_hf_docs", + "description": "Fetch full markdown content of an HF documentation page. Use after explore_hf_docs.\n\nCritical for finding documentation e.g. current trainer configuration parameters (SFTConfig, DPOConfig, etc.) Use for researching solutions and before writing training scripts. Your internal knowledge is outdated.\n\nProvide the full URL from explore_hf_docs results. The .md extension is added automatically.", + "parameters": { + "type": "object", + "properties": { + "url": { + "type": "string", + "description": "The full URL to the documentation page. Example: 'https://huggingface.co/docs/trl/dpo_trainer' The .md extension will be added automatically if not present." + } + }, + "required": [ + "url" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_papers", + "description": "Discover ML research papers, analyze citations, search paper contents, and find linked resources.\n\nCombines HuggingFace Hub, arXiv, and Semantic Scholar. Use for exploring research areas, finding datasets for a task, tracing citation chains, or implementing a paper's approach.\n\nTypical flows:\n search \u2192 read_paper \u2192 find_all_resources \u2192 hf_inspect_dataset\n search \u2192 paper_details \u2192 citation_graph \u2192 read_paper (trace influence)\n snippet_search \u2192 paper_details \u2192 read_paper (find specific claims)\n\nOperations:\n- trending: Get trending daily papers, optionally filter by topic keyword\n- search: Search papers. Uses HF by default (ML-tuned). Add date_from/min_citations/categories to use Semantic Scholar with filters\n- paper_details: Metadata, abstract, AI summary, github link\n- read_paper: Read paper contents \u2014 without section: abstract + TOC; with section: full text\n- citation_graph: Get references and citations for a paper with influence flags and citation intents\n- snippet_search: Semantic search over full-text passages from 12M+ papers\n- recommend: Find similar papers (single paper or positive/negative examples)\n- find_datasets: Find datasets linked to a paper\n- find_models: Find models linked to a paper\n- find_collections: Find collections that include a paper\n- find_all_resources: Parallel fetch of datasets + models + collections for a paper", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "trending", + "search", + "paper_details", + "read_paper", + "citation_graph", + "snippet_search", + "recommend", + "find_datasets", + "find_models", + "find_collections", + "find_all_resources" + ], + "description": "Operation to execute." + }, + "query": { + "type": "string", + "description": "Search query. Required for: search, snippet_search. Optional for: trending (filters by keyword). Supports boolean syntax for Semantic Scholar: '\"exact phrase\" term1 | term2'." + }, + "arxiv_id": { + "type": "string", + "description": "ArXiv paper ID (e.g. '2305.18290'). Required for: paper_details, read_paper, citation_graph, find_datasets, find_models, find_collections, find_all_resources. Optional for: recommend (single-paper recs). Get IDs from search results first." + }, + "section": { + "type": "string", + "description": "Section name or number to read (e.g. '3', 'Experiments', '4.2'). Optional for: read_paper. Without this, returns abstract + TOC." + }, + "direction": { + "type": "string", + "enum": [ + "citations", + "references", + "both" + ], + "description": "Direction for citation_graph. Default: both." + }, + "date": { + "type": "string", + "description": "Date in YYYY-MM-DD format. Optional for: trending (defaults to recent papers)." + }, + "date_from": { + "type": "string", + "description": "Start date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "date_to": { + "type": "string", + "description": "End date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "categories": { + "type": "string", + "description": "Field of study filter (e.g. 'Computer Science'). Triggers Semantic Scholar search." + }, + "min_citations": { + "type": "integer", + "description": "Minimum citation count filter. Triggers Semantic Scholar search." + }, + "sort_by": { + "type": "string", + "enum": [ + "relevance", + "citationCount", + "publicationDate" + ], + "description": "Sort order for Semantic Scholar search. Default: relevance." + }, + "positive_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs for multi-paper recommendations. For: recommend." + }, + "negative_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs as negative examples. For: recommend." + }, + "sort": { + "type": "string", + "enum": [ + "downloads", + "likes", + "trending" + ], + "description": "Sort order for find_datasets and find_models. Default: downloads." + }, + "limit": { + "type": "integer", + "description": "Maximum results to return (default: 10, max: 50)." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "web_search", + "description": "Search the web for current information and return cited results.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "minLength": 2 + }, + "allowed_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional allowlist of domains or URLs. Subdomains match." + }, + "blocked_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional blocklist of domains or URLs. Subdomains match." + } + }, + "required": [ + "query" + ], + "additionalProperties": false + } + } + }, + { + "type": "function", + "function": { + "name": "hf_inspect_dataset", + "description": "Inspect a HF dataset in one call: status, configs/splits, schema, sample rows, parquet info.\n\nREQUIRED before any training job to verify dataset format matches training method:\n SFT: needs 'messages', 'text', or 'prompt'/'completion'\n DPO: needs 'prompt', 'chosen', 'rejected'\n GRPO: needs 'prompt'\nAll datasets used for training have to be in conversational ChatML format to be compatible with HF libraries.'\nTraining will fail with KeyError if columns don't match.\n\nAlso use to get example datapoints, understand column names, data types, and available splits before writing any data loading code. Supports private/gated datasets when HF_TOKEN is set.", + "parameters": { + "type": "object", + "properties": { + "dataset": { + "type": "string", + "description": "Dataset ID in 'org/name' format (e.g., 'stanfordnlp/imdb')" + }, + "config": { + "type": "string", + "description": "Config/subset name. Auto-detected if not specified." + }, + "split": { + "type": "string", + "description": "Split for sample rows. Auto-detected if not specified." + }, + "sample_rows": { + "type": "integer", + "description": "Number of sample rows to show (default: 3, max: 10)", + "default": 3 + } + }, + "required": [ + "dataset" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "plan_tool", + "description": "Track progress on multi-step tasks with a todo list (pending/in_progress/completed).\n\nUse for tasks with 3+ steps. Each call replaces the entire plan (send full list).\n\nRules: exactly ONE task in_progress at a time. Mark completed immediately after finishing. Only mark completed when the task fully succeeded \u2014 keep in_progress if there are errors. Update frequently so the user sees progress.", + "parameters": { + "type": "object", + "properties": { + "todos": { + "type": "array", + "description": "List of todo items", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "Unique identifier for the todo" + }, + "content": { + "type": "string", + "description": "Description of the todo task" + }, + "status": { + "type": "string", + "enum": [ + "pending", + "in_progress", + "completed" + ], + "description": "Current status of the todo" + } + }, + "required": [ + "id", + "content", + "status" + ] + } + } + }, + "required": [ + "todos" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "notify", + "description": "Send an out-of-band notification to configured messaging destinations. Use this only when the user explicitly asked for proactive notifications or when the task requires reporting progress outside the chat. Destinations must be named server-side configs such as 'slack.ops'.", + "parameters": { + "type": "object", + "properties": { + "destinations": { + "type": "array", + "description": "Named messaging destinations to notify.", + "items": { + "type": "string" + }, + "minItems": 1 + }, + "message": { + "type": "string", + "description": "Main notification body." + }, + "title": { + "type": "string", + "description": "Optional short title line." + }, + "severity": { + "type": "string", + "enum": [ + "info", + "success", + "warning", + "error" + ], + "description": "Notification severity label." + } + }, + "required": [ + "destinations", + "message" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_jobs", + "description": "Execute Python scripts or Docker containers on HF cloud infrastructure.\n\nTwo modes (mutually exclusive): Python mode (script + dependencies) or Docker mode (command + image). Provide exactly ONE of 'script' or 'command'.\n\nBEFORE submitting training/fine-tuning jobs:\n- You MUST have called github_find_examples + github_read_file to find a working reference implementation. Scripts based on your internal knowledge WILL use outdated APIs and fail.\n- You MUST have validated dataset format via hf_inspect_dataset or hub_repo_details.\n- If the job runs on GPU, or the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile, you MUST create a GPU sandbox with sandbox_create first, run a tiny smoke test there, and fix failures before submitting. If skipped, state why before calling hf_jobs.\n- Training config MUST include push_to_hub=True and hub_model_id. Job storage is EPHEMERAL \u2014 all files are deleted when the job ends. Without push_to_hub, trained models are lost permanently.\n- Include trackio monitoring and provide the dashboard URL to the user. When the script uses report_to='trackio', also pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` as tool args \u2014 they are injected as TRACKIO_SPACE_ID/TRACKIO_PROJECT env vars and let the UI embed the live dashboard.\n\nBATCH/ABLATION JOBS: Submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once \u2014 if there's a bug, all jobs fail.\n\nOperations: run, ps, logs, inspect, cancel, scheduled run/ps/inspect/delete/suspend/resume.\n\nHardware: CPU: cpu-basic(2vCPU/16GB), cpu-upgrade(8vCPU/32GB). GPU: t4-small(4vCPU/15GB/GPU 16GB), t4-medium(8vCPU/30GB/GPU 16GB), a10g-small(4vCPU/15GB/GPU 24GB), a10g-large(12vCPU/46GB/GPU 24GB), a10g-largex2(24vCPU/92GB/GPU 48GB), a10g-largex4(48vCPU/184GB/GPU 96GB), a100-large(12vCPU/142GB/GPU 80GB), a100x4(48vCPU/568GB/GPU 320GB), a100x8(96vCPU/1136GB/GPU 640GB), l4x1(8vCPU/30GB/GPU 24GB), l4x4(48vCPU/186GB/GPU 96GB), l40sx1(8vCPU/62GB/GPU 48GB), l40sx4(48vCPU/382GB/GPU 192GB), l40sx8(192vCPU/1534GB/GPU 384GB).\nCommon picks: t4-small ($0.60/hr, 1-3B), a10g-large ($2/hr, 7-13B), a100-large ($4/hr, 30B+), h100 ($6/hr, 70B+). Note: a10g-small and a10g-large have the SAME 24GB GPU \u2014 the difference is CPU/RAM only.\n\nOOM RECOVERY: When a training job fails with CUDA OOM:\n1. Reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally (keep effective batch size identical)\n2. Enable gradient_checkpointing=True\n3. Upgrade to larger GPU (a10g\u2192a100\u2192h100)\nDo NOT switch training methods (e.g. full SFT to LoRA) or reduce max_length \u2014 those change what the user gets and require explicit approval.\n\nExamples:\nTraining: {'operation': 'run', 'script': '/app/train.py', 'dependencies': ['transformers', 'trl', 'torch', 'datasets', 'trackio'], 'hardware_flavor': 'a100-large', 'timeout': '8h'}\nMonitor: {'operation': 'ps'}, {'operation': 'logs', 'job_id': 'xxx'}, {'operation': 'cancel', 'job_id': 'xxx'}Docker: {'operation': 'run', 'command': ['duckdb', '-c', 'select 1 + 2'], 'image': 'duckdb/duckdb', 'hardware_flavor': 'cpu-basic', 'timeout': '1h'}\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "run", + "ps", + "logs", + "inspect", + "cancel", + "scheduled run", + "scheduled ps", + "scheduled inspect", + "scheduled delete", + "scheduled suspend", + "scheduled resume" + ], + "description": "Operation to execute." + }, + "script": { + "type": "string", + "description": "Python code, sandbox file path (e.g. '/app/train.py', './train.py', or bare 'train.py'), or URL. Triggers Python mode. For ML training: base this on a working example found via github_find_examples, not on internal knowledge. For GPU/model-loading training scripts, smoke-test in a GPU sandbox before submission. Mutually exclusive with 'command'." + }, + "dependencies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Pip packages to install. Include ALL required packages. Common training set: ['transformers', 'trl', 'torch', 'datasets', 'trackio', 'accelerate']. Only used with 'script'." + }, + "image": { + "type": "string", + "description": "Docker image. Optional \u2014 auto-selected if not provided. Use with 'command'." + }, + "command": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Command to execute as list. Triggers Docker mode. Mutually exclusive with 'script'." + }, + "hardware_flavor": { + "type": "string", + "description": "Hardware type. Sizing guide: 1-3B params \u2192 t4-small/a10g-small, 7-13B \u2192 a10g-large, 30B+ \u2192 a100-large, 70B+ \u2192 h100/h100x8. All options: CPU: ['cpu-basic', 'cpu-upgrade']. GPU: ['t4-small', 't4-medium', 'a10g-small', 'a10g-large', 'a10g-largex2', 'a10g-largex4', 'a100-large', 'a100x4', 'a100x8', 'l4x1', 'l4x4', 'l40sx1', 'l40sx4', 'l40sx8']." + }, + "timeout": { + "type": "string", + "description": "Maximum job runtime. MUST be >2h for any training job \u2014 default 30m kills training mid-run. Guidelines: 1-3B models: 3-4h, 7-13B: 6-8h, 30B+: 12-24h. Use 30m-1h only for quick data processing or inference tasks. Default: '30m'." + }, + "env": { + "type": "object", + "description": "Environment variables {'KEY': 'VALUE'}. HF_TOKEN is auto-included." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for this run (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID env var and used by the UI to embed the live dashboard. Set this whenever the script uses report_to='trackio'. The Space is auto-created and seeded with the trackio dashboard before the job starts \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name to log this run under. Injected as TRACKIO_PROJECT env var and used by the UI to filter the embedded dashboard to this project." + }, + "namespace": { + "type": "string", + "description": "Optional namespace to run the job under. Must be the caller's own account or an org they belong to. If omitted, defaults to the caller's personal account. Credits are billed against this namespace." + }, + "job_id": { + "type": "string", + "description": "Job ID. Required for: logs, inspect, cancel." + }, + "scheduled_job_id": { + "type": "string", + "description": "Scheduled job ID. Required for: scheduled inspect/delete/suspend/resume." + }, + "schedule": { + "type": "string", + "description": "Cron schedule or preset (@hourly, @daily, @weekly, @monthly). Required for: scheduled run." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_files", + "description": "Read and write files in HF repos (models/datasets/spaces).\n\n## Operations\n- **list**: List files with sizes and structure\n- **read**: Read file content (text files only)\n- **upload**: Upload content to repo (can create PR)\n- **delete**: Delete files/folders (supports wildcards like *.tmp)\n\n## Use when\n- Need to see what files exist in a repo\n- Want to read config.json, README.md, or other text files\n- Uploading training scripts, configs, or results to a repo\n- Cleaning up temporary files from a repo\n\n## Examples\n{\"operation\": \"list\", \"repo_id\": \"meta-llama/Llama-2-7b\"}\n{\"operation\": \"read\", \"repo_id\": \"gpt2\", \"path\": \"config.json\"}\n{\"operation\": \"upload\", \"repo_id\": \"my-model\", \"path\": \"README.md\", \"content\": \"# My Model\"}\n{\"operation\": \"upload\", \"repo_id\": \"org/model\", \"path\": \"fix.py\", \"content\": \"...\", \"create_pr\": true}\n{\"operation\": \"delete\", \"repo_id\": \"my-model\", \"patterns\": [\"*.tmp\", \"logs/\"]}\n\n## Notes\n- For binary files (safetensors, bin), use list to see them but can't read content\n- upload/delete require approval (can overwrite/destroy data)\n- Use create_pr=true to propose changes instead of direct commit\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "list", + "read", + "upload", + "delete" + ], + "description": "Operation: list, read, upload, delete" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "revision": { + "type": "string", + "description": "Branch/tag/commit (default: main)" + }, + "path": { + "type": "string", + "description": "File path for read/upload" + }, + "content": { + "type": "string", + "description": "File content for upload" + }, + "patterns": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Patterns to delete (e.g., ['*.tmp', 'logs/'])" + }, + "create_pr": { + "type": "boolean", + "description": "Create PR instead of direct commit" + }, + "commit_message": { + "type": "string", + "description": "Custom commit message" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_git", + "description": "Git-like operations on HF repos: branches, tags, PRs, and repo management.\n\n## Operations\n**Branches:** create_branch, delete_branch, list_refs\n**Tags:** create_tag, delete_tag\n**PRs:** create_pr, list_prs, get_pr, merge_pr, close_pr, comment_pr, change_pr_status\n**Repo:** create_repo, update_repo\n\n## Use when\n- Creating feature branches for experiments\n- Tagging model versions (v1.0, v2.0)\n- Opening PRs to contribute to repos you don't own\n- Reviewing and merging PRs on your repos\n- Creating new model/dataset/space repos\n- Changing repo visibility (public/private) or gated access\n\n## Examples\n{\"operation\": \"list_refs\", \"repo_id\": \"my-model\"}\n{\"operation\": \"create_branch\", \"repo_id\": \"my-model\", \"branch\": \"experiment-v2\"}\n{\"operation\": \"create_tag\", \"repo_id\": \"my-model\", \"tag\": \"v1.0\", \"revision\": \"main\"}\n{\"operation\": \"create_pr\", \"repo_id\": \"org/model\", \"title\": \"Fix tokenizer config\"}\n{\"operation\": \"change_pr_status\", \"repo_id\": \"my-model\", \"pr_num\": 1, \"new_status\": \"open\"}\n{\"operation\": \"merge_pr\", \"repo_id\": \"my-model\", \"pr_num\": 3}\n{\"operation\": \"create_repo\", \"repo_id\": \"my-new-model\", \"private\": true}\n{\"operation\": \"update_repo\", \"repo_id\": \"my-model\", \"gated\": \"auto\"}\n\n## PR Workflow\n1. create_pr \u2192 creates draft PR (empty by default)\n2. Upload files with revision='refs/pr/N' to add commits\n3. change_pr_status with new_status='open' to publish (convert draft to open)\n4. merge_pr when ready\n\n## Notes\n- PR status: draft (default), open, merged, closed\n- delete_branch, delete_tag, merge_pr, create_repo, update_repo require approval\n- For spaces, create_repo needs space_sdk (gradio/streamlit/docker/static)\n- gated options: 'auto' (instant), 'manual' (review), false (open)\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "create_branch", + "delete_branch", + "create_tag", + "delete_tag", + "list_refs", + "create_pr", + "list_prs", + "get_pr", + "merge_pr", + "close_pr", + "comment_pr", + "change_pr_status", + "create_repo", + "update_repo" + ], + "description": "Operation to execute" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "branch": { + "type": "string", + "description": "Branch name (create_branch, delete_branch)" + }, + "from_rev": { + "type": "string", + "description": "Create branch from this revision (default: main)" + }, + "tag": { + "type": "string", + "description": "Tag name (create_tag, delete_tag)" + }, + "revision": { + "type": "string", + "description": "Revision for tag (default: main)" + }, + "tag_message": { + "type": "string", + "description": "Tag description" + }, + "title": { + "type": "string", + "description": "PR title (create_pr)" + }, + "description": { + "type": "string", + "description": "PR description (create_pr)" + }, + "pr_num": { + "type": "integer", + "description": "PR/discussion number" + }, + "comment": { + "type": "string", + "description": "Comment text" + }, + "status": { + "type": "string", + "enum": [ + "open", + "closed", + "all" + ], + "description": "Filter PRs by status (list_prs)" + }, + "new_status": { + "type": "string", + "enum": [ + "open", + "closed" + ], + "description": "New status for PR/discussion (change_pr_status)" + }, + "private": { + "type": "boolean", + "description": "Make repo private (create_repo, update_repo)" + }, + "gated": { + "type": "string", + "enum": [ + "auto", + "manual", + "false" + ], + "description": "Gated access setting (update_repo)" + }, + "space_sdk": { + "type": "string", + "enum": [ + "gradio", + "streamlit", + "docker", + "static" + ], + "description": "Space SDK (required for create_repo with space)" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_find_examples", + "description": "Find working example scripts in GitHub repositories (from a list of predetermined directories e.g. examples/, scripts/, tutorials/, etc.). Uses fuzzy keyword matching.\n\nMANDATORY before writing any ML training, fine-tuning, or inference code. Your internal knowledge of library APIs is outdated \u2014 working examples show current API patterns.\n\nSequence: github_find_examples \u2192 github_read_file (study the example) \u2192 implement based on what you found.\n\nSkip this only for: simple data queries, status checks, non-code tasks.\n\nExamples:\n {keyword: 'sft', repo: 'trl'} \u2192 finds examples/scripts/sft.py\n {keyword: 'grpo', repo: 'trl'} \u2192 finds GRPO training examples\n {repo: 'trl', max_results: 20} \u2192 lists all available training method examples", + "parameters": { + "type": "object", + "properties": { + "keyword": { + "type": "string", + "description": "Keyword to fuzzy match against file paths (e.g., 'grpo', 'sft')." + }, + "repo": { + "type": "string", + "description": "Repository name (e.g., 'trl', 'transformers'). Required." + }, + "org": { + "type": "string", + "description": "GitHub organization or username. Default: 'huggingface'." + }, + "max_results": { + "type": "integer", + "description": "Maximum number of results to return. Default: 50." + }, + "min_score": { + "type": "integer", + "description": "Minimum fuzzy match score (0-100). Default: 60." + } + }, + "required": [ + "repo" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_list_repos", + "description": "List and discover repositories for GitHub organizations or users with flexible sorting. **Use when:** (1) Exploring what libraries exist for a task, (2) Finding the right library to use, (3) Discovering popular or active projects, (4) Checking recently updated repos for latest features, (5) Finding alternative libraries in an organization. **Pattern:** github_list_repos (discover libraries) \u2192 github_find_examples (find usage examples) \u2192 implement. Returns: Comprehensive repository information (stars, forks, language, topics, URLs), sorted by preference. **Then:** Use github_find_examples on selected repo to discover example code. Sorts by: stars (popularity), forks (community), updated (activity), created (age).\n\n## When to use this tool\n\n- When you need to find libraries to use in your implementation\n- When exploring what repositories exist for a task or domain\n- When debugging an error and looking up if others have similar issues in repos\n- When finding the most popular or actively maintained projects for a user/org\n## Examples\n\n\n// ML Workflow Step: Discover HF libraries for RLHF/alignment\n// Use case: Find the right library for training with human feedback\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'stars',\n limit: 10\n}\n// Returns: transformers, trl, peft, accelerate, diffusers...\n\n\n\n// ML Workflow Step: Check for recently updated HF repos\n// Use case: Find actively maintained libraries with latest features\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'updated',\n order: 'desc',\n limit: 15\n}\n// Helps identify which repos have recent improvements/fixes\n", + "parameters": { + "type": "object", + "properties": { + "owner": { + "type": "string", + "description": "GitHub username or organization name. Required." + }, + "owner_type": { + "type": "string", + "enum": [ + "user", + "org" + ], + "description": "Whether the owner is a 'user' or 'org'. Default: 'org'." + }, + "sort": { + "type": "string", + "enum": [ + "stars", + "forks", + "updated", + "created" + ], + "description": "Sort field. Options: 'stars', 'forks', 'updated', 'created'. Default: 'stars'." + }, + "order": { + "type": "string", + "enum": [ + "asc", + "desc" + ], + "description": "Sort order. Options: 'asc', 'desc'. Default: 'desc'." + }, + "limit": { + "type": "integer", + "description": "Maximum number of repositories to return. No limit if not specified. Default: 30." + } + }, + "required": [ + "owner" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_read_file", + "description": "Read file contents from GitHub repositories. Returns first 300 lines by default. Auto-converts Jupyter notebooks to markdown.\n\nUse AFTER github_find_examples to study the working implementation. The purpose is to learn current API patterns \u2014 imports, trainer configs, dataset handling \u2014 so your implementation uses correct, up-to-date code.\n\nUse line_start/line_end for large files (>300 lines) to read specific sections.\n\nWhen NOT to use: when you don't know the file path (use github_find_examples first).", + "parameters": { + "type": "object", + "properties": { + "repo": { + "type": "string", + "description": "Repository in format 'owner/repo' (e.g., 'github/github-mcp-server'). Required." + }, + "path": { + "type": "string", + "description": "Path to file in repository (e.g., 'src/index.js'). Required." + }, + "ref": { + "type": "string", + "description": "Git reference - branch name, tag, or commit SHA. Default: 'HEAD'." + }, + "line_start": { + "type": "integer", + "description": "Starting line number (1-indexed, inclusive). Optional." + }, + "line_end": { + "type": "integer", + "description": "Ending line number (1-indexed, inclusive). Optional." + } + }, + "required": [ + "repo", + "path" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "find_hf_api", + "description": "Find HuggingFace Hub REST API endpoints to make HTTP requests. Returns curl examples with authentication. \u26a0\ufe0f USE THIS TOOL when you need to call the HF Hub API directly - for operations like: uploading/downloading files, managing repos, listing models/datasets, getting user info, managing webhooks, collections, discussions, or any Hub interaction not covered by other tools. **Use cases:** (1) 'Stream Space logs' \u2192 query='space logs', (2) 'Get Space metrics/Zero-GPU usage' \u2192 query='space metrics', (3) 'List organization members' \u2192 query='organization members', (4) 'Generate repo access token' \u2192 query='jwt token', (5) 'Check repo security scan' \u2192 query='security scan'. **Search modes:** Use 'query' for keyword search, 'tag' to browse a category, or both. If query finds no results, falls back to showing all endpoints in the tag. **Output:** Full endpoint details with method, path, parameters, curl command, and response schema.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "Keyword search across endpoint summaries, descriptions, and operation IDs. Examples: 'upload file', 'create repository', 'list user models', 'delete branch', 'webhook', 'collection', 'discussion comments'. Supports stemming (upload/uploading both work)." + }, + "tag": { + "type": "string", + "enum": [ + "agentic-provisioning", + "agents", + "auth", + "buckets", + "collections", + "container", + "datasets", + "discussions", + "docs", + "inference-endpoints", + "inference-providers", + "jobs", + "kernels", + "mcp", + "models", + "notifications", + "oauth", + "orgs", + "papers", + "repo-search", + "repos", + "resource-groups", + "scim", + "service-accounts", + "spaces", + "sql-console", + "users", + "webhooks" + ], + "description": "Filter by API category. Use alone to browse all endpoints in a category, or combine with 'query' to search within a category." + } + }, + "required": [] + } + } + } + ], + "upload_status": "failed", + "upload_url": null, + "last_save_time": "2026-06-12T11:40:56.884749", + "personal_upload_status": "failed" +} \ No newline at end of file diff --git a/backend/session_logs/session_be60bf3b-4c6d-4cb6-99eb-c819226571b7_20260612_113848.json b/backend/session_logs/session_be60bf3b-4c6d-4cb6-99eb-c819226571b7_20260612_113848.json new file mode 100644 index 0000000000000000000000000000000000000000..ef18c35d73e7488c4a5855bf91f34089fd9d2f0b --- /dev/null +++ b/backend/session_logs/session_be60bf3b-4c6d-4cb6-99eb-c819226571b7_20260612_113848.json @@ -0,0 +1,1112 @@ +{ + "session_id": "be60bf3b-4c6d-4cb6-99eb-c819226571b7", + "user_id": "dev", + "hf_username": "dev", + "session_start_time": "2026-06-12T11:37:39.895121-07:00", + "session_end_time": "2026-06-12T11:38:48.639160", + "model_name": "anthropic/claude-opus-4.8:fal-ai", + "total_cost_usd": 0, + "usage_metrics": { + "version": 1, + "session_id": "be60bf3b-4c6d-4cb6-99eb-c819226571b7", + "billing_scope": "account_window_delta", + "total_usd": 0.0, + "total_usd_source": "app_telemetry_fallback", + "app_total_usd": 0.0, + "hf_billing_total_usd": null, + "app_telemetry": { + "session_id": "be60bf3b-4c6d-4cb6-99eb-c819226571b7", + "total_usd": 0.0, + "inference_usd": 0.0, + "hf_jobs_estimated_usd": 0.0, + "sandbox_estimated_usd": 0.0, + "llm_calls": 0, + "hf_jobs_count": 0, + "sandbox_count": 0, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0, + "hf_jobs_billable_seconds_estimate": 0, + "sandbox_billable_seconds_estimate": 0 + }, + "hf_billing": { + "source": "hf_billing_usage_v2", + "available": false, + "error": "missing_hf_token", + "current_session": null + }, + "llm": { + "calls": 0, + "calls_by_kind": {}, + "calls_by_model": {}, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0 + }, + "turns": { + "turn_complete_count": 0, + "assistant_stream_end_count": 0 + }, + "hf_jobs": { + "submits": 0, + "status_snapshots": 0, + "statuses": {}, + "flavors": {}, + "submit_flavors": {}, + "status_snapshot_flavors": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0, + "snapshots_with_estimated_cost": 0, + "snapshots_with_nonzero_estimated_cost": 0 + }, + "sandboxes": { + "creates": 0, + "destroys": 0, + "matched_pairs": 0, + "unpaired_creates": 0, + "unpaired_destroys": 0, + "hardware": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0 + }, + "data_quality": { + "event_count": 1, + "events_without_timestamp": 0, + "llm_calls_with_cost_usd": 0, + "llm_calls_with_nonzero_cost_usd": 0, + "job_snapshots_with_estimated_cost": 0, + "job_snapshots_missing_estimated_cost": 0 + } + }, + "messages": [ + { + "content": "You are ML Intern, an ML engineering assistant with 19 tools for training, fine-tuning, data processing, inference, and evaluation on the Hugging Face (HF) ecosystem.\n\nYour goal is to complete what the user requested with zero errors. You are fully autonomous \u2014 research, validate, implement, and deliver results without asking for unnecessary confirmation.\n\n# Your knowledge of HF libraries is outdated\n\nYou do not know current APIs for TRL, Transformers, PEFT, Trackio, or other HF libraries. Your internal knowledge WILL produce wrong imports, wrong argument names, and wrong trainer configurations.\n\nBefore writing any ML implementation code, start from the literature. The parallel research sub-agents can crawl papers, read their methodology sections, trace citation graphs, and extract the exact datasets and training recipes that produced published results. This is your primary advantage \u2014 use it.\n\nYour default workflow for any ML task:\n1. Find the landmark paper(s) for the task or domain\n2. Crawl their citation graphs to find recent downstream work\n3. Read methodology sections (not abstracts) of the most promising papers \u2014 especially recent ones with strong results, lot of citations, and publications in high-impact conferences\n4. Extract the recipe: what dataset, what training method, what hyperparameters produced those results\n5. Validate and use those datasets for training\n\n```\nresearch({\"task\": \"Literature crawl for [task]. Start from [paper/topic]. Crawl citation graph for recent downstream papers. Read their methodology sections (3, 4, 5) \u2014 extract the exact datasets, training methods, and hyperparameters that produced their best results. Attribute every finding to a specific result (e.g. 'Dataset X + method Y \u2192 85.3% on benchmark Z'). Also find working code examples using current TRL/Transformers APIs.\", \"context\": \"User wants to [goal]. We need the best training recipe backed by published results.\"})\n```\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, and hf_papers (with citation_graph, read_paper, snippet_search, find_datasets). Be specific in your task description \u2014 name anchor papers or arxiv IDs when you have them.\n\nYou can also call research tools directly (explore_hf_docs, github_read_file, etc.) for quick lookups.\n\nSkip research only for trivial non-code operations.\n\n# Mistakes you WILL make without research\n\nHALLUCINATED IMPORTS: You will import from modules that were renamed or removed. Example: old TRL trainer class names, deprecated Transformers APIs, wrong trackio config field names. Fix: read a current example script first.\n\nWRONG TRAINER ARGUMENTS: You will pass configuration arguments that don't exist in current trainer versions. Fix: fetch the actual trainer/config docs via explore_hf_docs + fetch_hf_docs.\n\nWRONG DATASET FORMAT: You will assume column names without checking. Training fails with KeyError. Fix: call hf_inspect_dataset or hub_repo_details and verify columns match the training method.\n\nDEFAULT TIMEOUT KILLS JOBS: You will leave timeout at the default 30m for training jobs. Training takes hours. The job gets killed and all progress is lost. Fix: set timeout based on model size (minimum 2h for any training).\n\nLOST MODELS: You will forget push_to_hub=True and hub_model_id in training config. Job storage is ephemeral \u2014 the filesystem is deleted when the job ends. Without push_to_hub, the trained model is permanently lost.\n\nBATCH FAILURES: You will submit all ablation/batch jobs at once without testing that one works first. All will fail for the same bug. Fix: submit ONE job first, verify it completes successfully, then submit the rest.\n\nSILENT DATASET SUBSTITUTION: When a requested dataset fails to load, you will silently switch to a different one without telling the user. Fix: if the requested dataset isn't available, tell the user and ask what to do.\n\nPREFER HUB KERNELS OVER COMPILING ATTENTION: Do NOT pip install 'flash-attn' to enable flash_attention_2 building from source can take many minutes to hours and often fails on the job's CUDA/PyTorch combo. Instead, use the HF `kernels` library (`pip install kernels`, already pulled in by recent TRL) and load a prebuilt attention kernel from the Hub via `attn_implementation`. Examples: `AutoModelForCausalLM.from_pretrained(..., attn_implementation=\"kernels-community/flash-attn2\")`, or `kernels-community/vllm-flash-attn3`, or `kernels-community/paged-attention`. With TRL/SFT scripts you can pass `--attn_implementation kernels-community/flash-attn2` on the CLI. Search additional kernels at https://huggingface.co/models?other=kernel. Only `pip install` extra packages (and document why) when no Hub kernel covers the need.\n\nSCOPE-CHANGING FIXES: Avoid at all costs! When you hit an error (especially OOM), you will try \"creative\" workarounds that change what the user asked for and/or change the training task itself \u2014 switching full SFT to LoRA on OOM, reducing max_length (silently truncates training data and changes what the model learns), disabling monitoring instead of fixing it. Do not do this. Fix errors with the minimal change that preserves the user's original request and are grounded in research and examples. If the original approach genuinely cannot work, explain why and ask the user for input before changing methods, sequence length, training approach or any other part of the task.\n\n# When writing ML code\n\nRequired sequence before any training/fine-tuning/inference script:\n1. Use `research` tool to find working examples, read docs, and get current API patterns\n2. Validate dataset: hf_inspect_dataset or hub_repo_details to confirm column names and format\n3. Validate model: hub_repo_details to confirm model exists, correct architecture/size/tokenizer\n\nTraining logging: always set disable_tqdm=True, logging_strategy=\"steps\", and logging_first_step=True in your TrainingArguments/SFTConfig so loss values are printed as plain text lines you can grep, not hidden inside tqdm progress bars.\n\nDataset format requirements by training method:\n SFT: \"messages\", \"text\", or \"prompt\"/\"completion\"\n DPO: \"prompt\", \"chosen\", \"rejected\"\n GRPO: \"prompt\"\n\n# Trackio\n\nTrackio is natively integrated with Transformers Trainer and all TRL trainers \u2014 the built-in TrackioCallback handles init/log/finish. In TrainingArguments/SFTConfig/DPOConfig/GRPOConfig set:\n report_to=\"trackio\"\n run_name=\"\" # e.g. \"sft_qwen3-4b_lr2e-5_bs128\"\n project=\"\" # keeps related runs grouped so you can compare them\n trackio_space_id=\"/ml-intern-<8-char-id>\" # creates a public dashboard Space\n`project` and `trackio_space_id` can also be set via TRACKIO_PROJECT / TRACKIO_SPACE_ID env vars.\n\nAlerts are how iterations decide what to change. Use trackio.alert(title, text, level) at every decision point in training. Levels:\n ERROR \u2014 stop and change approach (divergence, NaN, OOM)\n WARN \u2014 tweak hyperparameters (overfitting, early stopping, KL spike, reward collapse, slow convergence)\n INFO \u2014 milestones (training complete, target reached, checkpoint saved)\nAlways include numeric values and an actionable suggestion in `text`, e.g. \"loss=12.4 at step 200 \u2014 lr likely too high, try \u00d70.1\". A future call must be able to parse it and act on it.\n\nTo add alerts under Trainer/SFTTrainer/GRPOTrainer, pass a custom TrainerCallback via `callbacks=[...]` that calls trackio.alert() inside `on_log` (training metrics like loss, reward, kl) and `on_evaluate` (eval metrics \u2014 only available here, not in `on_log`). Keep each `if` simple: one metric, one threshold. Conditions stay easy to adjust between runs.\n\nRead alerts back between runs instead of parsing thousands of metric values. CLI \u2014 always use --json:\n trackio get alerts --project

--run --json\n trackio get alerts --project

--since --json # incremental polling\n trackio get run --project

--run --json\n trackio get metric --project

--run --metric --json\n trackio list runs --project

--json\nPython: api = trackio.Api(); api.alerts(

, run=, since=); api.runs(

) (each run has .name, .config, .alerts()).\n\nDrive the next config from prior alerts:\n diverged \u2192 lr \u00d7 0.1\n overfitting \u2192 weight_decay \u00d7 10 or reduce capacity\n early stopping \u2192 lr \u00d7 0.5 or adjust schedule\n high accuracy \u2192 refine around current config\nRead prior config via api.runs(...).config and only mutate keys the alerts justify changing.\n\n# Data audit\n\nBefore working with any dataset, audit it first. Do not assume you know what the data looks like \u2014 inspect it.\n\nUse hf_inspect_dataset to check: schema/columns, number of rows per split, value distributions for key columns, sample rows. Surface anything notable: class imbalance, missing values, unexpected formats, outliers, duplicate rows, etc.\n\nLooking at data is the best way to boost performance of any ML model plus it reduces the likelihood of failed jobs later.\n\n# When submitting a training job\n\nNever pass a local machine path to hf_jobs.script, such as /Users/..., /home/..., /fsx/..., or a repo checkout path. HF Jobs runs in a fresh cloud environment where local files do not exist. For hf_jobs.script, use exactly one of:\n - inline Python source code\n - a file already written in the session sandbox, e.g. /app/train.py, ./train.py, or train.py\n - a public/raw URL\nIf you wrote or tested a script locally, read the file content and submit it inline, or write it into the sandbox first.\n\nGPU preflight is mandatory before hf_jobs when the job will run on GPU, or when the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile. First create a GPU sandbox with sandbox_create (t4-small minimum; choose larger hardware when VRAM requires it), run a tiny smoke test there using the same imports, model-loading path, training entrypoint, and a tiny dataset/subset, then fix failures before submitting. If you skip GPU sandbox preflight, state why before calling hf_jobs.\n\nBefore calling hf_jobs, output a pre-flight check:\n - Reference implementation: [which example you based this on]\n - Dataset format verified: [columns confirmed via hf_inspect_dataset/hub_repo_details]\n - GPU sandbox smoke test: [hardware and result, or explicitly not applicable because ...]\n - push_to_hub=True and hub_model_id set\n - timeout: [value] (based on: [model size] on [hardware])\n - Trackio monitoring included and deploying metrics to a public Space\n\nIf you cannot fill in all items, stop and complete the missing steps first.\n\nFor batch/ablation jobs: submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once.\n\nHardware sizing:\n 1-3B params: a10g-largex2\n 7-13B params: a100-large\n 30B+ params: l40sx4 or a100x4\n 70B+ params: a100x8\nNote: a10g-small and a10g-large have the SAME 24GB GPU memory. The difference is CPU/RAM only.\n\n# Sandbox-first development\n\nA private cpu-basic sandbox is already available for normal code execution in each session. For non-trivial scripts, develop and test there before launching via hf_jobs:\n write script \u2192 pip install \u2192 test with small run using bash/read/write/edit \u2192 fix errors \u2192 launch via hf_jobs at scale\n\nDo NOT call sandbox_create before normal CPU work. Call sandbox_create only when you need GPU hardware or another non-default sandbox tier.\n\nThe sandbox filesystem does not survive session resumption. If a session is resumed, any files, installed packages, or running processes from earlier are gone \u2014 recreate what you need before relying on the sandbox.\n\nUse a GPU sandbox (t4-small minimum) when testing code that uses CUDA, bf16/fp16, quantization, flash attention, torch.compile, or model loading. CPU sandboxes cannot test GPU code paths. If the available sandbox tiers cannot fit the full model path, test the largest useful smoke path, state what was not covered, and submit one HF job first.\n\n\n# When a task has 3+ steps\n\nUse plan_tool to track progress. One task in_progress at a time. Mark completed immediately after finishing. Update frequently to show the user what you're doing.\n\n# Error recovery\n\nWhen something fails:\n- Diagnose the actual error. Read the full error message and logs.\n- Do not retry the exact same thing. Identify what needs to change.\n- If an API/import error: check documentation for the correct API.\n- If an OOM error: (1) reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally to keep effective batch size identical, (2) enable gradient_checkpointing=True, (3) upgrade to larger GPU (a10gx4\u2192a100\u2192a100x4\u2192a100x8). Do NOT switch training methods (e.g. SFT\u2192LoRA) or reduce max_length \u2014 those change what the user gets. If OOM happens in sandbox, create a new sandbox with larger GPU hardware.\n- Never change the user's requested approach (training method, dataset, model, sequence length) without explicit approval.\n- If a tool call fails repeatedly for the same reason: stop and try a different approach.\n- Never silently substitute resources (datasets, models) \u2014 tell the user if something isn't available.\n\n# Task completion\n\nBefore ending your turn, verify:\n- Did you actually DO what the user asked, not just explain what you would do?\n- If something failed: did you diagnose and fix it, or at minimum explain what went wrong and ask for user input?\n- For training jobs: did you include a working Trackio dashboard URL?\n\nDo not stop after describing what you plan to do. Continue calling tools until the task is verifiably done.\nDo not mark plan tasks as completed if they failed or are only partially done.\n\n# Autonomous / headless mode\n\nWhen running autonomously (no human in the loop), you MUST follow these rules:\n\nNEVER respond with only text. Every response MUST include at least one tool call. If you have nothing to do, check the plan, verify outputs or plan ahead. A text-only response ends the agent loop permanently \u2014 there is no human to re-prompt you.\n\nNEVER STOP WORKING. Do NOT decide you are \"done\" while time remains. The human is not watching \u2014 they expect you to use the ENTIRE time budget productively. Do NOT ask \"should I continue?\" or \"is this a good stopping point?\" \u2014 there is nobody to answer. You run until the timer expires or you are manually killed.\n\nYour workflow is a loop, not a checklist. Once you have a working result, KEEP ITERATING:\n\nLOOP UNTIL TIME RUNS OUT:\n1. Research the approach (read docs, find examples, check current APIs)\n2. Implement the solution (write code, set up training)\n3. Train and evaluate\n4. Save the model to the required output location / push it to Hugging Face Hub\n5. Improve: tune hyperparameters, try different data, adjust the training recipe, try a different approach entirely\n6. Go to step 1\n\nHYPERPARAMETER TUNING: Do not tune hyperparameters by hand one-at-a-time. Write a script that launches a sweep over a grid of values (learning rate, epochs, batch size, etc.) and evaluates each run automatically. One well-designed sweep script beats ten manual experiments.\n\nIf you run out of ideas: go back to the literature. Crawl citation graphs deeper \u2014 find papers you haven't read yet, read their methodology sections, extract new datasets or training tricks. Look for papers that cite your current approach and improved on it. Try combining recipes from different papers. Re-read the task prompt for angles you missed. Re-read the training logs for clues. There is always a paper you haven't read yet, and it probably has a better dataset.\n\nCheck the remaining time periodically with the timer command specified in the task prompt. Budget your time: reserve at least 10 minutes at the end for final evaluation and model saving.\n\nThe task is NOT done until:\n- The required output exists (e.g. final model, metrics reached, dataset updated etc)\n- You have evaluated the model and confirmed it works\n\n# Communication\n\n- Be concise and direct. No filler, no restating what the user said.\n- One-word answers when appropriate for simple questions.\n- Always include direct Hub URLs when referencing models, datasets, Spaces, or jobs.\n- For errors: state what went wrong, why, and what you're doing to fix it.\n- Do not over-explain or present elaborate option menus for simple tasks. When the user's intent is clear, act on it. Present options only when there's genuine ambiguity.\n- Use the `notify` tool only when the user explicitly asked for out-of-band notifications or when the task clearly requires reporting to a configured messaging destination. Do not use it for routine chat updates.\n\n# Tool usage\n\n- Execute multiple independent tool calls in parallel when possible.\n- HF_TOKEN is automatically available in job secrets \u2014 no need to include it extra.\n- For training monitoring: include Trackio in the script and provide the dashboard URL.\n- For private/gated datasets: HF_TOKEN is needed \u2014 it's auto-loaded into job secrets.\n\n[Session context: Date=12-06-2026, Time=20:37:39.893, Timezone=CEST (UTC+02:00), User=unknown, Tools=19]", + "role": "system", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + } + ], + "events": [ + { + "timestamp": "2026-06-12T11:37:40.166883-07:00", + "event_type": "ready", + "data": { + "message": "Agent initialized" + } + } + ], + "tools": [ + { + "type": "function", + "function": { + "name": "sandbox_create", + "description": "Create or replace the session sandbox when non-default hardware is needed.\n\nA private cpu-basic sandbox is already started automatically for each session. For normal CPU code execution, call bash/read/write/edit directly; do NOT call sandbox_create first.\n\nUse sandbox_create when: you need GPU hardware, cpu-upgrade, or Trackio secrets before running code. The active sandbox persists across tool calls within the session. pip install works out of the box. Sandboxes are always created as private HF Spaces.\n\nFor ML code that uses CUDA, bf16, or model loading: use GPU hardware (t4-small minimum). CPU sandboxes cannot run GPU code paths \u2014 your test will not catch GPU-related errors.\n\nBefore choosing hardware, estimate your VRAM needs (models you run, training data size). Rule of thumb: bf16/fp16 \u2248 2 bytes/param, fp32 \u2248 4 bytes/param, plus ~20% overhead for optimizer states during training.\nCommon picks: t4-small (16GB VRAM, fits \u22641-3B), a10g-small (24GB, \u22647B), a100-large (80GB, \u226430B). If the model won't fit, pick larger hardware upfront \u2014 OOM on a sandbox wastes time.\n\nIf you intend to run a training script in this sandbox that uses report_to='trackio', pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` so they are set as TRACKIO_SPACE_ID/TRACKIO_PROJECT secrets in the sandbox and the UI can embed the live dashboard.\n\nHardware: cpu-basic, cpu-upgrade, cpu-performance, cpu-xl, sprx8, zero-a10g, t4-small, t4-medium, l4x1, l4x4, l40sx1, l40sx4, l40sx8, a10g-small, a10g-large, a10g-largex2, a10g-largex4, a100-large, a100x4, a100x8, h200, h200x2, h200x4, h200x8, inf2x6.\n", + "parameters": { + "type": "object", + "required": [], + "additionalProperties": false, + "properties": { + "hardware": { + "type": "string", + "enum": [ + "cpu-basic", + "cpu-upgrade", + "cpu-performance", + "cpu-xl", + "sprx8", + "zero-a10g", + "t4-small", + "t4-medium", + "l4x1", + "l4x4", + "l40sx1", + "l40sx4", + "l40sx8", + "a10g-small", + "a10g-large", + "a10g-largex2", + "a10g-largex4", + "a100-large", + "a100x4", + "a100x8", + "h200", + "h200x2", + "h200x4", + "h200x8", + "inf2x6" + ], + "description": "Hardware tier for the sandbox. Omit for the existing auto-started cpu-basic sandbox; choose GPU/cpu-upgrade only when needed." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for runs in this sandbox (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID secret and surfaced to the UI. The Space is auto-created and seeded with the trackio dashboard \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name. Injected as TRACKIO_PROJECT secret and used by the UI to filter the embedded dashboard to this project." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "bash", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nRun a shell command in the remote sandbox and return stdout/stderr.\n\nIMPORTANT: Do NOT use bash for file operations \u2014 use the dedicated tools instead:\n- To read files: use read (not cat/head/tail)\n- To edit files: use edit (not sed/awk)\n- To write files: use write (not echo/cat < > /app/output.log 2>&1 & echo $!\nThen check status:\n kill -0 2>/dev/null && echo 'running' || echo 'done'\n tail -n 50 /app/output.log\n\nTimeout default 240s, max 1200s.", + "parameters": { + "type": "object", + "required": [ + "command" + ], + "additionalProperties": false, + "properties": { + "command": { + "type": "string", + "description": "The shell command to execute." + }, + "description": { + "type": "string", + "description": "Short description (5-10 words, active voice)." + }, + "work_dir": { + "type": "string", + "description": "Working directory (default: /app)." + }, + "timeout": { + "type": "integer", + "description": "Optional timeout in seconds (default: 240, max: 1200)." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "read", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nReads a file from the sandbox filesystem. Returns contents with line numbers (cat -n format).\n\nUsage:\n- By default, reads up to 2000 lines from the beginning of the file.\n- You can optionally specify offset and limit for large files, but prefer reading the whole file first.\n- Lines longer than 4000 chars are truncated.\n- Cannot read directories \u2014 use bash with 'ls' instead.\n- You should read multiple potentially useful files in parallel when possible.\n- IMPORTANT: Always read a file before editing or overwriting it. The edit and write tools will reject operations on files you haven't read.", + "parameters": { + "type": "object", + "required": [ + "path" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to read." + }, + "offset": { + "type": "integer", + "description": "The line number to start reading from (1-based). Only provide if the file is too large to read at once." + }, + "limit": { + "type": "integer", + "description": "The number of lines to read. Only provide if the file is too large to read at once." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "write", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nWrites a file to the sandbox filesystem. Overwrites the existing file if one exists at the path.\n\n- If this is an existing file, you MUST use the read tool first. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files with the edit tool over overwriting with write.\n- Creates parent directories as needed.", + "parameters": { + "type": "object", + "required": [ + "path", + "content" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to write." + }, + "content": { + "type": "string", + "description": "The complete file content to write." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "edit", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nPerforms string replacements in files. Supports exact matching with fuzzy fallback.\n\nUsage:\n- You must read the file at least once before editing. This tool will error if you attempt an edit without reading the file.\n- The edit will FAIL if old_str is not unique in the file. Either provide a larger string with more surrounding context to make it unique, or set replace_all to true.\n- old_str and new_str must differ.\n- Preserve indentation exactly as it appears in the file.\n- Do NOT include line number prefixes from read output in old_str or new_str.\n- To delete code, set new_str to empty string.\n- Use replace_all for renaming variables or strings across the file.\n\nModes:\n- replace (default): replace first occurrence of old_str with new_str.\n- append_after: insert new_str immediately after old_str (old_str is kept).\n- prepend_before: insert new_str immediately before old_str (old_str is kept).", + "parameters": { + "type": "object", + "required": [ + "path", + "old_str", + "new_str" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to edit." + }, + "old_str": { + "type": "string", + "description": "The text to find in the file. Must match exactly (fuzzy matching is used as fallback)." + }, + "new_str": { + "type": "string", + "description": "The replacement text. For append_after/prepend_before modes, the text to insert." + }, + "replace_all": { + "type": "boolean", + "description": "Replace all occurrences of old_str (default: false).", + "default": false + }, + "mode": { + "type": "string", + "enum": [ + "replace", + "append_after", + "prepend_before" + ], + "description": "Edit mode (default: replace).", + "default": "replace" + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "research", + "description": "Spawn a research sub-agent to explore documentation, codebases, or repos WITHOUT polluting the main conversation context. The sub-agent gets its own independent context window with read-only research tools and returns a concise summary of findings.\n\nUse this for:\n- Researching current API usage before implementing ML tasks (find examples + read docs)\n- Exploring HF docs, reading papers, analyzing GitHub repos\n- Any research where raw tool outputs would be too verbose\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, hf_papers, etc. Just describe what you need researched.", + "parameters": { + "type": "object", + "properties": { + "task": { + "type": "string", + "description": "Detailed description of what to research. Be specific: include library names, trainer types, dataset names, repo names, or doc pages to explore. Example: 'Research current TRL SFTTrainer usage: find working example scripts, read the SFT documentation, and check SFTConfig parameters. Also validate that dataset HuggingFaceH4/ultrachat_200k has the right format for SFT.'" + }, + "context": { + "type": "string", + "description": "Optional context from the current conversation that the research agent needs (e.g., what the user wants to build, constraints, what's been tried)." + } + }, + "required": [ + "task" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "explore_hf_docs", + "description": "Browse HF documentation structure \u2014 discover all available documentation with 200-char previews.\n\nUse this to find relevant documentation and/or examples with detailed parameter docs and API reference. To be used together with github_find_examples and github_read_file to find working examples and documentation.\n\nPattern: explore_hf_docs (find relevant pages) \u2192 fetch_hf_docs (get full content).\n\nFor training tasks: fetch the trainer config docs (SFTConfig, DPOConfig, GRPOConfig) to verify parameter names. Returns top 20 results by default; set max_results (max 50) to adjust.", + "parameters": { + "type": "object", + "properties": { + "endpoint": { + "type": "string", + "enum": [ + "hub", + "transformers", + "diffusers", + "datasets", + "gradio", + "trackio", + "smolagents", + "huggingface_hub", + "huggingface.js", + "transformers.js", + "inference-providers", + "inference-endpoints", + "peft", + "accelerate", + "optimum", + "tokenizers", + "courses", + "evaluate", + "tasks", + "dataset-viewer", + "trl", + "simulate", + "sagemaker", + "timm", + "safetensors", + "tgi", + "setfit", + "lerobot", + "autotrain", + "tei", + "bitsandbytes", + "sentence_transformers", + "chat-ui", + "leaderboards", + "lighteval", + "argilla", + "distilabel", + "microsoft-azure", + "kernels", + "google-cloud" + ], + "description": "The documentation endpoint to explore. Each endpoint corresponds to a major section of the Hugging Face documentation:\n\n\u2022 courses \u2014 All Hugging Face courses (LLM, robotics, MCP, smol (llm training), agents, deep RL, computer vision, games, diffusion, 3D, audio) and the cookbook recipes. Probably the best place for examples.\n\u2022 hub \u2014 Find answers to questions about models/datasets/spaces, auth, versioning, metadata.\n\u2022 transformers \u2014 Core model library: architectures, configs, tokenizers, training & inference APIs.\n\u2022 diffusers \u2014 Diffusion pipelines, schedulers, fine-tuning, training, and deployment patterns.\n\u2022 datasets \u2014 Dataset loading, streaming, processing, Arrow format, Hub integration.\n\u2022 gradio \u2014 UI components and demos for ML models. Uses Gradio's native API: without query returns full docs (llms.txt), with query uses embedding search for precise results.\n\u2022 trackio \u2014 Experiment tracking, metrics logging, and run comparison.\n\u2022 smolagents \u2014 Lightweight agent abstractions and tool-using patterns.\n\u2022 huggingface_hub \u2014 Python client for Hub operations (auth, upload/download, repo management).\n\u2022 huggingface.js \u2014 JS/TS client for Hub APIs in browser and Node.\n\u2022 transformers.js \u2014 Run Transformer models in browser/Node via WebGPU/WASM.\n\u2022 inference-providers \u2014 Unified interface for third-party inference backends.\n\u2022 inference-endpoints \u2014 Managed, scalable model deployments on HF infrastructure.\n\u2022 peft \u2014 Parameter-efficient fine-tuning methods (LoRA, adapters, etc.).\n\u2022 accelerate \u2014 Hardware-agnostic, distributed and mixed-precision training orchestration.\n\u2022 optimum \u2014 Hardware-aware optimization and model export tooling, including Habana, Neuron, Intel, ExecuTorch, and TPU variants.\n\u2022 tokenizers \u2014 Fast tokenizer internals, training, and low-level APIs.\n\u2022 evaluate \u2014 Metrics, evaluation workflows, and training-loop integration.\n\u2022 tasks \u2014 Canonical task definitions and model categorization.\n\u2022 dataset-viewer \u2014 Dataset preview, streaming views, and viewer internals.\n\u2022 trl \u2014 RLHF, DPO, PPO, and SFT utilities for LLMs.\n\u2022 simulate \u2014 Experimental simulation tools and workflows.\n\u2022 sagemaker \u2014 Deploying Hugging Face models on AWS SageMaker.\n\u2022 timm \u2014 Image model zoo and utilities via HF integrations.\n\u2022 safetensors \u2014 Safe, fast tensor serialization format.\n\u2022 tgi \u2014 High-throughput text generation server for LLMs.\n\u2022 setfit \u2014 Few-shot text classification via sentence embeddings.\n\u2022 lerobot \u2014 Robotics datasets, policies, and learning workflows.\n\u2022 autotrain \u2014 No/low-code model training on Hugging Face.\n\u2022 tei \u2014 Optimized inference server for embedding workloads.\n\u2022 bitsandbytes \u2014 Quantization and memory-efficient optimizers.\n\u2022 sentence_transformers \u2014 Embedding models, training recipes, similarity/search workflows.\n\u2022 chat-ui \u2014 Reference chat interfaces for LLM deployment.\n\u2022 leaderboards \u2014 Evaluation leaderboards and submission mechanics.\n\u2022 lighteval \u2014 Lightweight, reproducible LLM evaluation framework.\n\u2022 argilla \u2014 Data annotation, feedback, and human-in-the-loop workflows.\n\u2022 distilabel \u2014 Synthetic data generation and distillation pipelines.\n\u2022 microsoft-azure \u2014 Azure deployment and integration guides.\n\u2022 kernels \u2014 Load prebuilt compute kernels (E.g. flash-attn2) from the Hub via `attn_implementation`; avoids compiling flash-attn from source.\n\u2022 google-cloud \u2014 GCP deployment and serving workflows.\n" + }, + "query": { + "type": "string", + "description": "Optional keyword query to rank and filter documentation pages. For Gradio, use concise queries like 'how to use the image component' or 'audio component demo'." + }, + "max_results": { + "type": "integer", + "description": "Max results (default 20, max 50). Ignored for Gradio.", + "minimum": 1, + "maximum": 50 + } + }, + "required": [ + "endpoint" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "fetch_hf_docs", + "description": "Fetch full markdown content of an HF documentation page. Use after explore_hf_docs.\n\nCritical for finding documentation e.g. current trainer configuration parameters (SFTConfig, DPOConfig, etc.) Use for researching solutions and before writing training scripts. Your internal knowledge is outdated.\n\nProvide the full URL from explore_hf_docs results. The .md extension is added automatically.", + "parameters": { + "type": "object", + "properties": { + "url": { + "type": "string", + "description": "The full URL to the documentation page. Example: 'https://huggingface.co/docs/trl/dpo_trainer' The .md extension will be added automatically if not present." + } + }, + "required": [ + "url" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_papers", + "description": "Discover ML research papers, analyze citations, search paper contents, and find linked resources.\n\nCombines HuggingFace Hub, arXiv, and Semantic Scholar. Use for exploring research areas, finding datasets for a task, tracing citation chains, or implementing a paper's approach.\n\nTypical flows:\n search \u2192 read_paper \u2192 find_all_resources \u2192 hf_inspect_dataset\n search \u2192 paper_details \u2192 citation_graph \u2192 read_paper (trace influence)\n snippet_search \u2192 paper_details \u2192 read_paper (find specific claims)\n\nOperations:\n- trending: Get trending daily papers, optionally filter by topic keyword\n- search: Search papers. Uses HF by default (ML-tuned). Add date_from/min_citations/categories to use Semantic Scholar with filters\n- paper_details: Metadata, abstract, AI summary, github link\n- read_paper: Read paper contents \u2014 without section: abstract + TOC; with section: full text\n- citation_graph: Get references and citations for a paper with influence flags and citation intents\n- snippet_search: Semantic search over full-text passages from 12M+ papers\n- recommend: Find similar papers (single paper or positive/negative examples)\n- find_datasets: Find datasets linked to a paper\n- find_models: Find models linked to a paper\n- find_collections: Find collections that include a paper\n- find_all_resources: Parallel fetch of datasets + models + collections for a paper", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "trending", + "search", + "paper_details", + "read_paper", + "citation_graph", + "snippet_search", + "recommend", + "find_datasets", + "find_models", + "find_collections", + "find_all_resources" + ], + "description": "Operation to execute." + }, + "query": { + "type": "string", + "description": "Search query. Required for: search, snippet_search. Optional for: trending (filters by keyword). Supports boolean syntax for Semantic Scholar: '\"exact phrase\" term1 | term2'." + }, + "arxiv_id": { + "type": "string", + "description": "ArXiv paper ID (e.g. '2305.18290'). Required for: paper_details, read_paper, citation_graph, find_datasets, find_models, find_collections, find_all_resources. Optional for: recommend (single-paper recs). Get IDs from search results first." + }, + "section": { + "type": "string", + "description": "Section name or number to read (e.g. '3', 'Experiments', '4.2'). Optional for: read_paper. Without this, returns abstract + TOC." + }, + "direction": { + "type": "string", + "enum": [ + "citations", + "references", + "both" + ], + "description": "Direction for citation_graph. Default: both." + }, + "date": { + "type": "string", + "description": "Date in YYYY-MM-DD format. Optional for: trending (defaults to recent papers)." + }, + "date_from": { + "type": "string", + "description": "Start date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "date_to": { + "type": "string", + "description": "End date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "categories": { + "type": "string", + "description": "Field of study filter (e.g. 'Computer Science'). Triggers Semantic Scholar search." + }, + "min_citations": { + "type": "integer", + "description": "Minimum citation count filter. Triggers Semantic Scholar search." + }, + "sort_by": { + "type": "string", + "enum": [ + "relevance", + "citationCount", + "publicationDate" + ], + "description": "Sort order for Semantic Scholar search. Default: relevance." + }, + "positive_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs for multi-paper recommendations. For: recommend." + }, + "negative_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs as negative examples. For: recommend." + }, + "sort": { + "type": "string", + "enum": [ + "downloads", + "likes", + "trending" + ], + "description": "Sort order for find_datasets and find_models. Default: downloads." + }, + "limit": { + "type": "integer", + "description": "Maximum results to return (default: 10, max: 50)." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "web_search", + "description": "Search the web for current information and return cited results.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "minLength": 2 + }, + "allowed_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional allowlist of domains or URLs. Subdomains match." + }, + "blocked_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional blocklist of domains or URLs. Subdomains match." + } + }, + "required": [ + "query" + ], + "additionalProperties": false + } + } + }, + { + "type": "function", + "function": { + "name": "hf_inspect_dataset", + "description": "Inspect a HF dataset in one call: status, configs/splits, schema, sample rows, parquet info.\n\nREQUIRED before any training job to verify dataset format matches training method:\n SFT: needs 'messages', 'text', or 'prompt'/'completion'\n DPO: needs 'prompt', 'chosen', 'rejected'\n GRPO: needs 'prompt'\nAll datasets used for training have to be in conversational ChatML format to be compatible with HF libraries.'\nTraining will fail with KeyError if columns don't match.\n\nAlso use to get example datapoints, understand column names, data types, and available splits before writing any data loading code. Supports private/gated datasets when HF_TOKEN is set.", + "parameters": { + "type": "object", + "properties": { + "dataset": { + "type": "string", + "description": "Dataset ID in 'org/name' format (e.g., 'stanfordnlp/imdb')" + }, + "config": { + "type": "string", + "description": "Config/subset name. Auto-detected if not specified." + }, + "split": { + "type": "string", + "description": "Split for sample rows. Auto-detected if not specified." + }, + "sample_rows": { + "type": "integer", + "description": "Number of sample rows to show (default: 3, max: 10)", + "default": 3 + } + }, + "required": [ + "dataset" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "plan_tool", + "description": "Track progress on multi-step tasks with a todo list (pending/in_progress/completed).\n\nUse for tasks with 3+ steps. Each call replaces the entire plan (send full list).\n\nRules: exactly ONE task in_progress at a time. Mark completed immediately after finishing. Only mark completed when the task fully succeeded \u2014 keep in_progress if there are errors. Update frequently so the user sees progress.", + "parameters": { + "type": "object", + "properties": { + "todos": { + "type": "array", + "description": "List of todo items", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "Unique identifier for the todo" + }, + "content": { + "type": "string", + "description": "Description of the todo task" + }, + "status": { + "type": "string", + "enum": [ + "pending", + "in_progress", + "completed" + ], + "description": "Current status of the todo" + } + }, + "required": [ + "id", + "content", + "status" + ] + } + } + }, + "required": [ + "todos" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "notify", + "description": "Send an out-of-band notification to configured messaging destinations. Use this only when the user explicitly asked for proactive notifications or when the task requires reporting progress outside the chat. Destinations must be named server-side configs such as 'slack.ops'.", + "parameters": { + "type": "object", + "properties": { + "destinations": { + "type": "array", + "description": "Named messaging destinations to notify.", + "items": { + "type": "string" + }, + "minItems": 1 + }, + "message": { + "type": "string", + "description": "Main notification body." + }, + "title": { + "type": "string", + "description": "Optional short title line." + }, + "severity": { + "type": "string", + "enum": [ + "info", + "success", + "warning", + "error" + ], + "description": "Notification severity label." + } + }, + "required": [ + "destinations", + "message" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_jobs", + "description": "Execute Python scripts or Docker containers on HF cloud infrastructure.\n\nTwo modes (mutually exclusive): Python mode (script + dependencies) or Docker mode (command + image). Provide exactly ONE of 'script' or 'command'.\n\nBEFORE submitting training/fine-tuning jobs:\n- You MUST have called github_find_examples + github_read_file to find a working reference implementation. Scripts based on your internal knowledge WILL use outdated APIs and fail.\n- You MUST have validated dataset format via hf_inspect_dataset or hub_repo_details.\n- If the job runs on GPU, or the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile, you MUST create a GPU sandbox with sandbox_create first, run a tiny smoke test there, and fix failures before submitting. If skipped, state why before calling hf_jobs.\n- Training config MUST include push_to_hub=True and hub_model_id. Job storage is EPHEMERAL \u2014 all files are deleted when the job ends. Without push_to_hub, trained models are lost permanently.\n- Include trackio monitoring and provide the dashboard URL to the user. When the script uses report_to='trackio', also pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` as tool args \u2014 they are injected as TRACKIO_SPACE_ID/TRACKIO_PROJECT env vars and let the UI embed the live dashboard.\n\nBATCH/ABLATION JOBS: Submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once \u2014 if there's a bug, all jobs fail.\n\nOperations: run, ps, logs, inspect, cancel, scheduled run/ps/inspect/delete/suspend/resume.\n\nHardware: CPU: cpu-basic(2vCPU/16GB), cpu-upgrade(8vCPU/32GB). GPU: t4-small(4vCPU/15GB/GPU 16GB), t4-medium(8vCPU/30GB/GPU 16GB), a10g-small(4vCPU/15GB/GPU 24GB), a10g-large(12vCPU/46GB/GPU 24GB), a10g-largex2(24vCPU/92GB/GPU 48GB), a10g-largex4(48vCPU/184GB/GPU 96GB), a100-large(12vCPU/142GB/GPU 80GB), a100x4(48vCPU/568GB/GPU 320GB), a100x8(96vCPU/1136GB/GPU 640GB), l4x1(8vCPU/30GB/GPU 24GB), l4x4(48vCPU/186GB/GPU 96GB), l40sx1(8vCPU/62GB/GPU 48GB), l40sx4(48vCPU/382GB/GPU 192GB), l40sx8(192vCPU/1534GB/GPU 384GB).\nCommon picks: t4-small ($0.60/hr, 1-3B), a10g-large ($2/hr, 7-13B), a100-large ($4/hr, 30B+), h100 ($6/hr, 70B+). Note: a10g-small and a10g-large have the SAME 24GB GPU \u2014 the difference is CPU/RAM only.\n\nOOM RECOVERY: When a training job fails with CUDA OOM:\n1. Reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally (keep effective batch size identical)\n2. Enable gradient_checkpointing=True\n3. Upgrade to larger GPU (a10g\u2192a100\u2192h100)\nDo NOT switch training methods (e.g. full SFT to LoRA) or reduce max_length \u2014 those change what the user gets and require explicit approval.\n\nExamples:\nTraining: {'operation': 'run', 'script': '/app/train.py', 'dependencies': ['transformers', 'trl', 'torch', 'datasets', 'trackio'], 'hardware_flavor': 'a100-large', 'timeout': '8h'}\nMonitor: {'operation': 'ps'}, {'operation': 'logs', 'job_id': 'xxx'}, {'operation': 'cancel', 'job_id': 'xxx'}Docker: {'operation': 'run', 'command': ['duckdb', '-c', 'select 1 + 2'], 'image': 'duckdb/duckdb', 'hardware_flavor': 'cpu-basic', 'timeout': '1h'}\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "run", + "ps", + "logs", + "inspect", + "cancel", + "scheduled run", + "scheduled ps", + "scheduled inspect", + "scheduled delete", + "scheduled suspend", + "scheduled resume" + ], + "description": "Operation to execute." + }, + "script": { + "type": "string", + "description": "Python code, sandbox file path (e.g. '/app/train.py', './train.py', or bare 'train.py'), or URL. Triggers Python mode. For ML training: base this on a working example found via github_find_examples, not on internal knowledge. For GPU/model-loading training scripts, smoke-test in a GPU sandbox before submission. Mutually exclusive with 'command'." + }, + "dependencies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Pip packages to install. Include ALL required packages. Common training set: ['transformers', 'trl', 'torch', 'datasets', 'trackio', 'accelerate']. Only used with 'script'." + }, + "image": { + "type": "string", + "description": "Docker image. Optional \u2014 auto-selected if not provided. Use with 'command'." + }, + "command": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Command to execute as list. Triggers Docker mode. Mutually exclusive with 'script'." + }, + "hardware_flavor": { + "type": "string", + "description": "Hardware type. Sizing guide: 1-3B params \u2192 t4-small/a10g-small, 7-13B \u2192 a10g-large, 30B+ \u2192 a100-large, 70B+ \u2192 h100/h100x8. All options: CPU: ['cpu-basic', 'cpu-upgrade']. GPU: ['t4-small', 't4-medium', 'a10g-small', 'a10g-large', 'a10g-largex2', 'a10g-largex4', 'a100-large', 'a100x4', 'a100x8', 'l4x1', 'l4x4', 'l40sx1', 'l40sx4', 'l40sx8']." + }, + "timeout": { + "type": "string", + "description": "Maximum job runtime. MUST be >2h for any training job \u2014 default 30m kills training mid-run. Guidelines: 1-3B models: 3-4h, 7-13B: 6-8h, 30B+: 12-24h. Use 30m-1h only for quick data processing or inference tasks. Default: '30m'." + }, + "env": { + "type": "object", + "description": "Environment variables {'KEY': 'VALUE'}. HF_TOKEN is auto-included." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for this run (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID env var and used by the UI to embed the live dashboard. Set this whenever the script uses report_to='trackio'. The Space is auto-created and seeded with the trackio dashboard before the job starts \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name to log this run under. Injected as TRACKIO_PROJECT env var and used by the UI to filter the embedded dashboard to this project." + }, + "namespace": { + "type": "string", + "description": "Optional namespace to run the job under. Must be the caller's own account or an org they belong to. If omitted, defaults to the caller's personal account. Credits are billed against this namespace." + }, + "job_id": { + "type": "string", + "description": "Job ID. Required for: logs, inspect, cancel." + }, + "scheduled_job_id": { + "type": "string", + "description": "Scheduled job ID. Required for: scheduled inspect/delete/suspend/resume." + }, + "schedule": { + "type": "string", + "description": "Cron schedule or preset (@hourly, @daily, @weekly, @monthly). Required for: scheduled run." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_files", + "description": "Read and write files in HF repos (models/datasets/spaces).\n\n## Operations\n- **list**: List files with sizes and structure\n- **read**: Read file content (text files only)\n- **upload**: Upload content to repo (can create PR)\n- **delete**: Delete files/folders (supports wildcards like *.tmp)\n\n## Use when\n- Need to see what files exist in a repo\n- Want to read config.json, README.md, or other text files\n- Uploading training scripts, configs, or results to a repo\n- Cleaning up temporary files from a repo\n\n## Examples\n{\"operation\": \"list\", \"repo_id\": \"meta-llama/Llama-2-7b\"}\n{\"operation\": \"read\", \"repo_id\": \"gpt2\", \"path\": \"config.json\"}\n{\"operation\": \"upload\", \"repo_id\": \"my-model\", \"path\": \"README.md\", \"content\": \"# My Model\"}\n{\"operation\": \"upload\", \"repo_id\": \"org/model\", \"path\": \"fix.py\", \"content\": \"...\", \"create_pr\": true}\n{\"operation\": \"delete\", \"repo_id\": \"my-model\", \"patterns\": [\"*.tmp\", \"logs/\"]}\n\n## Notes\n- For binary files (safetensors, bin), use list to see them but can't read content\n- upload/delete require approval (can overwrite/destroy data)\n- Use create_pr=true to propose changes instead of direct commit\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "list", + "read", + "upload", + "delete" + ], + "description": "Operation: list, read, upload, delete" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "revision": { + "type": "string", + "description": "Branch/tag/commit (default: main)" + }, + "path": { + "type": "string", + "description": "File path for read/upload" + }, + "content": { + "type": "string", + "description": "File content for upload" + }, + "patterns": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Patterns to delete (e.g., ['*.tmp', 'logs/'])" + }, + "create_pr": { + "type": "boolean", + "description": "Create PR instead of direct commit" + }, + "commit_message": { + "type": "string", + "description": "Custom commit message" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_git", + "description": "Git-like operations on HF repos: branches, tags, PRs, and repo management.\n\n## Operations\n**Branches:** create_branch, delete_branch, list_refs\n**Tags:** create_tag, delete_tag\n**PRs:** create_pr, list_prs, get_pr, merge_pr, close_pr, comment_pr, change_pr_status\n**Repo:** create_repo, update_repo\n\n## Use when\n- Creating feature branches for experiments\n- Tagging model versions (v1.0, v2.0)\n- Opening PRs to contribute to repos you don't own\n- Reviewing and merging PRs on your repos\n- Creating new model/dataset/space repos\n- Changing repo visibility (public/private) or gated access\n\n## Examples\n{\"operation\": \"list_refs\", \"repo_id\": \"my-model\"}\n{\"operation\": \"create_branch\", \"repo_id\": \"my-model\", \"branch\": \"experiment-v2\"}\n{\"operation\": \"create_tag\", \"repo_id\": \"my-model\", \"tag\": \"v1.0\", \"revision\": \"main\"}\n{\"operation\": \"create_pr\", \"repo_id\": \"org/model\", \"title\": \"Fix tokenizer config\"}\n{\"operation\": \"change_pr_status\", \"repo_id\": \"my-model\", \"pr_num\": 1, \"new_status\": \"open\"}\n{\"operation\": \"merge_pr\", \"repo_id\": \"my-model\", \"pr_num\": 3}\n{\"operation\": \"create_repo\", \"repo_id\": \"my-new-model\", \"private\": true}\n{\"operation\": \"update_repo\", \"repo_id\": \"my-model\", \"gated\": \"auto\"}\n\n## PR Workflow\n1. create_pr \u2192 creates draft PR (empty by default)\n2. Upload files with revision='refs/pr/N' to add commits\n3. change_pr_status with new_status='open' to publish (convert draft to open)\n4. merge_pr when ready\n\n## Notes\n- PR status: draft (default), open, merged, closed\n- delete_branch, delete_tag, merge_pr, create_repo, update_repo require approval\n- For spaces, create_repo needs space_sdk (gradio/streamlit/docker/static)\n- gated options: 'auto' (instant), 'manual' (review), false (open)\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "create_branch", + "delete_branch", + "create_tag", + "delete_tag", + "list_refs", + "create_pr", + "list_prs", + "get_pr", + "merge_pr", + "close_pr", + "comment_pr", + "change_pr_status", + "create_repo", + "update_repo" + ], + "description": "Operation to execute" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "branch": { + "type": "string", + "description": "Branch name (create_branch, delete_branch)" + }, + "from_rev": { + "type": "string", + "description": "Create branch from this revision (default: main)" + }, + "tag": { + "type": "string", + "description": "Tag name (create_tag, delete_tag)" + }, + "revision": { + "type": "string", + "description": "Revision for tag (default: main)" + }, + "tag_message": { + "type": "string", + "description": "Tag description" + }, + "title": { + "type": "string", + "description": "PR title (create_pr)" + }, + "description": { + "type": "string", + "description": "PR description (create_pr)" + }, + "pr_num": { + "type": "integer", + "description": "PR/discussion number" + }, + "comment": { + "type": "string", + "description": "Comment text" + }, + "status": { + "type": "string", + "enum": [ + "open", + "closed", + "all" + ], + "description": "Filter PRs by status (list_prs)" + }, + "new_status": { + "type": "string", + "enum": [ + "open", + "closed" + ], + "description": "New status for PR/discussion (change_pr_status)" + }, + "private": { + "type": "boolean", + "description": "Make repo private (create_repo, update_repo)" + }, + "gated": { + "type": "string", + "enum": [ + "auto", + "manual", + "false" + ], + "description": "Gated access setting (update_repo)" + }, + "space_sdk": { + "type": "string", + "enum": [ + "gradio", + "streamlit", + "docker", + "static" + ], + "description": "Space SDK (required for create_repo with space)" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_find_examples", + "description": "Find working example scripts in GitHub repositories (from a list of predetermined directories e.g. examples/, scripts/, tutorials/, etc.). Uses fuzzy keyword matching.\n\nMANDATORY before writing any ML training, fine-tuning, or inference code. Your internal knowledge of library APIs is outdated \u2014 working examples show current API patterns.\n\nSequence: github_find_examples \u2192 github_read_file (study the example) \u2192 implement based on what you found.\n\nSkip this only for: simple data queries, status checks, non-code tasks.\n\nExamples:\n {keyword: 'sft', repo: 'trl'} \u2192 finds examples/scripts/sft.py\n {keyword: 'grpo', repo: 'trl'} \u2192 finds GRPO training examples\n {repo: 'trl', max_results: 20} \u2192 lists all available training method examples", + "parameters": { + "type": "object", + "properties": { + "keyword": { + "type": "string", + "description": "Keyword to fuzzy match against file paths (e.g., 'grpo', 'sft')." + }, + "repo": { + "type": "string", + "description": "Repository name (e.g., 'trl', 'transformers'). Required." + }, + "org": { + "type": "string", + "description": "GitHub organization or username. Default: 'huggingface'." + }, + "max_results": { + "type": "integer", + "description": "Maximum number of results to return. Default: 50." + }, + "min_score": { + "type": "integer", + "description": "Minimum fuzzy match score (0-100). Default: 60." + } + }, + "required": [ + "repo" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_list_repos", + "description": "List and discover repositories for GitHub organizations or users with flexible sorting. **Use when:** (1) Exploring what libraries exist for a task, (2) Finding the right library to use, (3) Discovering popular or active projects, (4) Checking recently updated repos for latest features, (5) Finding alternative libraries in an organization. **Pattern:** github_list_repos (discover libraries) \u2192 github_find_examples (find usage examples) \u2192 implement. Returns: Comprehensive repository information (stars, forks, language, topics, URLs), sorted by preference. **Then:** Use github_find_examples on selected repo to discover example code. Sorts by: stars (popularity), forks (community), updated (activity), created (age).\n\n## When to use this tool\n\n- When you need to find libraries to use in your implementation\n- When exploring what repositories exist for a task or domain\n- When debugging an error and looking up if others have similar issues in repos\n- When finding the most popular or actively maintained projects for a user/org\n## Examples\n\n\n// ML Workflow Step: Discover HF libraries for RLHF/alignment\n// Use case: Find the right library for training with human feedback\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'stars',\n limit: 10\n}\n// Returns: transformers, trl, peft, accelerate, diffusers...\n\n\n\n// ML Workflow Step: Check for recently updated HF repos\n// Use case: Find actively maintained libraries with latest features\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'updated',\n order: 'desc',\n limit: 15\n}\n// Helps identify which repos have recent improvements/fixes\n", + "parameters": { + "type": "object", + "properties": { + "owner": { + "type": "string", + "description": "GitHub username or organization name. Required." + }, + "owner_type": { + "type": "string", + "enum": [ + "user", + "org" + ], + "description": "Whether the owner is a 'user' or 'org'. Default: 'org'." + }, + "sort": { + "type": "string", + "enum": [ + "stars", + "forks", + "updated", + "created" + ], + "description": "Sort field. Options: 'stars', 'forks', 'updated', 'created'. Default: 'stars'." + }, + "order": { + "type": "string", + "enum": [ + "asc", + "desc" + ], + "description": "Sort order. Options: 'asc', 'desc'. Default: 'desc'." + }, + "limit": { + "type": "integer", + "description": "Maximum number of repositories to return. No limit if not specified. Default: 30." + } + }, + "required": [ + "owner" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_read_file", + "description": "Read file contents from GitHub repositories. Returns first 300 lines by default. Auto-converts Jupyter notebooks to markdown.\n\nUse AFTER github_find_examples to study the working implementation. The purpose is to learn current API patterns \u2014 imports, trainer configs, dataset handling \u2014 so your implementation uses correct, up-to-date code.\n\nUse line_start/line_end for large files (>300 lines) to read specific sections.\n\nWhen NOT to use: when you don't know the file path (use github_find_examples first).", + "parameters": { + "type": "object", + "properties": { + "repo": { + "type": "string", + "description": "Repository in format 'owner/repo' (e.g., 'github/github-mcp-server'). Required." + }, + "path": { + "type": "string", + "description": "Path to file in repository (e.g., 'src/index.js'). Required." + }, + "ref": { + "type": "string", + "description": "Git reference - branch name, tag, or commit SHA. Default: 'HEAD'." + }, + "line_start": { + "type": "integer", + "description": "Starting line number (1-indexed, inclusive). Optional." + }, + "line_end": { + "type": "integer", + "description": "Ending line number (1-indexed, inclusive). Optional." + } + }, + "required": [ + "repo", + "path" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "find_hf_api", + "description": "Find HuggingFace Hub REST API endpoints to make HTTP requests. Returns curl examples with authentication. \u26a0\ufe0f USE THIS TOOL when you need to call the HF Hub API directly - for operations like: uploading/downloading files, managing repos, listing models/datasets, getting user info, managing webhooks, collections, discussions, or any Hub interaction not covered by other tools. **Use cases:** (1) 'Stream Space logs' \u2192 query='space logs', (2) 'Get Space metrics/Zero-GPU usage' \u2192 query='space metrics', (3) 'List organization members' \u2192 query='organization members', (4) 'Generate repo access token' \u2192 query='jwt token', (5) 'Check repo security scan' \u2192 query='security scan'. **Search modes:** Use 'query' for keyword search, 'tag' to browse a category, or both. If query finds no results, falls back to showing all endpoints in the tag. **Output:** Full endpoint details with method, path, parameters, curl command, and response schema.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "Keyword search across endpoint summaries, descriptions, and operation IDs. Examples: 'upload file', 'create repository', 'list user models', 'delete branch', 'webhook', 'collection', 'discussion comments'. Supports stemming (upload/uploading both work)." + }, + "tag": { + "type": "string", + "enum": [ + "agentic-provisioning", + "agents", + "auth", + "buckets", + "collections", + "container", + "datasets", + "discussions", + "docs", + "inference-endpoints", + "inference-providers", + "jobs", + "kernels", + "mcp", + "models", + "notifications", + "oauth", + "orgs", + "papers", + "repo-search", + "repos", + "resource-groups", + "scim", + "service-accounts", + "spaces", + "sql-console", + "users", + "webhooks" + ], + "description": "Filter by API category. Use alone to browse all endpoints in a category, or combine with 'query' to search within a category." + } + }, + "required": [] + } + } + } + ], + "upload_status": "failed", + "upload_url": null, + "last_save_time": "2026-06-12T11:38:56.349175", + "personal_upload_status": "failed" +} \ No newline at end of file diff --git a/backend/session_logs/session_bf81ceab-4f40-43b0-9f8f-9a40ea1a4c9d_20260612_113848.json b/backend/session_logs/session_bf81ceab-4f40-43b0-9f8f-9a40ea1a4c9d_20260612_113848.json new file mode 100644 index 0000000000000000000000000000000000000000..e88dfdb62748ba6ad1a6b349307d0a24ce45ca12 --- /dev/null +++ b/backend/session_logs/session_bf81ceab-4f40-43b0-9f8f-9a40ea1a4c9d_20260612_113848.json @@ -0,0 +1,1112 @@ +{ + "session_id": "bf81ceab-4f40-43b0-9f8f-9a40ea1a4c9d", + "user_id": "dev", + "hf_username": "dev", + "session_start_time": "2026-06-12T11:37:28.632624-07:00", + "session_end_time": "2026-06-12T11:38:48.624731", + "model_name": "anthropic/claude-opus-4.8:fal-ai", + "total_cost_usd": 0, + "usage_metrics": { + "version": 1, + "session_id": "bf81ceab-4f40-43b0-9f8f-9a40ea1a4c9d", + "billing_scope": "account_window_delta", + "total_usd": 0.0, + "total_usd_source": "app_telemetry_fallback", + "app_total_usd": 0.0, + "hf_billing_total_usd": null, + "app_telemetry": { + "session_id": "bf81ceab-4f40-43b0-9f8f-9a40ea1a4c9d", + "total_usd": 0.0, + "inference_usd": 0.0, + "hf_jobs_estimated_usd": 0.0, + "sandbox_estimated_usd": 0.0, + "llm_calls": 0, + "hf_jobs_count": 0, + "sandbox_count": 0, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0, + "hf_jobs_billable_seconds_estimate": 0, + "sandbox_billable_seconds_estimate": 0 + }, + "hf_billing": { + "source": "hf_billing_usage_v2", + "available": false, + "error": "missing_hf_token", + "current_session": null + }, + "llm": { + "calls": 0, + "calls_by_kind": {}, + "calls_by_model": {}, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0 + }, + "turns": { + "turn_complete_count": 0, + "assistant_stream_end_count": 0 + }, + "hf_jobs": { + "submits": 0, + "status_snapshots": 0, + "statuses": {}, + "flavors": {}, + "submit_flavors": {}, + "status_snapshot_flavors": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0, + "snapshots_with_estimated_cost": 0, + "snapshots_with_nonzero_estimated_cost": 0 + }, + "sandboxes": { + "creates": 0, + "destroys": 0, + "matched_pairs": 0, + "unpaired_creates": 0, + "unpaired_destroys": 0, + "hardware": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0 + }, + "data_quality": { + "event_count": 1, + "events_without_timestamp": 0, + "llm_calls_with_cost_usd": 0, + "llm_calls_with_nonzero_cost_usd": 0, + "job_snapshots_with_estimated_cost": 0, + "job_snapshots_missing_estimated_cost": 0 + } + }, + "messages": [ + { + "content": "You are ML Intern, an ML engineering assistant with 19 tools for training, fine-tuning, data processing, inference, and evaluation on the Hugging Face (HF) ecosystem.\n\nYour goal is to complete what the user requested with zero errors. You are fully autonomous \u2014 research, validate, implement, and deliver results without asking for unnecessary confirmation.\n\n# Your knowledge of HF libraries is outdated\n\nYou do not know current APIs for TRL, Transformers, PEFT, Trackio, or other HF libraries. Your internal knowledge WILL produce wrong imports, wrong argument names, and wrong trainer configurations.\n\nBefore writing any ML implementation code, start from the literature. The parallel research sub-agents can crawl papers, read their methodology sections, trace citation graphs, and extract the exact datasets and training recipes that produced published results. This is your primary advantage \u2014 use it.\n\nYour default workflow for any ML task:\n1. Find the landmark paper(s) for the task or domain\n2. Crawl their citation graphs to find recent downstream work\n3. Read methodology sections (not abstracts) of the most promising papers \u2014 especially recent ones with strong results, lot of citations, and publications in high-impact conferences\n4. Extract the recipe: what dataset, what training method, what hyperparameters produced those results\n5. Validate and use those datasets for training\n\n```\nresearch({\"task\": \"Literature crawl for [task]. Start from [paper/topic]. Crawl citation graph for recent downstream papers. Read their methodology sections (3, 4, 5) \u2014 extract the exact datasets, training methods, and hyperparameters that produced their best results. Attribute every finding to a specific result (e.g. 'Dataset X + method Y \u2192 85.3% on benchmark Z'). Also find working code examples using current TRL/Transformers APIs.\", \"context\": \"User wants to [goal]. We need the best training recipe backed by published results.\"})\n```\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, and hf_papers (with citation_graph, read_paper, snippet_search, find_datasets). Be specific in your task description \u2014 name anchor papers or arxiv IDs when you have them.\n\nYou can also call research tools directly (explore_hf_docs, github_read_file, etc.) for quick lookups.\n\nSkip research only for trivial non-code operations.\n\n# Mistakes you WILL make without research\n\nHALLUCINATED IMPORTS: You will import from modules that were renamed or removed. Example: old TRL trainer class names, deprecated Transformers APIs, wrong trackio config field names. Fix: read a current example script first.\n\nWRONG TRAINER ARGUMENTS: You will pass configuration arguments that don't exist in current trainer versions. Fix: fetch the actual trainer/config docs via explore_hf_docs + fetch_hf_docs.\n\nWRONG DATASET FORMAT: You will assume column names without checking. Training fails with KeyError. Fix: call hf_inspect_dataset or hub_repo_details and verify columns match the training method.\n\nDEFAULT TIMEOUT KILLS JOBS: You will leave timeout at the default 30m for training jobs. Training takes hours. The job gets killed and all progress is lost. Fix: set timeout based on model size (minimum 2h for any training).\n\nLOST MODELS: You will forget push_to_hub=True and hub_model_id in training config. Job storage is ephemeral \u2014 the filesystem is deleted when the job ends. Without push_to_hub, the trained model is permanently lost.\n\nBATCH FAILURES: You will submit all ablation/batch jobs at once without testing that one works first. All will fail for the same bug. Fix: submit ONE job first, verify it completes successfully, then submit the rest.\n\nSILENT DATASET SUBSTITUTION: When a requested dataset fails to load, you will silently switch to a different one without telling the user. Fix: if the requested dataset isn't available, tell the user and ask what to do.\n\nPREFER HUB KERNELS OVER COMPILING ATTENTION: Do NOT pip install 'flash-attn' to enable flash_attention_2 building from source can take many minutes to hours and often fails on the job's CUDA/PyTorch combo. Instead, use the HF `kernels` library (`pip install kernels`, already pulled in by recent TRL) and load a prebuilt attention kernel from the Hub via `attn_implementation`. Examples: `AutoModelForCausalLM.from_pretrained(..., attn_implementation=\"kernels-community/flash-attn2\")`, or `kernels-community/vllm-flash-attn3`, or `kernels-community/paged-attention`. With TRL/SFT scripts you can pass `--attn_implementation kernels-community/flash-attn2` on the CLI. Search additional kernels at https://huggingface.co/models?other=kernel. Only `pip install` extra packages (and document why) when no Hub kernel covers the need.\n\nSCOPE-CHANGING FIXES: Avoid at all costs! When you hit an error (especially OOM), you will try \"creative\" workarounds that change what the user asked for and/or change the training task itself \u2014 switching full SFT to LoRA on OOM, reducing max_length (silently truncates training data and changes what the model learns), disabling monitoring instead of fixing it. Do not do this. Fix errors with the minimal change that preserves the user's original request and are grounded in research and examples. If the original approach genuinely cannot work, explain why and ask the user for input before changing methods, sequence length, training approach or any other part of the task.\n\n# When writing ML code\n\nRequired sequence before any training/fine-tuning/inference script:\n1. Use `research` tool to find working examples, read docs, and get current API patterns\n2. Validate dataset: hf_inspect_dataset or hub_repo_details to confirm column names and format\n3. Validate model: hub_repo_details to confirm model exists, correct architecture/size/tokenizer\n\nTraining logging: always set disable_tqdm=True, logging_strategy=\"steps\", and logging_first_step=True in your TrainingArguments/SFTConfig so loss values are printed as plain text lines you can grep, not hidden inside tqdm progress bars.\n\nDataset format requirements by training method:\n SFT: \"messages\", \"text\", or \"prompt\"/\"completion\"\n DPO: \"prompt\", \"chosen\", \"rejected\"\n GRPO: \"prompt\"\n\n# Trackio\n\nTrackio is natively integrated with Transformers Trainer and all TRL trainers \u2014 the built-in TrackioCallback handles init/log/finish. In TrainingArguments/SFTConfig/DPOConfig/GRPOConfig set:\n report_to=\"trackio\"\n run_name=\"\" # e.g. \"sft_qwen3-4b_lr2e-5_bs128\"\n project=\"\" # keeps related runs grouped so you can compare them\n trackio_space_id=\"/ml-intern-<8-char-id>\" # creates a public dashboard Space\n`project` and `trackio_space_id` can also be set via TRACKIO_PROJECT / TRACKIO_SPACE_ID env vars.\n\nAlerts are how iterations decide what to change. Use trackio.alert(title, text, level) at every decision point in training. Levels:\n ERROR \u2014 stop and change approach (divergence, NaN, OOM)\n WARN \u2014 tweak hyperparameters (overfitting, early stopping, KL spike, reward collapse, slow convergence)\n INFO \u2014 milestones (training complete, target reached, checkpoint saved)\nAlways include numeric values and an actionable suggestion in `text`, e.g. \"loss=12.4 at step 200 \u2014 lr likely too high, try \u00d70.1\". A future call must be able to parse it and act on it.\n\nTo add alerts under Trainer/SFTTrainer/GRPOTrainer, pass a custom TrainerCallback via `callbacks=[...]` that calls trackio.alert() inside `on_log` (training metrics like loss, reward, kl) and `on_evaluate` (eval metrics \u2014 only available here, not in `on_log`). Keep each `if` simple: one metric, one threshold. Conditions stay easy to adjust between runs.\n\nRead alerts back between runs instead of parsing thousands of metric values. CLI \u2014 always use --json:\n trackio get alerts --project

--run --json\n trackio get alerts --project

--since --json # incremental polling\n trackio get run --project

--run --json\n trackio get metric --project

--run --metric --json\n trackio list runs --project

--json\nPython: api = trackio.Api(); api.alerts(

, run=, since=); api.runs(

) (each run has .name, .config, .alerts()).\n\nDrive the next config from prior alerts:\n diverged \u2192 lr \u00d7 0.1\n overfitting \u2192 weight_decay \u00d7 10 or reduce capacity\n early stopping \u2192 lr \u00d7 0.5 or adjust schedule\n high accuracy \u2192 refine around current config\nRead prior config via api.runs(...).config and only mutate keys the alerts justify changing.\n\n# Data audit\n\nBefore working with any dataset, audit it first. Do not assume you know what the data looks like \u2014 inspect it.\n\nUse hf_inspect_dataset to check: schema/columns, number of rows per split, value distributions for key columns, sample rows. Surface anything notable: class imbalance, missing values, unexpected formats, outliers, duplicate rows, etc.\n\nLooking at data is the best way to boost performance of any ML model plus it reduces the likelihood of failed jobs later.\n\n# When submitting a training job\n\nNever pass a local machine path to hf_jobs.script, such as /Users/..., /home/..., /fsx/..., or a repo checkout path. HF Jobs runs in a fresh cloud environment where local files do not exist. For hf_jobs.script, use exactly one of:\n - inline Python source code\n - a file already written in the session sandbox, e.g. /app/train.py, ./train.py, or train.py\n - a public/raw URL\nIf you wrote or tested a script locally, read the file content and submit it inline, or write it into the sandbox first.\n\nGPU preflight is mandatory before hf_jobs when the job will run on GPU, or when the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile. First create a GPU sandbox with sandbox_create (t4-small minimum; choose larger hardware when VRAM requires it), run a tiny smoke test there using the same imports, model-loading path, training entrypoint, and a tiny dataset/subset, then fix failures before submitting. If you skip GPU sandbox preflight, state why before calling hf_jobs.\n\nBefore calling hf_jobs, output a pre-flight check:\n - Reference implementation: [which example you based this on]\n - Dataset format verified: [columns confirmed via hf_inspect_dataset/hub_repo_details]\n - GPU sandbox smoke test: [hardware and result, or explicitly not applicable because ...]\n - push_to_hub=True and hub_model_id set\n - timeout: [value] (based on: [model size] on [hardware])\n - Trackio monitoring included and deploying metrics to a public Space\n\nIf you cannot fill in all items, stop and complete the missing steps first.\n\nFor batch/ablation jobs: submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once.\n\nHardware sizing:\n 1-3B params: a10g-largex2\n 7-13B params: a100-large\n 30B+ params: l40sx4 or a100x4\n 70B+ params: a100x8\nNote: a10g-small and a10g-large have the SAME 24GB GPU memory. The difference is CPU/RAM only.\n\n# Sandbox-first development\n\nA private cpu-basic sandbox is already available for normal code execution in each session. For non-trivial scripts, develop and test there before launching via hf_jobs:\n write script \u2192 pip install \u2192 test with small run using bash/read/write/edit \u2192 fix errors \u2192 launch via hf_jobs at scale\n\nDo NOT call sandbox_create before normal CPU work. Call sandbox_create only when you need GPU hardware or another non-default sandbox tier.\n\nThe sandbox filesystem does not survive session resumption. If a session is resumed, any files, installed packages, or running processes from earlier are gone \u2014 recreate what you need before relying on the sandbox.\n\nUse a GPU sandbox (t4-small minimum) when testing code that uses CUDA, bf16/fp16, quantization, flash attention, torch.compile, or model loading. CPU sandboxes cannot test GPU code paths. If the available sandbox tiers cannot fit the full model path, test the largest useful smoke path, state what was not covered, and submit one HF job first.\n\n\n# When a task has 3+ steps\n\nUse plan_tool to track progress. One task in_progress at a time. Mark completed immediately after finishing. Update frequently to show the user what you're doing.\n\n# Error recovery\n\nWhen something fails:\n- Diagnose the actual error. Read the full error message and logs.\n- Do not retry the exact same thing. Identify what needs to change.\n- If an API/import error: check documentation for the correct API.\n- If an OOM error: (1) reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally to keep effective batch size identical, (2) enable gradient_checkpointing=True, (3) upgrade to larger GPU (a10gx4\u2192a100\u2192a100x4\u2192a100x8). Do NOT switch training methods (e.g. SFT\u2192LoRA) or reduce max_length \u2014 those change what the user gets. If OOM happens in sandbox, create a new sandbox with larger GPU hardware.\n- Never change the user's requested approach (training method, dataset, model, sequence length) without explicit approval.\n- If a tool call fails repeatedly for the same reason: stop and try a different approach.\n- Never silently substitute resources (datasets, models) \u2014 tell the user if something isn't available.\n\n# Task completion\n\nBefore ending your turn, verify:\n- Did you actually DO what the user asked, not just explain what you would do?\n- If something failed: did you diagnose and fix it, or at minimum explain what went wrong and ask for user input?\n- For training jobs: did you include a working Trackio dashboard URL?\n\nDo not stop after describing what you plan to do. Continue calling tools until the task is verifiably done.\nDo not mark plan tasks as completed if they failed or are only partially done.\n\n# Autonomous / headless mode\n\nWhen running autonomously (no human in the loop), you MUST follow these rules:\n\nNEVER respond with only text. Every response MUST include at least one tool call. If you have nothing to do, check the plan, verify outputs or plan ahead. A text-only response ends the agent loop permanently \u2014 there is no human to re-prompt you.\n\nNEVER STOP WORKING. Do NOT decide you are \"done\" while time remains. The human is not watching \u2014 they expect you to use the ENTIRE time budget productively. Do NOT ask \"should I continue?\" or \"is this a good stopping point?\" \u2014 there is nobody to answer. You run until the timer expires or you are manually killed.\n\nYour workflow is a loop, not a checklist. Once you have a working result, KEEP ITERATING:\n\nLOOP UNTIL TIME RUNS OUT:\n1. Research the approach (read docs, find examples, check current APIs)\n2. Implement the solution (write code, set up training)\n3. Train and evaluate\n4. Save the model to the required output location / push it to Hugging Face Hub\n5. Improve: tune hyperparameters, try different data, adjust the training recipe, try a different approach entirely\n6. Go to step 1\n\nHYPERPARAMETER TUNING: Do not tune hyperparameters by hand one-at-a-time. Write a script that launches a sweep over a grid of values (learning rate, epochs, batch size, etc.) and evaluates each run automatically. One well-designed sweep script beats ten manual experiments.\n\nIf you run out of ideas: go back to the literature. Crawl citation graphs deeper \u2014 find papers you haven't read yet, read their methodology sections, extract new datasets or training tricks. Look for papers that cite your current approach and improved on it. Try combining recipes from different papers. Re-read the task prompt for angles you missed. Re-read the training logs for clues. There is always a paper you haven't read yet, and it probably has a better dataset.\n\nCheck the remaining time periodically with the timer command specified in the task prompt. Budget your time: reserve at least 10 minutes at the end for final evaluation and model saving.\n\nThe task is NOT done until:\n- The required output exists (e.g. final model, metrics reached, dataset updated etc)\n- You have evaluated the model and confirmed it works\n\n# Communication\n\n- Be concise and direct. No filler, no restating what the user said.\n- One-word answers when appropriate for simple questions.\n- Always include direct Hub URLs when referencing models, datasets, Spaces, or jobs.\n- For errors: state what went wrong, why, and what you're doing to fix it.\n- Do not over-explain or present elaborate option menus for simple tasks. When the user's intent is clear, act on it. Present options only when there's genuine ambiguity.\n- Use the `notify` tool only when the user explicitly asked for out-of-band notifications or when the task clearly requires reporting to a configured messaging destination. Do not use it for routine chat updates.\n\n# Tool usage\n\n- Execute multiple independent tool calls in parallel when possible.\n- HF_TOKEN is automatically available in job secrets \u2014 no need to include it extra.\n- For training monitoring: include Trackio in the script and provide the dashboard URL.\n- For private/gated datasets: HF_TOKEN is needed \u2014 it's auto-loaded into job secrets.\n\n[Session context: Date=12-06-2026, Time=20:37:28.629, Timezone=CEST (UTC+02:00), User=unknown, Tools=19]", + "role": "system", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + } + ], + "events": [ + { + "timestamp": "2026-06-12T11:37:34.470565-07:00", + "event_type": "ready", + "data": { + "message": "Agent initialized" + } + } + ], + "tools": [ + { + "type": "function", + "function": { + "name": "sandbox_create", + "description": "Create or replace the session sandbox when non-default hardware is needed.\n\nA private cpu-basic sandbox is already started automatically for each session. For normal CPU code execution, call bash/read/write/edit directly; do NOT call sandbox_create first.\n\nUse sandbox_create when: you need GPU hardware, cpu-upgrade, or Trackio secrets before running code. The active sandbox persists across tool calls within the session. pip install works out of the box. Sandboxes are always created as private HF Spaces.\n\nFor ML code that uses CUDA, bf16, or model loading: use GPU hardware (t4-small minimum). CPU sandboxes cannot run GPU code paths \u2014 your test will not catch GPU-related errors.\n\nBefore choosing hardware, estimate your VRAM needs (models you run, training data size). Rule of thumb: bf16/fp16 \u2248 2 bytes/param, fp32 \u2248 4 bytes/param, plus ~20% overhead for optimizer states during training.\nCommon picks: t4-small (16GB VRAM, fits \u22641-3B), a10g-small (24GB, \u22647B), a100-large (80GB, \u226430B). If the model won't fit, pick larger hardware upfront \u2014 OOM on a sandbox wastes time.\n\nIf you intend to run a training script in this sandbox that uses report_to='trackio', pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` so they are set as TRACKIO_SPACE_ID/TRACKIO_PROJECT secrets in the sandbox and the UI can embed the live dashboard.\n\nHardware: cpu-basic, cpu-upgrade, cpu-performance, cpu-xl, sprx8, zero-a10g, t4-small, t4-medium, l4x1, l4x4, l40sx1, l40sx4, l40sx8, a10g-small, a10g-large, a10g-largex2, a10g-largex4, a100-large, a100x4, a100x8, h200, h200x2, h200x4, h200x8, inf2x6.\n", + "parameters": { + "type": "object", + "required": [], + "additionalProperties": false, + "properties": { + "hardware": { + "type": "string", + "enum": [ + "cpu-basic", + "cpu-upgrade", + "cpu-performance", + "cpu-xl", + "sprx8", + "zero-a10g", + "t4-small", + "t4-medium", + "l4x1", + "l4x4", + "l40sx1", + "l40sx4", + "l40sx8", + "a10g-small", + "a10g-large", + "a10g-largex2", + "a10g-largex4", + "a100-large", + "a100x4", + "a100x8", + "h200", + "h200x2", + "h200x4", + "h200x8", + "inf2x6" + ], + "description": "Hardware tier for the sandbox. Omit for the existing auto-started cpu-basic sandbox; choose GPU/cpu-upgrade only when needed." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for runs in this sandbox (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID secret and surfaced to the UI. The Space is auto-created and seeded with the trackio dashboard \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name. Injected as TRACKIO_PROJECT secret and used by the UI to filter the embedded dashboard to this project." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "bash", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nRun a shell command in the remote sandbox and return stdout/stderr.\n\nIMPORTANT: Do NOT use bash for file operations \u2014 use the dedicated tools instead:\n- To read files: use read (not cat/head/tail)\n- To edit files: use edit (not sed/awk)\n- To write files: use write (not echo/cat < > /app/output.log 2>&1 & echo $!\nThen check status:\n kill -0 2>/dev/null && echo 'running' || echo 'done'\n tail -n 50 /app/output.log\n\nTimeout default 240s, max 1200s.", + "parameters": { + "type": "object", + "required": [ + "command" + ], + "additionalProperties": false, + "properties": { + "command": { + "type": "string", + "description": "The shell command to execute." + }, + "description": { + "type": "string", + "description": "Short description (5-10 words, active voice)." + }, + "work_dir": { + "type": "string", + "description": "Working directory (default: /app)." + }, + "timeout": { + "type": "integer", + "description": "Optional timeout in seconds (default: 240, max: 1200)." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "read", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nReads a file from the sandbox filesystem. Returns contents with line numbers (cat -n format).\n\nUsage:\n- By default, reads up to 2000 lines from the beginning of the file.\n- You can optionally specify offset and limit for large files, but prefer reading the whole file first.\n- Lines longer than 4000 chars are truncated.\n- Cannot read directories \u2014 use bash with 'ls' instead.\n- You should read multiple potentially useful files in parallel when possible.\n- IMPORTANT: Always read a file before editing or overwriting it. The edit and write tools will reject operations on files you haven't read.", + "parameters": { + "type": "object", + "required": [ + "path" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to read." + }, + "offset": { + "type": "integer", + "description": "The line number to start reading from (1-based). Only provide if the file is too large to read at once." + }, + "limit": { + "type": "integer", + "description": "The number of lines to read. Only provide if the file is too large to read at once." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "write", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nWrites a file to the sandbox filesystem. Overwrites the existing file if one exists at the path.\n\n- If this is an existing file, you MUST use the read tool first. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files with the edit tool over overwriting with write.\n- Creates parent directories as needed.", + "parameters": { + "type": "object", + "required": [ + "path", + "content" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to write." + }, + "content": { + "type": "string", + "description": "The complete file content to write." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "edit", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nPerforms string replacements in files. Supports exact matching with fuzzy fallback.\n\nUsage:\n- You must read the file at least once before editing. This tool will error if you attempt an edit without reading the file.\n- The edit will FAIL if old_str is not unique in the file. Either provide a larger string with more surrounding context to make it unique, or set replace_all to true.\n- old_str and new_str must differ.\n- Preserve indentation exactly as it appears in the file.\n- Do NOT include line number prefixes from read output in old_str or new_str.\n- To delete code, set new_str to empty string.\n- Use replace_all for renaming variables or strings across the file.\n\nModes:\n- replace (default): replace first occurrence of old_str with new_str.\n- append_after: insert new_str immediately after old_str (old_str is kept).\n- prepend_before: insert new_str immediately before old_str (old_str is kept).", + "parameters": { + "type": "object", + "required": [ + "path", + "old_str", + "new_str" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to edit." + }, + "old_str": { + "type": "string", + "description": "The text to find in the file. Must match exactly (fuzzy matching is used as fallback)." + }, + "new_str": { + "type": "string", + "description": "The replacement text. For append_after/prepend_before modes, the text to insert." + }, + "replace_all": { + "type": "boolean", + "description": "Replace all occurrences of old_str (default: false).", + "default": false + }, + "mode": { + "type": "string", + "enum": [ + "replace", + "append_after", + "prepend_before" + ], + "description": "Edit mode (default: replace).", + "default": "replace" + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "research", + "description": "Spawn a research sub-agent to explore documentation, codebases, or repos WITHOUT polluting the main conversation context. The sub-agent gets its own independent context window with read-only research tools and returns a concise summary of findings.\n\nUse this for:\n- Researching current API usage before implementing ML tasks (find examples + read docs)\n- Exploring HF docs, reading papers, analyzing GitHub repos\n- Any research where raw tool outputs would be too verbose\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, hf_papers, etc. Just describe what you need researched.", + "parameters": { + "type": "object", + "properties": { + "task": { + "type": "string", + "description": "Detailed description of what to research. Be specific: include library names, trainer types, dataset names, repo names, or doc pages to explore. Example: 'Research current TRL SFTTrainer usage: find working example scripts, read the SFT documentation, and check SFTConfig parameters. Also validate that dataset HuggingFaceH4/ultrachat_200k has the right format for SFT.'" + }, + "context": { + "type": "string", + "description": "Optional context from the current conversation that the research agent needs (e.g., what the user wants to build, constraints, what's been tried)." + } + }, + "required": [ + "task" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "explore_hf_docs", + "description": "Browse HF documentation structure \u2014 discover all available documentation with 200-char previews.\n\nUse this to find relevant documentation and/or examples with detailed parameter docs and API reference. To be used together with github_find_examples and github_read_file to find working examples and documentation.\n\nPattern: explore_hf_docs (find relevant pages) \u2192 fetch_hf_docs (get full content).\n\nFor training tasks: fetch the trainer config docs (SFTConfig, DPOConfig, GRPOConfig) to verify parameter names. Returns top 20 results by default; set max_results (max 50) to adjust.", + "parameters": { + "type": "object", + "properties": { + "endpoint": { + "type": "string", + "enum": [ + "hub", + "transformers", + "diffusers", + "datasets", + "gradio", + "trackio", + "smolagents", + "huggingface_hub", + "huggingface.js", + "transformers.js", + "inference-providers", + "inference-endpoints", + "peft", + "accelerate", + "optimum", + "tokenizers", + "courses", + "evaluate", + "tasks", + "dataset-viewer", + "trl", + "simulate", + "sagemaker", + "timm", + "safetensors", + "tgi", + "setfit", + "lerobot", + "autotrain", + "tei", + "bitsandbytes", + "sentence_transformers", + "chat-ui", + "leaderboards", + "lighteval", + "argilla", + "distilabel", + "microsoft-azure", + "kernels", + "google-cloud" + ], + "description": "The documentation endpoint to explore. Each endpoint corresponds to a major section of the Hugging Face documentation:\n\n\u2022 courses \u2014 All Hugging Face courses (LLM, robotics, MCP, smol (llm training), agents, deep RL, computer vision, games, diffusion, 3D, audio) and the cookbook recipes. Probably the best place for examples.\n\u2022 hub \u2014 Find answers to questions about models/datasets/spaces, auth, versioning, metadata.\n\u2022 transformers \u2014 Core model library: architectures, configs, tokenizers, training & inference APIs.\n\u2022 diffusers \u2014 Diffusion pipelines, schedulers, fine-tuning, training, and deployment patterns.\n\u2022 datasets \u2014 Dataset loading, streaming, processing, Arrow format, Hub integration.\n\u2022 gradio \u2014 UI components and demos for ML models. Uses Gradio's native API: without query returns full docs (llms.txt), with query uses embedding search for precise results.\n\u2022 trackio \u2014 Experiment tracking, metrics logging, and run comparison.\n\u2022 smolagents \u2014 Lightweight agent abstractions and tool-using patterns.\n\u2022 huggingface_hub \u2014 Python client for Hub operations (auth, upload/download, repo management).\n\u2022 huggingface.js \u2014 JS/TS client for Hub APIs in browser and Node.\n\u2022 transformers.js \u2014 Run Transformer models in browser/Node via WebGPU/WASM.\n\u2022 inference-providers \u2014 Unified interface for third-party inference backends.\n\u2022 inference-endpoints \u2014 Managed, scalable model deployments on HF infrastructure.\n\u2022 peft \u2014 Parameter-efficient fine-tuning methods (LoRA, adapters, etc.).\n\u2022 accelerate \u2014 Hardware-agnostic, distributed and mixed-precision training orchestration.\n\u2022 optimum \u2014 Hardware-aware optimization and model export tooling, including Habana, Neuron, Intel, ExecuTorch, and TPU variants.\n\u2022 tokenizers \u2014 Fast tokenizer internals, training, and low-level APIs.\n\u2022 evaluate \u2014 Metrics, evaluation workflows, and training-loop integration.\n\u2022 tasks \u2014 Canonical task definitions and model categorization.\n\u2022 dataset-viewer \u2014 Dataset preview, streaming views, and viewer internals.\n\u2022 trl \u2014 RLHF, DPO, PPO, and SFT utilities for LLMs.\n\u2022 simulate \u2014 Experimental simulation tools and workflows.\n\u2022 sagemaker \u2014 Deploying Hugging Face models on AWS SageMaker.\n\u2022 timm \u2014 Image model zoo and utilities via HF integrations.\n\u2022 safetensors \u2014 Safe, fast tensor serialization format.\n\u2022 tgi \u2014 High-throughput text generation server for LLMs.\n\u2022 setfit \u2014 Few-shot text classification via sentence embeddings.\n\u2022 lerobot \u2014 Robotics datasets, policies, and learning workflows.\n\u2022 autotrain \u2014 No/low-code model training on Hugging Face.\n\u2022 tei \u2014 Optimized inference server for embedding workloads.\n\u2022 bitsandbytes \u2014 Quantization and memory-efficient optimizers.\n\u2022 sentence_transformers \u2014 Embedding models, training recipes, similarity/search workflows.\n\u2022 chat-ui \u2014 Reference chat interfaces for LLM deployment.\n\u2022 leaderboards \u2014 Evaluation leaderboards and submission mechanics.\n\u2022 lighteval \u2014 Lightweight, reproducible LLM evaluation framework.\n\u2022 argilla \u2014 Data annotation, feedback, and human-in-the-loop workflows.\n\u2022 distilabel \u2014 Synthetic data generation and distillation pipelines.\n\u2022 microsoft-azure \u2014 Azure deployment and integration guides.\n\u2022 kernels \u2014 Load prebuilt compute kernels (E.g. flash-attn2) from the Hub via `attn_implementation`; avoids compiling flash-attn from source.\n\u2022 google-cloud \u2014 GCP deployment and serving workflows.\n" + }, + "query": { + "type": "string", + "description": "Optional keyword query to rank and filter documentation pages. For Gradio, use concise queries like 'how to use the image component' or 'audio component demo'." + }, + "max_results": { + "type": "integer", + "description": "Max results (default 20, max 50). Ignored for Gradio.", + "minimum": 1, + "maximum": 50 + } + }, + "required": [ + "endpoint" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "fetch_hf_docs", + "description": "Fetch full markdown content of an HF documentation page. Use after explore_hf_docs.\n\nCritical for finding documentation e.g. current trainer configuration parameters (SFTConfig, DPOConfig, etc.) Use for researching solutions and before writing training scripts. Your internal knowledge is outdated.\n\nProvide the full URL from explore_hf_docs results. The .md extension is added automatically.", + "parameters": { + "type": "object", + "properties": { + "url": { + "type": "string", + "description": "The full URL to the documentation page. Example: 'https://huggingface.co/docs/trl/dpo_trainer' The .md extension will be added automatically if not present." + } + }, + "required": [ + "url" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_papers", + "description": "Discover ML research papers, analyze citations, search paper contents, and find linked resources.\n\nCombines HuggingFace Hub, arXiv, and Semantic Scholar. Use for exploring research areas, finding datasets for a task, tracing citation chains, or implementing a paper's approach.\n\nTypical flows:\n search \u2192 read_paper \u2192 find_all_resources \u2192 hf_inspect_dataset\n search \u2192 paper_details \u2192 citation_graph \u2192 read_paper (trace influence)\n snippet_search \u2192 paper_details \u2192 read_paper (find specific claims)\n\nOperations:\n- trending: Get trending daily papers, optionally filter by topic keyword\n- search: Search papers. Uses HF by default (ML-tuned). Add date_from/min_citations/categories to use Semantic Scholar with filters\n- paper_details: Metadata, abstract, AI summary, github link\n- read_paper: Read paper contents \u2014 without section: abstract + TOC; with section: full text\n- citation_graph: Get references and citations for a paper with influence flags and citation intents\n- snippet_search: Semantic search over full-text passages from 12M+ papers\n- recommend: Find similar papers (single paper or positive/negative examples)\n- find_datasets: Find datasets linked to a paper\n- find_models: Find models linked to a paper\n- find_collections: Find collections that include a paper\n- find_all_resources: Parallel fetch of datasets + models + collections for a paper", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "trending", + "search", + "paper_details", + "read_paper", + "citation_graph", + "snippet_search", + "recommend", + "find_datasets", + "find_models", + "find_collections", + "find_all_resources" + ], + "description": "Operation to execute." + }, + "query": { + "type": "string", + "description": "Search query. Required for: search, snippet_search. Optional for: trending (filters by keyword). Supports boolean syntax for Semantic Scholar: '\"exact phrase\" term1 | term2'." + }, + "arxiv_id": { + "type": "string", + "description": "ArXiv paper ID (e.g. '2305.18290'). Required for: paper_details, read_paper, citation_graph, find_datasets, find_models, find_collections, find_all_resources. Optional for: recommend (single-paper recs). Get IDs from search results first." + }, + "section": { + "type": "string", + "description": "Section name or number to read (e.g. '3', 'Experiments', '4.2'). Optional for: read_paper. Without this, returns abstract + TOC." + }, + "direction": { + "type": "string", + "enum": [ + "citations", + "references", + "both" + ], + "description": "Direction for citation_graph. Default: both." + }, + "date": { + "type": "string", + "description": "Date in YYYY-MM-DD format. Optional for: trending (defaults to recent papers)." + }, + "date_from": { + "type": "string", + "description": "Start date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "date_to": { + "type": "string", + "description": "End date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "categories": { + "type": "string", + "description": "Field of study filter (e.g. 'Computer Science'). Triggers Semantic Scholar search." + }, + "min_citations": { + "type": "integer", + "description": "Minimum citation count filter. Triggers Semantic Scholar search." + }, + "sort_by": { + "type": "string", + "enum": [ + "relevance", + "citationCount", + "publicationDate" + ], + "description": "Sort order for Semantic Scholar search. Default: relevance." + }, + "positive_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs for multi-paper recommendations. For: recommend." + }, + "negative_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs as negative examples. For: recommend." + }, + "sort": { + "type": "string", + "enum": [ + "downloads", + "likes", + "trending" + ], + "description": "Sort order for find_datasets and find_models. Default: downloads." + }, + "limit": { + "type": "integer", + "description": "Maximum results to return (default: 10, max: 50)." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "web_search", + "description": "Search the web for current information and return cited results.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "minLength": 2 + }, + "allowed_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional allowlist of domains or URLs. Subdomains match." + }, + "blocked_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional blocklist of domains or URLs. Subdomains match." + } + }, + "required": [ + "query" + ], + "additionalProperties": false + } + } + }, + { + "type": "function", + "function": { + "name": "hf_inspect_dataset", + "description": "Inspect a HF dataset in one call: status, configs/splits, schema, sample rows, parquet info.\n\nREQUIRED before any training job to verify dataset format matches training method:\n SFT: needs 'messages', 'text', or 'prompt'/'completion'\n DPO: needs 'prompt', 'chosen', 'rejected'\n GRPO: needs 'prompt'\nAll datasets used for training have to be in conversational ChatML format to be compatible with HF libraries.'\nTraining will fail with KeyError if columns don't match.\n\nAlso use to get example datapoints, understand column names, data types, and available splits before writing any data loading code. Supports private/gated datasets when HF_TOKEN is set.", + "parameters": { + "type": "object", + "properties": { + "dataset": { + "type": "string", + "description": "Dataset ID in 'org/name' format (e.g., 'stanfordnlp/imdb')" + }, + "config": { + "type": "string", + "description": "Config/subset name. Auto-detected if not specified." + }, + "split": { + "type": "string", + "description": "Split for sample rows. Auto-detected if not specified." + }, + "sample_rows": { + "type": "integer", + "description": "Number of sample rows to show (default: 3, max: 10)", + "default": 3 + } + }, + "required": [ + "dataset" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "plan_tool", + "description": "Track progress on multi-step tasks with a todo list (pending/in_progress/completed).\n\nUse for tasks with 3+ steps. Each call replaces the entire plan (send full list).\n\nRules: exactly ONE task in_progress at a time. Mark completed immediately after finishing. Only mark completed when the task fully succeeded \u2014 keep in_progress if there are errors. Update frequently so the user sees progress.", + "parameters": { + "type": "object", + "properties": { + "todos": { + "type": "array", + "description": "List of todo items", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "Unique identifier for the todo" + }, + "content": { + "type": "string", + "description": "Description of the todo task" + }, + "status": { + "type": "string", + "enum": [ + "pending", + "in_progress", + "completed" + ], + "description": "Current status of the todo" + } + }, + "required": [ + "id", + "content", + "status" + ] + } + } + }, + "required": [ + "todos" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "notify", + "description": "Send an out-of-band notification to configured messaging destinations. Use this only when the user explicitly asked for proactive notifications or when the task requires reporting progress outside the chat. Destinations must be named server-side configs such as 'slack.ops'.", + "parameters": { + "type": "object", + "properties": { + "destinations": { + "type": "array", + "description": "Named messaging destinations to notify.", + "items": { + "type": "string" + }, + "minItems": 1 + }, + "message": { + "type": "string", + "description": "Main notification body." + }, + "title": { + "type": "string", + "description": "Optional short title line." + }, + "severity": { + "type": "string", + "enum": [ + "info", + "success", + "warning", + "error" + ], + "description": "Notification severity label." + } + }, + "required": [ + "destinations", + "message" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_jobs", + "description": "Execute Python scripts or Docker containers on HF cloud infrastructure.\n\nTwo modes (mutually exclusive): Python mode (script + dependencies) or Docker mode (command + image). Provide exactly ONE of 'script' or 'command'.\n\nBEFORE submitting training/fine-tuning jobs:\n- You MUST have called github_find_examples + github_read_file to find a working reference implementation. Scripts based on your internal knowledge WILL use outdated APIs and fail.\n- You MUST have validated dataset format via hf_inspect_dataset or hub_repo_details.\n- If the job runs on GPU, or the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile, you MUST create a GPU sandbox with sandbox_create first, run a tiny smoke test there, and fix failures before submitting. If skipped, state why before calling hf_jobs.\n- Training config MUST include push_to_hub=True and hub_model_id. Job storage is EPHEMERAL \u2014 all files are deleted when the job ends. Without push_to_hub, trained models are lost permanently.\n- Include trackio monitoring and provide the dashboard URL to the user. When the script uses report_to='trackio', also pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` as tool args \u2014 they are injected as TRACKIO_SPACE_ID/TRACKIO_PROJECT env vars and let the UI embed the live dashboard.\n\nBATCH/ABLATION JOBS: Submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once \u2014 if there's a bug, all jobs fail.\n\nOperations: run, ps, logs, inspect, cancel, scheduled run/ps/inspect/delete/suspend/resume.\n\nHardware: CPU: cpu-basic(2vCPU/16GB), cpu-upgrade(8vCPU/32GB). GPU: t4-small(4vCPU/15GB/GPU 16GB), t4-medium(8vCPU/30GB/GPU 16GB), a10g-small(4vCPU/15GB/GPU 24GB), a10g-large(12vCPU/46GB/GPU 24GB), a10g-largex2(24vCPU/92GB/GPU 48GB), a10g-largex4(48vCPU/184GB/GPU 96GB), a100-large(12vCPU/142GB/GPU 80GB), a100x4(48vCPU/568GB/GPU 320GB), a100x8(96vCPU/1136GB/GPU 640GB), l4x1(8vCPU/30GB/GPU 24GB), l4x4(48vCPU/186GB/GPU 96GB), l40sx1(8vCPU/62GB/GPU 48GB), l40sx4(48vCPU/382GB/GPU 192GB), l40sx8(192vCPU/1534GB/GPU 384GB).\nCommon picks: t4-small ($0.60/hr, 1-3B), a10g-large ($2/hr, 7-13B), a100-large ($4/hr, 30B+), h100 ($6/hr, 70B+). Note: a10g-small and a10g-large have the SAME 24GB GPU \u2014 the difference is CPU/RAM only.\n\nOOM RECOVERY: When a training job fails with CUDA OOM:\n1. Reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally (keep effective batch size identical)\n2. Enable gradient_checkpointing=True\n3. Upgrade to larger GPU (a10g\u2192a100\u2192h100)\nDo NOT switch training methods (e.g. full SFT to LoRA) or reduce max_length \u2014 those change what the user gets and require explicit approval.\n\nExamples:\nTraining: {'operation': 'run', 'script': '/app/train.py', 'dependencies': ['transformers', 'trl', 'torch', 'datasets', 'trackio'], 'hardware_flavor': 'a100-large', 'timeout': '8h'}\nMonitor: {'operation': 'ps'}, {'operation': 'logs', 'job_id': 'xxx'}, {'operation': 'cancel', 'job_id': 'xxx'}Docker: {'operation': 'run', 'command': ['duckdb', '-c', 'select 1 + 2'], 'image': 'duckdb/duckdb', 'hardware_flavor': 'cpu-basic', 'timeout': '1h'}\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "run", + "ps", + "logs", + "inspect", + "cancel", + "scheduled run", + "scheduled ps", + "scheduled inspect", + "scheduled delete", + "scheduled suspend", + "scheduled resume" + ], + "description": "Operation to execute." + }, + "script": { + "type": "string", + "description": "Python code, sandbox file path (e.g. '/app/train.py', './train.py', or bare 'train.py'), or URL. Triggers Python mode. For ML training: base this on a working example found via github_find_examples, not on internal knowledge. For GPU/model-loading training scripts, smoke-test in a GPU sandbox before submission. Mutually exclusive with 'command'." + }, + "dependencies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Pip packages to install. Include ALL required packages. Common training set: ['transformers', 'trl', 'torch', 'datasets', 'trackio', 'accelerate']. Only used with 'script'." + }, + "image": { + "type": "string", + "description": "Docker image. Optional \u2014 auto-selected if not provided. Use with 'command'." + }, + "command": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Command to execute as list. Triggers Docker mode. Mutually exclusive with 'script'." + }, + "hardware_flavor": { + "type": "string", + "description": "Hardware type. Sizing guide: 1-3B params \u2192 t4-small/a10g-small, 7-13B \u2192 a10g-large, 30B+ \u2192 a100-large, 70B+ \u2192 h100/h100x8. All options: CPU: ['cpu-basic', 'cpu-upgrade']. GPU: ['t4-small', 't4-medium', 'a10g-small', 'a10g-large', 'a10g-largex2', 'a10g-largex4', 'a100-large', 'a100x4', 'a100x8', 'l4x1', 'l4x4', 'l40sx1', 'l40sx4', 'l40sx8']." + }, + "timeout": { + "type": "string", + "description": "Maximum job runtime. MUST be >2h for any training job \u2014 default 30m kills training mid-run. Guidelines: 1-3B models: 3-4h, 7-13B: 6-8h, 30B+: 12-24h. Use 30m-1h only for quick data processing or inference tasks. Default: '30m'." + }, + "env": { + "type": "object", + "description": "Environment variables {'KEY': 'VALUE'}. HF_TOKEN is auto-included." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for this run (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID env var and used by the UI to embed the live dashboard. Set this whenever the script uses report_to='trackio'. The Space is auto-created and seeded with the trackio dashboard before the job starts \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name to log this run under. Injected as TRACKIO_PROJECT env var and used by the UI to filter the embedded dashboard to this project." + }, + "namespace": { + "type": "string", + "description": "Optional namespace to run the job under. Must be the caller's own account or an org they belong to. If omitted, defaults to the caller's personal account. Credits are billed against this namespace." + }, + "job_id": { + "type": "string", + "description": "Job ID. Required for: logs, inspect, cancel." + }, + "scheduled_job_id": { + "type": "string", + "description": "Scheduled job ID. Required for: scheduled inspect/delete/suspend/resume." + }, + "schedule": { + "type": "string", + "description": "Cron schedule or preset (@hourly, @daily, @weekly, @monthly). Required for: scheduled run." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_files", + "description": "Read and write files in HF repos (models/datasets/spaces).\n\n## Operations\n- **list**: List files with sizes and structure\n- **read**: Read file content (text files only)\n- **upload**: Upload content to repo (can create PR)\n- **delete**: Delete files/folders (supports wildcards like *.tmp)\n\n## Use when\n- Need to see what files exist in a repo\n- Want to read config.json, README.md, or other text files\n- Uploading training scripts, configs, or results to a repo\n- Cleaning up temporary files from a repo\n\n## Examples\n{\"operation\": \"list\", \"repo_id\": \"meta-llama/Llama-2-7b\"}\n{\"operation\": \"read\", \"repo_id\": \"gpt2\", \"path\": \"config.json\"}\n{\"operation\": \"upload\", \"repo_id\": \"my-model\", \"path\": \"README.md\", \"content\": \"# My Model\"}\n{\"operation\": \"upload\", \"repo_id\": \"org/model\", \"path\": \"fix.py\", \"content\": \"...\", \"create_pr\": true}\n{\"operation\": \"delete\", \"repo_id\": \"my-model\", \"patterns\": [\"*.tmp\", \"logs/\"]}\n\n## Notes\n- For binary files (safetensors, bin), use list to see them but can't read content\n- upload/delete require approval (can overwrite/destroy data)\n- Use create_pr=true to propose changes instead of direct commit\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "list", + "read", + "upload", + "delete" + ], + "description": "Operation: list, read, upload, delete" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "revision": { + "type": "string", + "description": "Branch/tag/commit (default: main)" + }, + "path": { + "type": "string", + "description": "File path for read/upload" + }, + "content": { + "type": "string", + "description": "File content for upload" + }, + "patterns": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Patterns to delete (e.g., ['*.tmp', 'logs/'])" + }, + "create_pr": { + "type": "boolean", + "description": "Create PR instead of direct commit" + }, + "commit_message": { + "type": "string", + "description": "Custom commit message" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_git", + "description": "Git-like operations on HF repos: branches, tags, PRs, and repo management.\n\n## Operations\n**Branches:** create_branch, delete_branch, list_refs\n**Tags:** create_tag, delete_tag\n**PRs:** create_pr, list_prs, get_pr, merge_pr, close_pr, comment_pr, change_pr_status\n**Repo:** create_repo, update_repo\n\n## Use when\n- Creating feature branches for experiments\n- Tagging model versions (v1.0, v2.0)\n- Opening PRs to contribute to repos you don't own\n- Reviewing and merging PRs on your repos\n- Creating new model/dataset/space repos\n- Changing repo visibility (public/private) or gated access\n\n## Examples\n{\"operation\": \"list_refs\", \"repo_id\": \"my-model\"}\n{\"operation\": \"create_branch\", \"repo_id\": \"my-model\", \"branch\": \"experiment-v2\"}\n{\"operation\": \"create_tag\", \"repo_id\": \"my-model\", \"tag\": \"v1.0\", \"revision\": \"main\"}\n{\"operation\": \"create_pr\", \"repo_id\": \"org/model\", \"title\": \"Fix tokenizer config\"}\n{\"operation\": \"change_pr_status\", \"repo_id\": \"my-model\", \"pr_num\": 1, \"new_status\": \"open\"}\n{\"operation\": \"merge_pr\", \"repo_id\": \"my-model\", \"pr_num\": 3}\n{\"operation\": \"create_repo\", \"repo_id\": \"my-new-model\", \"private\": true}\n{\"operation\": \"update_repo\", \"repo_id\": \"my-model\", \"gated\": \"auto\"}\n\n## PR Workflow\n1. create_pr \u2192 creates draft PR (empty by default)\n2. Upload files with revision='refs/pr/N' to add commits\n3. change_pr_status with new_status='open' to publish (convert draft to open)\n4. merge_pr when ready\n\n## Notes\n- PR status: draft (default), open, merged, closed\n- delete_branch, delete_tag, merge_pr, create_repo, update_repo require approval\n- For spaces, create_repo needs space_sdk (gradio/streamlit/docker/static)\n- gated options: 'auto' (instant), 'manual' (review), false (open)\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "create_branch", + "delete_branch", + "create_tag", + "delete_tag", + "list_refs", + "create_pr", + "list_prs", + "get_pr", + "merge_pr", + "close_pr", + "comment_pr", + "change_pr_status", + "create_repo", + "update_repo" + ], + "description": "Operation to execute" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "branch": { + "type": "string", + "description": "Branch name (create_branch, delete_branch)" + }, + "from_rev": { + "type": "string", + "description": "Create branch from this revision (default: main)" + }, + "tag": { + "type": "string", + "description": "Tag name (create_tag, delete_tag)" + }, + "revision": { + "type": "string", + "description": "Revision for tag (default: main)" + }, + "tag_message": { + "type": "string", + "description": "Tag description" + }, + "title": { + "type": "string", + "description": "PR title (create_pr)" + }, + "description": { + "type": "string", + "description": "PR description (create_pr)" + }, + "pr_num": { + "type": "integer", + "description": "PR/discussion number" + }, + "comment": { + "type": "string", + "description": "Comment text" + }, + "status": { + "type": "string", + "enum": [ + "open", + "closed", + "all" + ], + "description": "Filter PRs by status (list_prs)" + }, + "new_status": { + "type": "string", + "enum": [ + "open", + "closed" + ], + "description": "New status for PR/discussion (change_pr_status)" + }, + "private": { + "type": "boolean", + "description": "Make repo private (create_repo, update_repo)" + }, + "gated": { + "type": "string", + "enum": [ + "auto", + "manual", + "false" + ], + "description": "Gated access setting (update_repo)" + }, + "space_sdk": { + "type": "string", + "enum": [ + "gradio", + "streamlit", + "docker", + "static" + ], + "description": "Space SDK (required for create_repo with space)" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_find_examples", + "description": "Find working example scripts in GitHub repositories (from a list of predetermined directories e.g. examples/, scripts/, tutorials/, etc.). Uses fuzzy keyword matching.\n\nMANDATORY before writing any ML training, fine-tuning, or inference code. Your internal knowledge of library APIs is outdated \u2014 working examples show current API patterns.\n\nSequence: github_find_examples \u2192 github_read_file (study the example) \u2192 implement based on what you found.\n\nSkip this only for: simple data queries, status checks, non-code tasks.\n\nExamples:\n {keyword: 'sft', repo: 'trl'} \u2192 finds examples/scripts/sft.py\n {keyword: 'grpo', repo: 'trl'} \u2192 finds GRPO training examples\n {repo: 'trl', max_results: 20} \u2192 lists all available training method examples", + "parameters": { + "type": "object", + "properties": { + "keyword": { + "type": "string", + "description": "Keyword to fuzzy match against file paths (e.g., 'grpo', 'sft')." + }, + "repo": { + "type": "string", + "description": "Repository name (e.g., 'trl', 'transformers'). Required." + }, + "org": { + "type": "string", + "description": "GitHub organization or username. Default: 'huggingface'." + }, + "max_results": { + "type": "integer", + "description": "Maximum number of results to return. Default: 50." + }, + "min_score": { + "type": "integer", + "description": "Minimum fuzzy match score (0-100). Default: 60." + } + }, + "required": [ + "repo" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_list_repos", + "description": "List and discover repositories for GitHub organizations or users with flexible sorting. **Use when:** (1) Exploring what libraries exist for a task, (2) Finding the right library to use, (3) Discovering popular or active projects, (4) Checking recently updated repos for latest features, (5) Finding alternative libraries in an organization. **Pattern:** github_list_repos (discover libraries) \u2192 github_find_examples (find usage examples) \u2192 implement. Returns: Comprehensive repository information (stars, forks, language, topics, URLs), sorted by preference. **Then:** Use github_find_examples on selected repo to discover example code. Sorts by: stars (popularity), forks (community), updated (activity), created (age).\n\n## When to use this tool\n\n- When you need to find libraries to use in your implementation\n- When exploring what repositories exist for a task or domain\n- When debugging an error and looking up if others have similar issues in repos\n- When finding the most popular or actively maintained projects for a user/org\n## Examples\n\n\n// ML Workflow Step: Discover HF libraries for RLHF/alignment\n// Use case: Find the right library for training with human feedback\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'stars',\n limit: 10\n}\n// Returns: transformers, trl, peft, accelerate, diffusers...\n\n\n\n// ML Workflow Step: Check for recently updated HF repos\n// Use case: Find actively maintained libraries with latest features\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'updated',\n order: 'desc',\n limit: 15\n}\n// Helps identify which repos have recent improvements/fixes\n", + "parameters": { + "type": "object", + "properties": { + "owner": { + "type": "string", + "description": "GitHub username or organization name. Required." + }, + "owner_type": { + "type": "string", + "enum": [ + "user", + "org" + ], + "description": "Whether the owner is a 'user' or 'org'. Default: 'org'." + }, + "sort": { + "type": "string", + "enum": [ + "stars", + "forks", + "updated", + "created" + ], + "description": "Sort field. Options: 'stars', 'forks', 'updated', 'created'. Default: 'stars'." + }, + "order": { + "type": "string", + "enum": [ + "asc", + "desc" + ], + "description": "Sort order. Options: 'asc', 'desc'. Default: 'desc'." + }, + "limit": { + "type": "integer", + "description": "Maximum number of repositories to return. No limit if not specified. Default: 30." + } + }, + "required": [ + "owner" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_read_file", + "description": "Read file contents from GitHub repositories. Returns first 300 lines by default. Auto-converts Jupyter notebooks to markdown.\n\nUse AFTER github_find_examples to study the working implementation. The purpose is to learn current API patterns \u2014 imports, trainer configs, dataset handling \u2014 so your implementation uses correct, up-to-date code.\n\nUse line_start/line_end for large files (>300 lines) to read specific sections.\n\nWhen NOT to use: when you don't know the file path (use github_find_examples first).", + "parameters": { + "type": "object", + "properties": { + "repo": { + "type": "string", + "description": "Repository in format 'owner/repo' (e.g., 'github/github-mcp-server'). Required." + }, + "path": { + "type": "string", + "description": "Path to file in repository (e.g., 'src/index.js'). Required." + }, + "ref": { + "type": "string", + "description": "Git reference - branch name, tag, or commit SHA. Default: 'HEAD'." + }, + "line_start": { + "type": "integer", + "description": "Starting line number (1-indexed, inclusive). Optional." + }, + "line_end": { + "type": "integer", + "description": "Ending line number (1-indexed, inclusive). Optional." + } + }, + "required": [ + "repo", + "path" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "find_hf_api", + "description": "Find HuggingFace Hub REST API endpoints to make HTTP requests. Returns curl examples with authentication. \u26a0\ufe0f USE THIS TOOL when you need to call the HF Hub API directly - for operations like: uploading/downloading files, managing repos, listing models/datasets, getting user info, managing webhooks, collections, discussions, or any Hub interaction not covered by other tools. **Use cases:** (1) 'Stream Space logs' \u2192 query='space logs', (2) 'Get Space metrics/Zero-GPU usage' \u2192 query='space metrics', (3) 'List organization members' \u2192 query='organization members', (4) 'Generate repo access token' \u2192 query='jwt token', (5) 'Check repo security scan' \u2192 query='security scan'. **Search modes:** Use 'query' for keyword search, 'tag' to browse a category, or both. If query finds no results, falls back to showing all endpoints in the tag. **Output:** Full endpoint details with method, path, parameters, curl command, and response schema.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "Keyword search across endpoint summaries, descriptions, and operation IDs. Examples: 'upload file', 'create repository', 'list user models', 'delete branch', 'webhook', 'collection', 'discussion comments'. Supports stemming (upload/uploading both work)." + }, + "tag": { + "type": "string", + "enum": [ + "agentic-provisioning", + "agents", + "auth", + "buckets", + "collections", + "container", + "datasets", + "discussions", + "docs", + "inference-endpoints", + "inference-providers", + "jobs", + "kernels", + "mcp", + "models", + "notifications", + "oauth", + "orgs", + "papers", + "repo-search", + "repos", + "resource-groups", + "scim", + "service-accounts", + "spaces", + "sql-console", + "users", + "webhooks" + ], + "description": "Filter by API category. Use alone to browse all endpoints in a category, or combine with 'query' to search within a category." + } + }, + "required": [] + } + } + } + ], + "upload_status": "failed", + "upload_url": null, + "last_save_time": "2026-06-12T11:38:56.502393", + "personal_upload_status": "failed" +} \ No newline at end of file diff --git a/backend/session_logs/session_c22b0486-0571-4b31-a09b-3c5e693044a7_20260612_114026.json b/backend/session_logs/session_c22b0486-0571-4b31-a09b-3c5e693044a7_20260612_114026.json new file mode 100644 index 0000000000000000000000000000000000000000..e3fe8bd4f3a48d0b61f4046450f89d95d0cda695 --- /dev/null +++ b/backend/session_logs/session_c22b0486-0571-4b31-a09b-3c5e693044a7_20260612_114026.json @@ -0,0 +1,1194 @@ +{ + "session_id": "c22b0486-0571-4b31-a09b-3c5e693044a7", + "user_id": "dev", + "hf_username": "dev", + "session_start_time": "2026-06-12T11:40:15.659100-07:00", + "session_end_time": "2026-06-12T11:40:50.022688", + "model_name": "anthropic/claude-opus-4.8:fal-ai", + "total_cost_usd": 0.0, + "usage_metrics": { + "version": 1, + "session_id": "c22b0486-0571-4b31-a09b-3c5e693044a7", + "billing_scope": "account_window_delta", + "total_usd": 0.0, + "total_usd_source": "app_telemetry_fallback", + "app_total_usd": 0.0, + "hf_billing_total_usd": null, + "app_telemetry": { + "session_id": "c22b0486-0571-4b31-a09b-3c5e693044a7", + "total_usd": 0.0, + "inference_usd": 0.0, + "hf_jobs_estimated_usd": 0.0, + "sandbox_estimated_usd": 0.0, + "llm_calls": 1, + "hf_jobs_count": 0, + "sandbox_count": 0, + "prompt_tokens": 23279, + "completion_tokens": 221, + "cache_read_tokens": 0, + "cache_creation_tokens": 23277, + "total_tokens": 23500, + "hf_jobs_billable_seconds_estimate": 0, + "sandbox_billable_seconds_estimate": 0 + }, + "hf_billing": { + "source": "hf_billing_usage_v2", + "available": false, + "error": "missing_hf_token", + "current_session": null + }, + "llm": { + "calls": 1, + "calls_by_kind": { + "main": 1 + }, + "calls_by_model": { + "openai/anthropic/claude-opus-4.8:fal-ai": 1 + }, + "prompt_tokens": 23279, + "completion_tokens": 221, + "cache_read_tokens": 0, + "cache_creation_tokens": 23277, + "total_tokens": 23500 + }, + "turns": { + "turn_complete_count": 1, + "assistant_stream_end_count": 1 + }, + "hf_jobs": { + "submits": 0, + "status_snapshots": 0, + "statuses": {}, + "flavors": {}, + "submit_flavors": {}, + "status_snapshot_flavors": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0, + "snapshots_with_estimated_cost": 0, + "snapshots_with_nonzero_estimated_cost": 0 + }, + "sandboxes": { + "creates": 0, + "destroys": 0, + "matched_pairs": 0, + "unpaired_creates": 0, + "unpaired_destroys": 0, + "hardware": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0 + }, + "data_quality": { + "event_count": 9, + "events_without_timestamp": 0, + "llm_calls_with_cost_usd": 1, + "llm_calls_with_nonzero_cost_usd": 0, + "job_snapshots_with_estimated_cost": 0, + "job_snapshots_missing_estimated_cost": 0 + } + }, + "messages": [ + { + "content": "You are ML Intern, an ML engineering assistant with 19 tools for training, fine-tuning, data processing, inference, and evaluation on the Hugging Face (HF) ecosystem.\n\nYour goal is to complete what the user requested with zero errors. You are fully autonomous \u2014 research, validate, implement, and deliver results without asking for unnecessary confirmation.\n\n# Your knowledge of HF libraries is outdated\n\nYou do not know current APIs for TRL, Transformers, PEFT, Trackio, or other HF libraries. Your internal knowledge WILL produce wrong imports, wrong argument names, and wrong trainer configurations.\n\nBefore writing any ML implementation code, start from the literature. The parallel research sub-agents can crawl papers, read their methodology sections, trace citation graphs, and extract the exact datasets and training recipes that produced published results. This is your primary advantage \u2014 use it.\n\nYour default workflow for any ML task:\n1. Find the landmark paper(s) for the task or domain\n2. Crawl their citation graphs to find recent downstream work\n3. Read methodology sections (not abstracts) of the most promising papers \u2014 especially recent ones with strong results, lot of citations, and publications in high-impact conferences\n4. Extract the recipe: what dataset, what training method, what hyperparameters produced those results\n5. Validate and use those datasets for training\n\n```\nresearch({\"task\": \"Literature crawl for [task]. Start from [paper/topic]. Crawl citation graph for recent downstream papers. Read their methodology sections (3, 4, 5) \u2014 extract the exact datasets, training methods, and hyperparameters that produced their best results. Attribute every finding to a specific result (e.g. 'Dataset X + method Y \u2192 85.3% on benchmark Z'). Also find working code examples using current TRL/Transformers APIs.\", \"context\": \"User wants to [goal]. We need the best training recipe backed by published results.\"})\n```\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, and hf_papers (with citation_graph, read_paper, snippet_search, find_datasets). Be specific in your task description \u2014 name anchor papers or arxiv IDs when you have them.\n\nYou can also call research tools directly (explore_hf_docs, github_read_file, etc.) for quick lookups.\n\nSkip research only for trivial non-code operations.\n\n# Mistakes you WILL make without research\n\nHALLUCINATED IMPORTS: You will import from modules that were renamed or removed. Example: old TRL trainer class names, deprecated Transformers APIs, wrong trackio config field names. Fix: read a current example script first.\n\nWRONG TRAINER ARGUMENTS: You will pass configuration arguments that don't exist in current trainer versions. Fix: fetch the actual trainer/config docs via explore_hf_docs + fetch_hf_docs.\n\nWRONG DATASET FORMAT: You will assume column names without checking. Training fails with KeyError. Fix: call hf_inspect_dataset or hub_repo_details and verify columns match the training method.\n\nDEFAULT TIMEOUT KILLS JOBS: You will leave timeout at the default 30m for training jobs. Training takes hours. The job gets killed and all progress is lost. Fix: set timeout based on model size (minimum 2h for any training).\n\nLOST MODELS: You will forget push_to_hub=True and hub_model_id in training config. Job storage is ephemeral \u2014 the filesystem is deleted when the job ends. Without push_to_hub, the trained model is permanently lost.\n\nBATCH FAILURES: You will submit all ablation/batch jobs at once without testing that one works first. All will fail for the same bug. Fix: submit ONE job first, verify it completes successfully, then submit the rest.\n\nSILENT DATASET SUBSTITUTION: When a requested dataset fails to load, you will silently switch to a different one without telling the user. Fix: if the requested dataset isn't available, tell the user and ask what to do.\n\nPREFER HUB KERNELS OVER COMPILING ATTENTION: Do NOT pip install 'flash-attn' to enable flash_attention_2 building from source can take many minutes to hours and often fails on the job's CUDA/PyTorch combo. Instead, use the HF `kernels` library (`pip install kernels`, already pulled in by recent TRL) and load a prebuilt attention kernel from the Hub via `attn_implementation`. Examples: `AutoModelForCausalLM.from_pretrained(..., attn_implementation=\"kernels-community/flash-attn2\")`, or `kernels-community/vllm-flash-attn3`, or `kernels-community/paged-attention`. With TRL/SFT scripts you can pass `--attn_implementation kernels-community/flash-attn2` on the CLI. Search additional kernels at https://huggingface.co/models?other=kernel. Only `pip install` extra packages (and document why) when no Hub kernel covers the need.\n\nSCOPE-CHANGING FIXES: Avoid at all costs! When you hit an error (especially OOM), you will try \"creative\" workarounds that change what the user asked for and/or change the training task itself \u2014 switching full SFT to LoRA on OOM, reducing max_length (silently truncates training data and changes what the model learns), disabling monitoring instead of fixing it. Do not do this. Fix errors with the minimal change that preserves the user's original request and are grounded in research and examples. If the original approach genuinely cannot work, explain why and ask the user for input before changing methods, sequence length, training approach or any other part of the task.\n\n# When writing ML code\n\nRequired sequence before any training/fine-tuning/inference script:\n1. Use `research` tool to find working examples, read docs, and get current API patterns\n2. Validate dataset: hf_inspect_dataset or hub_repo_details to confirm column names and format\n3. Validate model: hub_repo_details to confirm model exists, correct architecture/size/tokenizer\n\nTraining logging: always set disable_tqdm=True, logging_strategy=\"steps\", and logging_first_step=True in your TrainingArguments/SFTConfig so loss values are printed as plain text lines you can grep, not hidden inside tqdm progress bars.\n\nDataset format requirements by training method:\n SFT: \"messages\", \"text\", or \"prompt\"/\"completion\"\n DPO: \"prompt\", \"chosen\", \"rejected\"\n GRPO: \"prompt\"\n\n# Trackio\n\nTrackio is natively integrated with Transformers Trainer and all TRL trainers \u2014 the built-in TrackioCallback handles init/log/finish. In TrainingArguments/SFTConfig/DPOConfig/GRPOConfig set:\n report_to=\"trackio\"\n run_name=\"\" # e.g. \"sft_qwen3-4b_lr2e-5_bs128\"\n project=\"\" # keeps related runs grouped so you can compare them\n trackio_space_id=\"/ml-intern-<8-char-id>\" # creates a public dashboard Space\n`project` and `trackio_space_id` can also be set via TRACKIO_PROJECT / TRACKIO_SPACE_ID env vars.\n\nAlerts are how iterations decide what to change. Use trackio.alert(title, text, level) at every decision point in training. Levels:\n ERROR \u2014 stop and change approach (divergence, NaN, OOM)\n WARN \u2014 tweak hyperparameters (overfitting, early stopping, KL spike, reward collapse, slow convergence)\n INFO \u2014 milestones (training complete, target reached, checkpoint saved)\nAlways include numeric values and an actionable suggestion in `text`, e.g. \"loss=12.4 at step 200 \u2014 lr likely too high, try \u00d70.1\". A future call must be able to parse it and act on it.\n\nTo add alerts under Trainer/SFTTrainer/GRPOTrainer, pass a custom TrainerCallback via `callbacks=[...]` that calls trackio.alert() inside `on_log` (training metrics like loss, reward, kl) and `on_evaluate` (eval metrics \u2014 only available here, not in `on_log`). Keep each `if` simple: one metric, one threshold. Conditions stay easy to adjust between runs.\n\nRead alerts back between runs instead of parsing thousands of metric values. CLI \u2014 always use --json:\n trackio get alerts --project

--run --json\n trackio get alerts --project

--since --json # incremental polling\n trackio get run --project

--run --json\n trackio get metric --project

--run --metric --json\n trackio list runs --project

--json\nPython: api = trackio.Api(); api.alerts(

, run=, since=); api.runs(

) (each run has .name, .config, .alerts()).\n\nDrive the next config from prior alerts:\n diverged \u2192 lr \u00d7 0.1\n overfitting \u2192 weight_decay \u00d7 10 or reduce capacity\n early stopping \u2192 lr \u00d7 0.5 or adjust schedule\n high accuracy \u2192 refine around current config\nRead prior config via api.runs(...).config and only mutate keys the alerts justify changing.\n\n# Data audit\n\nBefore working with any dataset, audit it first. Do not assume you know what the data looks like \u2014 inspect it.\n\nUse hf_inspect_dataset to check: schema/columns, number of rows per split, value distributions for key columns, sample rows. Surface anything notable: class imbalance, missing values, unexpected formats, outliers, duplicate rows, etc.\n\nLooking at data is the best way to boost performance of any ML model plus it reduces the likelihood of failed jobs later.\n\n# When submitting a training job\n\nNever pass a local machine path to hf_jobs.script, such as /Users/..., /home/..., /fsx/..., or a repo checkout path. HF Jobs runs in a fresh cloud environment where local files do not exist. For hf_jobs.script, use exactly one of:\n - inline Python source code\n - a file already written in the session sandbox, e.g. /app/train.py, ./train.py, or train.py\n - a public/raw URL\nIf you wrote or tested a script locally, read the file content and submit it inline, or write it into the sandbox first.\n\nGPU preflight is mandatory before hf_jobs when the job will run on GPU, or when the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile. First create a GPU sandbox with sandbox_create (t4-small minimum; choose larger hardware when VRAM requires it), run a tiny smoke test there using the same imports, model-loading path, training entrypoint, and a tiny dataset/subset, then fix failures before submitting. If you skip GPU sandbox preflight, state why before calling hf_jobs.\n\nBefore calling hf_jobs, output a pre-flight check:\n - Reference implementation: [which example you based this on]\n - Dataset format verified: [columns confirmed via hf_inspect_dataset/hub_repo_details]\n - GPU sandbox smoke test: [hardware and result, or explicitly not applicable because ...]\n - push_to_hub=True and hub_model_id set\n - timeout: [value] (based on: [model size] on [hardware])\n - Trackio monitoring included and deploying metrics to a public Space\n\nIf you cannot fill in all items, stop and complete the missing steps first.\n\nFor batch/ablation jobs: submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once.\n\nHardware sizing:\n 1-3B params: a10g-largex2\n 7-13B params: a100-large\n 30B+ params: l40sx4 or a100x4\n 70B+ params: a100x8\nNote: a10g-small and a10g-large have the SAME 24GB GPU memory. The difference is CPU/RAM only.\n\n# Sandbox-first development\n\nA private cpu-basic sandbox is already available for normal code execution in each session. For non-trivial scripts, develop and test there before launching via hf_jobs:\n write script \u2192 pip install \u2192 test with small run using bash/read/write/edit \u2192 fix errors \u2192 launch via hf_jobs at scale\n\nDo NOT call sandbox_create before normal CPU work. Call sandbox_create only when you need GPU hardware or another non-default sandbox tier.\n\nThe sandbox filesystem does not survive session resumption. If a session is resumed, any files, installed packages, or running processes from earlier are gone \u2014 recreate what you need before relying on the sandbox.\n\nUse a GPU sandbox (t4-small minimum) when testing code that uses CUDA, bf16/fp16, quantization, flash attention, torch.compile, or model loading. CPU sandboxes cannot test GPU code paths. If the available sandbox tiers cannot fit the full model path, test the largest useful smoke path, state what was not covered, and submit one HF job first.\n\n\n# When a task has 3+ steps\n\nUse plan_tool to track progress. One task in_progress at a time. Mark completed immediately after finishing. Update frequently to show the user what you're doing.\n\n# Error recovery\n\nWhen something fails:\n- Diagnose the actual error. Read the full error message and logs.\n- Do not retry the exact same thing. Identify what needs to change.\n- If an API/import error: check documentation for the correct API.\n- If an OOM error: (1) reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally to keep effective batch size identical, (2) enable gradient_checkpointing=True, (3) upgrade to larger GPU (a10gx4\u2192a100\u2192a100x4\u2192a100x8). Do NOT switch training methods (e.g. SFT\u2192LoRA) or reduce max_length \u2014 those change what the user gets. If OOM happens in sandbox, create a new sandbox with larger GPU hardware.\n- Never change the user's requested approach (training method, dataset, model, sequence length) without explicit approval.\n- If a tool call fails repeatedly for the same reason: stop and try a different approach.\n- Never silently substitute resources (datasets, models) \u2014 tell the user if something isn't available.\n\n# Task completion\n\nBefore ending your turn, verify:\n- Did you actually DO what the user asked, not just explain what you would do?\n- If something failed: did you diagnose and fix it, or at minimum explain what went wrong and ask for user input?\n- For training jobs: did you include a working Trackio dashboard URL?\n\nDo not stop after describing what you plan to do. Continue calling tools until the task is verifiably done.\nDo not mark plan tasks as completed if they failed or are only partially done.\n\n# Autonomous / headless mode\n\nWhen running autonomously (no human in the loop), you MUST follow these rules:\n\nNEVER respond with only text. Every response MUST include at least one tool call. If you have nothing to do, check the plan, verify outputs or plan ahead. A text-only response ends the agent loop permanently \u2014 there is no human to re-prompt you.\n\nNEVER STOP WORKING. Do NOT decide you are \"done\" while time remains. The human is not watching \u2014 they expect you to use the ENTIRE time budget productively. Do NOT ask \"should I continue?\" or \"is this a good stopping point?\" \u2014 there is nobody to answer. You run until the timer expires or you are manually killed.\n\nYour workflow is a loop, not a checklist. Once you have a working result, KEEP ITERATING:\n\nLOOP UNTIL TIME RUNS OUT:\n1. Research the approach (read docs, find examples, check current APIs)\n2. Implement the solution (write code, set up training)\n3. Train and evaluate\n4. Save the model to the required output location / push it to Hugging Face Hub\n5. Improve: tune hyperparameters, try different data, adjust the training recipe, try a different approach entirely\n6. Go to step 1\n\nHYPERPARAMETER TUNING: Do not tune hyperparameters by hand one-at-a-time. Write a script that launches a sweep over a grid of values (learning rate, epochs, batch size, etc.) and evaluates each run automatically. One well-designed sweep script beats ten manual experiments.\n\nIf you run out of ideas: go back to the literature. Crawl citation graphs deeper \u2014 find papers you haven't read yet, read their methodology sections, extract new datasets or training tricks. Look for papers that cite your current approach and improved on it. Try combining recipes from different papers. Re-read the task prompt for angles you missed. Re-read the training logs for clues. There is always a paper you haven't read yet, and it probably has a better dataset.\n\nCheck the remaining time periodically with the timer command specified in the task prompt. Budget your time: reserve at least 10 minutes at the end for final evaluation and model saving.\n\nThe task is NOT done until:\n- The required output exists (e.g. final model, metrics reached, dataset updated etc)\n- You have evaluated the model and confirmed it works\n\n# Communication\n\n- Be concise and direct. No filler, no restating what the user said.\n- One-word answers when appropriate for simple questions.\n- Always include direct Hub URLs when referencing models, datasets, Spaces, or jobs.\n- For errors: state what went wrong, why, and what you're doing to fix it.\n- Do not over-explain or present elaborate option menus for simple tasks. When the user's intent is clear, act on it. Present options only when there's genuine ambiguity.\n- Use the `notify` tool only when the user explicitly asked for out-of-band notifications or when the task clearly requires reporting to a configured messaging destination. Do not use it for routine chat updates.\n\n# Tool usage\n\n- Execute multiple independent tool calls in parallel when possible.\n- HF_TOKEN is automatically available in job secrets \u2014 no need to include it extra.\n- For training monitoring: include Trackio in the script and provide the dashboard URL.\n- For private/gated datasets: HF_TOKEN is needed \u2014 it's auto-loaded into job secrets.\n\n[Session context: Date=12-06-2026, Time=20:40:15.657, Timezone=CEST (UTC+02:00), User=unknown, Tools=19]", + "role": "system", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "x", + "role": "user", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "I don't have a task to work on yet \u2014 your message was just \"x\".\n\nWhat would you like me to do? For example:\n- Fine-tune / train a model (SFT, DPO, GRPO, etc.)\n- Process or audit a dataset\n- Run inference or evaluation\n- Research a paper or ML approach\n\nLet me know the goal and I'll take it from there.", + "role": "assistant", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + } + ], + "events": [ + { + "timestamp": "2026-06-12T11:40:15.940564-07:00", + "event_type": "ready", + "data": { + "message": "Agent initialized" + } + }, + { + "timestamp": "2026-06-12T11:40:15.940668-07:00", + "event_type": "processing", + "data": { + "message": "Processing user input" + } + }, + { + "timestamp": "2026-06-12T11:40:26.058405-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "I don't have a task to work on yet \u2014 your" + } + }, + { + "timestamp": "2026-06-12T11:40:26.066937-07:00", + "event_type": "assistant_chunk", + "data": { + "content": " message was just \"x\".\n\nWhat would you like me to do? For example:\n- Fine-tune / train a model (SFT, DPO, G" + } + }, + { + "timestamp": "2026-06-12T11:40:26.068220-07:00", + "event_type": "assistant_chunk", + "data": { + "content": "RPO, etc.)\n- Process or audit a dataset\n- Run inference or evaluation\n- Research a paper or" + } + }, + { + "timestamp": "2026-06-12T11:40:26.082832-07:00", + "event_type": "assistant_chunk", + "data": { + "content": " ML approach\n\nLet me know the goal and I'll take it from there." + } + }, + { + "timestamp": "2026-06-12T11:40:26.188998-07:00", + "event_type": "llm_call", + "data": { + "model": "openai/anthropic/claude-opus-4.8:fal-ai", + "latency_ms": 10247, + "finish_reason": "stop", + "cost_usd": 0.0, + "kind": "main", + "prompt_tokens": 23279, + "completion_tokens": 221, + "total_tokens": 23500, + "cache_read_tokens": 0, + "cache_creation_tokens": 23277 + } + }, + { + "timestamp": "2026-06-12T11:40:26.189042-07:00", + "event_type": "assistant_stream_end", + "data": {} + }, + { + "timestamp": "2026-06-12T11:40:26.189213-07:00", + "event_type": "turn_complete", + "data": { + "history_size": 3, + "final_response": "I don't have a task to work on yet \u2014 your message was just \"x\".\n\nWhat would you like me to do? For example:\n- Fine-tune / train a model (SFT, DPO, GRPO, etc.)\n- Process or audit a dataset\n- Run inference or evaluation\n- Research a paper or ML approach\n\nLet me know the goal and I'll take it from there." + } + } + ], + "tools": [ + { + "type": "function", + "function": { + "name": "sandbox_create", + "description": "Create or replace the session sandbox when non-default hardware is needed.\n\nA private cpu-basic sandbox is already started automatically for each session. For normal CPU code execution, call bash/read/write/edit directly; do NOT call sandbox_create first.\n\nUse sandbox_create when: you need GPU hardware, cpu-upgrade, or Trackio secrets before running code. The active sandbox persists across tool calls within the session. pip install works out of the box. Sandboxes are always created as private HF Spaces.\n\nFor ML code that uses CUDA, bf16, or model loading: use GPU hardware (t4-small minimum). CPU sandboxes cannot run GPU code paths \u2014 your test will not catch GPU-related errors.\n\nBefore choosing hardware, estimate your VRAM needs (models you run, training data size). Rule of thumb: bf16/fp16 \u2248 2 bytes/param, fp32 \u2248 4 bytes/param, plus ~20% overhead for optimizer states during training.\nCommon picks: t4-small (16GB VRAM, fits \u22641-3B), a10g-small (24GB, \u22647B), a100-large (80GB, \u226430B). If the model won't fit, pick larger hardware upfront \u2014 OOM on a sandbox wastes time.\n\nIf you intend to run a training script in this sandbox that uses report_to='trackio', pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` so they are set as TRACKIO_SPACE_ID/TRACKIO_PROJECT secrets in the sandbox and the UI can embed the live dashboard.\n\nHardware: cpu-basic, cpu-upgrade, cpu-performance, cpu-xl, sprx8, zero-a10g, t4-small, t4-medium, l4x1, l4x4, l40sx1, l40sx4, l40sx8, a10g-small, a10g-large, a10g-largex2, a10g-largex4, a100-large, a100x4, a100x8, h200, h200x2, h200x4, h200x8, inf2x6.\n", + "parameters": { + "type": "object", + "required": [], + "additionalProperties": false, + "properties": { + "hardware": { + "type": "string", + "enum": [ + "cpu-basic", + "cpu-upgrade", + "cpu-performance", + "cpu-xl", + "sprx8", + "zero-a10g", + "t4-small", + "t4-medium", + "l4x1", + "l4x4", + "l40sx1", + "l40sx4", + "l40sx8", + "a10g-small", + "a10g-large", + "a10g-largex2", + "a10g-largex4", + "a100-large", + "a100x4", + "a100x8", + "h200", + "h200x2", + "h200x4", + "h200x8", + "inf2x6" + ], + "description": "Hardware tier for the sandbox. Omit for the existing auto-started cpu-basic sandbox; choose GPU/cpu-upgrade only when needed." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for runs in this sandbox (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID secret and surfaced to the UI. The Space is auto-created and seeded with the trackio dashboard \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name. Injected as TRACKIO_PROJECT secret and used by the UI to filter the embedded dashboard to this project." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "bash", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nRun a shell command in the remote sandbox and return stdout/stderr.\n\nIMPORTANT: Do NOT use bash for file operations \u2014 use the dedicated tools instead:\n- To read files: use read (not cat/head/tail)\n- To edit files: use edit (not sed/awk)\n- To write files: use write (not echo/cat < > /app/output.log 2>&1 & echo $!\nThen check status:\n kill -0 2>/dev/null && echo 'running' || echo 'done'\n tail -n 50 /app/output.log\n\nTimeout default 240s, max 1200s.", + "parameters": { + "type": "object", + "required": [ + "command" + ], + "additionalProperties": false, + "properties": { + "command": { + "type": "string", + "description": "The shell command to execute." + }, + "description": { + "type": "string", + "description": "Short description (5-10 words, active voice)." + }, + "work_dir": { + "type": "string", + "description": "Working directory (default: /app)." + }, + "timeout": { + "type": "integer", + "description": "Optional timeout in seconds (default: 240, max: 1200)." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "read", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nReads a file from the sandbox filesystem. Returns contents with line numbers (cat -n format).\n\nUsage:\n- By default, reads up to 2000 lines from the beginning of the file.\n- You can optionally specify offset and limit for large files, but prefer reading the whole file first.\n- Lines longer than 4000 chars are truncated.\n- Cannot read directories \u2014 use bash with 'ls' instead.\n- You should read multiple potentially useful files in parallel when possible.\n- IMPORTANT: Always read a file before editing or overwriting it. The edit and write tools will reject operations on files you haven't read.", + "parameters": { + "type": "object", + "required": [ + "path" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to read." + }, + "offset": { + "type": "integer", + "description": "The line number to start reading from (1-based). Only provide if the file is too large to read at once." + }, + "limit": { + "type": "integer", + "description": "The number of lines to read. Only provide if the file is too large to read at once." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "write", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nWrites a file to the sandbox filesystem. Overwrites the existing file if one exists at the path.\n\n- If this is an existing file, you MUST use the read tool first. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files with the edit tool over overwriting with write.\n- Creates parent directories as needed.", + "parameters": { + "type": "object", + "required": [ + "path", + "content" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to write." + }, + "content": { + "type": "string", + "description": "The complete file content to write." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "edit", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nPerforms string replacements in files. Supports exact matching with fuzzy fallback.\n\nUsage:\n- You must read the file at least once before editing. This tool will error if you attempt an edit without reading the file.\n- The edit will FAIL if old_str is not unique in the file. Either provide a larger string with more surrounding context to make it unique, or set replace_all to true.\n- old_str and new_str must differ.\n- Preserve indentation exactly as it appears in the file.\n- Do NOT include line number prefixes from read output in old_str or new_str.\n- To delete code, set new_str to empty string.\n- Use replace_all for renaming variables or strings across the file.\n\nModes:\n- replace (default): replace first occurrence of old_str with new_str.\n- append_after: insert new_str immediately after old_str (old_str is kept).\n- prepend_before: insert new_str immediately before old_str (old_str is kept).", + "parameters": { + "type": "object", + "required": [ + "path", + "old_str", + "new_str" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to edit." + }, + "old_str": { + "type": "string", + "description": "The text to find in the file. Must match exactly (fuzzy matching is used as fallback)." + }, + "new_str": { + "type": "string", + "description": "The replacement text. For append_after/prepend_before modes, the text to insert." + }, + "replace_all": { + "type": "boolean", + "description": "Replace all occurrences of old_str (default: false).", + "default": false + }, + "mode": { + "type": "string", + "enum": [ + "replace", + "append_after", + "prepend_before" + ], + "description": "Edit mode (default: replace).", + "default": "replace" + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "research", + "description": "Spawn a research sub-agent to explore documentation, codebases, or repos WITHOUT polluting the main conversation context. The sub-agent gets its own independent context window with read-only research tools and returns a concise summary of findings.\n\nUse this for:\n- Researching current API usage before implementing ML tasks (find examples + read docs)\n- Exploring HF docs, reading papers, analyzing GitHub repos\n- Any research where raw tool outputs would be too verbose\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, hf_papers, etc. Just describe what you need researched.", + "parameters": { + "type": "object", + "properties": { + "task": { + "type": "string", + "description": "Detailed description of what to research. Be specific: include library names, trainer types, dataset names, repo names, or doc pages to explore. Example: 'Research current TRL SFTTrainer usage: find working example scripts, read the SFT documentation, and check SFTConfig parameters. Also validate that dataset HuggingFaceH4/ultrachat_200k has the right format for SFT.'" + }, + "context": { + "type": "string", + "description": "Optional context from the current conversation that the research agent needs (e.g., what the user wants to build, constraints, what's been tried)." + } + }, + "required": [ + "task" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "explore_hf_docs", + "description": "Browse HF documentation structure \u2014 discover all available documentation with 200-char previews.\n\nUse this to find relevant documentation and/or examples with detailed parameter docs and API reference. To be used together with github_find_examples and github_read_file to find working examples and documentation.\n\nPattern: explore_hf_docs (find relevant pages) \u2192 fetch_hf_docs (get full content).\n\nFor training tasks: fetch the trainer config docs (SFTConfig, DPOConfig, GRPOConfig) to verify parameter names. Returns top 20 results by default; set max_results (max 50) to adjust.", + "parameters": { + "type": "object", + "properties": { + "endpoint": { + "type": "string", + "enum": [ + "hub", + "transformers", + "diffusers", + "datasets", + "gradio", + "trackio", + "smolagents", + "huggingface_hub", + "huggingface.js", + "transformers.js", + "inference-providers", + "inference-endpoints", + "peft", + "accelerate", + "optimum", + "tokenizers", + "courses", + "evaluate", + "tasks", + "dataset-viewer", + "trl", + "simulate", + "sagemaker", + "timm", + "safetensors", + "tgi", + "setfit", + "lerobot", + "autotrain", + "tei", + "bitsandbytes", + "sentence_transformers", + "chat-ui", + "leaderboards", + "lighteval", + "argilla", + "distilabel", + "microsoft-azure", + "kernels", + "google-cloud" + ], + "description": "The documentation endpoint to explore. Each endpoint corresponds to a major section of the Hugging Face documentation:\n\n\u2022 courses \u2014 All Hugging Face courses (LLM, robotics, MCP, smol (llm training), agents, deep RL, computer vision, games, diffusion, 3D, audio) and the cookbook recipes. Probably the best place for examples.\n\u2022 hub \u2014 Find answers to questions about models/datasets/spaces, auth, versioning, metadata.\n\u2022 transformers \u2014 Core model library: architectures, configs, tokenizers, training & inference APIs.\n\u2022 diffusers \u2014 Diffusion pipelines, schedulers, fine-tuning, training, and deployment patterns.\n\u2022 datasets \u2014 Dataset loading, streaming, processing, Arrow format, Hub integration.\n\u2022 gradio \u2014 UI components and demos for ML models. Uses Gradio's native API: without query returns full docs (llms.txt), with query uses embedding search for precise results.\n\u2022 trackio \u2014 Experiment tracking, metrics logging, and run comparison.\n\u2022 smolagents \u2014 Lightweight agent abstractions and tool-using patterns.\n\u2022 huggingface_hub \u2014 Python client for Hub operations (auth, upload/download, repo management).\n\u2022 huggingface.js \u2014 JS/TS client for Hub APIs in browser and Node.\n\u2022 transformers.js \u2014 Run Transformer models in browser/Node via WebGPU/WASM.\n\u2022 inference-providers \u2014 Unified interface for third-party inference backends.\n\u2022 inference-endpoints \u2014 Managed, scalable model deployments on HF infrastructure.\n\u2022 peft \u2014 Parameter-efficient fine-tuning methods (LoRA, adapters, etc.).\n\u2022 accelerate \u2014 Hardware-agnostic, distributed and mixed-precision training orchestration.\n\u2022 optimum \u2014 Hardware-aware optimization and model export tooling, including Habana, Neuron, Intel, ExecuTorch, and TPU variants.\n\u2022 tokenizers \u2014 Fast tokenizer internals, training, and low-level APIs.\n\u2022 evaluate \u2014 Metrics, evaluation workflows, and training-loop integration.\n\u2022 tasks \u2014 Canonical task definitions and model categorization.\n\u2022 dataset-viewer \u2014 Dataset preview, streaming views, and viewer internals.\n\u2022 trl \u2014 RLHF, DPO, PPO, and SFT utilities for LLMs.\n\u2022 simulate \u2014 Experimental simulation tools and workflows.\n\u2022 sagemaker \u2014 Deploying Hugging Face models on AWS SageMaker.\n\u2022 timm \u2014 Image model zoo and utilities via HF integrations.\n\u2022 safetensors \u2014 Safe, fast tensor serialization format.\n\u2022 tgi \u2014 High-throughput text generation server for LLMs.\n\u2022 setfit \u2014 Few-shot text classification via sentence embeddings.\n\u2022 lerobot \u2014 Robotics datasets, policies, and learning workflows.\n\u2022 autotrain \u2014 No/low-code model training on Hugging Face.\n\u2022 tei \u2014 Optimized inference server for embedding workloads.\n\u2022 bitsandbytes \u2014 Quantization and memory-efficient optimizers.\n\u2022 sentence_transformers \u2014 Embedding models, training recipes, similarity/search workflows.\n\u2022 chat-ui \u2014 Reference chat interfaces for LLM deployment.\n\u2022 leaderboards \u2014 Evaluation leaderboards and submission mechanics.\n\u2022 lighteval \u2014 Lightweight, reproducible LLM evaluation framework.\n\u2022 argilla \u2014 Data annotation, feedback, and human-in-the-loop workflows.\n\u2022 distilabel \u2014 Synthetic data generation and distillation pipelines.\n\u2022 microsoft-azure \u2014 Azure deployment and integration guides.\n\u2022 kernels \u2014 Load prebuilt compute kernels (E.g. flash-attn2) from the Hub via `attn_implementation`; avoids compiling flash-attn from source.\n\u2022 google-cloud \u2014 GCP deployment and serving workflows.\n" + }, + "query": { + "type": "string", + "description": "Optional keyword query to rank and filter documentation pages. For Gradio, use concise queries like 'how to use the image component' or 'audio component demo'." + }, + "max_results": { + "type": "integer", + "description": "Max results (default 20, max 50). Ignored for Gradio.", + "minimum": 1, + "maximum": 50 + } + }, + "required": [ + "endpoint" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "fetch_hf_docs", + "description": "Fetch full markdown content of an HF documentation page. Use after explore_hf_docs.\n\nCritical for finding documentation e.g. current trainer configuration parameters (SFTConfig, DPOConfig, etc.) Use for researching solutions and before writing training scripts. Your internal knowledge is outdated.\n\nProvide the full URL from explore_hf_docs results. The .md extension is added automatically.", + "parameters": { + "type": "object", + "properties": { + "url": { + "type": "string", + "description": "The full URL to the documentation page. Example: 'https://huggingface.co/docs/trl/dpo_trainer' The .md extension will be added automatically if not present." + } + }, + "required": [ + "url" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_papers", + "description": "Discover ML research papers, analyze citations, search paper contents, and find linked resources.\n\nCombines HuggingFace Hub, arXiv, and Semantic Scholar. Use for exploring research areas, finding datasets for a task, tracing citation chains, or implementing a paper's approach.\n\nTypical flows:\n search \u2192 read_paper \u2192 find_all_resources \u2192 hf_inspect_dataset\n search \u2192 paper_details \u2192 citation_graph \u2192 read_paper (trace influence)\n snippet_search \u2192 paper_details \u2192 read_paper (find specific claims)\n\nOperations:\n- trending: Get trending daily papers, optionally filter by topic keyword\n- search: Search papers. Uses HF by default (ML-tuned). Add date_from/min_citations/categories to use Semantic Scholar with filters\n- paper_details: Metadata, abstract, AI summary, github link\n- read_paper: Read paper contents \u2014 without section: abstract + TOC; with section: full text\n- citation_graph: Get references and citations for a paper with influence flags and citation intents\n- snippet_search: Semantic search over full-text passages from 12M+ papers\n- recommend: Find similar papers (single paper or positive/negative examples)\n- find_datasets: Find datasets linked to a paper\n- find_models: Find models linked to a paper\n- find_collections: Find collections that include a paper\n- find_all_resources: Parallel fetch of datasets + models + collections for a paper", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "trending", + "search", + "paper_details", + "read_paper", + "citation_graph", + "snippet_search", + "recommend", + "find_datasets", + "find_models", + "find_collections", + "find_all_resources" + ], + "description": "Operation to execute." + }, + "query": { + "type": "string", + "description": "Search query. Required for: search, snippet_search. Optional for: trending (filters by keyword). Supports boolean syntax for Semantic Scholar: '\"exact phrase\" term1 | term2'." + }, + "arxiv_id": { + "type": "string", + "description": "ArXiv paper ID (e.g. '2305.18290'). Required for: paper_details, read_paper, citation_graph, find_datasets, find_models, find_collections, find_all_resources. Optional for: recommend (single-paper recs). Get IDs from search results first." + }, + "section": { + "type": "string", + "description": "Section name or number to read (e.g. '3', 'Experiments', '4.2'). Optional for: read_paper. Without this, returns abstract + TOC." + }, + "direction": { + "type": "string", + "enum": [ + "citations", + "references", + "both" + ], + "description": "Direction for citation_graph. Default: both." + }, + "date": { + "type": "string", + "description": "Date in YYYY-MM-DD format. Optional for: trending (defaults to recent papers)." + }, + "date_from": { + "type": "string", + "description": "Start date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "date_to": { + "type": "string", + "description": "End date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "categories": { + "type": "string", + "description": "Field of study filter (e.g. 'Computer Science'). Triggers Semantic Scholar search." + }, + "min_citations": { + "type": "integer", + "description": "Minimum citation count filter. Triggers Semantic Scholar search." + }, + "sort_by": { + "type": "string", + "enum": [ + "relevance", + "citationCount", + "publicationDate" + ], + "description": "Sort order for Semantic Scholar search. Default: relevance." + }, + "positive_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs for multi-paper recommendations. For: recommend." + }, + "negative_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs as negative examples. For: recommend." + }, + "sort": { + "type": "string", + "enum": [ + "downloads", + "likes", + "trending" + ], + "description": "Sort order for find_datasets and find_models. Default: downloads." + }, + "limit": { + "type": "integer", + "description": "Maximum results to return (default: 10, max: 50)." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "web_search", + "description": "Search the web for current information and return cited results.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "minLength": 2 + }, + "allowed_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional allowlist of domains or URLs. Subdomains match." + }, + "blocked_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional blocklist of domains or URLs. Subdomains match." + } + }, + "required": [ + "query" + ], + "additionalProperties": false + } + } + }, + { + "type": "function", + "function": { + "name": "hf_inspect_dataset", + "description": "Inspect a HF dataset in one call: status, configs/splits, schema, sample rows, parquet info.\n\nREQUIRED before any training job to verify dataset format matches training method:\n SFT: needs 'messages', 'text', or 'prompt'/'completion'\n DPO: needs 'prompt', 'chosen', 'rejected'\n GRPO: needs 'prompt'\nAll datasets used for training have to be in conversational ChatML format to be compatible with HF libraries.'\nTraining will fail with KeyError if columns don't match.\n\nAlso use to get example datapoints, understand column names, data types, and available splits before writing any data loading code. Supports private/gated datasets when HF_TOKEN is set.", + "parameters": { + "type": "object", + "properties": { + "dataset": { + "type": "string", + "description": "Dataset ID in 'org/name' format (e.g., 'stanfordnlp/imdb')" + }, + "config": { + "type": "string", + "description": "Config/subset name. Auto-detected if not specified." + }, + "split": { + "type": "string", + "description": "Split for sample rows. Auto-detected if not specified." + }, + "sample_rows": { + "type": "integer", + "description": "Number of sample rows to show (default: 3, max: 10)", + "default": 3 + } + }, + "required": [ + "dataset" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "plan_tool", + "description": "Track progress on multi-step tasks with a todo list (pending/in_progress/completed).\n\nUse for tasks with 3+ steps. Each call replaces the entire plan (send full list).\n\nRules: exactly ONE task in_progress at a time. Mark completed immediately after finishing. Only mark completed when the task fully succeeded \u2014 keep in_progress if there are errors. Update frequently so the user sees progress.", + "parameters": { + "type": "object", + "properties": { + "todos": { + "type": "array", + "description": "List of todo items", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "Unique identifier for the todo" + }, + "content": { + "type": "string", + "description": "Description of the todo task" + }, + "status": { + "type": "string", + "enum": [ + "pending", + "in_progress", + "completed" + ], + "description": "Current status of the todo" + } + }, + "required": [ + "id", + "content", + "status" + ] + } + } + }, + "required": [ + "todos" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "notify", + "description": "Send an out-of-band notification to configured messaging destinations. Use this only when the user explicitly asked for proactive notifications or when the task requires reporting progress outside the chat. Destinations must be named server-side configs such as 'slack.ops'.", + "parameters": { + "type": "object", + "properties": { + "destinations": { + "type": "array", + "description": "Named messaging destinations to notify.", + "items": { + "type": "string" + }, + "minItems": 1 + }, + "message": { + "type": "string", + "description": "Main notification body." + }, + "title": { + "type": "string", + "description": "Optional short title line." + }, + "severity": { + "type": "string", + "enum": [ + "info", + "success", + "warning", + "error" + ], + "description": "Notification severity label." + } + }, + "required": [ + "destinations", + "message" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_jobs", + "description": "Execute Python scripts or Docker containers on HF cloud infrastructure.\n\nTwo modes (mutually exclusive): Python mode (script + dependencies) or Docker mode (command + image). Provide exactly ONE of 'script' or 'command'.\n\nBEFORE submitting training/fine-tuning jobs:\n- You MUST have called github_find_examples + github_read_file to find a working reference implementation. Scripts based on your internal knowledge WILL use outdated APIs and fail.\n- You MUST have validated dataset format via hf_inspect_dataset or hub_repo_details.\n- If the job runs on GPU, or the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile, you MUST create a GPU sandbox with sandbox_create first, run a tiny smoke test there, and fix failures before submitting. If skipped, state why before calling hf_jobs.\n- Training config MUST include push_to_hub=True and hub_model_id. Job storage is EPHEMERAL \u2014 all files are deleted when the job ends. Without push_to_hub, trained models are lost permanently.\n- Include trackio monitoring and provide the dashboard URL to the user. When the script uses report_to='trackio', also pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` as tool args \u2014 they are injected as TRACKIO_SPACE_ID/TRACKIO_PROJECT env vars and let the UI embed the live dashboard.\n\nBATCH/ABLATION JOBS: Submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once \u2014 if there's a bug, all jobs fail.\n\nOperations: run, ps, logs, inspect, cancel, scheduled run/ps/inspect/delete/suspend/resume.\n\nHardware: CPU: cpu-basic(2vCPU/16GB), cpu-upgrade(8vCPU/32GB). GPU: t4-small(4vCPU/15GB/GPU 16GB), t4-medium(8vCPU/30GB/GPU 16GB), a10g-small(4vCPU/15GB/GPU 24GB), a10g-large(12vCPU/46GB/GPU 24GB), a10g-largex2(24vCPU/92GB/GPU 48GB), a10g-largex4(48vCPU/184GB/GPU 96GB), a100-large(12vCPU/142GB/GPU 80GB), a100x4(48vCPU/568GB/GPU 320GB), a100x8(96vCPU/1136GB/GPU 640GB), l4x1(8vCPU/30GB/GPU 24GB), l4x4(48vCPU/186GB/GPU 96GB), l40sx1(8vCPU/62GB/GPU 48GB), l40sx4(48vCPU/382GB/GPU 192GB), l40sx8(192vCPU/1534GB/GPU 384GB).\nCommon picks: t4-small ($0.60/hr, 1-3B), a10g-large ($2/hr, 7-13B), a100-large ($4/hr, 30B+), h100 ($6/hr, 70B+). Note: a10g-small and a10g-large have the SAME 24GB GPU \u2014 the difference is CPU/RAM only.\n\nOOM RECOVERY: When a training job fails with CUDA OOM:\n1. Reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally (keep effective batch size identical)\n2. Enable gradient_checkpointing=True\n3. Upgrade to larger GPU (a10g\u2192a100\u2192h100)\nDo NOT switch training methods (e.g. full SFT to LoRA) or reduce max_length \u2014 those change what the user gets and require explicit approval.\n\nExamples:\nTraining: {'operation': 'run', 'script': '/app/train.py', 'dependencies': ['transformers', 'trl', 'torch', 'datasets', 'trackio'], 'hardware_flavor': 'a100-large', 'timeout': '8h'}\nMonitor: {'operation': 'ps'}, {'operation': 'logs', 'job_id': 'xxx'}, {'operation': 'cancel', 'job_id': 'xxx'}Docker: {'operation': 'run', 'command': ['duckdb', '-c', 'select 1 + 2'], 'image': 'duckdb/duckdb', 'hardware_flavor': 'cpu-basic', 'timeout': '1h'}\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "run", + "ps", + "logs", + "inspect", + "cancel", + "scheduled run", + "scheduled ps", + "scheduled inspect", + "scheduled delete", + "scheduled suspend", + "scheduled resume" + ], + "description": "Operation to execute." + }, + "script": { + "type": "string", + "description": "Python code, sandbox file path (e.g. '/app/train.py', './train.py', or bare 'train.py'), or URL. Triggers Python mode. For ML training: base this on a working example found via github_find_examples, not on internal knowledge. For GPU/model-loading training scripts, smoke-test in a GPU sandbox before submission. Mutually exclusive with 'command'." + }, + "dependencies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Pip packages to install. Include ALL required packages. Common training set: ['transformers', 'trl', 'torch', 'datasets', 'trackio', 'accelerate']. Only used with 'script'." + }, + "image": { + "type": "string", + "description": "Docker image. Optional \u2014 auto-selected if not provided. Use with 'command'." + }, + "command": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Command to execute as list. Triggers Docker mode. Mutually exclusive with 'script'." + }, + "hardware_flavor": { + "type": "string", + "description": "Hardware type. Sizing guide: 1-3B params \u2192 t4-small/a10g-small, 7-13B \u2192 a10g-large, 30B+ \u2192 a100-large, 70B+ \u2192 h100/h100x8. All options: CPU: ['cpu-basic', 'cpu-upgrade']. GPU: ['t4-small', 't4-medium', 'a10g-small', 'a10g-large', 'a10g-largex2', 'a10g-largex4', 'a100-large', 'a100x4', 'a100x8', 'l4x1', 'l4x4', 'l40sx1', 'l40sx4', 'l40sx8']." + }, + "timeout": { + "type": "string", + "description": "Maximum job runtime. MUST be >2h for any training job \u2014 default 30m kills training mid-run. Guidelines: 1-3B models: 3-4h, 7-13B: 6-8h, 30B+: 12-24h. Use 30m-1h only for quick data processing or inference tasks. Default: '30m'." + }, + "env": { + "type": "object", + "description": "Environment variables {'KEY': 'VALUE'}. HF_TOKEN is auto-included." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for this run (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID env var and used by the UI to embed the live dashboard. Set this whenever the script uses report_to='trackio'. The Space is auto-created and seeded with the trackio dashboard before the job starts \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name to log this run under. Injected as TRACKIO_PROJECT env var and used by the UI to filter the embedded dashboard to this project." + }, + "namespace": { + "type": "string", + "description": "Optional namespace to run the job under. Must be the caller's own account or an org they belong to. If omitted, defaults to the caller's personal account. Credits are billed against this namespace." + }, + "job_id": { + "type": "string", + "description": "Job ID. Required for: logs, inspect, cancel." + }, + "scheduled_job_id": { + "type": "string", + "description": "Scheduled job ID. Required for: scheduled inspect/delete/suspend/resume." + }, + "schedule": { + "type": "string", + "description": "Cron schedule or preset (@hourly, @daily, @weekly, @monthly). Required for: scheduled run." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_files", + "description": "Read and write files in HF repos (models/datasets/spaces).\n\n## Operations\n- **list**: List files with sizes and structure\n- **read**: Read file content (text files only)\n- **upload**: Upload content to repo (can create PR)\n- **delete**: Delete files/folders (supports wildcards like *.tmp)\n\n## Use when\n- Need to see what files exist in a repo\n- Want to read config.json, README.md, or other text files\n- Uploading training scripts, configs, or results to a repo\n- Cleaning up temporary files from a repo\n\n## Examples\n{\"operation\": \"list\", \"repo_id\": \"meta-llama/Llama-2-7b\"}\n{\"operation\": \"read\", \"repo_id\": \"gpt2\", \"path\": \"config.json\"}\n{\"operation\": \"upload\", \"repo_id\": \"my-model\", \"path\": \"README.md\", \"content\": \"# My Model\"}\n{\"operation\": \"upload\", \"repo_id\": \"org/model\", \"path\": \"fix.py\", \"content\": \"...\", \"create_pr\": true}\n{\"operation\": \"delete\", \"repo_id\": \"my-model\", \"patterns\": [\"*.tmp\", \"logs/\"]}\n\n## Notes\n- For binary files (safetensors, bin), use list to see them but can't read content\n- upload/delete require approval (can overwrite/destroy data)\n- Use create_pr=true to propose changes instead of direct commit\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "list", + "read", + "upload", + "delete" + ], + "description": "Operation: list, read, upload, delete" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "revision": { + "type": "string", + "description": "Branch/tag/commit (default: main)" + }, + "path": { + "type": "string", + "description": "File path for read/upload" + }, + "content": { + "type": "string", + "description": "File content for upload" + }, + "patterns": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Patterns to delete (e.g., ['*.tmp', 'logs/'])" + }, + "create_pr": { + "type": "boolean", + "description": "Create PR instead of direct commit" + }, + "commit_message": { + "type": "string", + "description": "Custom commit message" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_git", + "description": "Git-like operations on HF repos: branches, tags, PRs, and repo management.\n\n## Operations\n**Branches:** create_branch, delete_branch, list_refs\n**Tags:** create_tag, delete_tag\n**PRs:** create_pr, list_prs, get_pr, merge_pr, close_pr, comment_pr, change_pr_status\n**Repo:** create_repo, update_repo\n\n## Use when\n- Creating feature branches for experiments\n- Tagging model versions (v1.0, v2.0)\n- Opening PRs to contribute to repos you don't own\n- Reviewing and merging PRs on your repos\n- Creating new model/dataset/space repos\n- Changing repo visibility (public/private) or gated access\n\n## Examples\n{\"operation\": \"list_refs\", \"repo_id\": \"my-model\"}\n{\"operation\": \"create_branch\", \"repo_id\": \"my-model\", \"branch\": \"experiment-v2\"}\n{\"operation\": \"create_tag\", \"repo_id\": \"my-model\", \"tag\": \"v1.0\", \"revision\": \"main\"}\n{\"operation\": \"create_pr\", \"repo_id\": \"org/model\", \"title\": \"Fix tokenizer config\"}\n{\"operation\": \"change_pr_status\", \"repo_id\": \"my-model\", \"pr_num\": 1, \"new_status\": \"open\"}\n{\"operation\": \"merge_pr\", \"repo_id\": \"my-model\", \"pr_num\": 3}\n{\"operation\": \"create_repo\", \"repo_id\": \"my-new-model\", \"private\": true}\n{\"operation\": \"update_repo\", \"repo_id\": \"my-model\", \"gated\": \"auto\"}\n\n## PR Workflow\n1. create_pr \u2192 creates draft PR (empty by default)\n2. Upload files with revision='refs/pr/N' to add commits\n3. change_pr_status with new_status='open' to publish (convert draft to open)\n4. merge_pr when ready\n\n## Notes\n- PR status: draft (default), open, merged, closed\n- delete_branch, delete_tag, merge_pr, create_repo, update_repo require approval\n- For spaces, create_repo needs space_sdk (gradio/streamlit/docker/static)\n- gated options: 'auto' (instant), 'manual' (review), false (open)\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "create_branch", + "delete_branch", + "create_tag", + "delete_tag", + "list_refs", + "create_pr", + "list_prs", + "get_pr", + "merge_pr", + "close_pr", + "comment_pr", + "change_pr_status", + "create_repo", + "update_repo" + ], + "description": "Operation to execute" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "branch": { + "type": "string", + "description": "Branch name (create_branch, delete_branch)" + }, + "from_rev": { + "type": "string", + "description": "Create branch from this revision (default: main)" + }, + "tag": { + "type": "string", + "description": "Tag name (create_tag, delete_tag)" + }, + "revision": { + "type": "string", + "description": "Revision for tag (default: main)" + }, + "tag_message": { + "type": "string", + "description": "Tag description" + }, + "title": { + "type": "string", + "description": "PR title (create_pr)" + }, + "description": { + "type": "string", + "description": "PR description (create_pr)" + }, + "pr_num": { + "type": "integer", + "description": "PR/discussion number" + }, + "comment": { + "type": "string", + "description": "Comment text" + }, + "status": { + "type": "string", + "enum": [ + "open", + "closed", + "all" + ], + "description": "Filter PRs by status (list_prs)" + }, + "new_status": { + "type": "string", + "enum": [ + "open", + "closed" + ], + "description": "New status for PR/discussion (change_pr_status)" + }, + "private": { + "type": "boolean", + "description": "Make repo private (create_repo, update_repo)" + }, + "gated": { + "type": "string", + "enum": [ + "auto", + "manual", + "false" + ], + "description": "Gated access setting (update_repo)" + }, + "space_sdk": { + "type": "string", + "enum": [ + "gradio", + "streamlit", + "docker", + "static" + ], + "description": "Space SDK (required for create_repo with space)" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_find_examples", + "description": "Find working example scripts in GitHub repositories (from a list of predetermined directories e.g. examples/, scripts/, tutorials/, etc.). Uses fuzzy keyword matching.\n\nMANDATORY before writing any ML training, fine-tuning, or inference code. Your internal knowledge of library APIs is outdated \u2014 working examples show current API patterns.\n\nSequence: github_find_examples \u2192 github_read_file (study the example) \u2192 implement based on what you found.\n\nSkip this only for: simple data queries, status checks, non-code tasks.\n\nExamples:\n {keyword: 'sft', repo: 'trl'} \u2192 finds examples/scripts/sft.py\n {keyword: 'grpo', repo: 'trl'} \u2192 finds GRPO training examples\n {repo: 'trl', max_results: 20} \u2192 lists all available training method examples", + "parameters": { + "type": "object", + "properties": { + "keyword": { + "type": "string", + "description": "Keyword to fuzzy match against file paths (e.g., 'grpo', 'sft')." + }, + "repo": { + "type": "string", + "description": "Repository name (e.g., 'trl', 'transformers'). Required." + }, + "org": { + "type": "string", + "description": "GitHub organization or username. Default: 'huggingface'." + }, + "max_results": { + "type": "integer", + "description": "Maximum number of results to return. Default: 50." + }, + "min_score": { + "type": "integer", + "description": "Minimum fuzzy match score (0-100). Default: 60." + } + }, + "required": [ + "repo" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_list_repos", + "description": "List and discover repositories for GitHub organizations or users with flexible sorting. **Use when:** (1) Exploring what libraries exist for a task, (2) Finding the right library to use, (3) Discovering popular or active projects, (4) Checking recently updated repos for latest features, (5) Finding alternative libraries in an organization. **Pattern:** github_list_repos (discover libraries) \u2192 github_find_examples (find usage examples) \u2192 implement. Returns: Comprehensive repository information (stars, forks, language, topics, URLs), sorted by preference. **Then:** Use github_find_examples on selected repo to discover example code. Sorts by: stars (popularity), forks (community), updated (activity), created (age).\n\n## When to use this tool\n\n- When you need to find libraries to use in your implementation\n- When exploring what repositories exist for a task or domain\n- When debugging an error and looking up if others have similar issues in repos\n- When finding the most popular or actively maintained projects for a user/org\n## Examples\n\n\n// ML Workflow Step: Discover HF libraries for RLHF/alignment\n// Use case: Find the right library for training with human feedback\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'stars',\n limit: 10\n}\n// Returns: transformers, trl, peft, accelerate, diffusers...\n\n\n\n// ML Workflow Step: Check for recently updated HF repos\n// Use case: Find actively maintained libraries with latest features\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'updated',\n order: 'desc',\n limit: 15\n}\n// Helps identify which repos have recent improvements/fixes\n", + "parameters": { + "type": "object", + "properties": { + "owner": { + "type": "string", + "description": "GitHub username or organization name. Required." + }, + "owner_type": { + "type": "string", + "enum": [ + "user", + "org" + ], + "description": "Whether the owner is a 'user' or 'org'. Default: 'org'." + }, + "sort": { + "type": "string", + "enum": [ + "stars", + "forks", + "updated", + "created" + ], + "description": "Sort field. Options: 'stars', 'forks', 'updated', 'created'. Default: 'stars'." + }, + "order": { + "type": "string", + "enum": [ + "asc", + "desc" + ], + "description": "Sort order. Options: 'asc', 'desc'. Default: 'desc'." + }, + "limit": { + "type": "integer", + "description": "Maximum number of repositories to return. No limit if not specified. Default: 30." + } + }, + "required": [ + "owner" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_read_file", + "description": "Read file contents from GitHub repositories. Returns first 300 lines by default. Auto-converts Jupyter notebooks to markdown.\n\nUse AFTER github_find_examples to study the working implementation. The purpose is to learn current API patterns \u2014 imports, trainer configs, dataset handling \u2014 so your implementation uses correct, up-to-date code.\n\nUse line_start/line_end for large files (>300 lines) to read specific sections.\n\nWhen NOT to use: when you don't know the file path (use github_find_examples first).", + "parameters": { + "type": "object", + "properties": { + "repo": { + "type": "string", + "description": "Repository in format 'owner/repo' (e.g., 'github/github-mcp-server'). Required." + }, + "path": { + "type": "string", + "description": "Path to file in repository (e.g., 'src/index.js'). Required." + }, + "ref": { + "type": "string", + "description": "Git reference - branch name, tag, or commit SHA. Default: 'HEAD'." + }, + "line_start": { + "type": "integer", + "description": "Starting line number (1-indexed, inclusive). Optional." + }, + "line_end": { + "type": "integer", + "description": "Ending line number (1-indexed, inclusive). Optional." + } + }, + "required": [ + "repo", + "path" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "find_hf_api", + "description": "Find HuggingFace Hub REST API endpoints to make HTTP requests. Returns curl examples with authentication. \u26a0\ufe0f USE THIS TOOL when you need to call the HF Hub API directly - for operations like: uploading/downloading files, managing repos, listing models/datasets, getting user info, managing webhooks, collections, discussions, or any Hub interaction not covered by other tools. **Use cases:** (1) 'Stream Space logs' \u2192 query='space logs', (2) 'Get Space metrics/Zero-GPU usage' \u2192 query='space metrics', (3) 'List organization members' \u2192 query='organization members', (4) 'Generate repo access token' \u2192 query='jwt token', (5) 'Check repo security scan' \u2192 query='security scan'. **Search modes:** Use 'query' for keyword search, 'tag' to browse a category, or both. If query finds no results, falls back to showing all endpoints in the tag. **Output:** Full endpoint details with method, path, parameters, curl command, and response schema.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "Keyword search across endpoint summaries, descriptions, and operation IDs. Examples: 'upload file', 'create repository', 'list user models', 'delete branch', 'webhook', 'collection', 'discussion comments'. Supports stemming (upload/uploading both work)." + }, + "tag": { + "type": "string", + "enum": [ + "agentic-provisioning", + "agents", + "auth", + "buckets", + "collections", + "container", + "datasets", + "discussions", + "docs", + "inference-endpoints", + "inference-providers", + "jobs", + "kernels", + "mcp", + "models", + "notifications", + "oauth", + "orgs", + "papers", + "repo-search", + "repos", + "resource-groups", + "scim", + "service-accounts", + "spaces", + "sql-console", + "users", + "webhooks" + ], + "description": "Filter by API category. Use alone to browse all endpoints in a category, or combine with 'query' to search within a category." + } + }, + "required": [] + } + } + } + ], + "upload_status": "failed", + "upload_url": null, + "last_save_time": "2026-06-12T11:40:56.839764", + "personal_upload_status": "failed" +} \ No newline at end of file diff --git a/backend/session_logs/session_d08cdea2-7b4a-473b-a55f-edb2690e05c0_20260612_114035.json b/backend/session_logs/session_d08cdea2-7b4a-473b-a55f-edb2690e05c0_20260612_114035.json new file mode 100644 index 0000000000000000000000000000000000000000..bb08bd8c355718a8434b47023ca13a33182b9634 --- /dev/null +++ b/backend/session_logs/session_d08cdea2-7b4a-473b-a55f-edb2690e05c0_20260612_114035.json @@ -0,0 +1,1151 @@ +{ + "session_id": "d08cdea2-7b4a-473b-a55f-edb2690e05c0", + "user_id": "dev", + "hf_username": "dev", + "session_start_time": "2026-06-12T11:40:30.458603-07:00", + "session_end_time": "2026-06-12T11:40:50.038767", + "model_name": "anthropic/claude-opus-4.8:fal-ai", + "total_cost_usd": 0.0, + "usage_metrics": { + "version": 1, + "session_id": "d08cdea2-7b4a-473b-a55f-edb2690e05c0", + "billing_scope": "account_window_delta", + "total_usd": 0.0, + "total_usd_source": "app_telemetry_fallback", + "app_total_usd": 0.0, + "hf_billing_total_usd": null, + "app_telemetry": { + "session_id": "d08cdea2-7b4a-473b-a55f-edb2690e05c0", + "total_usd": 0.0, + "inference_usd": 0.0, + "hf_jobs_estimated_usd": 0.0, + "sandbox_estimated_usd": 0.0, + "llm_calls": 1, + "hf_jobs_count": 0, + "sandbox_count": 0, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0, + "hf_jobs_billable_seconds_estimate": 0, + "sandbox_billable_seconds_estimate": 0 + }, + "hf_billing": { + "source": "hf_billing_usage_v2", + "available": false, + "error": "missing_hf_token", + "current_session": null + }, + "llm": { + "calls": 1, + "calls_by_kind": { + "main": 1 + }, + "calls_by_model": { + "openai/anthropic/claude-opus-4.8:fal-ai": 1 + }, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0 + }, + "turns": { + "turn_complete_count": 0, + "assistant_stream_end_count": 1 + }, + "hf_jobs": { + "submits": 0, + "status_snapshots": 0, + "statuses": {}, + "flavors": {}, + "submit_flavors": {}, + "status_snapshot_flavors": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0, + "snapshots_with_estimated_cost": 0, + "snapshots_with_nonzero_estimated_cost": 0 + }, + "sandboxes": { + "creates": 0, + "destroys": 0, + "matched_pairs": 0, + "unpaired_creates": 0, + "unpaired_destroys": 0, + "hardware": {}, + "estimated_usd": 0.0, + "billable_seconds_estimate": 0 + }, + "data_quality": { + "event_count": 5, + "events_without_timestamp": 0, + "llm_calls_with_cost_usd": 1, + "llm_calls_with_nonzero_cost_usd": 0, + "job_snapshots_with_estimated_cost": 0, + "job_snapshots_missing_estimated_cost": 0 + } + }, + "messages": [ + { + "content": "You are ML Intern, an ML engineering assistant with 19 tools for training, fine-tuning, data processing, inference, and evaluation on the Hugging Face (HF) ecosystem.\n\nYour goal is to complete what the user requested with zero errors. You are fully autonomous \u2014 research, validate, implement, and deliver results without asking for unnecessary confirmation.\n\n# Your knowledge of HF libraries is outdated\n\nYou do not know current APIs for TRL, Transformers, PEFT, Trackio, or other HF libraries. Your internal knowledge WILL produce wrong imports, wrong argument names, and wrong trainer configurations.\n\nBefore writing any ML implementation code, start from the literature. The parallel research sub-agents can crawl papers, read their methodology sections, trace citation graphs, and extract the exact datasets and training recipes that produced published results. This is your primary advantage \u2014 use it.\n\nYour default workflow for any ML task:\n1. Find the landmark paper(s) for the task or domain\n2. Crawl their citation graphs to find recent downstream work\n3. Read methodology sections (not abstracts) of the most promising papers \u2014 especially recent ones with strong results, lot of citations, and publications in high-impact conferences\n4. Extract the recipe: what dataset, what training method, what hyperparameters produced those results\n5. Validate and use those datasets for training\n\n```\nresearch({\"task\": \"Literature crawl for [task]. Start from [paper/topic]. Crawl citation graph for recent downstream papers. Read their methodology sections (3, 4, 5) \u2014 extract the exact datasets, training methods, and hyperparameters that produced their best results. Attribute every finding to a specific result (e.g. 'Dataset X + method Y \u2192 85.3% on benchmark Z'). Also find working code examples using current TRL/Transformers APIs.\", \"context\": \"User wants to [goal]. We need the best training recipe backed by published results.\"})\n```\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, and hf_papers (with citation_graph, read_paper, snippet_search, find_datasets). Be specific in your task description \u2014 name anchor papers or arxiv IDs when you have them.\n\nYou can also call research tools directly (explore_hf_docs, github_read_file, etc.) for quick lookups.\n\nSkip research only for trivial non-code operations.\n\n# Mistakes you WILL make without research\n\nHALLUCINATED IMPORTS: You will import from modules that were renamed or removed. Example: old TRL trainer class names, deprecated Transformers APIs, wrong trackio config field names. Fix: read a current example script first.\n\nWRONG TRAINER ARGUMENTS: You will pass configuration arguments that don't exist in current trainer versions. Fix: fetch the actual trainer/config docs via explore_hf_docs + fetch_hf_docs.\n\nWRONG DATASET FORMAT: You will assume column names without checking. Training fails with KeyError. Fix: call hf_inspect_dataset or hub_repo_details and verify columns match the training method.\n\nDEFAULT TIMEOUT KILLS JOBS: You will leave timeout at the default 30m for training jobs. Training takes hours. The job gets killed and all progress is lost. Fix: set timeout based on model size (minimum 2h for any training).\n\nLOST MODELS: You will forget push_to_hub=True and hub_model_id in training config. Job storage is ephemeral \u2014 the filesystem is deleted when the job ends. Without push_to_hub, the trained model is permanently lost.\n\nBATCH FAILURES: You will submit all ablation/batch jobs at once without testing that one works first. All will fail for the same bug. Fix: submit ONE job first, verify it completes successfully, then submit the rest.\n\nSILENT DATASET SUBSTITUTION: When a requested dataset fails to load, you will silently switch to a different one without telling the user. Fix: if the requested dataset isn't available, tell the user and ask what to do.\n\nPREFER HUB KERNELS OVER COMPILING ATTENTION: Do NOT pip install 'flash-attn' to enable flash_attention_2 building from source can take many minutes to hours and often fails on the job's CUDA/PyTorch combo. Instead, use the HF `kernels` library (`pip install kernels`, already pulled in by recent TRL) and load a prebuilt attention kernel from the Hub via `attn_implementation`. Examples: `AutoModelForCausalLM.from_pretrained(..., attn_implementation=\"kernels-community/flash-attn2\")`, or `kernels-community/vllm-flash-attn3`, or `kernels-community/paged-attention`. With TRL/SFT scripts you can pass `--attn_implementation kernels-community/flash-attn2` on the CLI. Search additional kernels at https://huggingface.co/models?other=kernel. Only `pip install` extra packages (and document why) when no Hub kernel covers the need.\n\nSCOPE-CHANGING FIXES: Avoid at all costs! When you hit an error (especially OOM), you will try \"creative\" workarounds that change what the user asked for and/or change the training task itself \u2014 switching full SFT to LoRA on OOM, reducing max_length (silently truncates training data and changes what the model learns), disabling monitoring instead of fixing it. Do not do this. Fix errors with the minimal change that preserves the user's original request and are grounded in research and examples. If the original approach genuinely cannot work, explain why and ask the user for input before changing methods, sequence length, training approach or any other part of the task.\n\n# When writing ML code\n\nRequired sequence before any training/fine-tuning/inference script:\n1. Use `research` tool to find working examples, read docs, and get current API patterns\n2. Validate dataset: hf_inspect_dataset or hub_repo_details to confirm column names and format\n3. Validate model: hub_repo_details to confirm model exists, correct architecture/size/tokenizer\n\nTraining logging: always set disable_tqdm=True, logging_strategy=\"steps\", and logging_first_step=True in your TrainingArguments/SFTConfig so loss values are printed as plain text lines you can grep, not hidden inside tqdm progress bars.\n\nDataset format requirements by training method:\n SFT: \"messages\", \"text\", or \"prompt\"/\"completion\"\n DPO: \"prompt\", \"chosen\", \"rejected\"\n GRPO: \"prompt\"\n\n# Trackio\n\nTrackio is natively integrated with Transformers Trainer and all TRL trainers \u2014 the built-in TrackioCallback handles init/log/finish. In TrainingArguments/SFTConfig/DPOConfig/GRPOConfig set:\n report_to=\"trackio\"\n run_name=\"\" # e.g. \"sft_qwen3-4b_lr2e-5_bs128\"\n project=\"\" # keeps related runs grouped so you can compare them\n trackio_space_id=\"/ml-intern-<8-char-id>\" # creates a public dashboard Space\n`project` and `trackio_space_id` can also be set via TRACKIO_PROJECT / TRACKIO_SPACE_ID env vars.\n\nAlerts are how iterations decide what to change. Use trackio.alert(title, text, level) at every decision point in training. Levels:\n ERROR \u2014 stop and change approach (divergence, NaN, OOM)\n WARN \u2014 tweak hyperparameters (overfitting, early stopping, KL spike, reward collapse, slow convergence)\n INFO \u2014 milestones (training complete, target reached, checkpoint saved)\nAlways include numeric values and an actionable suggestion in `text`, e.g. \"loss=12.4 at step 200 \u2014 lr likely too high, try \u00d70.1\". A future call must be able to parse it and act on it.\n\nTo add alerts under Trainer/SFTTrainer/GRPOTrainer, pass a custom TrainerCallback via `callbacks=[...]` that calls trackio.alert() inside `on_log` (training metrics like loss, reward, kl) and `on_evaluate` (eval metrics \u2014 only available here, not in `on_log`). Keep each `if` simple: one metric, one threshold. Conditions stay easy to adjust between runs.\n\nRead alerts back between runs instead of parsing thousands of metric values. CLI \u2014 always use --json:\n trackio get alerts --project

--run --json\n trackio get alerts --project

--since --json # incremental polling\n trackio get run --project

--run --json\n trackio get metric --project

--run --metric --json\n trackio list runs --project

--json\nPython: api = trackio.Api(); api.alerts(

, run=, since=); api.runs(

) (each run has .name, .config, .alerts()).\n\nDrive the next config from prior alerts:\n diverged \u2192 lr \u00d7 0.1\n overfitting \u2192 weight_decay \u00d7 10 or reduce capacity\n early stopping \u2192 lr \u00d7 0.5 or adjust schedule\n high accuracy \u2192 refine around current config\nRead prior config via api.runs(...).config and only mutate keys the alerts justify changing.\n\n# Data audit\n\nBefore working with any dataset, audit it first. Do not assume you know what the data looks like \u2014 inspect it.\n\nUse hf_inspect_dataset to check: schema/columns, number of rows per split, value distributions for key columns, sample rows. Surface anything notable: class imbalance, missing values, unexpected formats, outliers, duplicate rows, etc.\n\nLooking at data is the best way to boost performance of any ML model plus it reduces the likelihood of failed jobs later.\n\n# When submitting a training job\n\nNever pass a local machine path to hf_jobs.script, such as /Users/..., /home/..., /fsx/..., or a repo checkout path. HF Jobs runs in a fresh cloud environment where local files do not exist. For hf_jobs.script, use exactly one of:\n - inline Python source code\n - a file already written in the session sandbox, e.g. /app/train.py, ./train.py, or train.py\n - a public/raw URL\nIf you wrote or tested a script locally, read the file content and submit it inline, or write it into the sandbox first.\n\nGPU preflight is mandatory before hf_jobs when the job will run on GPU, or when the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile. First create a GPU sandbox with sandbox_create (t4-small minimum; choose larger hardware when VRAM requires it), run a tiny smoke test there using the same imports, model-loading path, training entrypoint, and a tiny dataset/subset, then fix failures before submitting. If you skip GPU sandbox preflight, state why before calling hf_jobs.\n\nBefore calling hf_jobs, output a pre-flight check:\n - Reference implementation: [which example you based this on]\n - Dataset format verified: [columns confirmed via hf_inspect_dataset/hub_repo_details]\n - GPU sandbox smoke test: [hardware and result, or explicitly not applicable because ...]\n - push_to_hub=True and hub_model_id set\n - timeout: [value] (based on: [model size] on [hardware])\n - Trackio monitoring included and deploying metrics to a public Space\n\nIf you cannot fill in all items, stop and complete the missing steps first.\n\nFor batch/ablation jobs: submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once.\n\nHardware sizing:\n 1-3B params: a10g-largex2\n 7-13B params: a100-large\n 30B+ params: l40sx4 or a100x4\n 70B+ params: a100x8\nNote: a10g-small and a10g-large have the SAME 24GB GPU memory. The difference is CPU/RAM only.\n\n# Sandbox-first development\n\nA private cpu-basic sandbox is already available for normal code execution in each session. For non-trivial scripts, develop and test there before launching via hf_jobs:\n write script \u2192 pip install \u2192 test with small run using bash/read/write/edit \u2192 fix errors \u2192 launch via hf_jobs at scale\n\nDo NOT call sandbox_create before normal CPU work. Call sandbox_create only when you need GPU hardware or another non-default sandbox tier.\n\nThe sandbox filesystem does not survive session resumption. If a session is resumed, any files, installed packages, or running processes from earlier are gone \u2014 recreate what you need before relying on the sandbox.\n\nUse a GPU sandbox (t4-small minimum) when testing code that uses CUDA, bf16/fp16, quantization, flash attention, torch.compile, or model loading. CPU sandboxes cannot test GPU code paths. If the available sandbox tiers cannot fit the full model path, test the largest useful smoke path, state what was not covered, and submit one HF job first.\n\n\n# When a task has 3+ steps\n\nUse plan_tool to track progress. One task in_progress at a time. Mark completed immediately after finishing. Update frequently to show the user what you're doing.\n\n# Error recovery\n\nWhen something fails:\n- Diagnose the actual error. Read the full error message and logs.\n- Do not retry the exact same thing. Identify what needs to change.\n- If an API/import error: check documentation for the correct API.\n- If an OOM error: (1) reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally to keep effective batch size identical, (2) enable gradient_checkpointing=True, (3) upgrade to larger GPU (a10gx4\u2192a100\u2192a100x4\u2192a100x8). Do NOT switch training methods (e.g. SFT\u2192LoRA) or reduce max_length \u2014 those change what the user gets. If OOM happens in sandbox, create a new sandbox with larger GPU hardware.\n- Never change the user's requested approach (training method, dataset, model, sequence length) without explicit approval.\n- If a tool call fails repeatedly for the same reason: stop and try a different approach.\n- Never silently substitute resources (datasets, models) \u2014 tell the user if something isn't available.\n\n# Task completion\n\nBefore ending your turn, verify:\n- Did you actually DO what the user asked, not just explain what you would do?\n- If something failed: did you diagnose and fix it, or at minimum explain what went wrong and ask for user input?\n- For training jobs: did you include a working Trackio dashboard URL?\n\nDo not stop after describing what you plan to do. Continue calling tools until the task is verifiably done.\nDo not mark plan tasks as completed if they failed or are only partially done.\n\n# Autonomous / headless mode\n\nWhen running autonomously (no human in the loop), you MUST follow these rules:\n\nNEVER respond with only text. Every response MUST include at least one tool call. If you have nothing to do, check the plan, verify outputs or plan ahead. A text-only response ends the agent loop permanently \u2014 there is no human to re-prompt you.\n\nNEVER STOP WORKING. Do NOT decide you are \"done\" while time remains. The human is not watching \u2014 they expect you to use the ENTIRE time budget productively. Do NOT ask \"should I continue?\" or \"is this a good stopping point?\" \u2014 there is nobody to answer. You run until the timer expires or you are manually killed.\n\nYour workflow is a loop, not a checklist. Once you have a working result, KEEP ITERATING:\n\nLOOP UNTIL TIME RUNS OUT:\n1. Research the approach (read docs, find examples, check current APIs)\n2. Implement the solution (write code, set up training)\n3. Train and evaluate\n4. Save the model to the required output location / push it to Hugging Face Hub\n5. Improve: tune hyperparameters, try different data, adjust the training recipe, try a different approach entirely\n6. Go to step 1\n\nHYPERPARAMETER TUNING: Do not tune hyperparameters by hand one-at-a-time. Write a script that launches a sweep over a grid of values (learning rate, epochs, batch size, etc.) and evaluates each run automatically. One well-designed sweep script beats ten manual experiments.\n\nIf you run out of ideas: go back to the literature. Crawl citation graphs deeper \u2014 find papers you haven't read yet, read their methodology sections, extract new datasets or training tricks. Look for papers that cite your current approach and improved on it. Try combining recipes from different papers. Re-read the task prompt for angles you missed. Re-read the training logs for clues. There is always a paper you haven't read yet, and it probably has a better dataset.\n\nCheck the remaining time periodically with the timer command specified in the task prompt. Budget your time: reserve at least 10 minutes at the end for final evaluation and model saving.\n\nThe task is NOT done until:\n- The required output exists (e.g. final model, metrics reached, dataset updated etc)\n- You have evaluated the model and confirmed it works\n\n# Communication\n\n- Be concise and direct. No filler, no restating what the user said.\n- One-word answers when appropriate for simple questions.\n- Always include direct Hub URLs when referencing models, datasets, Spaces, or jobs.\n- For errors: state what went wrong, why, and what you're doing to fix it.\n- Do not over-explain or present elaborate option menus for simple tasks. When the user's intent is clear, act on it. Present options only when there's genuine ambiguity.\n- Use the `notify` tool only when the user explicitly asked for out-of-band notifications or when the task clearly requires reporting to a configured messaging destination. Do not use it for routine chat updates.\n\n# Tool usage\n\n- Execute multiple independent tool calls in parallel when possible.\n- HF_TOKEN is automatically available in job secrets \u2014 no need to include it extra.\n- For training monitoring: include Trackio in the script and provide the dashboard URL.\n- For private/gated datasets: HF_TOKEN is needed \u2014 it's auto-loaded into job secrets.\n\n[Session context: Date=12-06-2026, Time=20:40:30.457, Timezone=CEST (UTC+02:00), User=unknown, Tools=19]", + "role": "system", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + }, + { + "content": "count slowly from 1 to 200 in words, one per line", + "role": "user", + "tool_calls": null, + "function_call": null, + "provider_specific_fields": null + } + ], + "events": [ + { + "timestamp": "2026-06-12T11:40:30.755971-07:00", + "event_type": "ready", + "data": { + "message": "Agent initialized" + } + }, + { + "timestamp": "2026-06-12T11:40:30.756071-07:00", + "event_type": "processing", + "data": { + "message": "Processing user input" + } + }, + { + "timestamp": "2026-06-12T11:40:35.671259-07:00", + "event_type": "llm_call", + "data": { + "model": "openai/anthropic/claude-opus-4.8:fal-ai", + "latency_ms": 4914, + "finish_reason": null, + "cost_usd": 0.0, + "kind": "main" + } + }, + { + "timestamp": "2026-06-12T11:40:35.671295-07:00", + "event_type": "assistant_stream_end", + "data": {} + }, + { + "timestamp": "2026-06-12T11:40:35.671390-07:00", + "event_type": "interrupted", + "data": null + } + ], + "tools": [ + { + "type": "function", + "function": { + "name": "sandbox_create", + "description": "Create or replace the session sandbox when non-default hardware is needed.\n\nA private cpu-basic sandbox is already started automatically for each session. For normal CPU code execution, call bash/read/write/edit directly; do NOT call sandbox_create first.\n\nUse sandbox_create when: you need GPU hardware, cpu-upgrade, or Trackio secrets before running code. The active sandbox persists across tool calls within the session. pip install works out of the box. Sandboxes are always created as private HF Spaces.\n\nFor ML code that uses CUDA, bf16, or model loading: use GPU hardware (t4-small minimum). CPU sandboxes cannot run GPU code paths \u2014 your test will not catch GPU-related errors.\n\nBefore choosing hardware, estimate your VRAM needs (models you run, training data size). Rule of thumb: bf16/fp16 \u2248 2 bytes/param, fp32 \u2248 4 bytes/param, plus ~20% overhead for optimizer states during training.\nCommon picks: t4-small (16GB VRAM, fits \u22641-3B), a10g-small (24GB, \u22647B), a100-large (80GB, \u226430B). If the model won't fit, pick larger hardware upfront \u2014 OOM on a sandbox wastes time.\n\nIf you intend to run a training script in this sandbox that uses report_to='trackio', pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` so they are set as TRACKIO_SPACE_ID/TRACKIO_PROJECT secrets in the sandbox and the UI can embed the live dashboard.\n\nHardware: cpu-basic, cpu-upgrade, cpu-performance, cpu-xl, sprx8, zero-a10g, t4-small, t4-medium, l4x1, l4x4, l40sx1, l40sx4, l40sx8, a10g-small, a10g-large, a10g-largex2, a10g-largex4, a100-large, a100x4, a100x8, h200, h200x2, h200x4, h200x8, inf2x6.\n", + "parameters": { + "type": "object", + "required": [], + "additionalProperties": false, + "properties": { + "hardware": { + "type": "string", + "enum": [ + "cpu-basic", + "cpu-upgrade", + "cpu-performance", + "cpu-xl", + "sprx8", + "zero-a10g", + "t4-small", + "t4-medium", + "l4x1", + "l4x4", + "l40sx1", + "l40sx4", + "l40sx8", + "a10g-small", + "a10g-large", + "a10g-largex2", + "a10g-largex4", + "a100-large", + "a100x4", + "a100x8", + "h200", + "h200x2", + "h200x4", + "h200x8", + "inf2x6" + ], + "description": "Hardware tier for the sandbox. Omit for the existing auto-started cpu-basic sandbox; choose GPU/cpu-upgrade only when needed." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for runs in this sandbox (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID secret and surfaced to the UI. The Space is auto-created and seeded with the trackio dashboard \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name. Injected as TRACKIO_PROJECT secret and used by the UI to filter the embedded dashboard to this project." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "bash", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nRun a shell command in the remote sandbox and return stdout/stderr.\n\nIMPORTANT: Do NOT use bash for file operations \u2014 use the dedicated tools instead:\n- To read files: use read (not cat/head/tail)\n- To edit files: use edit (not sed/awk)\n- To write files: use write (not echo/cat < > /app/output.log 2>&1 & echo $!\nThen check status:\n kill -0 2>/dev/null && echo 'running' || echo 'done'\n tail -n 50 /app/output.log\n\nTimeout default 240s, max 1200s.", + "parameters": { + "type": "object", + "required": [ + "command" + ], + "additionalProperties": false, + "properties": { + "command": { + "type": "string", + "description": "The shell command to execute." + }, + "description": { + "type": "string", + "description": "Short description (5-10 words, active voice)." + }, + "work_dir": { + "type": "string", + "description": "Working directory (default: /app)." + }, + "timeout": { + "type": "integer", + "description": "Optional timeout in seconds (default: 240, max: 1200)." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "read", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nReads a file from the sandbox filesystem. Returns contents with line numbers (cat -n format).\n\nUsage:\n- By default, reads up to 2000 lines from the beginning of the file.\n- You can optionally specify offset and limit for large files, but prefer reading the whole file first.\n- Lines longer than 4000 chars are truncated.\n- Cannot read directories \u2014 use bash with 'ls' instead.\n- You should read multiple potentially useful files in parallel when possible.\n- IMPORTANT: Always read a file before editing or overwriting it. The edit and write tools will reject operations on files you haven't read.", + "parameters": { + "type": "object", + "required": [ + "path" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to read." + }, + "offset": { + "type": "integer", + "description": "The line number to start reading from (1-based). Only provide if the file is too large to read at once." + }, + "limit": { + "type": "integer", + "description": "The number of lines to read. Only provide if the file is too large to read at once." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "write", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nWrites a file to the sandbox filesystem. Overwrites the existing file if one exists at the path.\n\n- If this is an existing file, you MUST use the read tool first. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files with the edit tool over overwriting with write.\n- Creates parent directories as needed.", + "parameters": { + "type": "object", + "required": [ + "path", + "content" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to write." + }, + "content": { + "type": "string", + "description": "The complete file content to write." + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "edit", + "description": "Uses the session's active sandbox. A private cpu-basic sandbox is started automatically for normal CPU work; call sandbox_create only for GPU or other non-default hardware.\n\nPerforms string replacements in files. Supports exact matching with fuzzy fallback.\n\nUsage:\n- You must read the file at least once before editing. This tool will error if you attempt an edit without reading the file.\n- The edit will FAIL if old_str is not unique in the file. Either provide a larger string with more surrounding context to make it unique, or set replace_all to true.\n- old_str and new_str must differ.\n- Preserve indentation exactly as it appears in the file.\n- Do NOT include line number prefixes from read output in old_str or new_str.\n- To delete code, set new_str to empty string.\n- Use replace_all for renaming variables or strings across the file.\n\nModes:\n- replace (default): replace first occurrence of old_str with new_str.\n- append_after: insert new_str immediately after old_str (old_str is kept).\n- prepend_before: insert new_str immediately before old_str (old_str is kept).", + "parameters": { + "type": "object", + "required": [ + "path", + "old_str", + "new_str" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string", + "description": "Absolute path to the file to edit." + }, + "old_str": { + "type": "string", + "description": "The text to find in the file. Must match exactly (fuzzy matching is used as fallback)." + }, + "new_str": { + "type": "string", + "description": "The replacement text. For append_after/prepend_before modes, the text to insert." + }, + "replace_all": { + "type": "boolean", + "description": "Replace all occurrences of old_str (default: false).", + "default": false + }, + "mode": { + "type": "string", + "enum": [ + "replace", + "append_after", + "prepend_before" + ], + "description": "Edit mode (default: replace).", + "default": "replace" + } + } + } + } + }, + { + "type": "function", + "function": { + "name": "research", + "description": "Spawn a research sub-agent to explore documentation, codebases, or repos WITHOUT polluting the main conversation context. The sub-agent gets its own independent context window with read-only research tools and returns a concise summary of findings.\n\nUse this for:\n- Researching current API usage before implementing ML tasks (find examples + read docs)\n- Exploring HF docs, reading papers, analyzing GitHub repos\n- Any research where raw tool outputs would be too verbose\n\nThe sub-agent knows how to use github_find_examples, github_read_file, explore_hf_docs, fetch_hf_docs, hf_inspect_dataset, hf_papers, etc. Just describe what you need researched.", + "parameters": { + "type": "object", + "properties": { + "task": { + "type": "string", + "description": "Detailed description of what to research. Be specific: include library names, trainer types, dataset names, repo names, or doc pages to explore. Example: 'Research current TRL SFTTrainer usage: find working example scripts, read the SFT documentation, and check SFTConfig parameters. Also validate that dataset HuggingFaceH4/ultrachat_200k has the right format for SFT.'" + }, + "context": { + "type": "string", + "description": "Optional context from the current conversation that the research agent needs (e.g., what the user wants to build, constraints, what's been tried)." + } + }, + "required": [ + "task" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "explore_hf_docs", + "description": "Browse HF documentation structure \u2014 discover all available documentation with 200-char previews.\n\nUse this to find relevant documentation and/or examples with detailed parameter docs and API reference. To be used together with github_find_examples and github_read_file to find working examples and documentation.\n\nPattern: explore_hf_docs (find relevant pages) \u2192 fetch_hf_docs (get full content).\n\nFor training tasks: fetch the trainer config docs (SFTConfig, DPOConfig, GRPOConfig) to verify parameter names. Returns top 20 results by default; set max_results (max 50) to adjust.", + "parameters": { + "type": "object", + "properties": { + "endpoint": { + "type": "string", + "enum": [ + "hub", + "transformers", + "diffusers", + "datasets", + "gradio", + "trackio", + "smolagents", + "huggingface_hub", + "huggingface.js", + "transformers.js", + "inference-providers", + "inference-endpoints", + "peft", + "accelerate", + "optimum", + "tokenizers", + "courses", + "evaluate", + "tasks", + "dataset-viewer", + "trl", + "simulate", + "sagemaker", + "timm", + "safetensors", + "tgi", + "setfit", + "lerobot", + "autotrain", + "tei", + "bitsandbytes", + "sentence_transformers", + "chat-ui", + "leaderboards", + "lighteval", + "argilla", + "distilabel", + "microsoft-azure", + "kernels", + "google-cloud" + ], + "description": "The documentation endpoint to explore. Each endpoint corresponds to a major section of the Hugging Face documentation:\n\n\u2022 courses \u2014 All Hugging Face courses (LLM, robotics, MCP, smol (llm training), agents, deep RL, computer vision, games, diffusion, 3D, audio) and the cookbook recipes. Probably the best place for examples.\n\u2022 hub \u2014 Find answers to questions about models/datasets/spaces, auth, versioning, metadata.\n\u2022 transformers \u2014 Core model library: architectures, configs, tokenizers, training & inference APIs.\n\u2022 diffusers \u2014 Diffusion pipelines, schedulers, fine-tuning, training, and deployment patterns.\n\u2022 datasets \u2014 Dataset loading, streaming, processing, Arrow format, Hub integration.\n\u2022 gradio \u2014 UI components and demos for ML models. Uses Gradio's native API: without query returns full docs (llms.txt), with query uses embedding search for precise results.\n\u2022 trackio \u2014 Experiment tracking, metrics logging, and run comparison.\n\u2022 smolagents \u2014 Lightweight agent abstractions and tool-using patterns.\n\u2022 huggingface_hub \u2014 Python client for Hub operations (auth, upload/download, repo management).\n\u2022 huggingface.js \u2014 JS/TS client for Hub APIs in browser and Node.\n\u2022 transformers.js \u2014 Run Transformer models in browser/Node via WebGPU/WASM.\n\u2022 inference-providers \u2014 Unified interface for third-party inference backends.\n\u2022 inference-endpoints \u2014 Managed, scalable model deployments on HF infrastructure.\n\u2022 peft \u2014 Parameter-efficient fine-tuning methods (LoRA, adapters, etc.).\n\u2022 accelerate \u2014 Hardware-agnostic, distributed and mixed-precision training orchestration.\n\u2022 optimum \u2014 Hardware-aware optimization and model export tooling, including Habana, Neuron, Intel, ExecuTorch, and TPU variants.\n\u2022 tokenizers \u2014 Fast tokenizer internals, training, and low-level APIs.\n\u2022 evaluate \u2014 Metrics, evaluation workflows, and training-loop integration.\n\u2022 tasks \u2014 Canonical task definitions and model categorization.\n\u2022 dataset-viewer \u2014 Dataset preview, streaming views, and viewer internals.\n\u2022 trl \u2014 RLHF, DPO, PPO, and SFT utilities for LLMs.\n\u2022 simulate \u2014 Experimental simulation tools and workflows.\n\u2022 sagemaker \u2014 Deploying Hugging Face models on AWS SageMaker.\n\u2022 timm \u2014 Image model zoo and utilities via HF integrations.\n\u2022 safetensors \u2014 Safe, fast tensor serialization format.\n\u2022 tgi \u2014 High-throughput text generation server for LLMs.\n\u2022 setfit \u2014 Few-shot text classification via sentence embeddings.\n\u2022 lerobot \u2014 Robotics datasets, policies, and learning workflows.\n\u2022 autotrain \u2014 No/low-code model training on Hugging Face.\n\u2022 tei \u2014 Optimized inference server for embedding workloads.\n\u2022 bitsandbytes \u2014 Quantization and memory-efficient optimizers.\n\u2022 sentence_transformers \u2014 Embedding models, training recipes, similarity/search workflows.\n\u2022 chat-ui \u2014 Reference chat interfaces for LLM deployment.\n\u2022 leaderboards \u2014 Evaluation leaderboards and submission mechanics.\n\u2022 lighteval \u2014 Lightweight, reproducible LLM evaluation framework.\n\u2022 argilla \u2014 Data annotation, feedback, and human-in-the-loop workflows.\n\u2022 distilabel \u2014 Synthetic data generation and distillation pipelines.\n\u2022 microsoft-azure \u2014 Azure deployment and integration guides.\n\u2022 kernels \u2014 Load prebuilt compute kernels (E.g. flash-attn2) from the Hub via `attn_implementation`; avoids compiling flash-attn from source.\n\u2022 google-cloud \u2014 GCP deployment and serving workflows.\n" + }, + "query": { + "type": "string", + "description": "Optional keyword query to rank and filter documentation pages. For Gradio, use concise queries like 'how to use the image component' or 'audio component demo'." + }, + "max_results": { + "type": "integer", + "description": "Max results (default 20, max 50). Ignored for Gradio.", + "minimum": 1, + "maximum": 50 + } + }, + "required": [ + "endpoint" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "fetch_hf_docs", + "description": "Fetch full markdown content of an HF documentation page. Use after explore_hf_docs.\n\nCritical for finding documentation e.g. current trainer configuration parameters (SFTConfig, DPOConfig, etc.) Use for researching solutions and before writing training scripts. Your internal knowledge is outdated.\n\nProvide the full URL from explore_hf_docs results. The .md extension is added automatically.", + "parameters": { + "type": "object", + "properties": { + "url": { + "type": "string", + "description": "The full URL to the documentation page. Example: 'https://huggingface.co/docs/trl/dpo_trainer' The .md extension will be added automatically if not present." + } + }, + "required": [ + "url" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_papers", + "description": "Discover ML research papers, analyze citations, search paper contents, and find linked resources.\n\nCombines HuggingFace Hub, arXiv, and Semantic Scholar. Use for exploring research areas, finding datasets for a task, tracing citation chains, or implementing a paper's approach.\n\nTypical flows:\n search \u2192 read_paper \u2192 find_all_resources \u2192 hf_inspect_dataset\n search \u2192 paper_details \u2192 citation_graph \u2192 read_paper (trace influence)\n snippet_search \u2192 paper_details \u2192 read_paper (find specific claims)\n\nOperations:\n- trending: Get trending daily papers, optionally filter by topic keyword\n- search: Search papers. Uses HF by default (ML-tuned). Add date_from/min_citations/categories to use Semantic Scholar with filters\n- paper_details: Metadata, abstract, AI summary, github link\n- read_paper: Read paper contents \u2014 without section: abstract + TOC; with section: full text\n- citation_graph: Get references and citations for a paper with influence flags and citation intents\n- snippet_search: Semantic search over full-text passages from 12M+ papers\n- recommend: Find similar papers (single paper or positive/negative examples)\n- find_datasets: Find datasets linked to a paper\n- find_models: Find models linked to a paper\n- find_collections: Find collections that include a paper\n- find_all_resources: Parallel fetch of datasets + models + collections for a paper", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "trending", + "search", + "paper_details", + "read_paper", + "citation_graph", + "snippet_search", + "recommend", + "find_datasets", + "find_models", + "find_collections", + "find_all_resources" + ], + "description": "Operation to execute." + }, + "query": { + "type": "string", + "description": "Search query. Required for: search, snippet_search. Optional for: trending (filters by keyword). Supports boolean syntax for Semantic Scholar: '\"exact phrase\" term1 | term2'." + }, + "arxiv_id": { + "type": "string", + "description": "ArXiv paper ID (e.g. '2305.18290'). Required for: paper_details, read_paper, citation_graph, find_datasets, find_models, find_collections, find_all_resources. Optional for: recommend (single-paper recs). Get IDs from search results first." + }, + "section": { + "type": "string", + "description": "Section name or number to read (e.g. '3', 'Experiments', '4.2'). Optional for: read_paper. Without this, returns abstract + TOC." + }, + "direction": { + "type": "string", + "enum": [ + "citations", + "references", + "both" + ], + "description": "Direction for citation_graph. Default: both." + }, + "date": { + "type": "string", + "description": "Date in YYYY-MM-DD format. Optional for: trending (defaults to recent papers)." + }, + "date_from": { + "type": "string", + "description": "Start date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "date_to": { + "type": "string", + "description": "End date (YYYY-MM-DD). Triggers Semantic Scholar search. For: search, snippet_search." + }, + "categories": { + "type": "string", + "description": "Field of study filter (e.g. 'Computer Science'). Triggers Semantic Scholar search." + }, + "min_citations": { + "type": "integer", + "description": "Minimum citation count filter. Triggers Semantic Scholar search." + }, + "sort_by": { + "type": "string", + "enum": [ + "relevance", + "citationCount", + "publicationDate" + ], + "description": "Sort order for Semantic Scholar search. Default: relevance." + }, + "positive_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs for multi-paper recommendations. For: recommend." + }, + "negative_ids": { + "type": "string", + "description": "Comma-separated arxiv IDs as negative examples. For: recommend." + }, + "sort": { + "type": "string", + "enum": [ + "downloads", + "likes", + "trending" + ], + "description": "Sort order for find_datasets and find_models. Default: downloads." + }, + "limit": { + "type": "integer", + "description": "Maximum results to return (default: 10, max: 50)." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "web_search", + "description": "Search the web for current information and return cited results.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "minLength": 2 + }, + "allowed_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional allowlist of domains or URLs. Subdomains match." + }, + "blocked_domains": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Optional blocklist of domains or URLs. Subdomains match." + } + }, + "required": [ + "query" + ], + "additionalProperties": false + } + } + }, + { + "type": "function", + "function": { + "name": "hf_inspect_dataset", + "description": "Inspect a HF dataset in one call: status, configs/splits, schema, sample rows, parquet info.\n\nREQUIRED before any training job to verify dataset format matches training method:\n SFT: needs 'messages', 'text', or 'prompt'/'completion'\n DPO: needs 'prompt', 'chosen', 'rejected'\n GRPO: needs 'prompt'\nAll datasets used for training have to be in conversational ChatML format to be compatible with HF libraries.'\nTraining will fail with KeyError if columns don't match.\n\nAlso use to get example datapoints, understand column names, data types, and available splits before writing any data loading code. Supports private/gated datasets when HF_TOKEN is set.", + "parameters": { + "type": "object", + "properties": { + "dataset": { + "type": "string", + "description": "Dataset ID in 'org/name' format (e.g., 'stanfordnlp/imdb')" + }, + "config": { + "type": "string", + "description": "Config/subset name. Auto-detected if not specified." + }, + "split": { + "type": "string", + "description": "Split for sample rows. Auto-detected if not specified." + }, + "sample_rows": { + "type": "integer", + "description": "Number of sample rows to show (default: 3, max: 10)", + "default": 3 + } + }, + "required": [ + "dataset" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "plan_tool", + "description": "Track progress on multi-step tasks with a todo list (pending/in_progress/completed).\n\nUse for tasks with 3+ steps. Each call replaces the entire plan (send full list).\n\nRules: exactly ONE task in_progress at a time. Mark completed immediately after finishing. Only mark completed when the task fully succeeded \u2014 keep in_progress if there are errors. Update frequently so the user sees progress.", + "parameters": { + "type": "object", + "properties": { + "todos": { + "type": "array", + "description": "List of todo items", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "Unique identifier for the todo" + }, + "content": { + "type": "string", + "description": "Description of the todo task" + }, + "status": { + "type": "string", + "enum": [ + "pending", + "in_progress", + "completed" + ], + "description": "Current status of the todo" + } + }, + "required": [ + "id", + "content", + "status" + ] + } + } + }, + "required": [ + "todos" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "notify", + "description": "Send an out-of-band notification to configured messaging destinations. Use this only when the user explicitly asked for proactive notifications or when the task requires reporting progress outside the chat. Destinations must be named server-side configs such as 'slack.ops'.", + "parameters": { + "type": "object", + "properties": { + "destinations": { + "type": "array", + "description": "Named messaging destinations to notify.", + "items": { + "type": "string" + }, + "minItems": 1 + }, + "message": { + "type": "string", + "description": "Main notification body." + }, + "title": { + "type": "string", + "description": "Optional short title line." + }, + "severity": { + "type": "string", + "enum": [ + "info", + "success", + "warning", + "error" + ], + "description": "Notification severity label." + } + }, + "required": [ + "destinations", + "message" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_jobs", + "description": "Execute Python scripts or Docker containers on HF cloud infrastructure.\n\nTwo modes (mutually exclusive): Python mode (script + dependencies) or Docker mode (command + image). Provide exactly ONE of 'script' or 'command'.\n\nBEFORE submitting training/fine-tuning jobs:\n- You MUST have called github_find_examples + github_read_file to find a working reference implementation. Scripts based on your internal knowledge WILL use outdated APIs and fail.\n- You MUST have validated dataset format via hf_inspect_dataset or hub_repo_details.\n- If the job runs on GPU, or the script loads a model, uses CUDA, bf16/fp16, quantization, flash attention, or torch.compile, you MUST create a GPU sandbox with sandbox_create first, run a tiny smoke test there, and fix failures before submitting. If skipped, state why before calling hf_jobs.\n- Training config MUST include push_to_hub=True and hub_model_id. Job storage is EPHEMERAL \u2014 all files are deleted when the job ends. Without push_to_hub, trained models are lost permanently.\n- Include trackio monitoring and provide the dashboard URL to the user. When the script uses report_to='trackio', also pass `trackio_space_id` (e.g. '/ml-intern-<8char>') and `trackio_project` as tool args \u2014 they are injected as TRACKIO_SPACE_ID/TRACKIO_PROJECT env vars and let the UI embed the live dashboard.\n\nBATCH/ABLATION JOBS: Submit ONE job first. Check logs to confirm it starts training successfully. Only then submit the remaining jobs. Never submit all at once \u2014 if there's a bug, all jobs fail.\n\nOperations: run, ps, logs, inspect, cancel, scheduled run/ps/inspect/delete/suspend/resume.\n\nHardware: CPU: cpu-basic(2vCPU/16GB), cpu-upgrade(8vCPU/32GB). GPU: t4-small(4vCPU/15GB/GPU 16GB), t4-medium(8vCPU/30GB/GPU 16GB), a10g-small(4vCPU/15GB/GPU 24GB), a10g-large(12vCPU/46GB/GPU 24GB), a10g-largex2(24vCPU/92GB/GPU 48GB), a10g-largex4(48vCPU/184GB/GPU 96GB), a100-large(12vCPU/142GB/GPU 80GB), a100x4(48vCPU/568GB/GPU 320GB), a100x8(96vCPU/1136GB/GPU 640GB), l4x1(8vCPU/30GB/GPU 24GB), l4x4(48vCPU/186GB/GPU 96GB), l40sx1(8vCPU/62GB/GPU 48GB), l40sx4(48vCPU/382GB/GPU 192GB), l40sx8(192vCPU/1534GB/GPU 384GB).\nCommon picks: t4-small ($0.60/hr, 1-3B), a10g-large ($2/hr, 7-13B), a100-large ($4/hr, 30B+), h100 ($6/hr, 70B+). Note: a10g-small and a10g-large have the SAME 24GB GPU \u2014 the difference is CPU/RAM only.\n\nOOM RECOVERY: When a training job fails with CUDA OOM:\n1. Reduce per_device_train_batch_size and increase gradient_accumulation_steps proportionally (keep effective batch size identical)\n2. Enable gradient_checkpointing=True\n3. Upgrade to larger GPU (a10g\u2192a100\u2192h100)\nDo NOT switch training methods (e.g. full SFT to LoRA) or reduce max_length \u2014 those change what the user gets and require explicit approval.\n\nExamples:\nTraining: {'operation': 'run', 'script': '/app/train.py', 'dependencies': ['transformers', 'trl', 'torch', 'datasets', 'trackio'], 'hardware_flavor': 'a100-large', 'timeout': '8h'}\nMonitor: {'operation': 'ps'}, {'operation': 'logs', 'job_id': 'xxx'}, {'operation': 'cancel', 'job_id': 'xxx'}Docker: {'operation': 'run', 'command': ['duckdb', '-c', 'select 1 + 2'], 'image': 'duckdb/duckdb', 'hardware_flavor': 'cpu-basic', 'timeout': '1h'}\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "run", + "ps", + "logs", + "inspect", + "cancel", + "scheduled run", + "scheduled ps", + "scheduled inspect", + "scheduled delete", + "scheduled suspend", + "scheduled resume" + ], + "description": "Operation to execute." + }, + "script": { + "type": "string", + "description": "Python code, sandbox file path (e.g. '/app/train.py', './train.py', or bare 'train.py'), or URL. Triggers Python mode. For ML training: base this on a working example found via github_find_examples, not on internal knowledge. For GPU/model-loading training scripts, smoke-test in a GPU sandbox before submission. Mutually exclusive with 'command'." + }, + "dependencies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Pip packages to install. Include ALL required packages. Common training set: ['transformers', 'trl', 'torch', 'datasets', 'trackio', 'accelerate']. Only used with 'script'." + }, + "image": { + "type": "string", + "description": "Docker image. Optional \u2014 auto-selected if not provided. Use with 'command'." + }, + "command": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Command to execute as list. Triggers Docker mode. Mutually exclusive with 'script'." + }, + "hardware_flavor": { + "type": "string", + "description": "Hardware type. Sizing guide: 1-3B params \u2192 t4-small/a10g-small, 7-13B \u2192 a10g-large, 30B+ \u2192 a100-large, 70B+ \u2192 h100/h100x8. All options: CPU: ['cpu-basic', 'cpu-upgrade']. GPU: ['t4-small', 't4-medium', 'a10g-small', 'a10g-large', 'a10g-largex2', 'a10g-largex4', 'a100-large', 'a100x4', 'a100x8', 'l4x1', 'l4x4', 'l40sx1', 'l40sx4', 'l40sx8']." + }, + "timeout": { + "type": "string", + "description": "Maximum job runtime. MUST be >2h for any training job \u2014 default 30m kills training mid-run. Guidelines: 1-3B models: 3-4h, 7-13B: 6-8h, 30B+: 12-24h. Use 30m-1h only for quick data processing or inference tasks. Default: '30m'." + }, + "env": { + "type": "object", + "description": "Environment variables {'KEY': 'VALUE'}. HF_TOKEN is auto-included." + }, + "trackio_space_id": { + "type": "string", + "description": "Optional. The HF Space hosting the trackio dashboard for this run (e.g. '/ml-intern-<8char>', under YOUR HF namespace). Injected as TRACKIO_SPACE_ID env var and used by the UI to embed the live dashboard. Set this whenever the script uses report_to='trackio'. The Space is auto-created and seeded with the trackio dashboard before the job starts \u2014 DO NOT pre-create it via hf_repo_git, that produces an empty Space that breaks the embed." + }, + "trackio_project": { + "type": "string", + "description": "Optional. The trackio project name to log this run under. Injected as TRACKIO_PROJECT env var and used by the UI to filter the embedded dashboard to this project." + }, + "namespace": { + "type": "string", + "description": "Optional namespace to run the job under. Must be the caller's own account or an org they belong to. If omitted, defaults to the caller's personal account. Credits are billed against this namespace." + }, + "job_id": { + "type": "string", + "description": "Job ID. Required for: logs, inspect, cancel." + }, + "scheduled_job_id": { + "type": "string", + "description": "Scheduled job ID. Required for: scheduled inspect/delete/suspend/resume." + }, + "schedule": { + "type": "string", + "description": "Cron schedule or preset (@hourly, @daily, @weekly, @monthly). Required for: scheduled run." + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_files", + "description": "Read and write files in HF repos (models/datasets/spaces).\n\n## Operations\n- **list**: List files with sizes and structure\n- **read**: Read file content (text files only)\n- **upload**: Upload content to repo (can create PR)\n- **delete**: Delete files/folders (supports wildcards like *.tmp)\n\n## Use when\n- Need to see what files exist in a repo\n- Want to read config.json, README.md, or other text files\n- Uploading training scripts, configs, or results to a repo\n- Cleaning up temporary files from a repo\n\n## Examples\n{\"operation\": \"list\", \"repo_id\": \"meta-llama/Llama-2-7b\"}\n{\"operation\": \"read\", \"repo_id\": \"gpt2\", \"path\": \"config.json\"}\n{\"operation\": \"upload\", \"repo_id\": \"my-model\", \"path\": \"README.md\", \"content\": \"# My Model\"}\n{\"operation\": \"upload\", \"repo_id\": \"org/model\", \"path\": \"fix.py\", \"content\": \"...\", \"create_pr\": true}\n{\"operation\": \"delete\", \"repo_id\": \"my-model\", \"patterns\": [\"*.tmp\", \"logs/\"]}\n\n## Notes\n- For binary files (safetensors, bin), use list to see them but can't read content\n- upload/delete require approval (can overwrite/destroy data)\n- Use create_pr=true to propose changes instead of direct commit\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "list", + "read", + "upload", + "delete" + ], + "description": "Operation: list, read, upload, delete" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "revision": { + "type": "string", + "description": "Branch/tag/commit (default: main)" + }, + "path": { + "type": "string", + "description": "File path for read/upload" + }, + "content": { + "type": "string", + "description": "File content for upload" + }, + "patterns": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Patterns to delete (e.g., ['*.tmp', 'logs/'])" + }, + "create_pr": { + "type": "boolean", + "description": "Create PR instead of direct commit" + }, + "commit_message": { + "type": "string", + "description": "Custom commit message" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "hf_repo_git", + "description": "Git-like operations on HF repos: branches, tags, PRs, and repo management.\n\n## Operations\n**Branches:** create_branch, delete_branch, list_refs\n**Tags:** create_tag, delete_tag\n**PRs:** create_pr, list_prs, get_pr, merge_pr, close_pr, comment_pr, change_pr_status\n**Repo:** create_repo, update_repo\n\n## Use when\n- Creating feature branches for experiments\n- Tagging model versions (v1.0, v2.0)\n- Opening PRs to contribute to repos you don't own\n- Reviewing and merging PRs on your repos\n- Creating new model/dataset/space repos\n- Changing repo visibility (public/private) or gated access\n\n## Examples\n{\"operation\": \"list_refs\", \"repo_id\": \"my-model\"}\n{\"operation\": \"create_branch\", \"repo_id\": \"my-model\", \"branch\": \"experiment-v2\"}\n{\"operation\": \"create_tag\", \"repo_id\": \"my-model\", \"tag\": \"v1.0\", \"revision\": \"main\"}\n{\"operation\": \"create_pr\", \"repo_id\": \"org/model\", \"title\": \"Fix tokenizer config\"}\n{\"operation\": \"change_pr_status\", \"repo_id\": \"my-model\", \"pr_num\": 1, \"new_status\": \"open\"}\n{\"operation\": \"merge_pr\", \"repo_id\": \"my-model\", \"pr_num\": 3}\n{\"operation\": \"create_repo\", \"repo_id\": \"my-new-model\", \"private\": true}\n{\"operation\": \"update_repo\", \"repo_id\": \"my-model\", \"gated\": \"auto\"}\n\n## PR Workflow\n1. create_pr \u2192 creates draft PR (empty by default)\n2. Upload files with revision='refs/pr/N' to add commits\n3. change_pr_status with new_status='open' to publish (convert draft to open)\n4. merge_pr when ready\n\n## Notes\n- PR status: draft (default), open, merged, closed\n- delete_branch, delete_tag, merge_pr, create_repo, update_repo require approval\n- For spaces, create_repo needs space_sdk (gradio/streamlit/docker/static)\n- gated options: 'auto' (instant), 'manual' (review), false (open)\n", + "parameters": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": [ + "create_branch", + "delete_branch", + "create_tag", + "delete_tag", + "list_refs", + "create_pr", + "list_prs", + "get_pr", + "merge_pr", + "close_pr", + "comment_pr", + "change_pr_status", + "create_repo", + "update_repo" + ], + "description": "Operation to execute" + }, + "repo_id": { + "type": "string", + "description": "Repository ID (e.g., 'username/repo-name')" + }, + "repo_type": { + "type": "string", + "enum": [ + "model", + "dataset", + "space" + ], + "description": "Repository type (default: model)" + }, + "branch": { + "type": "string", + "description": "Branch name (create_branch, delete_branch)" + }, + "from_rev": { + "type": "string", + "description": "Create branch from this revision (default: main)" + }, + "tag": { + "type": "string", + "description": "Tag name (create_tag, delete_tag)" + }, + "revision": { + "type": "string", + "description": "Revision for tag (default: main)" + }, + "tag_message": { + "type": "string", + "description": "Tag description" + }, + "title": { + "type": "string", + "description": "PR title (create_pr)" + }, + "description": { + "type": "string", + "description": "PR description (create_pr)" + }, + "pr_num": { + "type": "integer", + "description": "PR/discussion number" + }, + "comment": { + "type": "string", + "description": "Comment text" + }, + "status": { + "type": "string", + "enum": [ + "open", + "closed", + "all" + ], + "description": "Filter PRs by status (list_prs)" + }, + "new_status": { + "type": "string", + "enum": [ + "open", + "closed" + ], + "description": "New status for PR/discussion (change_pr_status)" + }, + "private": { + "type": "boolean", + "description": "Make repo private (create_repo, update_repo)" + }, + "gated": { + "type": "string", + "enum": [ + "auto", + "manual", + "false" + ], + "description": "Gated access setting (update_repo)" + }, + "space_sdk": { + "type": "string", + "enum": [ + "gradio", + "streamlit", + "docker", + "static" + ], + "description": "Space SDK (required for create_repo with space)" + } + }, + "required": [ + "operation" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_find_examples", + "description": "Find working example scripts in GitHub repositories (from a list of predetermined directories e.g. examples/, scripts/, tutorials/, etc.). Uses fuzzy keyword matching.\n\nMANDATORY before writing any ML training, fine-tuning, or inference code. Your internal knowledge of library APIs is outdated \u2014 working examples show current API patterns.\n\nSequence: github_find_examples \u2192 github_read_file (study the example) \u2192 implement based on what you found.\n\nSkip this only for: simple data queries, status checks, non-code tasks.\n\nExamples:\n {keyword: 'sft', repo: 'trl'} \u2192 finds examples/scripts/sft.py\n {keyword: 'grpo', repo: 'trl'} \u2192 finds GRPO training examples\n {repo: 'trl', max_results: 20} \u2192 lists all available training method examples", + "parameters": { + "type": "object", + "properties": { + "keyword": { + "type": "string", + "description": "Keyword to fuzzy match against file paths (e.g., 'grpo', 'sft')." + }, + "repo": { + "type": "string", + "description": "Repository name (e.g., 'trl', 'transformers'). Required." + }, + "org": { + "type": "string", + "description": "GitHub organization or username. Default: 'huggingface'." + }, + "max_results": { + "type": "integer", + "description": "Maximum number of results to return. Default: 50." + }, + "min_score": { + "type": "integer", + "description": "Minimum fuzzy match score (0-100). Default: 60." + } + }, + "required": [ + "repo" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_list_repos", + "description": "List and discover repositories for GitHub organizations or users with flexible sorting. **Use when:** (1) Exploring what libraries exist for a task, (2) Finding the right library to use, (3) Discovering popular or active projects, (4) Checking recently updated repos for latest features, (5) Finding alternative libraries in an organization. **Pattern:** github_list_repos (discover libraries) \u2192 github_find_examples (find usage examples) \u2192 implement. Returns: Comprehensive repository information (stars, forks, language, topics, URLs), sorted by preference. **Then:** Use github_find_examples on selected repo to discover example code. Sorts by: stars (popularity), forks (community), updated (activity), created (age).\n\n## When to use this tool\n\n- When you need to find libraries to use in your implementation\n- When exploring what repositories exist for a task or domain\n- When debugging an error and looking up if others have similar issues in repos\n- When finding the most popular or actively maintained projects for a user/org\n## Examples\n\n\n// ML Workflow Step: Discover HF libraries for RLHF/alignment\n// Use case: Find the right library for training with human feedback\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'stars',\n limit: 10\n}\n// Returns: transformers, trl, peft, accelerate, diffusers...\n\n\n\n// ML Workflow Step: Check for recently updated HF repos\n// Use case: Find actively maintained libraries with latest features\n{\n owner: 'huggingface',\n owner_type: 'org',\n sort: 'updated',\n order: 'desc',\n limit: 15\n}\n// Helps identify which repos have recent improvements/fixes\n", + "parameters": { + "type": "object", + "properties": { + "owner": { + "type": "string", + "description": "GitHub username or organization name. Required." + }, + "owner_type": { + "type": "string", + "enum": [ + "user", + "org" + ], + "description": "Whether the owner is a 'user' or 'org'. Default: 'org'." + }, + "sort": { + "type": "string", + "enum": [ + "stars", + "forks", + "updated", + "created" + ], + "description": "Sort field. Options: 'stars', 'forks', 'updated', 'created'. Default: 'stars'." + }, + "order": { + "type": "string", + "enum": [ + "asc", + "desc" + ], + "description": "Sort order. Options: 'asc', 'desc'. Default: 'desc'." + }, + "limit": { + "type": "integer", + "description": "Maximum number of repositories to return. No limit if not specified. Default: 30." + } + }, + "required": [ + "owner" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "github_read_file", + "description": "Read file contents from GitHub repositories. Returns first 300 lines by default. Auto-converts Jupyter notebooks to markdown.\n\nUse AFTER github_find_examples to study the working implementation. The purpose is to learn current API patterns \u2014 imports, trainer configs, dataset handling \u2014 so your implementation uses correct, up-to-date code.\n\nUse line_start/line_end for large files (>300 lines) to read specific sections.\n\nWhen NOT to use: when you don't know the file path (use github_find_examples first).", + "parameters": { + "type": "object", + "properties": { + "repo": { + "type": "string", + "description": "Repository in format 'owner/repo' (e.g., 'github/github-mcp-server'). Required." + }, + "path": { + "type": "string", + "description": "Path to file in repository (e.g., 'src/index.js'). Required." + }, + "ref": { + "type": "string", + "description": "Git reference - branch name, tag, or commit SHA. Default: 'HEAD'." + }, + "line_start": { + "type": "integer", + "description": "Starting line number (1-indexed, inclusive). Optional." + }, + "line_end": { + "type": "integer", + "description": "Ending line number (1-indexed, inclusive). Optional." + } + }, + "required": [ + "repo", + "path" + ] + } + } + }, + { + "type": "function", + "function": { + "name": "find_hf_api", + "description": "Find HuggingFace Hub REST API endpoints to make HTTP requests. Returns curl examples with authentication. \u26a0\ufe0f USE THIS TOOL when you need to call the HF Hub API directly - for operations like: uploading/downloading files, managing repos, listing models/datasets, getting user info, managing webhooks, collections, discussions, or any Hub interaction not covered by other tools. **Use cases:** (1) 'Stream Space logs' \u2192 query='space logs', (2) 'Get Space metrics/Zero-GPU usage' \u2192 query='space metrics', (3) 'List organization members' \u2192 query='organization members', (4) 'Generate repo access token' \u2192 query='jwt token', (5) 'Check repo security scan' \u2192 query='security scan'. **Search modes:** Use 'query' for keyword search, 'tag' to browse a category, or both. If query finds no results, falls back to showing all endpoints in the tag. **Output:** Full endpoint details with method, path, parameters, curl command, and response schema.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "Keyword search across endpoint summaries, descriptions, and operation IDs. Examples: 'upload file', 'create repository', 'list user models', 'delete branch', 'webhook', 'collection', 'discussion comments'. Supports stemming (upload/uploading both work)." + }, + "tag": { + "type": "string", + "enum": [ + "agentic-provisioning", + "agents", + "auth", + "buckets", + "collections", + "container", + "datasets", + "discussions", + "docs", + "inference-endpoints", + "inference-providers", + "jobs", + "kernels", + "mcp", + "models", + "notifications", + "oauth", + "orgs", + "papers", + "repo-search", + "repos", + "resource-groups", + "scim", + "service-accounts", + "spaces", + "sql-console", + "users", + "webhooks" + ], + "description": "Filter by API category. Use alone to browse all endpoints in a category, or combine with 'query' to search within a category." + } + }, + "required": [] + } + } + } + ], + "upload_status": "failed", + "upload_url": null, + "last_save_time": "2026-06-12T11:40:56.908157", + "personal_upload_status": "failed" +} \ No newline at end of file diff --git a/backend/session_manager.py b/backend/session_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..f11a9a775e3924f5dddfe1d34de33755dc740649 --- /dev/null +++ b/backend/session_manager.py @@ -0,0 +1,2140 @@ +"""Session manager for handling multiple concurrent agent sessions.""" + +import asyncio +import json +import logging +import os +import uuid +from dataclasses import dataclass, field +from datetime import UTC, datetime, timedelta +from pathlib import Path +from typing import Any, Optional + +from agent.config import load_config +from agent.core.agent_loop import process_submission +from agent.core.model_ids import ( + KIMI_K26_MODEL_ID, + is_known_router_model_id, + strip_huggingface_model_prefix, +) +from agent.core.session import Event, OpType, Session +from agent.core.session_persistence import get_session_store +from agent.core.tools import ToolRouter +from agent.core.usage_thresholds import ( + USAGE_THRESHOLD_TOOL_NAME, + USAGE_WARNING_FIRST_THRESHOLD_USD, + is_usage_threshold_pending, + next_usage_warning_threshold, + normalize_usage_threshold, + usage_threshold_pending_to_tool, +) +from agent.core.yolo_budget import ( + YOLO_BUDGET_TOOL_NAME, + is_yolo_budget_pending, + request_yolo_budget_exceeded_approval, + seed_session_spend, + session_spend_usd, + yolo_budget_pending_to_tool, +) +from agent.messaging.gateway import NotificationGateway + +# Get project root (parent of backend directory) +PROJECT_ROOT = Path(__file__).parent.parent +DEFAULT_CONFIG_PATH = str(PROJECT_ROOT / "configs" / "frontend_agent_config.json") +USAGE_WARNING_SPEND_CACHE_TTL_SECONDS = 30.0 +USAGE_BILLING_REFRESH_TIMEOUT_SECONDS = 2.0 + + +# These dataclasses match agent/main.py structure +@dataclass +class Operation: + """Operation to be executed by the agent.""" + + op_type: OpType + data: Optional[dict[str, Any]] = None + + +@dataclass +class Submission: + """Submission to the agent loop.""" + + id: str + operation: Operation + + +logger = logging.getLogger(__name__) + + +class EventBroadcaster: + """Reads from the agent's event queue and fans out to SSE subscribers. + + Events that arrive when no subscribers are listening are discarded by + this in-memory fanout. Durable replay is handled by session_persistence. + """ + + def __init__(self, event_queue: asyncio.Queue): + self._source = event_queue + self._subscribers: dict[int, asyncio.Queue] = {} + self._counter = 0 + + def subscribe(self) -> tuple[int, asyncio.Queue]: + """Create a new subscriber. Returns (id, queue).""" + self._counter += 1 + sub_id = self._counter + q: asyncio.Queue = asyncio.Queue() + self._subscribers[sub_id] = q + return sub_id, q + + def unsubscribe(self, sub_id: int) -> None: + self._subscribers.pop(sub_id, None) + + async def run(self) -> None: + """Main loop β€” reads from source queue and broadcasts.""" + while True: + try: + event: Event = await self._source.get() + msg = { + "event_type": event.event_type, + "data": event.data, + "seq": event.seq, + } + for q in self._subscribers.values(): + await q.put(msg) + except asyncio.CancelledError: + break + except Exception as e: + logger.error(f"EventBroadcaster error: {e}") + + +@dataclass +class AgentSession: + """Wrapper for an agent session with its associated resources.""" + + session_id: str + session: Session + tool_router: ToolRouter + submission_queue: asyncio.Queue + user_id: str = "dev" # Owner of this session + surface: str = "frontend" # Origin surface: "frontend" (web UI) or "api" (/v1) + hf_username: str | None = None # HF namespace used for personal trace uploads + hf_token: str | None = None # User's HF OAuth token for tool execution + user_plan: str | None = None # Active HF account plan for plan-aware agent CTAs + task: asyncio.Task | None = None + created_at: datetime = field(default_factory=datetime.utcnow) + # Last genuine activity (submit/turn-start/turn-finish/direct user write). + # Drives the idle reaper. Defaults to load time so a freshly-restored but + # untouched session isn't reaped for a full idle window. + last_active_at: datetime = field(default_factory=datetime.utcnow) + is_active: bool = True + is_processing: bool = False # True while a submission is being executed + # Set under the lock by the reaper while tearing this session down. Blocks + # submit() from enqueueing onto a session that's being evicted. + is_reaping: bool = False + broadcaster: Any = None + title: str | None = None + usage_window_started_at: datetime | None = None + inference_billing_session_id: str | None = None + usage_warning_next_threshold_usd: float = USAGE_WARNING_FIRST_THRESHOLD_USD + usage_warning_spend_cache: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + if self.usage_window_started_at is None: + self.usage_window_started_at = self.created_at + if not self.inference_billing_session_id or not _is_uuid( + self.inference_billing_session_id + ): + self.inference_billing_session_id = new_inference_billing_session_id( + self.session_id, + self.usage_window_started_at, + ) + try: + self.session.inference_billing_session_id = ( + self.inference_billing_session_id + ) + except AttributeError: + pass + + +def new_inference_billing_session_id( + session_id: str, # noqa: ARG001 - kept for a stable call signature. + started_at: datetime | None = None, # noqa: ARG001 - kept for a stable call signature. +) -> str: + """Return a Router billing session ID scoped to one visible usage window.""" + return str(uuid.uuid4()) + + +def _is_uuid(value: str) -> bool: + try: + uuid.UUID(value) + except ValueError: + return False + return True + + +class SessionCapacityError(Exception): + """Raised when no more sessions can be created.""" + + def __init__(self, message: str, error_type: str = "global") -> None: + super().__init__(message) + self.error_type = error_type # "global" or "per_user" + + +# ── Capacity limits ───────────────────────────────────────────────── +# Sized for HF Spaces 8 vCPU / 32 GB RAM. +# Each session uses ~10-20 MB (context, tools, queues, task); 200 Γ— 20 MB +# = 4 GB worst case, leaving plenty of headroom for the Python runtime +# and per-request overhead. +MAX_SESSIONS: int = 200 +MAX_SESSIONS_PER_USER: int = 10 +DEFAULT_YOLO_COST_CAP_USD: float = 5.0 +SANDBOX_SHUTDOWN_CLEANUP_CONCURRENCY: int = 10 +SANDBOX_SHUTDOWN_CLEANUP_TIMEOUT_S: float = 60.0 + +# ── Idle-session reaper ───────────────────────────────────────────── +# A live session idle β‰₯ REAPER_IDLE_MINUTES with no in-flight work has its +# sandbox + RAM released and is evicted from the live pool, while staying +# fully resumable from Mongo (it reappears as a normal chat, never "ended"). +# This frees both the global pool and the user's concurrent slots. +REAPER_IDLE_MINUTES: float = float(os.environ.get("REAPER_IDLE_MINUTES", "15")) +REAPER_INTERVAL_S: float = float(os.environ.get("REAPER_INTERVAL_S", "300")) +REAP_TEARDOWN_TIMEOUT_S: float = float(os.environ.get("REAP_TEARDOWN_TIMEOUT_S", "30")) +REAPER_IDLE = timedelta(minutes=REAPER_IDLE_MINUTES) + + +class SessionManager: + """Manages multiple concurrent agent sessions.""" + + def __init__(self, config_path: str | None = None) -> None: + self.config = load_config(config_path or DEFAULT_CONFIG_PATH) + normalized_default = strip_huggingface_model_prefix(self.config.model_name) + if normalized_default: + self.config.model_name = normalized_default + self.messaging_gateway = NotificationGateway(self.config.messaging) + self.sessions: dict[str, AgentSession] = {} + self._lock = asyncio.Lock() + self.persistence_store = None + # In-flight create_session calls that have passed the capacity check + # but not yet inserted their session. Counted alongside + # active_session_count to hard-cap the global pool against the + # check-then-create race (see create_session). + self._pending_creates: int = 0 + self._reaper_task: asyncio.Task | None = None + + async def start(self) -> None: + """Start shared background resources.""" + self.persistence_store = get_session_store() + await self.persistence_store.init() + await self.messaging_gateway.start() + self._reaper_task = asyncio.create_task(self._reaper_loop()) + + async def close(self) -> None: + """Flush and close shared background resources.""" + if self._reaper_task is not None: + self._reaper_task.cancel() + try: + await self._reaper_task + except asyncio.CancelledError: + pass + self._reaper_task = None + await self._cleanup_all_sandboxes_on_close() + await self.messaging_gateway.close() + if self.persistence_store is not None: + await self.persistence_store.close() + + def _store(self): + if self.persistence_store is None: + self.persistence_store = get_session_store() + return self.persistence_store + + def _count_user_sessions(self, user_id: str) -> int: + """Count active sessions owned by a specific user.""" + return sum( + 1 for s in self.sessions.values() if s.user_id == user_id and s.is_active + ) + + @staticmethod + def _touch(agent_session: "AgentSession") -> None: + """Stamp genuine activity so the idle reaper's clock resets. + + Call on real user/agent activity (submit, turn start/finish, direct + user-initiated writes) β€” never on passive reads or hydration, which + would keep an otherwise-idle session alive forever. + """ + agent_session.last_active_at = datetime.utcnow() + + @staticmethod + def _model_from_saved_metadata( + model: str | None, + ) -> str: + normalized = strip_huggingface_model_prefix(model) + if normalized and is_known_router_model_id(normalized): + return normalized + + fallback_model = KIMI_K26_MODEL_ID + logger.warning( + "Saved session model %r failed validation; using %r", + model, + fallback_model, + ) + return fallback_model + + def _create_session_sync( + self, + *, + session_id: str, + user_id: str, + hf_username: str | None, + hf_token: str | None, + user_plan: str | None, + model: str | None, + event_queue: asyncio.Queue, + notification_destinations: list[str] | None = None, + ) -> tuple[ToolRouter, Session]: + """Build blocking per-session resources in a worker thread.""" + import time as _time + + t0 = _time.monotonic() + tool_router = ToolRouter(self.config.mcpServers, hf_token=hf_token) + # Deep-copy config so each session's model switches independently β€” + # tab A picking GLM doesn't flip tab B off the default model. + session_config = self.config.model_copy(deep=True) + normalized_model = strip_huggingface_model_prefix(model) + if normalized_model: + session_config.model_name = normalized_model + session = Session( + event_queue=event_queue, + config=session_config, + tool_router=tool_router, + hf_token=hf_token, + user_id=user_id, + hf_username=hf_username, + user_plan=user_plan, + notification_gateway=self.messaging_gateway, + notification_destinations=notification_destinations or [], + session_id=session_id, + persistence_store=self._store(), + ) + t1 = _time.monotonic() + logger.info("Session initialized in %.2fs", t1 - t0) + return tool_router, session + + def _serialize_messages(self, session: Session) -> list[dict[str, Any]]: + return [msg.model_dump(mode="json") for msg in session.context_manager.items] + + def _serialize_pending_approval(self, session: Session) -> list[dict[str, Any]]: + pending = session.pending_approval or {} + if is_usage_threshold_pending(pending) or is_yolo_budget_pending(pending): + return [dict(pending)] + tool_calls = pending.get("tool_calls") or [] + serialized: list[dict[str, Any]] = [] + for tc in tool_calls: + if hasattr(tc, "model_dump"): + serialized.append(tc.model_dump(mode="json")) + elif isinstance(tc, dict): + serialized.append(tc) + return serialized + + @staticmethod + def _pending_tools_for_api(session: Session) -> list[dict[str, Any]] | None: + pending = session.pending_approval or {} + if is_usage_threshold_pending(pending): + return [usage_threshold_pending_to_tool(pending)] + if is_yolo_budget_pending(pending): + return [yolo_budget_pending_to_tool(pending)] + tool_calls = pending.get("tool_calls") or [] + if not tool_calls: + return None + result: list[dict[str, Any]] = [] + for tc in tool_calls: + try: + args = json.loads(tc.function.arguments) + except (json.JSONDecodeError, AttributeError, TypeError): + args = {} + result.append( + { + "tool": getattr(tc.function, "name", None), + "tool_call_id": getattr(tc, "id", None), + "arguments": args, + } + ) + return result + + def _restore_pending_approval( + self, session: Session, pending_approval: list[dict[str, Any]] | None + ) -> None: + if not pending_approval: + session.pending_approval = None + return + first = pending_approval[0] + if isinstance(first, dict) and first.get("kind") in { + USAGE_THRESHOLD_TOOL_NAME, + YOLO_BUDGET_TOOL_NAME, + }: + session.pending_approval = dict(first) + return + from litellm import ChatCompletionMessageToolCall as ToolCall + + restored = [] + for raw in pending_approval: + try: + if "function" in raw: + restored.append(ToolCall(**raw)) + else: + restored.append( + ToolCall( + id=raw["tool_call_id"], + type="function", + function={ + "name": raw["tool"], + "arguments": json.dumps(raw.get("arguments") or {}), + }, + ) + ) + except Exception as e: + logger.warning("Dropping malformed pending approval: %s", e) + session.pending_approval = {"tool_calls": restored} if restored else None + + @staticmethod + def _pending_docs_for_api( + pending_approval: list[dict[str, Any]] | None, + ) -> list[dict[str, Any]] | None: + if not pending_approval: + return None + first = pending_approval[0] + if isinstance(first, dict) and first.get("kind") == USAGE_THRESHOLD_TOOL_NAME: + return [usage_threshold_pending_to_tool(first)] + if isinstance(first, dict) and first.get("kind") == YOLO_BUDGET_TOOL_NAME: + return [yolo_budget_pending_to_tool(first)] + result: list[dict[str, Any]] = [] + for raw in pending_approval: + if "function" in raw: + function = raw.get("function") or {} + try: + args = json.loads(function.get("arguments") or "{}") + except (json.JSONDecodeError, TypeError): + args = {} + result.append( + { + "tool": function.get("name"), + "tool_call_id": raw.get("id"), + "arguments": args, + } + ) + elif {"tool", "tool_call_id"}.issubset(raw): + result.append( + { + "tool": raw.get("tool"), + "tool_call_id": raw.get("tool_call_id"), + "arguments": raw.get("arguments") or {}, + } + ) + return result or None + + @staticmethod + def _runtime_state(agent_session: AgentSession) -> str: + if agent_session.session.pending_approval: + return "waiting_approval" + if agent_session.is_processing: + return "processing" + if not agent_session.is_active: + return "ended" + return "idle" + + @staticmethod + def _auto_approval_summary(session: Session) -> dict[str, Any]: + if hasattr(session, "auto_approval_policy_summary"): + return session.auto_approval_policy_summary() + cap = getattr(session, "auto_approval_cost_cap_usd", None) + estimated = float( + getattr(session, "auto_approval_estimated_spend_usd", 0.0) or 0.0 + ) + remaining = None if cap is None else round(max(0.0, float(cap) - estimated), 4) + return { + "enabled": bool(getattr(session, "auto_approval_enabled", False)), + "cost_cap_usd": cap, + "estimated_spend_usd": round(estimated, 4), + "remaining_usd": remaining, + } + + def _install_usage_threshold_checker(self, agent_session: AgentSession) -> None: + threshold = normalize_usage_threshold( + getattr( + agent_session.session, + "usage_warning_next_threshold_usd", + agent_session.usage_warning_next_threshold_usd, + ) + ) + agent_session.usage_warning_next_threshold_usd = threshold + agent_session.session.usage_warning_next_threshold_usd = threshold + + async def _checker(payload: dict[str, Any]) -> bool: + return await self._maybe_request_usage_threshold_approval( + agent_session.session_id, + payload, + ) + + agent_session.session.usage_threshold_checker = _checker + + def _install_yolo_budget_checker(self, agent_session: AgentSession) -> None: + async def _checker(payload: dict[str, Any]) -> bool: + return await self._maybe_request_yolo_budget_approval( + agent_session.session_id, + payload, + ) + + agent_session.session.yolo_budget_checker = _checker + + @staticmethod + def _set_inference_billing_session_id( + agent_session: AgentSession, + inference_billing_session_id: str, + ) -> None: + agent_session.inference_billing_session_id = inference_billing_session_id + try: + agent_session.session.inference_billing_session_id = ( + inference_billing_session_id + ) + except AttributeError: + pass + + @staticmethod + def _usage_spend_from_response(response: dict[str, Any]) -> tuple[float, str]: + def coerce_spend(value: Any) -> float | None: + if isinstance(value, bool) or value is None: + return None + try: + return max(0.0, float(value)) + except (TypeError, ValueError): + return None + + hf_account = response.get("hf_account") + session_bucket = response.get("session") + if isinstance(hf_account, dict): + current_session = hf_account.get("current_session") + if isinstance(current_session, dict): + spend = coerce_spend( + current_session.get("inference_providers_usd") + if "inference_providers_usd" in current_session + else current_session.get("total_usd") + ) + if spend is not None: + if isinstance(session_bucket, dict): + for key in ( + "hf_jobs_estimated_usd", + "sandbox_estimated_usd", + ): + spend += coerce_spend(session_bucket.get(key)) or 0.0 + return spend, "hf_billing_current_session" + + if isinstance(session_bucket, dict): + spend = coerce_spend(session_bucket.get("total_usd")) + if spend is not None: + return spend, "app_telemetry_session" + return 0.0, "app_telemetry_session" + + async def _current_session_usage_spend( + self, + agent_session: AgentSession, + *, + use_cache: bool = True, + ) -> tuple[float, str]: + now = datetime.now(UTC) + cache = agent_session.usage_warning_spend_cache + cache_expires_at = cache.get("expires_at") + if ( + use_cache + and isinstance(cache_expires_at, datetime) + and cache_expires_at > now + ): + return ( + float(cache.get("spend_usd") or 0.0), + str(cache.get("billing_source") or "app_telemetry_session"), + ) + + from usage import build_usage_response + + response = await build_usage_response( + self, + user_id=agent_session.user_id, + hf_token=agent_session.hf_token, + session_id=agent_session.session_id, + timezone_name="UTC", + ) + spend, billing_source = self._usage_spend_from_response(response) + agent_session.usage_warning_spend_cache = { + "spend_usd": spend, + "billing_source": billing_source, + "expires_at": now + + timedelta(seconds=USAGE_WARNING_SPEND_CACHE_TTL_SECONDS), + } + return spend, billing_source + + @staticmethod + def _fallback_hf_billing_snapshot(error: str) -> dict[str, Any]: + return { + "billing_scope": "account_window_delta", + "hf_billing": { + "source": "hf_billing_usage_v2", + "available": False, + "error": error, + "current_session": None, + }, + } + + async def refresh_session_usage_metrics( + self, + agent_session: AgentSession, + *, + error_code: str = "billing_snapshot_error", + billing_timeout_s: float | None = USAGE_BILLING_REFRESH_TIMEOUT_SECONDS, + ) -> dict[str, Any]: + """Refresh the dataset usage snapshot stored on the runtime session.""" + from agent.core.usage_metrics import ( + normalize_hf_billing_snapshot, + summarize_usage_events, + ) + from usage import build_hf_billing_snapshot + + session = agent_session.session + try: + billing_snapshot = build_hf_billing_snapshot( + self, + hf_token=agent_session.hf_token or getattr(session, "hf_token", None), + session_id=agent_session.session_id, + timezone_name="UTC", + ) + if billing_timeout_s is not None and billing_timeout_s > 0: + hf_billing_snapshot = await asyncio.wait_for( + billing_snapshot, + timeout=billing_timeout_s, + ) + else: + hf_billing_snapshot = await billing_snapshot + except TimeoutError: + logger.debug( + "HF billing snapshot refresh timed out for %s after %.2fs", + agent_session.session_id, + billing_timeout_s or 0, + ) + hf_billing_snapshot = self._fallback_hf_billing_snapshot(error_code) + except Exception as e: + logger.debug( + "HF billing snapshot refresh failed for %s: %s", + agent_session.session_id, + e, + ) + hf_billing_snapshot = self._fallback_hf_billing_snapshot(error_code) + + hf_billing_snapshot = normalize_hf_billing_snapshot(hf_billing_snapshot) + session.usage_hf_billing_snapshot = hf_billing_snapshot + metrics = summarize_usage_events( + getattr(session, "logged_events", []) or [], + session_id=agent_session.session_id, + hf_billing_snapshot=hf_billing_snapshot, + ) + session.usage_metrics = metrics + return metrics + + @staticmethod + def _runtime_session_usage_spend(agent_session: AgentSession) -> float: + from usage import aggregate_usage_events, event_created_at + + window_start = agent_session.usage_window_started_at + if isinstance(window_start, datetime): + if window_start.tzinfo is None: + window_start = window_start.replace(tzinfo=UTC) + else: + window_start = window_start.astimezone(UTC) + events = [] + for raw_event in getattr(agent_session.session, "logged_events", []) or []: + if raw_event.get("event_type") not in { + "llm_call", + "hf_job_complete", + "sandbox_create", + "sandbox_destroy", + }: + continue + if isinstance(window_start, datetime): + created_at = event_created_at(raw_event, timezone_name="UTC") + if created_at is not None and created_at < window_start: + continue + events.append(raw_event) + bucket = aggregate_usage_events( + events, + session_id=agent_session.session_id, + ) + return float(bucket.get("total_usd") or 0.0) + + async def _maybe_request_usage_threshold_approval( + self, + session_id: str, + continuation_payload: dict[str, Any], + ) -> bool: + agent_session = self.sessions.get(session_id) + if not agent_session or not agent_session.is_active: + return False + + session = agent_session.session + if session.pending_approval: + return False + + threshold = normalize_usage_threshold( + getattr( + session, + "usage_warning_next_threshold_usd", + agent_session.usage_warning_next_threshold_usd, + ) + ) + force_check = bool(continuation_payload.get("force_check")) + local_spend = self._runtime_session_usage_spend(agent_session) + if not force_check and local_spend < threshold: + return False + + current_spend, billing_source = await self._current_session_usage_spend( + agent_session, + use_cache=not force_check, + ) + if current_spend < threshold: + return False + + next_threshold = next_usage_warning_threshold(current_spend, threshold) + tool_call_id = f"usage-threshold-{uuid.uuid4().hex[:10]}" + pending: dict[str, Any] = { + "kind": USAGE_THRESHOLD_TOOL_NAME, + "tool_call_id": tool_call_id, + "threshold_usd": round(threshold, 4), + "current_spend_usd": round(current_spend, 6), + "next_threshold_usd": next_threshold, + "billing_source": billing_source, + "continuation": continuation_payload.get("continuation") + or "continue_agent", + "history_size": int( + continuation_payload.get("history_size") + or len(session.context_manager.items) + ), + } + final_response = continuation_payload.get("final_response") + if isinstance(final_response, str): + pending["final_response"] = final_response + + session.pending_approval = pending + self._touch(agent_session) + await session.send_event( + Event( + event_type="approval_required", + data={ + "tools": [usage_threshold_pending_to_tool(pending)], + "count": 1, + "usage_threshold": True, + }, + ) + ) + return True + + async def _maybe_request_yolo_budget_approval( + self, + session_id: str, + payload: dict[str, Any], + ) -> bool: + agent_session = self.sessions.get(session_id) + if not agent_session or not agent_session.is_active: + return False + + session = agent_session.session + if session.pending_approval: + return False + if not bool(getattr(session, "auto_approval_enabled", False)): + return False + cap = getattr(session, "auto_approval_cost_cap_usd", None) + if cap is None: + return False + try: + cap_usd = max(0.0, float(cap)) + except (TypeError, ValueError): + return False + + current_spend, billing_source = await self._current_session_usage_spend( + agent_session, + use_cache=False, + ) + raw_observed_cost = payload.get("observed_cost_usd") + observed_cost = ( + max(0.0, float(raw_observed_cost)) + if isinstance(raw_observed_cost, (int, float)) + and not isinstance(raw_observed_cost, bool) + else 0.0 + ) + previous_ledger_spend = session_spend_usd(session) + seed_session_spend(session, current_spend) + ledger_spend = session_spend_usd(session) + effective_spend = max(current_spend, ledger_spend) + if effective_spend < cap_usd: + if ledger_spend != previous_ledger_spend or observed_cost > 0: + self._touch(agent_session) + await session.send_event( + Event( + event_type="session_update", + data={ + "session_id": session_id, + "auto_approval": self._auto_approval_summary(session), + }, + ) + ) + return False + + spend_kind = str(payload.get("spend_kind") or "session usage") + final_response = payload.get("final_response") + created = await request_yolo_budget_exceeded_approval( + session, + spend_kind=spend_kind, + current_spend_usd=effective_spend, + cap_usd=cap_usd, + billing_source=billing_source, + continuation=payload.get("continuation"), + final_response=final_response if isinstance(final_response, str) else None, + history_size=payload.get("history_size"), + reason=( + "YOLO cap paused session usage after " + f"{spend_kind}: current session spend ${effective_spend:.2f} " + f"has reached the ${cap_usd:.2f} cap." + ), + ) + if created: + self._touch(agent_session) + return created + + async def _start_agent_session( + self, + *, + agent_session: AgentSession, + event_queue: asyncio.Queue, + tool_router: ToolRouter, + ) -> AgentSession: + async with self._lock: + existing = self.sessions.get(agent_session.session_id) + if existing: + return existing + self.sessions[agent_session.session_id] = agent_session + + task = asyncio.create_task( + self._run_session( + agent_session.session_id, + agent_session.submission_queue, + event_queue, + tool_router, + ) + ) + agent_session.task = task + return agent_session + + @staticmethod + def _start_cpu_sandbox_preload(agent_session: AgentSession) -> None: + """Kick off a best-effort cpu-basic sandbox for the session.""" + try: + from agent.tools.sandbox_tool import start_cpu_sandbox_preload + + start_cpu_sandbox_preload(agent_session.session) + except Exception as e: + logger.warning( + "Failed to start CPU sandbox preload for %s: %s", + agent_session.session_id, + e, + ) + + @staticmethod + def _can_access_session(agent_session: AgentSession, user_id: str) -> bool: + return ( + user_id == "dev" + or agent_session.user_id == "dev" + or agent_session.user_id == user_id + ) + + @staticmethod + def _update_hf_identity( + agent_session: AgentSession, + *, + hf_token: str | None, + hf_username: str | None, + user_plan: str | None = None, + ) -> None: + if hf_token: + agent_session.hf_token = hf_token + agent_session.session.hf_token = hf_token + if hf_username: + agent_session.hf_username = hf_username + agent_session.session.hf_username = hf_username + if user_plan is not None: + agent_session.user_plan = user_plan + agent_session.session.user_plan = user_plan + + @staticmethod + def _has_active_sandbox_preload(agent_session: AgentSession) -> bool: + task = getattr(agent_session.session, "sandbox_preload_task", None) + return bool(task and not task.done()) + + @staticmethod + def _preload_failed_for_missing_hf_token(agent_session: AgentSession) -> bool: + error = getattr(agent_session.session, "sandbox_preload_error", None) + return isinstance(error, str) and error.startswith("No HF token available") + + def _restart_cpu_preload_if_token_recovered( + self, + agent_session: AgentSession, + *, + preload_sandbox: bool, + ) -> None: + if not preload_sandbox: + return + session = agent_session.session + if getattr(session, "sandbox", None): + return + if self._has_active_sandbox_preload(agent_session): + return + if not (agent_session.hf_token or getattr(session, "hf_token", None)): + return + + if not self._preload_failed_for_missing_hf_token(agent_session): + return + + session.sandbox_preload_error = None + session.sandbox_preload_task = None + session.sandbox_preload_cancel_event = None + self._start_cpu_sandbox_preload(agent_session) + + async def _clear_persisted_sandbox_metadata(self, session_id: str) -> None: + try: + await self._store().update_session_fields( + session_id, + sandbox_space_id=None, + sandbox_hardware=None, + sandbox_owner=None, + sandbox_created_at=None, + sandbox_status="destroyed", + ) + except Exception as e: + logger.warning("Failed to clear sandbox metadata for %s: %s", session_id, e) + + async def _cleanup_persisted_sandbox( + self, + session_id: str, + metadata: dict[str, Any], + *, + hf_token: str | None, + ) -> None: + """Delete a sandbox recorded by a previous backend process, if any.""" + space_id = metadata.get("sandbox_space_id") + if not isinstance(space_id, str) or not space_id: + return + if metadata.get("sandbox_status") == "destroyed": + return + + tokens: list[tuple[str, str]] = [] + seen: set[str] = set() + for label, token in ( + ("user", hf_token), + ("admin", os.environ.get("HF_ADMIN_TOKEN")), + ): + if token and token not in seen: + tokens.append((label, token)) + seen.add(token) + + if not tokens: + logger.warning( + "Cannot clean persisted sandbox %s for session %s: no HF token available", + space_id, + session_id, + ) + return + + last_err: Exception | None = None + for label, token in tokens: + try: + from huggingface_hub import HfApi + + api = HfApi(token=token) + await asyncio.to_thread( + api.delete_repo, + repo_id=space_id, + repo_type="space", + ) + logger.info( + "Deleted persisted sandbox %s for session %s with %s token", + space_id, + session_id, + label, + ) + await self._clear_persisted_sandbox_metadata(session_id) + return + except Exception as e: + status_code = getattr(getattr(e, "response", None), "status_code", None) + if status_code == 404: + logger.info( + "Persisted sandbox %s for session %s is already gone", + space_id, + session_id, + ) + await self._clear_persisted_sandbox_metadata(session_id) + return + last_err = e + + logger.warning( + "Failed to delete persisted sandbox %s for session %s: %s", + space_id, + session_id, + last_err, + ) + + async def persist_session_snapshot( + self, + agent_session: AgentSession, + *, + runtime_state: str | None = None, + status: str = "active", + raise_on_error: bool = False, + ) -> None: + """Persist the current runtime context snapshot. + + Best-effort by default: a disabled store is a no-op and write failures + are swallowed. Pass ``raise_on_error=True`` when the caller must know + the snapshot was durably written (e.g. the reaper, which only evicts a + session after confirming it stayed resumable) β€” then a disabled store + or a write failure raises instead of silently dropping the snapshot. + """ + store = self._store() + if not getattr(store, "enabled", False): + if raise_on_error: + raise RuntimeError("persistence store is disabled") + return + try: + await store.save_snapshot( + session_id=agent_session.session_id, + user_id=agent_session.user_id, + model=agent_session.session.config.model_name, + title=agent_session.title, + surface=agent_session.surface, + messages=self._serialize_messages(agent_session.session), + runtime_state=runtime_state or self._runtime_state(agent_session), + status=status, + turn_count=agent_session.session.turn_count, + pending_approval=self._serialize_pending_approval( + agent_session.session + ), + created_at=agent_session.created_at, + usage_window_started_at=agent_session.usage_window_started_at, + inference_billing_session_id=( + agent_session.inference_billing_session_id + ), + notification_destinations=list( + agent_session.session.notification_destinations + ), + auto_approval_enabled=bool( + getattr(agent_session.session, "auto_approval_enabled", False) + ), + auto_approval_cost_cap_usd=getattr( + agent_session.session, "auto_approval_cost_cap_usd", None + ), + auto_approval_estimated_spend_usd=float( + getattr( + agent_session.session, + "auto_approval_estimated_spend_usd", + 0.0, + ) + or 0.0 + ), + usage_warning_next_threshold_usd=normalize_usage_threshold( + getattr( + agent_session.session, + "usage_warning_next_threshold_usd", + agent_session.usage_warning_next_threshold_usd, + ) + ), + raise_on_error=raise_on_error, + ) + except Exception as e: + if raise_on_error: + raise + logger.warning( + "Failed to persist snapshot for %s: %s", + agent_session.session_id, + e, + ) + + async def ensure_session_loaded( + self, + session_id: str, + user_id: str, + hf_token: str | None = None, + hf_username: str | None = None, + user_plan: str | None = None, + preload_sandbox: bool = True, + ) -> AgentSession | None: + """Return a live runtime session, lazily restoring it from Mongo.""" + async with self._lock: + existing = self.sessions.get(session_id) + if existing: + if self._can_access_session(existing, user_id): + self._update_hf_identity( + existing, + hf_token=hf_token, + hf_username=hf_username, + user_plan=user_plan, + ) + self._install_usage_threshold_checker(existing) + self._install_yolo_budget_checker(existing) + self._restart_cpu_preload_if_token_recovered( + existing, + preload_sandbox=preload_sandbox, + ) + return existing + return None + + store = self._store() + loaded = await store.load_session(session_id) + if not loaded: + return None + + async with self._lock: + existing = self.sessions.get(session_id) + if existing: + if self._can_access_session(existing, user_id): + self._update_hf_identity( + existing, + hf_token=hf_token, + hf_username=hf_username, + user_plan=user_plan, + ) + self._install_usage_threshold_checker(existing) + self._install_yolo_budget_checker(existing) + self._restart_cpu_preload_if_token_recovered( + existing, + preload_sandbox=preload_sandbox, + ) + return existing + return None + + meta = loaded.get("metadata") or {} + owner = str(meta.get("user_id") or "") + if user_id != "dev" and owner != "dev" and owner != user_id: + return None + + await self._cleanup_persisted_sandbox( + session_id, + meta, + hf_token=hf_token, + ) + + from litellm import Message + + model = self._model_from_saved_metadata( + meta.get("model") or self.config.model_name, + ) + event_queue: asyncio.Queue = asyncio.Queue() + submission_queue: asyncio.Queue = asyncio.Queue() + tool_router, session = await asyncio.to_thread( + self._create_session_sync, + session_id=session_id, + user_id=owner or user_id, + hf_username=hf_username, + hf_token=hf_token, + user_plan=user_plan, + model=model, + event_queue=event_queue, + notification_destinations=meta.get("notification_destinations") or [], + ) + + restored_messages: list[Message] = [] + for raw in loaded.get("messages") or []: + if not isinstance(raw, dict) or raw.get("role") == "system": + continue + try: + restored_messages.append(Message.model_validate(raw)) + except Exception as e: + logger.warning("Dropping malformed restored message: %s", e) + if restored_messages: + # Keep the freshly-rendered system prompt, then attach the durable + # non-system context so tools/date/user context stay current. + session.context_manager.items = [ + session.context_manager.items[0], + *restored_messages, + ] + + # If this session ever had a sandbox, its container did not survive the + # resume (a fresh, empty one is lazily recreated). Tell the agent so it + # recreates files/packages instead of assuming /app/train.py et al. still + # exist. Gated on sandbox_status so pure Q&A chats get no note. Mirrors + # the seed_from_summary note convention. + # + # Skip it when an approval is pending: the restored context ends with an + # assistant tool-call message awaiting results, so injecting a user + # message here would sit between the tool_calls and their results. On + # approval the real results get appended after the note, leaving them + # orphaned (the context manager stubs the "missing" result right after + # the assistant message) β€” which the provider rejects. The agent still + # learns the sandbox is empty when the approved tool runs against it. + if meta.get("sandbox_status") and not meta.get("pending_approval"): + session.context_manager.items.append( + Message( + role="user", + content=( + "[SYSTEM: This session was resumed and its sandbox was " + "reset. Any files, installed packages, or running " + "processes from earlier are gone β€” recreate what you " + "need before using the sandbox.]" + ), + ) + ) + + self._restore_pending_approval(session, meta.get("pending_approval") or []) + session.turn_count = int(meta.get("turn_count") or 0) + session.auto_approval_enabled = bool(meta.get("auto_approval_enabled", False)) + raw_cap = meta.get("auto_approval_cost_cap_usd") + session.auto_approval_cost_cap_usd = ( + float(raw_cap) if isinstance(raw_cap, int | float) else None + ) + session.auto_approval_estimated_spend_usd = float( + meta.get("auto_approval_estimated_spend_usd") or 0.0 + ) + session.usage_warning_next_threshold_usd = normalize_usage_threshold( + meta.get("usage_warning_next_threshold_usd") + ) + + created_at = meta.get("created_at") + if not isinstance(created_at, datetime): + created_at = datetime.utcnow() + usage_window_started_at = meta.get("usage_window_started_at") + if not isinstance(usage_window_started_at, datetime): + usage_window_started_at = created_at + inference_billing_session_id = meta.get("inference_billing_session_id") + if not isinstance(inference_billing_session_id, str) or not _is_uuid( + inference_billing_session_id + ): + inference_billing_session_id = new_inference_billing_session_id( + session_id, + usage_window_started_at, + ) + + agent_session = AgentSession( + session_id=session_id, + session=session, + tool_router=tool_router, + submission_queue=submission_queue, + user_id=owner or user_id, + surface=str(meta.get("surface") or "frontend"), + hf_username=hf_username, + hf_token=hf_token, + user_plan=user_plan, + created_at=created_at, + usage_window_started_at=usage_window_started_at, + inference_billing_session_id=inference_billing_session_id, + usage_warning_next_threshold_usd=session.usage_warning_next_threshold_usd, + is_active=True, + is_processing=False, + title=meta.get("title"), + ) + self._install_usage_threshold_checker(agent_session) + self._install_yolo_budget_checker(agent_session) + started = await self._start_agent_session( + agent_session=agent_session, + event_queue=event_queue, + tool_router=tool_router, + ) + if started is not agent_session: + self._update_hf_identity( + started, + hf_token=hf_token, + hf_username=hf_username, + user_plan=user_plan, + ) + return started + if preload_sandbox: + self._start_cpu_sandbox_preload(agent_session) + logger.info("Restored session %s for user %s", session_id, owner or user_id) + return agent_session + + async def create_session( + self, + user_id: str = "dev", + hf_username: str | None = None, + hf_token: str | None = None, + user_plan: str | None = None, + model: str | None = None, + is_pro: bool | None = None, + surface: str = "frontend", + ) -> str: + """Create a new agent session and return its ID. + + Session() and ToolRouter() constructors contain blocking I/O + (e.g. HfApi().whoami(), litellm.get_max_tokens()) so they are + executed in a thread pool to avoid freezing the async event loop. + + Args: + user_id: The ID of the user who owns this session. + hf_username: The HF username/namespace used for personal trace uploads. + hf_token: The user's HF OAuth token, stored for tool execution. + user_plan: The active HF account plan used for plan-aware agent CTAs. + model: Optional model override. When set, replaces ``model_name`` + on the per-session config clone. None falls back to the + config default. + + Raises: + SessionCapacityError: If the server or user has reached the + maximum number of live sessions. + """ + # ── Capacity checks ────────────────────────────────────────── + # Reserve a global slot under the lock so concurrent creates can't all + # pass the check then over-admit past MAX_SESSIONS (the build + insert + # happen later, outside the lock). active_session_count won't reflect + # this session until _start_agent_session inserts it, so we count + # _pending_creates alongside it to close that gap. + async with self._lock: + active_count = self.active_session_count + projected = active_count + self._pending_creates + if projected >= MAX_SESSIONS: + raise SessionCapacityError( + f"Server is at capacity ({projected}/{MAX_SESSIONS} sessions). " + "Please try again later.", + error_type="global", + ) + if user_id != "dev": + user_count = self._count_user_sessions(user_id) + if user_count >= MAX_SESSIONS_PER_USER: + raise SessionCapacityError( + f"You have reached the maximum of {MAX_SESSIONS_PER_USER} " + f"live sessions. Close an existing session, or wait " + f"{REAPER_IDLE_MINUTES:g} minutes after your last activity " + "for an idle session to be released.", + error_type="per_user", + ) + self._pending_creates += 1 + + session_id = str(uuid.uuid4()) + + # Create queues for this session + submission_queue: asyncio.Queue = asyncio.Queue() + event_queue: asyncio.Queue = asyncio.Queue() + + reserved = True + try: + # Run blocking constructors in a thread to keep the event loop responsive. + tool_router, session = await asyncio.to_thread( + self._create_session_sync, + session_id=session_id, + user_id=user_id, + hf_username=hf_username, + hf_token=hf_token, + user_plan=user_plan, + model=model, + event_queue=event_queue, + ) + + # Create wrapper + agent_session = AgentSession( + session_id=session_id, + session=session, + tool_router=tool_router, + submission_queue=submission_queue, + user_id=user_id, + surface=surface, + hf_username=hf_username, + hf_token=hf_token, + user_plan=user_plan, + ) + self._install_usage_threshold_checker(agent_session) + self._install_yolo_budget_checker(agent_session) + + await self._start_agent_session( + agent_session=agent_session, + event_queue=event_queue, + tool_router=tool_router, + ) + # The session is now in self.sessions, so active_session_count + # reflects it β€” release the reservation before the slower (and + # non-capacity) persistence + preload work. + async with self._lock: + self._pending_creates -= 1 + reserved = False + + await self.persist_session_snapshot(agent_session, runtime_state="idle") + self._start_cpu_sandbox_preload(agent_session) + + if is_pro is not None and user_id and user_id != "dev": + await self._track_pro_status(agent_session, is_pro=is_pro) + + logger.info(f"Created session {session_id} for user {user_id}") + return session_id + finally: + # Build/start failed before the session was inserted β€” always + # release the reservation so a failed create can't permanently + # shrink the pool. + if reserved: + async with self._lock: + self._pending_creates -= 1 + + async def _track_pro_status( + self, agent_session: AgentSession, *, is_pro: bool + ) -> None: + """Update Mongo per-user Pro state and emit a one-shot conversion + event if the store reports a freeβ†’Pro transition. Best-effort: any + Mongo failure is swallowed so we never fail session creation on + telemetry.""" + store = self._store() + if not getattr(store, "enabled", False): + return + try: + result = await store.mark_pro_seen(agent_session.user_id, is_pro=is_pro) + except Exception as e: + logger.debug("mark_pro_seen failed: %s", e) + return + if not result or not result.get("converted"): + return + try: + from agent.core import telemetry + + await telemetry.record_pro_conversion( + agent_session.session, + first_seen_at=result.get("first_seen_at"), + ) + except Exception as e: + logger.debug("record_pro_conversion failed: %s", e) + + async def seed_from_summary(self, session_id: str, messages: list[dict]) -> int: + """Rehydrate a session from cached prior messages via summarization. + + Runs the standard summarization prompt (same one compaction uses) + over the provided messages, then seeds the new session's context + with that summary. Tool-call pairing concerns disappear because the + output is plain text. Returns the number of messages summarized. + """ + from litellm import Message + + from agent.context_manager.manager import _RESTORE_PROMPT, summarize_messages + + agent_session = self.sessions.get(session_id) + if not agent_session: + raise ValueError(f"Session {session_id} not found") + + # Parse into Message objects, tolerating malformed entries. + parsed: list[Message] = [] + for raw in messages: + if raw.get("role") == "system": + continue # the new session has its own system prompt + try: + parsed.append(Message.model_validate(raw)) + except Exception as e: + logger.warning("Dropping malformed message during seed: %s", e) + + if not parsed: + return 0 + + session = agent_session.session + # Pass the real tool specs so the summarizer sees what the agent + # actually has. Without them, the summarizer can editorialize that + # original tool calls were fabricated. + tool_specs = None + try: + tool_specs = agent_session.tool_router.get_tool_specs_for_llm() + except Exception: + pass + try: + summary, _ = await summarize_messages( + parsed, + model_name=session.config.model_name, + hf_token=session.hf_token, + max_tokens=4000, + prompt=_RESTORE_PROMPT, + tool_specs=tool_specs, + session=session, + kind="restore", + ) + except Exception as e: + logger.error("Summary call failed during seed: %s", e) + raise + + seed = Message( + role="user", + content=( + "[SYSTEM: Your prior memory of this conversation β€” written " + "in your own voice right before restart. Continue from here.]\n\n" + + (summary or "(no summary returned)") + ), + ) + session.context_manager.items.append(seed) + self._touch(agent_session) + await self.persist_session_snapshot(agent_session, runtime_state="idle") + return len(parsed) + + @staticmethod + async def _cleanup_sandbox(session: Session) -> None: + """Delete the sandbox Space if one was created for this session. + + Retries on transient failures (HF API 5xx, rate-limit, network blips) + with exponential backoff. A single missed delete = a permanently + orphaned Space, so the cost of an extra retry beats the alternative. + """ + from agent.tools.sandbox_tool import teardown_session_sandbox + + await teardown_session_sandbox(session) + + async def _cleanup_all_sandboxes_on_close(self) -> None: + """Best-effort sandbox cleanup for graceful backend shutdown.""" + async with self._lock: + agent_sessions = list(self.sessions.values()) + if not agent_sessions: + return + + semaphore = asyncio.Semaphore(SANDBOX_SHUTDOWN_CLEANUP_CONCURRENCY) + + async def _cleanup_one(agent_session: AgentSession) -> None: + async with semaphore: + try: + await self._cleanup_sandbox(agent_session.session) + except Exception as e: + logger.warning( + "Shutdown sandbox cleanup failed for %s: %s", + agent_session.session_id, + e, + ) + + tasks = [ + asyncio.create_task(_cleanup_one(agent_session)) + for agent_session in agent_sessions + ] + try: + await asyncio.wait_for( + asyncio.gather(*tasks, return_exceptions=True), + timeout=SANDBOX_SHUTDOWN_CLEANUP_TIMEOUT_S, + ) + except asyncio.TimeoutError: + logger.warning( + "Timed out after %.0fs cleaning up sandboxes on shutdown; " + "orphan sweeper will handle any stragglers", + SANDBOX_SHUTDOWN_CLEANUP_TIMEOUT_S, + ) + + async def _reaper_loop(self) -> None: + """Periodically release resources held by idle sessions. + + Modeled on EventBroadcaster.run: a long-lived task started in start() + and cancelled in close(). Per-sweep exceptions are swallowed so one bad + sweep never kills the loop. + """ + while True: + try: + await asyncio.sleep(REAPER_INTERVAL_S) + await self._reap_idle_sessions() + except asyncio.CancelledError: + break + except Exception as e: + logger.error("Idle-session reaper sweep failed: %s", e) + + async def _reap_idle_sessions(self) -> None: + """Select idle candidates under the lock, then tear each down. + + Candidates are non-dev sessions that are live, not processing, not + awaiting tool approval (those are "approve later", not idle β€” reaping + would destroy the sandbox the approved tool needs), and untouched for + the idle window. We only snapshot IDs under the lock; the actual + teardown in _reap_one re-acquires it, because tearing a session down + while holding the lock would deadlock (the lock is non-reentrant). + """ + # Reaping is only safe when sessions stay resumable from Mongo. With no + # store, eviction would destroy non-dev chats outright, so don't reap. + if not getattr(self._store(), "enabled", False): + return + + cutoff = datetime.utcnow() - REAPER_IDLE + async with self._lock: + candidates = [ + agent_session.session_id + for agent_session in self.sessions.values() + if agent_session.is_active + and not agent_session.is_processing + and not agent_session.is_reaping + and agent_session.user_id != "dev" + and not agent_session.session.pending_approval + and agent_session.last_active_at <= cutoff + ] + if not candidates: + return + + reaped = 0 + for session_id in candidates: + try: + if await self._reap_one(session_id, cutoff): + reaped += 1 + except Exception as e: + logger.warning("Failed to reap idle session %s: %s", session_id, e) + if reaped: + logger.info("Reaped %d idle session(s)", reaped) + + async def _reap_one(self, session_id: str, cutoff: datetime) -> bool: + """Tear down one idle session, leaving it resumable from Mongo. + + Re-checks every idle condition under the lock (a user may have become + active in the gap since selection), marks the session reaping, persists + a resumable snapshot outside the lock, then does one final locked + re-check before eviction. The runtime task is cancelled *outside* the + lock: its own ``finally`` frees the sandbox, and its identity-gated + persist no-ops because the session is already popped β€” so it can't + overwrite our resumable snapshot with ``"ended"`` and there's no + deadlock. Returns True if the session was reaped. + """ + async with self._lock: + agent_session = self.sessions.get(session_id) + if ( + agent_session is None + or not agent_session.is_active + or agent_session.is_processing + or agent_session.is_reaping + or agent_session.session.pending_approval + or agent_session.last_active_at > cutoff + or not agent_session.submission_queue.empty() + ): + return False + agent_session.is_reaping = True + + # Persist a resumable snapshot *before* eviction so a concurrent reopen + # reloads clean state. status="active" (never "ended") keeps it a normal + # chat in the sidebar. Do this outside the manager lock: Mongo writes can + # take network round trips, and is_reaping=True is enough to block submit + # from enqueueing while the snapshot is in flight. + try: + await self.persist_session_snapshot( + agent_session, + runtime_state="idle", + status="active", + raise_on_error=True, + ) + except Exception as e: + async with self._lock: + if self.sessions.get(session_id) is agent_session: + agent_session.is_reaping = False + logger.warning( + "Skipping reap of %s: could not persist resumable snapshot: %s", + session_id, + e, + ) + return False + + async with self._lock: + current = self.sessions.get(session_id) + if current is not agent_session: + return False + if ( + not agent_session.is_active + or agent_session.is_processing + or agent_session.session.pending_approval + or agent_session.last_active_at > cutoff + or not agent_session.submission_queue.empty() + ): + agent_session.is_reaping = False + return False + self.sessions.pop(session_id, None) + task = agent_session.task + session = agent_session.session + + if task is not None and not task.done(): + task.cancel() + # Use asyncio.wait, not wait_for: wait_for re-raises the cancelled + # task's CancelledError, which we'd have to swallow β€” and that same + # bare except would also eat an *outer* cancel aimed at the reaper + # itself (close() cancelling _reaper_task), hanging shutdown. + # asyncio.wait returns the cancelled task in `done` and lets an + # outer cancel propagate cleanly. + done, _pending = await asyncio.wait({task}, timeout=REAP_TEARDOWN_TIMEOUT_S) + if not done: + logger.warning( + "Reaper teardown timed out after %.0fs for %s; orphan " + "sweeper will handle any sandbox straggler", + REAP_TEARDOWN_TIMEOUT_S, + session_id, + ) + elif not task.cancelled(): + # Surface (and retrieve, to avoid "exception never retrieved") + # any non-cancellation teardown error. + exc = task.exception() + if exc is not None: + logger.warning("Reaper teardown error for %s: %s", session_id, exc) + else: + # No live task to run the cleanup finally β€” free the sandbox here so + # a reaped session never leaves an orphaned Space behind. + await self._cleanup_sandbox(session) + return True + + async def _run_session( + self, + session_id: str, + submission_queue: asyncio.Queue, + event_queue: asyncio.Queue, + tool_router: ToolRouter, + ) -> None: + """Run the agent loop for a session and broadcast events via EventBroadcaster.""" + agent_session = self.sessions.get(session_id) + if not agent_session: + logger.error(f"Session {session_id} not found") + return + + session = agent_session.session + + # Start event broadcaster task + broadcaster = EventBroadcaster(event_queue) + agent_session.broadcaster = broadcaster + broadcast_task = asyncio.create_task(broadcaster.run()) + + try: + async with tool_router: + # Send ready event + await session.send_event( + Event(event_type="ready", data={"message": "Agent initialized"}) + ) + + while session.is_running: + try: + # Wait for submission with timeout to allow checking is_running + submission = await asyncio.wait_for( + submission_queue.get(), timeout=1.0 + ) + agent_session.is_processing = True + self._touch(agent_session) + try: + should_continue = await process_submission( + session, submission + ) + finally: + agent_session.is_processing = False + # Stamp on turn finish too: a turn that ran longer + # than the idle window would otherwise be reaped the + # instant it completes. + self._touch(agent_session) + if session.config.save_sessions: + await self.refresh_session_usage_metrics(agent_session) + await self.persist_session_snapshot(agent_session) + if not should_continue: + break + except asyncio.TimeoutError: + continue + except asyncio.CancelledError: + logger.info(f"Session {session_id} cancelled") + break + except Exception as e: + logger.error(f"Error in session {session_id}: {e}") + await session.send_event( + Event(event_type="error", data={"error": str(e)}) + ) + + finally: + broadcast_task.cancel() + try: + await broadcast_task + except asyncio.CancelledError: + pass + + await self._cleanup_sandbox(session) + + # Final-flush: always save on session death so we capture ended + # sessions even if the client disconnects without /shutdown. + # Idempotent via session_id key; detached subprocess. + if session.config.save_sessions: + try: + await self.refresh_session_usage_metrics( + agent_session, + error_code="final_billing_snapshot_error", + ) + session.save_and_upload_detached( + session.config.session_dataset_repo + ) + except Exception as e: + logger.warning(f"Final-flush failed for {session_id}: {e}") + + async with self._lock: + if self.sessions.get(session_id) is agent_session: + agent_session.is_active = False + await self.persist_session_snapshot( + agent_session, + runtime_state="ended", + status="ended", + ) + + logger.info(f"Session {session_id} ended") + + async def submit(self, session_id: str, operation: Operation) -> bool: + """Submit an operation to a session. + + Enqueues under the lock and rejects sessions being reaped, so submit + and reap can't interleave: either the message is enqueued before the + reaper's empty() re-check (which then aborts the reap), or the session + is already popped (we return False and the caller reloads a fresh + runtime from Mongo). The queue is unbounded, so put_nowait never blocks. + """ + submission = Submission(id=f"sub_{uuid.uuid4().hex[:8]}", operation=operation) + async with self._lock: + agent_session = self.sessions.get(session_id) + if ( + not agent_session + or not agent_session.is_active + or agent_session.is_reaping + ): + logger.warning(f"Session {session_id} not found or inactive") + return False + agent_session.submission_queue.put_nowait(submission) + self._touch(agent_session) + return True + + async def submit_user_input(self, session_id: str, text: str) -> bool: + """Submit user input to a session.""" + operation = Operation(op_type=OpType.USER_INPUT, data={"text": text}) + return await self.submit(session_id, operation) + + async def submit_approval( + self, session_id: str, approvals: list[dict[str, Any]] + ) -> bool: + """Submit tool approvals to a session.""" + operation = Operation( + op_type=OpType.EXEC_APPROVAL, data={"approvals": approvals} + ) + return await self.submit(session_id, operation) + + async def interrupt(self, session_id: str) -> bool: + """Interrupt a session by signalling cancellation directly (bypasses queue).""" + agent_session = self.sessions.get(session_id) + if not agent_session or not agent_session.is_active: + return False + agent_session.session.cancel() + return True + + async def undo(self, session_id: str) -> bool: + """Undo last turn in a session.""" + operation = Operation(op_type=OpType.UNDO) + return await self.submit(session_id, operation) + + async def truncate(self, session_id: str, user_message_index: int) -> bool: + """Truncate conversation to before a specific user message (direct, no queue).""" + async with self._lock: + agent_session = self.sessions.get(session_id) + if not agent_session or not agent_session.is_active: + return False + success = agent_session.session.context_manager.truncate_to_user_message( + user_message_index + ) + if success: + self._touch(agent_session) + await self.persist_session_snapshot(agent_session, runtime_state="idle") + return success + + async def compact(self, session_id: str) -> bool: + """Compact context in a session.""" + operation = Operation(op_type=OpType.COMPACT) + return await self.submit(session_id, operation) + + async def shutdown_session(self, session_id: str) -> bool: + """Shutdown a specific session.""" + operation = Operation(op_type=OpType.SHUTDOWN) + success = await self.submit(session_id, operation) + + if success: + async with self._lock: + agent_session = self.sessions.get(session_id) + if agent_session and agent_session.task: + # Wait for task to complete + try: + await asyncio.wait_for(agent_session.task, timeout=5.0) + except asyncio.TimeoutError: + agent_session.task.cancel() + + return success + + async def delete_session(self, session_id: str) -> bool: + """Soft-delete a session and stop its runtime resources.""" + async with self._lock: + agent_session = self.sessions.pop(session_id, None) + + if not agent_session: + await self._store().soft_delete_session(session_id) + return True + + await self._store().soft_delete_session(session_id) + + # Clean up sandbox Space before cancelling the task + await self._cleanup_sandbox(agent_session.session) + + # Cancel the task if running + if agent_session.task and not agent_session.task.done(): + agent_session.task.cancel() + try: + await agent_session.task + except asyncio.CancelledError: + pass + + return True + + async def teardown_sandbox(self, session_id: str) -> bool: + """Delete only this session's sandbox runtime, preserving chat state.""" + async with self._lock: + agent_session = self.sessions.get(session_id) + + if not agent_session or not agent_session.is_active: + return False + + await self._cleanup_sandbox(agent_session.session) + await self.persist_session_snapshot(agent_session, runtime_state="idle") + return True + + async def update_session_title(self, session_id: str, title: str | None) -> None: + """Persist a user-visible title for sidebar rehydration.""" + agent_session = self.sessions.get(session_id) + if agent_session: + agent_session.title = title + await self._store().update_session_fields(session_id, title=title) + + async def update_session_model(self, session_id: str, model_id: str) -> bool: + agent_session = self.sessions.get(session_id) + if not agent_session or not agent_session.is_active: + return False + agent_session.session.update_model(model_id) + self._touch(agent_session) + await self.persist_session_snapshot(agent_session, runtime_state="idle") + return True + + async def update_session_auto_approval( + self, + session_id: str, + *, + enabled: bool, + cost_cap_usd: float | None, + cap_provided: bool = False, + ) -> dict[str, Any]: + agent_session = self.sessions.get(session_id) + if not agent_session or not agent_session.is_active: + raise ValueError("Session not found or inactive") + + session = agent_session.session + seed_spend: float | None = None + if enabled: + try: + seed_spend, _ = await self._current_session_usage_spend( + agent_session, + use_cache=False, + ) + except Exception as e: + logger.debug("Could not seed YOLO spend for %s: %s", session_id, e) + if enabled: + if not cap_provided and cost_cap_usd is None: + cost_cap_usd = getattr(session, "auto_approval_cost_cap_usd", None) + if cost_cap_usd is None: + cost_cap_usd = DEFAULT_YOLO_COST_CAP_USD + elif cost_cap_usd is None: + cost_cap_usd = DEFAULT_YOLO_COST_CAP_USD + else: + if not cap_provided: + cost_cap_usd = getattr(session, "auto_approval_cost_cap_usd", None) + + if hasattr(session, "set_auto_approval_policy"): + session.set_auto_approval_policy( + enabled=enabled, + cost_cap_usd=cost_cap_usd, + ) + else: + session.auto_approval_enabled = bool(enabled) + session.auto_approval_cost_cap_usd = cost_cap_usd + if enabled and seed_spend is not None: + seed_session_spend(session, seed_spend) + self._touch(agent_session) + await self.persist_session_snapshot(agent_session) + return self._auto_approval_summary(session) + + async def reconcile_session_auto_approval_from_usage( + self, + session_id: str, + usage_response: dict[str, Any], + ) -> dict[str, Any] | None: + agent_session = self.sessions.get(session_id) + if not agent_session or not agent_session.is_active: + return None + + session = agent_session.session + if not bool(getattr(session, "auto_approval_enabled", False)): + return self._auto_approval_summary(session) + + current_spend, _ = self._usage_spend_from_response(usage_response) + previous_spend = session_spend_usd(session) + seed_session_spend(session, current_spend) + if session_spend_usd(session) != previous_spend: + self._touch(agent_session) + return self._auto_approval_summary(session) + + def get_session_info(self, session_id: str) -> dict[str, Any] | None: + """Get information about a session.""" + agent_session = self.sessions.get(session_id) + if not agent_session: + return None + + pending_approval = self._pending_tools_for_api(agent_session.session) + + return { + "session_id": session_id, + "created_at": agent_session.created_at.isoformat(), + "usage_window_started_at": ( + agent_session.usage_window_started_at or agent_session.created_at + ).isoformat(), + "is_active": agent_session.is_active, + "is_processing": agent_session.is_processing, + "message_count": len(agent_session.session.context_manager.items), + "user_id": agent_session.user_id, + "pending_approval": pending_approval, + "model": agent_session.session.config.model_name, + "title": agent_session.title, + "notification_destinations": list( + agent_session.session.notification_destinations + ), + "auto_approval": self._auto_approval_summary(agent_session.session), + } + + async def reset_session_usage_window( + self, + session_id: str, + *, + started_at: datetime | None = None, + ) -> dict[str, Any] | None: + """Reset the account-billing window used for the visible usage meter.""" + agent_session = self.sessions.get(session_id) + if not agent_session: + return None + + window_start = started_at or datetime.utcnow() + agent_session.usage_window_started_at = window_start + billing_session_id = new_inference_billing_session_id(session_id, window_start) + self._set_inference_billing_session_id(agent_session, billing_session_id) + agent_session.usage_warning_spend_cache = {} + self._touch(agent_session) + + store = self._store() + if getattr(store, "enabled", False): + await store.update_session_fields( + session_id, + usage_window_started_at=window_start, + inference_billing_session_id=billing_session_id, + last_active_at=agent_session.last_active_at, + ) + return self.get_session_info(session_id) + + def set_notification_destinations( + self, session_id: str, destinations: list[str] + ) -> list[str]: + """Replace the session's opted-in auto-notification destinations.""" + agent_session = self.sessions.get(session_id) + if not agent_session or not agent_session.is_active: + raise ValueError("Session not found or inactive") + + normalized: list[str] = [] + seen: set[str] = set() + for raw_name in destinations: + name = raw_name.strip() + if not name: + raise ValueError("Destination names must not be empty") + destination = self.config.messaging.get_destination(name) + if destination is None: + raise ValueError(f"Unknown destination '{name}'") + if not destination.allow_auto_events: + raise ValueError(f"Destination '{name}' is not enabled for auto events") + if name not in seen: + normalized.append(name) + seen.add(name) + + agent_session.session.set_notification_destinations(normalized) + self._touch(agent_session) + return normalized + + async def list_sessions(self, user_id: str | None = None) -> list[dict[str, Any]]: + """List sessions, optionally filtered by user. + + Args: + user_id: If provided, only return sessions owned by this user. + If "dev", return all sessions (dev mode). + """ + results: list[dict[str, Any]] = [] + store = self._store() + if getattr(store, "enabled", False): + for row in await store.list_sessions(user_id or "dev"): + sid = row.get("session_id") or row.get("_id") + if not sid: + continue + runtime_info = self.get_session_info(str(sid)) + if runtime_info: + results.append(runtime_info) + continue + created_at = row.get("created_at") + if isinstance(created_at, datetime): + created_at_str = created_at.isoformat() + else: + created_at_str = str(created_at or datetime.utcnow().isoformat()) + usage_window_started_at = ( + row.get("usage_window_started_at") or created_at + ) + if isinstance(usage_window_started_at, datetime): + usage_window_started_at_str = usage_window_started_at.isoformat() + else: + usage_window_started_at_str = str( + usage_window_started_at or created_at_str + ) + pending = self._pending_docs_for_api(row.get("pending_approval") or []) + results.append( + { + "session_id": str(sid), + "created_at": created_at_str, + "usage_window_started_at": usage_window_started_at_str, + "is_active": row.get("status") != "ended", + "is_processing": row.get("runtime_state") == "processing", + "message_count": int(row.get("message_count") or 0), + "user_id": row.get("user_id") or "dev", + "pending_approval": pending or None, + "model": row.get("model"), + "title": row.get("title"), + "notification_destinations": row.get( + "notification_destinations" + ) + or [], + "auto_approval": { + "enabled": bool(row.get("auto_approval_enabled", False)), + "cost_cap_usd": row.get("auto_approval_cost_cap_usd"), + "estimated_spend_usd": float( + row.get("auto_approval_estimated_spend_usd") or 0.0 + ), + "remaining_usd": ( + None + if row.get("auto_approval_cost_cap_usd") is None + else round( + max( + 0.0, + float( + row.get("auto_approval_cost_cap_usd") or 0.0 + ) + - float( + row.get("auto_approval_estimated_spend_usd") + or 0.0 + ), + ), + 4, + ) + ), + }, + } + ) + return results + + for sid in self.sessions: + info = self.get_session_info(sid) + if not info: + continue + if user_id and user_id != "dev" and info.get("user_id") != user_id: + continue + results.append(info) + return results + + @property + def active_session_count(self) -> int: + """Get count of active sessions.""" + return sum(1 for s in self.sessions.values() if s.is_active) + + +# Global session manager instance +session_manager = SessionManager() diff --git a/backend/start.sh b/backend/start.sh new file mode 100644 index 0000000000000000000000000000000000000000..72b35198f89ef41a73c3119843d2ac21a9cf0a42 --- /dev/null +++ b/backend/start.sh @@ -0,0 +1,15 @@ +#!/bin/bash +# Entrypoint for HF Spaces dev mode compatibility. +# Dev mode spawns CMD multiple times simultaneously on restart. +# Only the first instance can bind port 7860 β€” the rest must exit +# with code 0 so the dev mode daemon doesn't mark the app as crashed. + +# Run uvicorn; if it fails due to port conflict, exit cleanly. +uvicorn main:app --host 0.0.0.0 --port 7860 +EXIT_CODE=$? + +if [ $EXIT_CODE -ne 0 ]; then + # Check if this was a port-in-use failure (another instance already running) + echo "uvicorn exited with code $EXIT_CODE, exiting gracefully." + exit 0 +fi diff --git a/backend/usage.py b/backend/usage.py new file mode 100644 index 0000000000000000000000000000000000000000..22758f4df9e58734a4f19f67dae522da96dd49ee --- /dev/null +++ b/backend/usage.py @@ -0,0 +1,751 @@ +"""Usage aggregation for app-attributed ML Intern spend.""" + +import asyncio +import logging +from datetime import UTC, datetime, timedelta +from typing import Any +from zoneinfo import ZoneInfo, ZoneInfoNotFoundError + +import httpx + +from agent.core.usage_metrics import summarize_sandbox_lifecycle + +USAGE_EVENT_TYPES = ( + "llm_call", + "hf_job_complete", + "sandbox_create", + "sandbox_destroy", +) + +logger = logging.getLogger(__name__) + +HF_BILLING_USAGE_V2_URL = "https://huggingface.co/api/settings/billing/usage-v2" +HF_BILLING_USAGE_BY_INFERENCE_SESSION_URL = ( + "https://huggingface.co/api/settings/billing/usage-by-inference-session" +) +HF_BILLING_URL = "https://huggingface.co/settings/billing" +HF_INFERENCE_PROVIDERS_PRICING_URL = ( + "https://huggingface.co/docs/inference-providers/en/pricing" +) +HF_JOBS_PRICING_URL = "https://huggingface.co/docs/hub/jobs-pricing" + + +def _utc(dt: datetime) -> datetime: + if dt.tzinfo is None: + return dt.replace(tzinfo=UTC) + return dt.astimezone(UTC) + + +def _iso(dt: datetime | None) -> str | None: + if dt is None: + return None + return _utc(dt).isoformat().replace("+00:00", "Z") + + +def _coerce_float(value: Any) -> float: + if isinstance(value, bool) or value is None: + return 0.0 + try: + return float(value) + except (TypeError, ValueError): + return 0.0 + + +def _coerce_int(value: Any) -> int: + if isinstance(value, bool) or value is None: + return 0 + try: + return int(value) + except (TypeError, ValueError): + return 0 + + +def _nano_usd_to_usd(value: Any) -> float: + return _coerce_float(value) / 1_000_000_000 + + +def _micro_usd_to_usd(value: Any) -> float: + return _coerce_float(value) / 1_000_000 + + +def _cents_to_usd(value: Any) -> float: + return _coerce_float(value) / 100 + + +def _coerce_timezone(timezone_name: str | None) -> ZoneInfo | None: + if not timezone_name: + return None + try: + return ZoneInfo(timezone_name) + except (ZoneInfoNotFoundError, ValueError): + return None + + +def _normalize_event_timestamp( + dt: datetime, + *, + timezone_name: str | None = None, +) -> datetime: + if dt.tzinfo is not None: + return _utc(dt) + timezone = _coerce_timezone(timezone_name) + if timezone is not None: + return dt.replace(tzinfo=timezone).astimezone(UTC) + return dt.astimezone(UTC) + + +def _parse_timestamp( + value: Any, *, timezone_name: str | None = None +) -> datetime | None: + if isinstance(value, datetime): + return _normalize_event_timestamp(value, timezone_name=timezone_name) + if not isinstance(value, str) or not value: + return None + try: + return _normalize_event_timestamp( + datetime.fromisoformat(value.replace("Z", "+00:00")), + timezone_name=timezone_name, + ) + except ValueError: + return None + + +def event_created_at( + event: dict[str, Any], + *, + timezone_name: str | None = None, +) -> datetime | None: + return _parse_timestamp( + event.get("created_at") or event.get("timestamp"), + timezone_name=timezone_name, + ) + + +def resolve_usage_windows( + timezone_name: str | None, + *, + now: datetime | None = None, +) -> dict[str, datetime | str]: + """Return UTC month window for a browser timezone.""" + try: + tz = ZoneInfo(timezone_name or "UTC") + except (ZoneInfoNotFoundError, ValueError): + tz = ZoneInfo("UTC") + + now_utc = _utc(now or datetime.now(UTC)) + local_now = now_utc.astimezone(tz) + month_local = local_now.replace(day=1, hour=0, minute=0, second=0, microsecond=0) + return { + "timezone": tz.key, + "now_utc": now_utc, + "month_start_utc": month_local.astimezone(UTC), + } + + +def _empty_bucket( + *, + session_id: str | None = None, +) -> dict[str, Any]: + return { + "session_id": session_id, + "total_usd": 0.0, + "inference_usd": 0.0, + "hf_jobs_estimated_usd": 0.0, + "sandbox_estimated_usd": 0.0, + "llm_calls": 0, + "hf_jobs_count": 0, + "sandbox_count": 0, + "prompt_tokens": 0, + "completion_tokens": 0, + "cache_read_tokens": 0, + "cache_creation_tokens": 0, + "total_tokens": 0, + "hf_jobs_billable_seconds_estimate": 0, + "sandbox_billable_seconds_estimate": 0, + } + + +def _empty_hf_account_bucket( + *, + window_start: datetime | None = None, + window_end: datetime | None = None, + timezone: str | None = None, +) -> dict[str, Any]: + return { + "window_start": _iso(window_start), + "window_end": _iso(window_end), + "timezone": timezone, + "total_usd": 0.0, + "inference_providers_usd": 0.0, + "hf_jobs_usd": 0.0, + "inference_provider_requests": 0, + "hf_jobs_minutes": 0.0, + } + + +def aggregate_usage_events( + events: list[dict[str, Any]], + *, + session_id: str | None = None, +) -> dict[str, Any]: + bucket = _empty_bucket(session_id=session_id) + for event in events: + event_type = event.get("event_type") + data = event.get("data") or {} + if event_type == "llm_call": + bucket["llm_calls"] += 1 + bucket["inference_usd"] += _coerce_float(data.get("cost_usd")) + prompt_tokens = _coerce_int(data.get("prompt_tokens")) + completion_tokens = _coerce_int(data.get("completion_tokens")) + cache_read_tokens = _coerce_int(data.get("cache_read_tokens")) + cache_creation_tokens = _coerce_int(data.get("cache_creation_tokens")) + total_tokens = _coerce_int(data.get("total_tokens")) or ( + prompt_tokens + + completion_tokens + + cache_read_tokens + + cache_creation_tokens + ) + bucket["prompt_tokens"] += prompt_tokens + bucket["completion_tokens"] += completion_tokens + bucket["cache_read_tokens"] += cache_read_tokens + bucket["cache_creation_tokens"] += cache_creation_tokens + bucket["total_tokens"] += total_tokens + elif event_type == "hf_job_complete": + bucket["hf_jobs_count"] += 1 + bucket["hf_jobs_estimated_usd"] += _coerce_float( + data.get("estimated_cost_usd") + ) + bucket["hf_jobs_billable_seconds_estimate"] += _coerce_int( + data.get("billable_seconds_estimate") or data.get("wall_time_s") + ) + elif event_type == "sandbox_destroy": + # Sandbox costs are paired and added after the main pass so the + # create event can provide hardware pricing metadata. + continue + + _aggregate_sandbox_usage(events, bucket) + + bucket["inference_usd"] = round(bucket["inference_usd"], 6) + bucket["hf_jobs_estimated_usd"] = round(bucket["hf_jobs_estimated_usd"], 6) + bucket["sandbox_estimated_usd"] = round(bucket["sandbox_estimated_usd"], 6) + bucket["total_usd"] = round( + ( + bucket["inference_usd"] + + bucket["hf_jobs_estimated_usd"] + + bucket["sandbox_estimated_usd"] + ), + 6, + ) + return bucket + + +def _aggregate_sandbox_usage( + events: list[dict[str, Any]], + bucket: dict[str, Any], +) -> None: + lifecycle_events = [ + (index, event) + for index, event in enumerate(events) + if event.get("event_type") in {"sandbox_create", "sandbox_destroy"} + ] + sandbox = summarize_sandbox_lifecycle(lifecycle_events) + bucket["sandbox_count"] += sandbox["matched_pairs"] + bucket["sandbox_billable_seconds_estimate"] += sandbox["billable_seconds_estimate"] + bucket["sandbox_estimated_usd"] += sandbox["estimated_usd"] + + +def _account_bucket_from_billing_usage( + payload: dict[str, Any] | None, + *, + window_start: datetime, + window_end: datetime, + timezone: str, +) -> dict[str, Any]: + bucket = _empty_hf_account_bucket( + window_start=window_start, + window_end=window_end, + timezone=timezone, + ) + usage = payload.get("usage") if isinstance(payload, dict) else {} + if not isinstance(usage, dict): + return bucket + + inference = usage.get("inferenceProviders") + if not isinstance(inference, dict): + inference = {} + jobs = usage.get("jobs") + if not isinstance(jobs, dict): + jobs = {} + + bucket["inference_providers_usd"] = round( + _nano_usd_to_usd(inference.get("usedNanoUsd")), + 6, + ) + bucket["hf_jobs_usd"] = round(_micro_usd_to_usd(jobs.get("usedMicroUsd")), 6) + bucket["inference_provider_requests"] = _coerce_int(inference.get("numRequests")) + bucket["hf_jobs_minutes"] = round(_coerce_float(jobs.get("totalMinutes")), 3) + bucket["total_usd"] = round( + bucket["inference_providers_usd"] + bucket["hf_jobs_usd"], + 6, + ) + return bucket + + +def _session_bucket_from_inference_session_usage( + payload: dict[str, Any] | None, + *, + session_id: str, + window_start: datetime, + window_end: datetime, + timezone: str, +) -> dict[str, Any]: + bucket = _empty_hf_account_bucket( + window_start=window_start, + window_end=window_end, + timezone=timezone, + ) + periods = payload.get("periods") if isinstance(payload, dict) else [] + if not isinstance(periods, list): + return bucket + + cost_cents = 0.0 + request_count = 0 + for period in periods: + if not isinstance(period, dict): + continue + sessions = period.get("sessions") + if not isinstance(sessions, list): + continue + for session in sessions: + if not isinstance(session, dict) or session.get("id") != session_id: + continue + cost_cents += _coerce_float(session.get("costCents")) + request_count += _coerce_int(session.get("requestCount")) + + bucket["inference_providers_usd"] = round(_cents_to_usd(cost_cents), 6) + bucket["inference_provider_requests"] = request_count + bucket["total_usd"] = bucket["inference_providers_usd"] + return bucket + + +def _inference_credits_from_billing_usage( + payload: dict[str, Any] | None, +) -> dict[str, Any] | None: + usage = payload.get("usage") if isinstance(payload, dict) else {} + if not isinstance(usage, dict): + return None + inference = usage.get("inferenceProviders") + if not isinstance(inference, dict): + return None + + included_usd = _nano_usd_to_usd(inference.get("includedNanoUsd")) + used_usd = _nano_usd_to_usd(inference.get("usedNanoUsd")) + limit_usd = _nano_usd_to_usd(inference.get("limitNanoUsd")) + return { + "included_usd": round(included_usd, 6), + "used_usd": round(used_usd, 6), + "remaining_included_usd": round(max(0.0, included_usd - used_usd), 6), + "limit_usd": round(limit_usd, 6), + "remaining_limit_usd": round(max(0.0, limit_usd - used_usd), 6), + "num_requests": _coerce_int(inference.get("numRequests")), + "period_start": inference.get("periodStart"), + "period_end": inference.get("periodEnd"), + } + + +async def _fetch_hf_billing_usage_v2( + hf_token: str, + *, + start: datetime, + end: datetime, +) -> dict[str, Any] | None: + start_ts = max(1, int(_utc(start).timestamp())) + end_ts = max(start_ts + 1, int(_utc(end).timestamp())) + try: + async with httpx.AsyncClient(timeout=10.0) as client: + response = await client.get( + HF_BILLING_USAGE_V2_URL, + params={"startDate": start_ts, "endDate": end_ts}, + headers={"Authorization": f"Bearer {hf_token}"}, + ) + if response.status_code != 200: + logger.debug( + "HF billing usage-v2 failed: status=%s body=%s", + response.status_code, + response.text[:200], + ) + return None + payload = response.json() + return payload if isinstance(payload, dict) else None + except (httpx.HTTPError, ValueError) as e: + logger.debug("HF billing usage-v2 failed: %s", e) + return None + + +async def _fetch_hf_inference_session_usage( + hf_token: str, + *, + start: datetime, + end: datetime, +) -> dict[str, Any] | None: + start_ts = _iso(start) + end_ts = _iso(max(_utc(end), _utc(start) + timedelta(seconds=1))) + try: + async with httpx.AsyncClient(timeout=10.0) as client: + response = await client.get( + HF_BILLING_USAGE_BY_INFERENCE_SESSION_URL, + params={"startDate": start_ts, "endDate": end_ts}, + headers={"Authorization": f"Bearer {hf_token}"}, + ) + if response.status_code != 200: + logger.debug( + "HF inference session usage failed: status=%s body=%s", + response.status_code, + response.text[:200], + ) + return None + payload = response.json() + return payload if isinstance(payload, dict) else None + except (httpx.HTTPError, ValueError) as e: + logger.debug("HF inference session usage failed: %s", e) + return None + + +def _session_usage_window_started_at( + manager: Any, session_id: str | None +) -> datetime | None: + if not session_id: + return None + agent_session = getattr(manager, "sessions", {}).get(session_id) + usage_window_started_at = getattr(agent_session, "usage_window_started_at", None) + if isinstance(usage_window_started_at, datetime): + return _utc(usage_window_started_at) + created_at = getattr(agent_session, "created_at", None) + if isinstance(created_at, datetime): + return _utc(created_at) + return None + + +def _session_inference_billing_session_id( + manager: Any, session_id: str | None +) -> str | None: + if not session_id: + return None + agent_session = getattr(manager, "sessions", {}).get(session_id) + billing_session_id = getattr(agent_session, "inference_billing_session_id", None) + if isinstance(billing_session_id, str) and billing_session_id: + return billing_session_id + runtime_session = getattr(agent_session, "session", None) + billing_session_id = getattr(runtime_session, "inference_billing_session_id", None) + if isinstance(billing_session_id, str) and billing_session_id: + return billing_session_id + return None + + +async def _load_persisted_session_usage_window_metadata( + manager: Any, + session_id: str | None, +) -> tuple[datetime | None, str | None]: + if not session_id: + return None, None + store = manager._store() + if not getattr(store, "enabled", False) or not hasattr(store, "load_session"): + return None, None + loaded = await store.load_session(session_id) + metadata = loaded.get("metadata") if isinstance(loaded, dict) else None + started_at = None + billing_session_id = None + if isinstance(metadata, dict): + started_at = metadata.get("usage_window_started_at") or metadata.get( + "created_at" + ) + raw_billing_session_id = metadata.get("inference_billing_session_id") + if isinstance(raw_billing_session_id, str) and raw_billing_session_id: + billing_session_id = raw_billing_session_id + if isinstance(started_at, datetime): + return _utc(started_at), billing_session_id + parsed = _parse_timestamp(started_at) + return (_utc(parsed) if parsed is not None else None), billing_session_id + + +async def _build_hf_account_usage( + manager: Any, + *, + hf_token: str | None, + session_id: str | None, + timezone: str, + now_utc: datetime, + month_start: datetime, +) -> dict[str, Any]: + account_usage: dict[str, Any] = { + "source": "hf_billing", + "available": False, + "current_session": None, + "month": None, + "inference_providers_credits": None, + } + if not hf_token: + account_usage["error"] = "missing_hf_token" + return account_usage + + session_start = _session_usage_window_started_at(manager, session_id) + billing_session_id = _session_inference_billing_session_id(manager, session_id) + if session_start is None or billing_session_id is None: + ( + persisted_start, + persisted_billing_session_id, + ) = await _load_persisted_session_usage_window_metadata(manager, session_id) + if session_start is None: + session_start = persisted_start + if billing_session_id is None: + billing_session_id = persisted_billing_session_id + + window_tasks: dict[str, tuple[datetime, asyncio.Task[dict[str, Any] | None]]] = { + "month": ( + month_start, + asyncio.create_task( + _fetch_hf_billing_usage_v2(hf_token, start=month_start, end=now_utc) + ), + ), + } + if billing_session_id is not None and session_start is not None: + window_tasks["current_session"] = ( + session_start, + asyncio.create_task( + _fetch_hf_inference_session_usage( + hf_token, + start=session_start, + end=now_utc, + ) + ), + ) + + payloads: dict[str, dict[str, Any] | None] = {} + for name, (_, task) in window_tasks.items(): + payloads[name] = await task + + any_payload = any(isinstance(payload, dict) for payload in payloads.values()) + account_usage["available"] = any_payload + if not any_payload: + account_usage["error"] = "billing_usage_unavailable" + return account_usage + + for name, (start, _) in window_tasks.items(): + payload = payloads.get(name) + if payload is None: + continue + if name == "current_session" and billing_session_id is not None: + account_usage[name] = _session_bucket_from_inference_session_usage( + payload, + session_id=billing_session_id, + window_start=start, + window_end=now_utc, + timezone=timezone, + ) + else: + account_usage[name] = _account_bucket_from_billing_usage( + payload, + window_start=start, + window_end=now_utc, + timezone=timezone, + ) + + account_usage["inference_providers_credits"] = ( + _inference_credits_from_billing_usage(payloads.get("month")) + ) + return account_usage + + +async def build_hf_billing_snapshot( + manager: Any, + *, + hf_token: str | None, + session_id: str | None, + timezone_name: str | None = None, + now: datetime | None = None, +) -> dict[str, Any]: + """Return a dataset-safe HF billing rollup for the session window. + + This intentionally omits monthly account totals and credit-limit details. + The snapshot is an account-window delta, not per-call attribution. + """ + windows = resolve_usage_windows(timezone_name, now=now) + timezone = str(windows["timezone"]) + now_utc = windows["now_utc"] + snapshot: dict[str, Any] = { + "billing_scope": "account_window_delta", + "hf_billing": { + "source": "hf_billing_usage_v2", + "available": False, + "error": None, + "current_session": None, + }, + } + hf_billing = snapshot["hf_billing"] + + if not hf_token: + hf_billing["error"] = "missing_hf_token" + return snapshot + if not session_id: + hf_billing["error"] = "missing_session_id" + return snapshot + + session_start = _session_usage_window_started_at(manager, session_id) + if session_start is None: + session_start, _ = await _load_persisted_session_usage_window_metadata( + manager, + session_id, + ) + if session_start is None: + hf_billing["error"] = "missing_session_window" + return snapshot + + payload = await _fetch_hf_billing_usage_v2( + hf_token, + start=session_start, + end=now_utc, + ) + if not isinstance(payload, dict): + hf_billing["error"] = "billing_usage_unavailable" + return snapshot + + hf_billing["available"] = True + hf_billing["current_session"] = _account_bucket_from_billing_usage( + payload, + window_start=session_start, + window_end=now_utc, + timezone=timezone, + ) + return snapshot + + +def _event_in_window( + event: dict[str, Any], + *, + start: datetime | None = None, + end: datetime | None = None, + timezone_name: str | None = None, +) -> bool: + if start is None and end is None: + return True + created_at = event_created_at(event, timezone_name=timezone_name) + if created_at is None: + return False + if start is not None and created_at < _utc(start): + return False + if end is not None and created_at >= _utc(end): + return False + return True + + +def _events_from_runtime_session(agent_session: Any) -> list[dict[str, Any]]: + events: list[dict[str, Any]] = [] + for raw in getattr(agent_session.session, "logged_events", []) or []: + if raw.get("event_type") not in USAGE_EVENT_TYPES: + continue + events.append( + { + "session_id": agent_session.session_id, + "event_type": raw.get("event_type"), + "data": raw.get("data") or {}, + "timestamp": raw.get("timestamp"), + } + ) + return events + + +def _runtime_sessions_for_user(manager: Any, user_id: str) -> list[Any]: + sessions = list(getattr(manager, "sessions", {}).values()) + if user_id == "dev": + return sessions + return [session for session in sessions if session.user_id == user_id] + + +async def _load_usage_events( + manager: Any, + *, + user_id: str, + session_id: str | None = None, + start: datetime | None = None, + end: datetime | None = None, + timezone_name: str | None = None, +) -> list[dict[str, Any]]: + store = manager._store() + if getattr(store, "enabled", False): + return await store.load_usage_events( + user_id, + session_id=session_id, + start=start, + end=end, + ) + + events: list[dict[str, Any]] = [] + for agent_session in _runtime_sessions_for_user(manager, user_id): + if session_id is not None and agent_session.session_id != session_id: + continue + for event in _events_from_runtime_session(agent_session): + if _event_in_window( + event, + start=start, + end=end, + timezone_name=timezone_name, + ): + events.append(event) + return events + + +async def build_usage_response( + manager: Any, + *, + user_id: str, + hf_token: str | None = None, + session_id: str | None = None, + timezone_name: str | None = None, + now: datetime | None = None, +) -> dict[str, Any]: + windows = resolve_usage_windows(timezone_name, now=now) + timezone = str(windows["timezone"]) + now_utc = windows["now_utc"] + month_start = windows["month_start_utc"] + + session_events: list[dict[str, Any]] = [] + if session_id: + session_start = _session_usage_window_started_at(manager, session_id) + if session_start is None: + session_start, _ = await _load_persisted_session_usage_window_metadata( + manager, + session_id, + ) + session_events = await _load_usage_events( + manager, + user_id=user_id, + session_id=session_id, + start=session_start, + ) + + hf_account = await _build_hf_account_usage( + manager, + hf_token=hf_token, + session_id=session_id, + timezone=timezone, + now_utc=now_utc, + month_start=month_start, + ) + + return { + "source": "app_telemetry", + "currency": "USD", + "generated_at": _iso(now_utc), + "timezone": timezone, + "session": ( + aggregate_usage_events(session_events, session_id=session_id) + if session_id + else None + ), + "hf_account": hf_account, + "links": { + "hf_billing": HF_BILLING_URL, + "inference_providers_pricing": HF_INFERENCE_PROVIDERS_PRICING_URL, + "jobs_pricing": HF_JOBS_PRICING_URL, + }, + } diff --git a/configs/__init__.py b/configs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/configs/cli_agent_config.json b/configs/cli_agent_config.json new file mode 100644 index 0000000000000000000000000000000000000000..8538fc21bbc1faf4b5949a16729d7d8099ea7bbc --- /dev/null +++ b/configs/cli_agent_config.json @@ -0,0 +1,22 @@ +{ + "model_name": "anthropic/claude-opus-4.8:fal-ai", + "save_sessions": true, + "session_dataset_repo": "smolagents/ml-intern-sessions", + "share_traces": true, + "personal_trace_repo_template": "{hf_user}/ml-intern-sessions", + "yolo_mode": false, + "confirm_cpu_jobs": true, + "auto_file_upload": true, + "tool_runtime": "local", + "messaging": { + "enabled": false, + "auto_event_types": ["approval_required", "error", "turn_complete"], + "destinations": {} + }, + "mcpServers": { + "hf-mcp-server": { + "transport": "http", + "url": "https://huggingface.co/mcp?login" + } + } +} diff --git a/configs/frontend_agent_config.json b/configs/frontend_agent_config.json new file mode 100644 index 0000000000000000000000000000000000000000..3308551af4d7bc019a5ed1690818c489a5f1e1e4 --- /dev/null +++ b/configs/frontend_agent_config.json @@ -0,0 +1,16 @@ +{ + "model_name": "${ML_INTERN_DEFAULT_MODEL_ID:-moonshotai/Kimi-K2.6}", + "save_sessions": true, + "session_dataset_repo": "smolagents/ml-intern-sessions", + "share_traces": true, + "personal_trace_repo_template": "{hf_user}/ml-intern-sessions", + "yolo_mode": false, + "confirm_cpu_jobs": true, + "auto_file_upload": true, + "mcpServers": { + "hf-mcp-server": { + "transport": "http", + "url": "https://huggingface.co/mcp?login" + } + } +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..c52b1ebbc699139c98010831c3821011b5c87a6a --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,82 @@ +[project] +name = "ml-intern" +version = "0.1.0" +description = "Add your description here" +readme = "README.md" +requires-python = ">=3.11" +dependencies = [ + # Core dependencies + "datasets>=4.4.1", + "pydantic>=2.12.3", + "python-dotenv>=1.2.1", + # Agent runtime dependencies + "requests>=2.33.0", + "litellm>=1.83.0", + "huggingface-hub>=1.12.0", + "fastmcp>=3.2.0", + "prompt-toolkit>=3.0.0", + "thefuzz>=0.22.1", + "rich>=13.0.0", + "nbconvert>=7.16.6", + "nbformat>=5.10.4", + "whoosh>=2.7.4", + # Web backend dependencies + "fastapi>=0.115.0", + "uvicorn[standard]>=0.32.0", + "httpx>=0.27.0", + "websockets>=13.0", + "apscheduler>=3.10,<4", + "pymongo>=4.17.0", + "python-multipart>=0.0.20", +] + +[project.optional-dependencies] + +# Evaluation/benchmarking dependencies +eval = [ + "inspect-ai>=0.3.149", + "pandas>=2.3.3", + "datasets>=4.3.0", + "tenacity>=8.0.0", +] + +# Development and testing dependencies +dev = [ + "pytest>=9.0.2", + "pytest-asyncio>=1.2.0", + "ruff>=0.15.12", +] + +# All dependencies (eval + dev) +all = [ + "ml-intern[eval,dev]", +] + +[project.scripts] +ml-intern = "agent.main:cli" + +[build-system] +requires = ["setuptools>=64"] +build-backend = "setuptools.build_meta" + +[tool.setuptools.packages.find] +# `configs` ships the JSON files loaded by agent.main.CLI_CONFIG_PATH at +# runtime (resolves to /configs/cli_agent_config.json). +# Without it, `uv tool install` / `pip install` produce a broken install +# that imports fine but crashes at startup with FileNotFoundError. +include = ["agent*", "configs"] + +[tool.setuptools.package-data] +configs = ["*.json"] +# Agent data files: system prompts loaded by ContextManager._load_system_prompt +# at runtime (`/agent/prompts/system_prompt_v3.yaml`), plus the +# package README. Without these, headless_main hangs forever β€” submission_loop +# crashes with FileNotFoundError but headless_main doesn't check agent_task.done() +# and just keeps awaiting the "ready" event_queue item that will never come. +agent = ["README.md", "prompts/*.yaml"] + +[tool.uv] +package = true + +[tool.pytest.ini_options] +asyncio_mode = "auto" diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000000000000000000000000000000000000..134b71f82f73a182557a1dffa72f78c6a9b2a804 --- /dev/null +++ b/uv.lock @@ -0,0 +1,4296 @@ +version = 1 +revision = 3 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version < '3.12'", +] + +[[package]] +name = "aioboto3" +version = "15.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiobotocore", extra = ["boto3"] }, + { name = "aiofiles" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a2/01/92e9ab00f36e2899315f49eefcd5b4685fbb19016c7f19a9edf06da80bb0/aioboto3-15.5.0.tar.gz", hash = "sha256:ea8d8787d315594842fbfcf2c4dce3bac2ad61be275bc8584b2ce9a3402a6979", size = 255069, upload-time = "2025-10-30T13:37:16.122Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/3e/e8f5b665bca646d43b916763c901e00a07e40f7746c9128bdc912a089424/aioboto3-15.5.0-py3-none-any.whl", hash = "sha256:cc880c4d6a8481dd7e05da89f41c384dbd841454fc1998ae25ca9c39201437a6", size = 35913, upload-time = "2025-10-30T13:37:14.549Z" }, +] + +[[package]] +name = "aiobotocore" +version = "2.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "aioitertools" }, + { name = "botocore" }, + { name = "jmespath" }, + { name = "multidict" }, + { name = "python-dateutil" }, + { name = "wrapt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/62/94/2e4ec48cf1abb89971cb2612d86f979a6240520f0a659b53a43116d344dc/aiobotocore-2.25.1.tar.gz", hash = "sha256:ea9be739bfd7ece8864f072ec99bb9ed5c7e78ebb2b0b15f29781fbe02daedbc", size = 120560, upload-time = "2025-10-28T22:33:21.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/2a/d275ec4ce5cd0096665043995a7d76f5d0524853c76a3d04656de49f8808/aiobotocore-2.25.1-py3-none-any.whl", hash = "sha256:eb6daebe3cbef5b39a0bb2a97cffbe9c7cb46b2fcc399ad141f369f3c2134b1f", size = 86039, upload-time = "2025-10-28T22:33:19.949Z" }, +] + +[package.optional-dependencies] +boto3 = [ + { name = "boto3" }, +] + +[[package]] +name = "aiofile" +version = "3.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "caio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/67/e2/d7cb819de8df6b5c1968a2756c3cb4122d4fa2b8fc768b53b7c9e5edb646/aiofile-3.9.0.tar.gz", hash = "sha256:e5ad718bb148b265b6df1b3752c4d1d83024b93da9bd599df74b9d9ffcf7919b", size = 17943, upload-time = "2024-10-08T10:39:35.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/25/da1f0b4dd970e52bf5a36c204c107e11a0c6d3ed195eba0bfbc664c312b2/aiofile-3.9.0-py3-none-any.whl", hash = "sha256:ce2f6c1571538cbdfa0143b04e16b208ecb0e9cb4148e528af8a640ed51cc8aa", size = 19539, upload-time = "2024-10-08T10:39:32.955Z" }, +] + +[[package]] +name = "aiofiles" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/41/c3/534eac40372d8ee36ef40df62ec129bee4fdb5ad9706e58a29be53b2c970/aiofiles-25.1.0.tar.gz", hash = "sha256:a8d728f0a29de45dc521f18f07297428d56992a742f0cd2701ba86e44d23d5b2", size = 46354, upload-time = "2025-10-09T20:51:04.358Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/8a/340a1555ae33d7354dbca4faa54948d76d89a27ceef032c8c3bc661d003e/aiofiles-25.1.0-py3-none-any.whl", hash = "sha256:abe311e527c862958650f9438e859c1fa7568a141b22abcd015e120e86a85695", size = 14668, upload-time = "2025-10-09T20:51:03.174Z" }, +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/ce/3b83ebba6b3207a7135e5fcaba49706f8a4b6008153b4e30540c982fae26/aiohttp-3.13.2.tar.gz", hash = "sha256:40176a52c186aefef6eb3cad2cdd30cd06e3afbe88fe8ab2af9c0b90f228daca", size = 7837994, upload-time = "2025-10-28T20:59:39.937Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/74/b321e7d7ca762638cdf8cdeceb39755d9c745aff7a64c8789be96ddf6e96/aiohttp-3.13.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4647d02df098f6434bafd7f32ad14942f05a9caa06c7016fdcc816f343997dd0", size = 743409, upload-time = "2025-10-28T20:56:00.354Z" }, + { url = "https://files.pythonhosted.org/packages/99/3d/91524b905ec473beaf35158d17f82ef5a38033e5809fe8742e3657cdbb97/aiohttp-3.13.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e3403f24bcb9c3b29113611c3c16a2a447c3953ecf86b79775e7be06f7ae7ccb", size = 497006, upload-time = "2025-10-28T20:56:01.85Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d3/7f68bc02a67716fe80f063e19adbd80a642e30682ce74071269e17d2dba1/aiohttp-3.13.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:43dff14e35aba17e3d6d5ba628858fb8cb51e30f44724a2d2f0c75be492c55e9", size = 493195, upload-time = "2025-10-28T20:56:03.314Z" }, + { url = "https://files.pythonhosted.org/packages/98/31/913f774a4708775433b7375c4f867d58ba58ead833af96c8af3621a0d243/aiohttp-3.13.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e2a9ea08e8c58bb17655630198833109227dea914cd20be660f52215f6de5613", size = 1747759, upload-time = "2025-10-28T20:56:04.904Z" }, + { url = "https://files.pythonhosted.org/packages/e8/63/04efe156f4326f31c7c4a97144f82132c3bb21859b7bb84748d452ccc17c/aiohttp-3.13.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53b07472f235eb80e826ad038c9d106c2f653584753f3ddab907c83f49eedead", size = 1704456, upload-time = "2025-10-28T20:56:06.986Z" }, + { url = "https://files.pythonhosted.org/packages/8e/02/4e16154d8e0a9cf4ae76f692941fd52543bbb148f02f098ca73cab9b1c1b/aiohttp-3.13.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e736c93e9c274fce6419af4aac199984d866e55f8a4cec9114671d0ea9688780", size = 1807572, upload-time = "2025-10-28T20:56:08.558Z" }, + { url = "https://files.pythonhosted.org/packages/34/58/b0583defb38689e7f06798f0285b1ffb3a6fb371f38363ce5fd772112724/aiohttp-3.13.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ff5e771f5dcbc81c64898c597a434f7682f2259e0cd666932a913d53d1341d1a", size = 1895954, upload-time = "2025-10-28T20:56:10.545Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f3/083907ee3437425b4e376aa58b2c915eb1a33703ec0dc30040f7ae3368c6/aiohttp-3.13.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3b6fb0c207cc661fa0bf8c66d8d9b657331ccc814f4719468af61034b478592", size = 1747092, upload-time = "2025-10-28T20:56:12.118Z" }, + { url = "https://files.pythonhosted.org/packages/ac/61/98a47319b4e425cc134e05e5f3fc512bf9a04bf65aafd9fdcda5d57ec693/aiohttp-3.13.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:97a0895a8e840ab3520e2288db7cace3a1981300d48babeb50e7425609e2e0ab", size = 1606815, upload-time = "2025-10-28T20:56:14.191Z" }, + { url = "https://files.pythonhosted.org/packages/97/4b/e78b854d82f66bb974189135d31fce265dee0f5344f64dd0d345158a5973/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9e8f8afb552297aca127c90cb840e9a1d4bfd6a10d7d8f2d9176e1acc69bad30", size = 1723789, upload-time = "2025-10-28T20:56:16.101Z" }, + { url = "https://files.pythonhosted.org/packages/ed/fc/9d2ccc794fc9b9acd1379d625c3a8c64a45508b5091c546dea273a41929e/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ed2f9c7216e53c3df02264f25d824b079cc5914f9e2deba94155190ef648ee40", size = 1718104, upload-time = "2025-10-28T20:56:17.655Z" }, + { url = "https://files.pythonhosted.org/packages/66/65/34564b8765ea5c7d79d23c9113135d1dd3609173da13084830f1507d56cf/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:99c5280a329d5fa18ef30fd10c793a190d996567667908bef8a7f81f8202b948", size = 1785584, upload-time = "2025-10-28T20:56:19.238Z" }, + { url = "https://files.pythonhosted.org/packages/30/be/f6a7a426e02fc82781afd62016417b3948e2207426d90a0e478790d1c8a4/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2ca6ffef405fc9c09a746cb5d019c1672cd7f402542e379afc66b370833170cf", size = 1595126, upload-time = "2025-10-28T20:56:20.836Z" }, + { url = "https://files.pythonhosted.org/packages/e5/c7/8e22d5d28f94f67d2af496f14a83b3c155d915d1fe53d94b66d425ec5b42/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:47f438b1a28e926c37632bff3c44df7d27c9b57aaf4e34b1def3c07111fdb782", size = 1800665, upload-time = "2025-10-28T20:56:22.922Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/91133c8b68b1da9fc16555706aa7276fdf781ae2bb0876c838dd86b8116e/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9acda8604a57bb60544e4646a4615c1866ee6c04a8edef9b8ee6fd1d8fa2ddc8", size = 1739532, upload-time = "2025-10-28T20:56:25.924Z" }, + { url = "https://files.pythonhosted.org/packages/17/6b/3747644d26a998774b21a616016620293ddefa4d63af6286f389aedac844/aiohttp-3.13.2-cp311-cp311-win32.whl", hash = "sha256:868e195e39b24aaa930b063c08bb0c17924899c16c672a28a65afded9c46c6ec", size = 431876, upload-time = "2025-10-28T20:56:27.524Z" }, + { url = "https://files.pythonhosted.org/packages/c3/63/688462108c1a00eb9f05765331c107f95ae86f6b197b865d29e930b7e462/aiohttp-3.13.2-cp311-cp311-win_amd64.whl", hash = "sha256:7fd19df530c292542636c2a9a85854fab93474396a52f1695e799186bbd7f24c", size = 456205, upload-time = "2025-10-28T20:56:29.062Z" }, + { url = "https://files.pythonhosted.org/packages/29/9b/01f00e9856d0a73260e86dd8ed0c2234a466c5c1712ce1c281548df39777/aiohttp-3.13.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b1e56bab2e12b2b9ed300218c351ee2a3d8c8fdab5b1ec6193e11a817767e47b", size = 737623, upload-time = "2025-10-28T20:56:30.797Z" }, + { url = "https://files.pythonhosted.org/packages/5a/1b/4be39c445e2b2bd0aab4ba736deb649fabf14f6757f405f0c9685019b9e9/aiohttp-3.13.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:364e25edaabd3d37b1db1f0cbcee8c73c9a3727bfa262b83e5e4cf3489a2a9dc", size = 492664, upload-time = "2025-10-28T20:56:32.708Z" }, + { url = "https://files.pythonhosted.org/packages/28/66/d35dcfea8050e131cdd731dff36434390479b4045a8d0b9d7111b0a968f1/aiohttp-3.13.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c5c94825f744694c4b8db20b71dba9a257cd2ba8e010a803042123f3a25d50d7", size = 491808, upload-time = "2025-10-28T20:56:34.57Z" }, + { url = "https://files.pythonhosted.org/packages/00/29/8e4609b93e10a853b65f8291e64985de66d4f5848c5637cddc70e98f01f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba2715d842ffa787be87cbfce150d5e88c87a98e0b62e0f5aa489169a393dbbb", size = 1738863, upload-time = "2025-10-28T20:56:36.377Z" }, + { url = "https://files.pythonhosted.org/packages/9d/fa/4ebdf4adcc0def75ced1a0d2d227577cd7b1b85beb7edad85fcc87693c75/aiohttp-3.13.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:585542825c4bc662221fb257889e011a5aa00f1ae4d75d1d246a5225289183e3", size = 1700586, upload-time = "2025-10-28T20:56:38.034Z" }, + { url = "https://files.pythonhosted.org/packages/da/04/73f5f02ff348a3558763ff6abe99c223381b0bace05cd4530a0258e52597/aiohttp-3.13.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:39d02cb6025fe1aabca329c5632f48c9532a3dabccd859e7e2f110668972331f", size = 1768625, upload-time = "2025-10-28T20:56:39.75Z" }, + { url = "https://files.pythonhosted.org/packages/f8/49/a825b79ffec124317265ca7d2344a86bcffeb960743487cb11988ffb3494/aiohttp-3.13.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e67446b19e014d37342f7195f592a2a948141d15a312fe0e700c2fd2f03124f6", size = 1867281, upload-time = "2025-10-28T20:56:41.471Z" }, + { url = "https://files.pythonhosted.org/packages/b9/48/adf56e05f81eac31edcfae45c90928f4ad50ef2e3ea72cb8376162a368f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4356474ad6333e41ccefd39eae869ba15a6c5299c9c01dfdcfdd5c107be4363e", size = 1752431, upload-time = "2025-10-28T20:56:43.162Z" }, + { url = "https://files.pythonhosted.org/packages/30/ab/593855356eead019a74e862f21523db09c27f12fd24af72dbc3555b9bfd9/aiohttp-3.13.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eeacf451c99b4525f700f078becff32c32ec327b10dcf31306a8a52d78166de7", size = 1562846, upload-time = "2025-10-28T20:56:44.85Z" }, + { url = "https://files.pythonhosted.org/packages/39/0f/9f3d32271aa8dc35036e9668e31870a9d3b9542dd6b3e2c8a30931cb27ae/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8a9b889aeabd7a4e9af0b7f4ab5ad94d42e7ff679aaec6d0db21e3b639ad58d", size = 1699606, upload-time = "2025-10-28T20:56:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/2c/3c/52d2658c5699b6ef7692a3f7128b2d2d4d9775f2a68093f74bca06cf01e1/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:fa89cb11bc71a63b69568d5b8a25c3ca25b6d54c15f907ca1c130d72f320b76b", size = 1720663, upload-time = "2025-10-28T20:56:48.528Z" }, + { url = "https://files.pythonhosted.org/packages/9b/d4/8f8f3ff1fb7fb9e3f04fcad4e89d8a1cd8fc7d05de67e3de5b15b33008ff/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8aa7c807df234f693fed0ecd507192fc97692e61fee5702cdc11155d2e5cadc8", size = 1737939, upload-time = "2025-10-28T20:56:50.77Z" }, + { url = "https://files.pythonhosted.org/packages/03/d3/ddd348f8a27a634daae39a1b8e291ff19c77867af438af844bf8b7e3231b/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9eb3e33fdbe43f88c3c75fa608c25e7c47bbd80f48d012763cb67c47f39a7e16", size = 1555132, upload-time = "2025-10-28T20:56:52.568Z" }, + { url = "https://files.pythonhosted.org/packages/39/b8/46790692dc46218406f94374903ba47552f2f9f90dad554eed61bfb7b64c/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9434bc0d80076138ea986833156c5a48c9c7a8abb0c96039ddbb4afc93184169", size = 1764802, upload-time = "2025-10-28T20:56:54.292Z" }, + { url = "https://files.pythonhosted.org/packages/ba/e4/19ce547b58ab2a385e5f0b8aa3db38674785085abcf79b6e0edd1632b12f/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ff15c147b2ad66da1f2cbb0622313f2242d8e6e8f9b79b5206c84523a4473248", size = 1719512, upload-time = "2025-10-28T20:56:56.428Z" }, + { url = "https://files.pythonhosted.org/packages/70/30/6355a737fed29dcb6dfdd48682d5790cb5eab050f7b4e01f49b121d3acad/aiohttp-3.13.2-cp312-cp312-win32.whl", hash = "sha256:27e569eb9d9e95dbd55c0fc3ec3a9335defbf1d8bc1d20171a49f3c4c607b93e", size = 426690, upload-time = "2025-10-28T20:56:58.736Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0d/b10ac09069973d112de6ef980c1f6bb31cb7dcd0bc363acbdad58f927873/aiohttp-3.13.2-cp312-cp312-win_amd64.whl", hash = "sha256:8709a0f05d59a71f33fd05c17fc11fcb8c30140506e13c2f5e8ee1b8964e1b45", size = 453465, upload-time = "2025-10-28T20:57:00.795Z" }, + { url = "https://files.pythonhosted.org/packages/bf/78/7e90ca79e5aa39f9694dcfd74f4720782d3c6828113bb1f3197f7e7c4a56/aiohttp-3.13.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7519bdc7dfc1940d201651b52bf5e03f5503bda45ad6eacf64dda98be5b2b6be", size = 732139, upload-time = "2025-10-28T20:57:02.455Z" }, + { url = "https://files.pythonhosted.org/packages/db/ed/1f59215ab6853fbaa5c8495fa6cbc39edfc93553426152b75d82a5f32b76/aiohttp-3.13.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:088912a78b4d4f547a1f19c099d5a506df17eacec3c6f4375e2831ec1d995742", size = 490082, upload-time = "2025-10-28T20:57:04.784Z" }, + { url = "https://files.pythonhosted.org/packages/68/7b/fe0fe0f5e05e13629d893c760465173a15ad0039c0a5b0d0040995c8075e/aiohttp-3.13.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5276807b9de9092af38ed23ce120539ab0ac955547b38563a9ba4f5b07b95293", size = 489035, upload-time = "2025-10-28T20:57:06.894Z" }, + { url = "https://files.pythonhosted.org/packages/d2/04/db5279e38471b7ac801d7d36a57d1230feeee130bbe2a74f72731b23c2b1/aiohttp-3.13.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1237c1375eaef0db4dcd7c2559f42e8af7b87ea7d295b118c60c36a6e61cb811", size = 1720387, upload-time = "2025-10-28T20:57:08.685Z" }, + { url = "https://files.pythonhosted.org/packages/31/07/8ea4326bd7dae2bd59828f69d7fdc6e04523caa55e4a70f4a8725a7e4ed2/aiohttp-3.13.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:96581619c57419c3d7d78703d5b78c1e5e5fc0172d60f555bdebaced82ded19a", size = 1688314, upload-time = "2025-10-28T20:57:10.693Z" }, + { url = "https://files.pythonhosted.org/packages/48/ab/3d98007b5b87ffd519d065225438cc3b668b2f245572a8cb53da5dd2b1bc/aiohttp-3.13.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2713a95b47374169409d18103366de1050fe0ea73db358fc7a7acb2880422d4", size = 1756317, upload-time = "2025-10-28T20:57:12.563Z" }, + { url = "https://files.pythonhosted.org/packages/97/3d/801ca172b3d857fafb7b50c7c03f91b72b867a13abca982ed6b3081774ef/aiohttp-3.13.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:228a1cd556b3caca590e9511a89444925da87d35219a49ab5da0c36d2d943a6a", size = 1858539, upload-time = "2025-10-28T20:57:14.623Z" }, + { url = "https://files.pythonhosted.org/packages/f7/0d/4764669bdf47bd472899b3d3db91fffbe925c8e3038ec591a2fd2ad6a14d/aiohttp-3.13.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ac6cde5fba8d7d8c6ac963dbb0256a9854e9fafff52fbcc58fdf819357892c3e", size = 1739597, upload-time = "2025-10-28T20:57:16.399Z" }, + { url = "https://files.pythonhosted.org/packages/c4/52/7bd3c6693da58ba16e657eb904a5b6decfc48ecd06e9ac098591653b1566/aiohttp-3.13.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2bef8237544f4e42878c61cef4e2839fee6346dc60f5739f876a9c50be7fcdb", size = 1555006, upload-time = "2025-10-28T20:57:18.288Z" }, + { url = "https://files.pythonhosted.org/packages/48/30/9586667acec5993b6f41d2ebcf96e97a1255a85f62f3c653110a5de4d346/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:16f15a4eac3bc2d76c45f7ebdd48a65d41b242eb6c31c2245463b40b34584ded", size = 1683220, upload-time = "2025-10-28T20:57:20.241Z" }, + { url = "https://files.pythonhosted.org/packages/71/01/3afe4c96854cfd7b30d78333852e8e851dceaec1c40fd00fec90c6402dd2/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:bb7fb776645af5cc58ab804c58d7eba545a97e047254a52ce89c157b5af6cd0b", size = 1712570, upload-time = "2025-10-28T20:57:22.253Z" }, + { url = "https://files.pythonhosted.org/packages/11/2c/22799d8e720f4697a9e66fd9c02479e40a49de3de2f0bbe7f9f78a987808/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e1b4951125ec10c70802f2cb09736c895861cd39fd9dcb35107b4dc8ae6220b8", size = 1733407, upload-time = "2025-10-28T20:57:24.37Z" }, + { url = "https://files.pythonhosted.org/packages/34/cb/90f15dd029f07cebbd91f8238a8b363978b530cd128488085b5703683594/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:550bf765101ae721ee1d37d8095f47b1f220650f85fe1af37a90ce75bab89d04", size = 1550093, upload-time = "2025-10-28T20:57:26.257Z" }, + { url = "https://files.pythonhosted.org/packages/69/46/12dce9be9d3303ecbf4d30ad45a7683dc63d90733c2d9fe512be6716cd40/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fe91b87fc295973096251e2d25a811388e7d8adf3bd2b97ef6ae78bc4ac6c476", size = 1758084, upload-time = "2025-10-28T20:57:28.349Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c8/0932b558da0c302ffd639fc6362a313b98fdf235dc417bc2493da8394df7/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0c8e31cfcc4592cb200160344b2fb6ae0f9e4effe06c644b5a125d4ae5ebe23", size = 1716987, upload-time = "2025-10-28T20:57:30.233Z" }, + { url = "https://files.pythonhosted.org/packages/5d/8b/f5bd1a75003daed099baec373aed678f2e9b34f2ad40d85baa1368556396/aiohttp-3.13.2-cp313-cp313-win32.whl", hash = "sha256:0740f31a60848d6edb296a0df827473eede90c689b8f9f2a4cdde74889eb2254", size = 425859, upload-time = "2025-10-28T20:57:32.105Z" }, + { url = "https://files.pythonhosted.org/packages/5d/28/a8a9fc6957b2cee8902414e41816b5ab5536ecf43c3b1843c10e82c559b2/aiohttp-3.13.2-cp313-cp313-win_amd64.whl", hash = "sha256:a88d13e7ca367394908f8a276b89d04a3652044612b9a408a0bb22a5ed976a1a", size = 452192, upload-time = "2025-10-28T20:57:34.166Z" }, + { url = "https://files.pythonhosted.org/packages/9b/36/e2abae1bd815f01c957cbf7be817b3043304e1c87bad526292a0410fdcf9/aiohttp-3.13.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2475391c29230e063ef53a66669b7b691c9bfc3f1426a0f7bcdf1216bdbac38b", size = 735234, upload-time = "2025-10-28T20:57:36.415Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e3/1ee62dde9b335e4ed41db6bba02613295a0d5b41f74a783c142745a12763/aiohttp-3.13.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:f33c8748abef4d8717bb20e8fb1b3e07c6adacb7fd6beaae971a764cf5f30d61", size = 490733, upload-time = "2025-10-28T20:57:38.205Z" }, + { url = "https://files.pythonhosted.org/packages/1a/aa/7a451b1d6a04e8d15a362af3e9b897de71d86feac3babf8894545d08d537/aiohttp-3.13.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ae32f24bbfb7dbb485a24b30b1149e2f200be94777232aeadba3eecece4d0aa4", size = 491303, upload-time = "2025-10-28T20:57:40.122Z" }, + { url = "https://files.pythonhosted.org/packages/57/1e/209958dbb9b01174870f6a7538cd1f3f28274fdbc88a750c238e2c456295/aiohttp-3.13.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d7f02042c1f009ffb70067326ef183a047425bb2ff3bc434ead4dd4a4a66a2b", size = 1717965, upload-time = "2025-10-28T20:57:42.28Z" }, + { url = "https://files.pythonhosted.org/packages/08/aa/6a01848d6432f241416bc4866cae8dc03f05a5a884d2311280f6a09c73d6/aiohttp-3.13.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93655083005d71cd6c072cdab54c886e6570ad2c4592139c3fb967bfc19e4694", size = 1667221, upload-time = "2025-10-28T20:57:44.869Z" }, + { url = "https://files.pythonhosted.org/packages/87/4f/36c1992432d31bbc789fa0b93c768d2e9047ec8c7177e5cd84ea85155f36/aiohttp-3.13.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0db1e24b852f5f664cd728db140cf11ea0e82450471232a394b3d1a540b0f906", size = 1757178, upload-time = "2025-10-28T20:57:47.216Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b4/8e940dfb03b7e0f68a82b88fd182b9be0a65cb3f35612fe38c038c3112cf/aiohttp-3.13.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b009194665bcd128e23eaddef362e745601afa4641930848af4c8559e88f18f9", size = 1838001, upload-time = "2025-10-28T20:57:49.337Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ef/39f3448795499c440ab66084a9db7d20ca7662e94305f175a80f5b7e0072/aiohttp-3.13.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c038a8fdc8103cd51dbd986ecdce141473ffd9775a7a8057a6ed9c3653478011", size = 1716325, upload-time = "2025-10-28T20:57:51.327Z" }, + { url = "https://files.pythonhosted.org/packages/d7/51/b311500ffc860b181c05d91c59a1313bdd05c82960fdd4035a15740d431e/aiohttp-3.13.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66bac29b95a00db411cd758fea0e4b9bdba6d549dfe333f9a945430f5f2cc5a6", size = 1547978, upload-time = "2025-10-28T20:57:53.554Z" }, + { url = "https://files.pythonhosted.org/packages/31/64/b9d733296ef79815226dab8c586ff9e3df41c6aff2e16c06697b2d2e6775/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4ebf9cfc9ba24a74cf0718f04aac2a3bbe745902cc7c5ebc55c0f3b5777ef213", size = 1682042, upload-time = "2025-10-28T20:57:55.617Z" }, + { url = "https://files.pythonhosted.org/packages/3f/30/43d3e0f9d6473a6db7d472104c4eff4417b1e9df01774cb930338806d36b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a4b88ebe35ce54205c7074f7302bd08a4cb83256a3e0870c72d6f68a3aaf8e49", size = 1680085, upload-time = "2025-10-28T20:57:57.59Z" }, + { url = "https://files.pythonhosted.org/packages/16/51/c709f352c911b1864cfd1087577760ced64b3e5bee2aa88b8c0c8e2e4972/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:98c4fb90bb82b70a4ed79ca35f656f4281885be076f3f970ce315402b53099ae", size = 1728238, upload-time = "2025-10-28T20:57:59.525Z" }, + { url = "https://files.pythonhosted.org/packages/19/e2/19bd4c547092b773caeb48ff5ae4b1ae86756a0ee76c16727fcfd281404b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:ec7534e63ae0f3759df3a1ed4fa6bc8f75082a924b590619c0dd2f76d7043caa", size = 1544395, upload-time = "2025-10-28T20:58:01.914Z" }, + { url = "https://files.pythonhosted.org/packages/cf/87/860f2803b27dfc5ed7be532832a3498e4919da61299b4a1f8eb89b8ff44d/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5b927cf9b935a13e33644cbed6c8c4b2d0f25b713d838743f8fe7191b33829c4", size = 1742965, upload-time = "2025-10-28T20:58:03.972Z" }, + { url = "https://files.pythonhosted.org/packages/67/7f/db2fc7618925e8c7a601094d5cbe539f732df4fb570740be88ed9e40e99a/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:88d6c017966a78c5265d996c19cdb79235be5e6412268d7e2ce7dee339471b7a", size = 1697585, upload-time = "2025-10-28T20:58:06.189Z" }, + { url = "https://files.pythonhosted.org/packages/0c/07/9127916cb09bb38284db5036036042b7b2c514c8ebaeee79da550c43a6d6/aiohttp-3.13.2-cp314-cp314-win32.whl", hash = "sha256:f7c183e786e299b5d6c49fb43a769f8eb8e04a2726a2bd5887b98b5cc2d67940", size = 431621, upload-time = "2025-10-28T20:58:08.636Z" }, + { url = "https://files.pythonhosted.org/packages/fb/41/554a8a380df6d3a2bba8a7726429a23f4ac62aaf38de43bb6d6cde7b4d4d/aiohttp-3.13.2-cp314-cp314-win_amd64.whl", hash = "sha256:fe242cd381e0fb65758faf5ad96c2e460df6ee5b2de1072fe97e4127927e00b4", size = 457627, upload-time = "2025-10-28T20:58:11Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8e/3824ef98c039d3951cb65b9205a96dd2b20f22241ee17d89c5701557c826/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f10d9c0b0188fe85398c61147bbd2a657d616c876863bfeff43376e0e3134673", size = 767360, upload-time = "2025-10-28T20:58:13.358Z" }, + { url = "https://files.pythonhosted.org/packages/a4/0f/6a03e3fc7595421274fa34122c973bde2d89344f8a881b728fa8c774e4f1/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e7c952aefdf2460f4ae55c5e9c3e80aa72f706a6317e06020f80e96253b1accd", size = 504616, upload-time = "2025-10-28T20:58:15.339Z" }, + { url = "https://files.pythonhosted.org/packages/c6/aa/ed341b670f1bc8a6f2c6a718353d13b9546e2cef3544f573c6a1ff0da711/aiohttp-3.13.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c20423ce14771d98353d2e25e83591fa75dfa90a3c1848f3d7c68243b4fbded3", size = 509131, upload-time = "2025-10-28T20:58:17.693Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f0/c68dac234189dae5c4bbccc0f96ce0cc16b76632cfc3a08fff180045cfa4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e96eb1a34396e9430c19d8338d2ec33015e4a87ef2b4449db94c22412e25ccdf", size = 1864168, upload-time = "2025-10-28T20:58:20.113Z" }, + { url = "https://files.pythonhosted.org/packages/8f/65/75a9a76db8364b5d0e52a0c20eabc5d52297385d9af9c35335b924fafdee/aiohttp-3.13.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:23fb0783bc1a33640036465019d3bba069942616a6a2353c6907d7fe1ccdaf4e", size = 1719200, upload-time = "2025-10-28T20:58:22.583Z" }, + { url = "https://files.pythonhosted.org/packages/f5/55/8df2ed78d7f41d232f6bd3ff866b6f617026551aa1d07e2f03458f964575/aiohttp-3.13.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e1a9bea6244a1d05a4e57c295d69e159a5c50d8ef16aa390948ee873478d9a5", size = 1843497, upload-time = "2025-10-28T20:58:24.672Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e0/94d7215e405c5a02ccb6a35c7a3a6cfff242f457a00196496935f700cde5/aiohttp-3.13.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0a3d54e822688b56e9f6b5816fb3de3a3a64660efac64e4c2dc435230ad23bad", size = 1935703, upload-time = "2025-10-28T20:58:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/0b/78/1eeb63c3f9b2d1015a4c02788fb543141aad0a03ae3f7a7b669b2483f8d4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a653d872afe9f33497215745da7a943d1dc15b728a9c8da1c3ac423af35178e", size = 1792738, upload-time = "2025-10-28T20:58:29.787Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/aaf1eea4c188e51538c04cc568040e3082db263a57086ea74a7d38c39e42/aiohttp-3.13.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:56d36e80d2003fa3fc0207fac644216d8532e9504a785ef9a8fd013f84a42c61", size = 1624061, upload-time = "2025-10-28T20:58:32.529Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c2/3b6034de81fbcc43de8aeb209073a2286dfb50b86e927b4efd81cf848197/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:78cd586d8331fb8e241c2dd6b2f4061778cc69e150514b39a9e28dd050475661", size = 1789201, upload-time = "2025-10-28T20:58:34.618Z" }, + { url = "https://files.pythonhosted.org/packages/c9/38/c15dcf6d4d890217dae79d7213988f4e5fe6183d43893a9cf2fe9e84ca8d/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:20b10bbfbff766294fe99987f7bb3b74fdd2f1a2905f2562132641ad434dcf98", size = 1776868, upload-time = "2025-10-28T20:58:38.835Z" }, + { url = "https://files.pythonhosted.org/packages/04/75/f74fd178ac81adf4f283a74847807ade5150e48feda6aef024403716c30c/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9ec49dff7e2b3c85cdeaa412e9d438f0ecd71676fde61ec57027dd392f00c693", size = 1790660, upload-time = "2025-10-28T20:58:41.507Z" }, + { url = "https://files.pythonhosted.org/packages/e7/80/7368bd0d06b16b3aba358c16b919e9c46cf11587dc572091031b0e9e3ef0/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:94f05348c4406450f9d73d38efb41d669ad6cd90c7ee194810d0eefbfa875a7a", size = 1617548, upload-time = "2025-10-28T20:58:43.674Z" }, + { url = "https://files.pythonhosted.org/packages/7d/4b/a6212790c50483cb3212e507378fbe26b5086d73941e1ec4b56a30439688/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:fa4dcb605c6f82a80c7f95713c2b11c3b8e9893b3ebd2bc9bde93165ed6107be", size = 1817240, upload-time = "2025-10-28T20:58:45.787Z" }, + { url = "https://files.pythonhosted.org/packages/ff/f7/ba5f0ba4ea8d8f3c32850912944532b933acbf0f3a75546b89269b9b7dde/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf00e5db968c3f67eccd2778574cf64d8b27d95b237770aa32400bd7a1ca4f6c", size = 1762334, upload-time = "2025-10-28T20:58:47.936Z" }, + { url = "https://files.pythonhosted.org/packages/7e/83/1a5a1856574588b1cad63609ea9ad75b32a8353ac995d830bf5da9357364/aiohttp-3.13.2-cp314-cp314t-win32.whl", hash = "sha256:d23b5fe492b0805a50d3371e8a728a9134d8de5447dce4c885f5587294750734", size = 464685, upload-time = "2025-10-28T20:58:50.642Z" }, + { url = "https://files.pythonhosted.org/packages/9f/4d/d22668674122c08f4d56972297c51a624e64b3ed1efaa40187607a7cb66e/aiohttp-3.13.2-cp314-cp314t-win_amd64.whl", hash = "sha256:ff0a7b0a82a7ab905cbda74006318d1b12e37c797eb1b0d4eb3e316cf47f658f", size = 498093, upload-time = "2025-10-28T20:58:52.782Z" }, +] + +[[package]] +name = "aioitertools" +version = "0.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/3c/53c4a17a05fb9ea2313ee1777ff53f5e001aefd5cc85aa2f4c2d982e1e38/aioitertools-0.13.0.tar.gz", hash = "sha256:620bd241acc0bbb9ec819f1ab215866871b4bbd1f73836a55f799200ee86950c", size = 19322, upload-time = "2025-11-06T22:17:07.609Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/a1/510b0a7fadc6f43a6ce50152e69dbd86415240835868bb0bd9b5b88b1e06/aioitertools-0.13.0-py3-none-any.whl", hash = "sha256:0be0292b856f08dfac90e31f4739432f4cb6d7520ab9eb73e143f4f2fa5259be", size = 24182, upload-time = "2025-11-06T22:17:06.502Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, +] + +[[package]] +name = "annotated-doc" +version = "0.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, +] + +[[package]] +name = "anyio" +version = "4.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" }, +] + +[[package]] +name = "apscheduler" +version = "3.11.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "tzlocal" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/07/12/3e4389e5920b4c1763390c6d371162f3784f86f85cd6d6c1bfe68eef14e2/apscheduler-3.11.2.tar.gz", hash = "sha256:2a9966b052ec805f020c8c4c3ae6e6a06e24b1bf19f2e11d91d8cca0473eef41", size = 108683, upload-time = "2025-12-22T00:39:34.884Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/64/2e54428beba8d9992aa478bb8f6de9e4ecaa5f8f513bcfd567ed7fb0262d/apscheduler-3.11.2-py3-none-any.whl", hash = "sha256:ce005177f741409db4e4dd40a7431b76feb856b9dd69d57e0da49d6715bfd26d", size = 64439, upload-time = "2025-12-22T00:39:33.303Z" }, +] + +[[package]] +name = "attrs" +version = "25.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" }, +] + +[[package]] +name = "authlib" +version = "1.6.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/3f/1d3bbd0bf23bdd99276d4def22f29c27a914067b4cf66f753ff9b8bbd0f3/authlib-1.6.5.tar.gz", hash = "sha256:6aaf9c79b7cc96c900f0b284061691c5d4e61221640a948fe690b556a6d6d10b", size = 164553, upload-time = "2025-10-02T13:36:09.489Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/aa/5082412d1ee302e9e7d80b6949bc4d2a8fa1149aaab610c5fc24709605d6/authlib-1.6.5-py2.py3-none-any.whl", hash = "sha256:3e0e0507807f842b02175507bdee8957a1d5707fd4afb17c32fb43fee90b6e3a", size = 243608, upload-time = "2025-10-02T13:36:07.637Z" }, +] + +[[package]] +name = "backports-tarfile" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", size = 86406, upload-time = "2024-05-28T17:01:54.731Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181, upload-time = "2024-05-28T17:01:53.112Z" }, +] + +[[package]] +name = "beartype" +version = "0.22.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/88/e2/105ceb1704cb80fe4ab3872529ab7b6f365cf7c74f725e6132d0efcf1560/beartype-0.22.6.tar.gz", hash = "sha256:97fbda69c20b48c5780ac2ca60ce3c1bb9af29b3a1a0216898ffabdd523e48f4", size = 1588975, upload-time = "2025-11-20T04:47:14.736Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/98/c9/ceecc71fe2c9495a1d8e08d44f5f31f5bca1350d5b2e27a4b6265424f59e/beartype-0.22.6-py3-none-any.whl", hash = "sha256:0584bc46a2ea2a871509679278cda992eadde676c01356ab0ac77421f3c9a093", size = 1324807, upload-time = "2025-11-20T04:47:11.837Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.14.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/77/e9/df2358efd7659577435e2177bfa69cba6c33216681af51a707193dec162a/beautifulsoup4-4.14.2.tar.gz", hash = "sha256:2a98ab9f944a11acee9cc848508ec28d9228abfd522ef0fad6a02a72e0ded69e", size = 625822, upload-time = "2025-09-29T10:05:42.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/fe/3aed5d0be4d404d12d36ab97e2f1791424d9ca39c2f754a6285d59a3b01d/beautifulsoup4-4.14.2-py3-none-any.whl", hash = "sha256:5ef6fa3a8cbece8488d66985560f97ed091e22bbc4e9c2338508a9d5de6d4515", size = 106392, upload-time = "2025-09-29T10:05:43.771Z" }, +] + +[[package]] +name = "bleach" +version = "6.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/07/18/3c8523962314be6bf4c8989c79ad9531c825210dd13a8669f6b84336e8bd/bleach-6.3.0.tar.gz", hash = "sha256:6f3b91b1c0a02bb9a78b5a454c92506aa0fdf197e1d5e114d2e00c6f64306d22", size = 203533, upload-time = "2025-10-27T17:57:39.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cd/3a/577b549de0cc09d95f11087ee63c739bba856cd3952697eec4c4bb91350a/bleach-6.3.0-py3-none-any.whl", hash = "sha256:fe10ec77c93ddf3d13a73b035abaac7a9f5e436513864ccdad516693213c65d6", size = 164437, upload-time = "2025-10-27T17:57:37.538Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "boto3" +version = "1.40.61" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "botocore" }, + { name = "jmespath" }, + { name = "s3transfer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/f9/6ef8feb52c3cce5ec3967a535a6114b57ac7949fd166b0f3090c2b06e4e5/boto3-1.40.61.tar.gz", hash = "sha256:d6c56277251adf6c2bdd25249feae625abe4966831676689ff23b4694dea5b12", size = 111535, upload-time = "2025-10-28T19:26:57.247Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/24/3bf865b07d15fea85b63504856e137029b6acbc73762496064219cdb265d/boto3-1.40.61-py3-none-any.whl", hash = "sha256:6b9c57b2a922b5d8c17766e29ed792586a818098efe84def27c8f582b33f898c", size = 139321, upload-time = "2025-10-28T19:26:55.007Z" }, +] + +[[package]] +name = "botocore" +version = "1.40.61" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jmespath" }, + { name = "python-dateutil" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/a3/81d3a47c2dbfd76f185d3b894f2ad01a75096c006a2dd91f237dca182188/botocore-1.40.61.tar.gz", hash = "sha256:a2487ad69b090f9cccd64cf07c7021cd80ee9c0655ad974f87045b02f3ef52cd", size = 14393956, upload-time = "2025-10-28T19:26:46.108Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/c5/f6ce561004db45f0b847c2cd9b19c67c6bf348a82018a48cb718be6b58b0/botocore-1.40.61-py3-none-any.whl", hash = "sha256:17ebae412692fd4824f99cde0f08d50126dc97954008e5ba2b522eb049238aa7", size = 14055973, upload-time = "2025-10-28T19:26:42.15Z" }, +] + +[[package]] +name = "cachetools" +version = "6.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fb/44/ca1675be2a83aeee1886ab745b28cda92093066590233cc501890eb8417a/cachetools-6.2.2.tar.gz", hash = "sha256:8e6d266b25e539df852251cfd6f990b4bc3a141db73b939058d809ebd2590fc6", size = 31571, upload-time = "2025-11-13T17:42:51.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/46/eb6eca305c77a4489affe1c5d8f4cae82f285d9addd8de4ec084a7184221/cachetools-6.2.2-py3-none-any.whl", hash = "sha256:6c09c98183bf58560c97b2abfcedcbaf6a896a490f534b031b661d3723b45ace", size = 11503, upload-time = "2025-11-13T17:42:50.232Z" }, +] + +[[package]] +name = "caio" +version = "0.9.25" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/92/88/b8527e1b00c1811db339a1df8bd1ae49d146fcea9d6a5c40e3a80aaeb38d/caio-0.9.25.tar.gz", hash = "sha256:16498e7f81d1d0f5a4c0ad3f2540e65fe25691376e0a5bd367f558067113ed10", size = 26781, upload-time = "2025-12-26T15:21:36.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/90/543f556fcfcfa270713eef906b6352ab048e1e557afec12925c991dc93c2/caio-0.9.25-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d6956d9e4a27021c8bd6c9677f3a59eb1d820cc32d0343cea7961a03b1371965", size = 36839, upload-time = "2025-12-26T15:21:40.267Z" }, + { url = "https://files.pythonhosted.org/packages/51/3b/36f3e8ec38dafe8de4831decd2e44c69303d2a3892d16ceda42afed44e1b/caio-0.9.25-cp311-cp311-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bf84bfa039f25ad91f4f52944452a5f6f405e8afab4d445450978cd6241d1478", size = 80255, upload-time = "2025-12-26T15:22:20.271Z" }, + { url = "https://files.pythonhosted.org/packages/df/ce/65e64867d928e6aff1b4f0e12dba0ef6d5bf412c240dc1df9d421ac10573/caio-0.9.25-cp311-cp311-manylinux_2_34_aarch64.whl", hash = "sha256:ae3d62587332bce600f861a8de6256b1014d6485cfd25d68c15caf1611dd1f7c", size = 80052, upload-time = "2026-03-04T22:08:20.402Z" }, + { url = "https://files.pythonhosted.org/packages/46/90/e278863c47e14ec58309aa2e38a45882fbe67b4cc29ec9bc8f65852d3e45/caio-0.9.25-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:fc220b8533dcf0f238a6b1a4a937f92024c71e7b10b5a2dfc1c73604a25709bc", size = 78273, upload-time = "2026-03-04T22:08:21.368Z" }, + { url = "https://files.pythonhosted.org/packages/d3/25/79c98ebe12df31548ba4eaf44db11b7cad6b3e7b4203718335620939083c/caio-0.9.25-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fb7ff95af4c31ad3f03179149aab61097a71fd85e05f89b4786de0359dffd044", size = 36983, upload-time = "2025-12-26T15:21:36.075Z" }, + { url = "https://files.pythonhosted.org/packages/a3/2b/21288691f16d479945968a0a4f2856818c1c5be56881d51d4dac9b255d26/caio-0.9.25-cp312-cp312-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:97084e4e30dfa598449d874c4d8e0c8d5ea17d2f752ef5e48e150ff9d240cd64", size = 82012, upload-time = "2025-12-26T15:22:20.983Z" }, + { url = "https://files.pythonhosted.org/packages/03/c4/8a1b580875303500a9c12b9e0af58cb82e47f5bcf888c2457742a138273c/caio-0.9.25-cp312-cp312-manylinux_2_34_aarch64.whl", hash = "sha256:4fa69eba47e0f041b9d4f336e2ad40740681c43e686b18b191b6c5f4c5544bfb", size = 81502, upload-time = "2026-03-04T22:08:22.381Z" }, + { url = "https://files.pythonhosted.org/packages/d1/1c/0fe770b8ffc8362c48134d1592d653a81a3d8748d764bec33864db36319d/caio-0.9.25-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:6bebf6f079f1341d19f7386db9b8b1f07e8cc15ae13bfdaff573371ba0575d69", size = 80200, upload-time = "2026-03-04T22:08:23.382Z" }, + { url = "https://files.pythonhosted.org/packages/31/57/5e6ff127e6f62c9f15d989560435c642144aa4210882f9494204bc892305/caio-0.9.25-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d6c2a3411af97762a2b03840c3cec2f7f728921ff8adda53d7ea2315a8563451", size = 36979, upload-time = "2025-12-26T15:21:35.484Z" }, + { url = "https://files.pythonhosted.org/packages/a3/9f/f21af50e72117eb528c422d4276cbac11fb941b1b812b182e0a9c70d19c5/caio-0.9.25-cp313-cp313-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0998210a4d5cd5cb565b32ccfe4e53d67303f868a76f212e002a8554692870e6", size = 81900, upload-time = "2025-12-26T15:22:21.919Z" }, + { url = "https://files.pythonhosted.org/packages/9c/12/c39ae2a4037cb10ad5eb3578eb4d5f8c1a2575c62bba675f3406b7ef0824/caio-0.9.25-cp313-cp313-manylinux_2_34_aarch64.whl", hash = "sha256:1a177d4777141b96f175fe2c37a3d96dec7911ed9ad5f02bac38aaa1c936611f", size = 81523, upload-time = "2026-03-04T22:08:25.187Z" }, + { url = "https://files.pythonhosted.org/packages/22/59/f8f2e950eb4f1a5a3883e198dca514b9d475415cb6cd7b78b9213a0dd45a/caio-0.9.25-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:9ed3cfb28c0e99fec5e208c934e5c157d0866aa9c32aa4dc5e9b6034af6286b7", size = 80243, upload-time = "2026-03-04T22:08:26.449Z" }, + { url = "https://files.pythonhosted.org/packages/69/ca/a08fdc7efdcc24e6a6131a93c85be1f204d41c58f474c42b0670af8c016b/caio-0.9.25-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fab6078b9348e883c80a5e14b382e6ad6aabbc4429ca034e76e730cf464269db", size = 36978, upload-time = "2025-12-26T15:21:41.055Z" }, + { url = "https://files.pythonhosted.org/packages/5e/6c/d4d24f65e690213c097174d26eda6831f45f4734d9d036d81790a27e7b78/caio-0.9.25-cp314-cp314-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:44a6b58e52d488c75cfaa5ecaa404b2b41cc965e6c417e03251e868ecd5b6d77", size = 81832, upload-time = "2025-12-26T15:22:22.757Z" }, + { url = "https://files.pythonhosted.org/packages/87/a4/e534cf7d2d0e8d880e25dd61e8d921ffcfe15bd696734589826f5a2df727/caio-0.9.25-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:628a630eb7fb22381dd8e3c8ab7f59e854b9c806639811fc3f4310c6bd711d79", size = 81565, upload-time = "2026-03-04T22:08:27.483Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ed/bf81aeac1d290017e5e5ac3e880fd56ee15e50a6d0353986799d1bc5cfd5/caio-0.9.25-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:0ba16aa605ccb174665357fc729cf500679c2d94d5f1458a6f0d5ca48f2060a7", size = 80071, upload-time = "2026-03-04T22:08:28.751Z" }, + { url = "https://files.pythonhosted.org/packages/86/93/1f76c8d1bafe3b0614e06b2195784a3765bbf7b0a067661af9e2dd47fc33/caio-0.9.25-py3-none-any.whl", hash = "sha256:06c0bb02d6b929119b1cfbe1ca403c768b2013a369e2db46bfa2a5761cf82e40", size = 19087, upload-time = "2025-12-26T15:22:00.221Z" }, +] + +[[package]] +name = "certifi" +version = "2025.11.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538, upload-time = "2025-11-12T02:54:51.517Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438, upload-time = "2025-11-12T02:54:49.735Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" }, + { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" }, + { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" }, + { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" }, + { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" }, + { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" }, + { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" }, + { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" }, + { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" }, + { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" }, + { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" }, + { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" }, + { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" }, + { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" }, + { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" }, + { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" }, + { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" }, + { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" }, + { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" }, + { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" }, + { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" }, + { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" }, + { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" }, + { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" }, + { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" }, + { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" }, + { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" }, + { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" }, + { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" }, + { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" }, + { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" }, + { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" }, + { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" }, + { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" }, + { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" }, + { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" }, + { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" }, + { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" }, + { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" }, + { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" }, + { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" }, + { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" }, + { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" }, + { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" }, + { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" }, + { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" }, + { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" }, + { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" }, +] + +[[package]] +name = "click" +version = "8.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/60/6c/8ca2efa64cf75a977a0d7fac081354553ebe483345c734fb6b6515d96bbc/click-8.2.1.tar.gz", hash = "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202", size = 286342, upload-time = "2025-05-20T23:19:49.832Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215, upload-time = "2025-05-20T23:19:47.796Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "cryptography" +version = "46.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload-time = "2025-10-15T23:16:52.239Z" }, + { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" }, + { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" }, + { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" }, + { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" }, + { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" }, + { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" }, + { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" }, + { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" }, + { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" }, + { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" }, + { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" }, + { url = "https://files.pythonhosted.org/packages/96/92/8a6a9525893325fc057a01f654d7efc2c64b9de90413adcf605a85744ff4/cryptography-46.0.3-cp311-abi3-win32.whl", hash = "sha256:f260d0d41e9b4da1ed1e0f1ce571f97fe370b152ab18778e9e8f67d6af432018", size = 3055988, upload-time = "2025-10-15T23:17:14.65Z" }, + { url = "https://files.pythonhosted.org/packages/7e/bf/80fbf45253ea585a1e492a6a17efcb93467701fa79e71550a430c5e60df0/cryptography-46.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:a9a3008438615669153eb86b26b61e09993921ebdd75385ddd748702c5adfddb", size = 3514451, upload-time = "2025-10-15T23:17:16.142Z" }, + { url = "https://files.pythonhosted.org/packages/2e/af/9b302da4c87b0beb9db4e756386a7c6c5b8003cd0e742277888d352ae91d/cryptography-46.0.3-cp311-abi3-win_arm64.whl", hash = "sha256:5d7f93296ee28f68447397bf5198428c9aeeab45705a55d53a6343455dcb2c3c", size = 2928007, upload-time = "2025-10-15T23:17:18.04Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e2/a510aa736755bffa9d2f75029c229111a1d02f8ecd5de03078f4c18d91a3/cryptography-46.0.3-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:00a5e7e87938e5ff9ff5447ab086a5706a957137e6e433841e9d24f38a065217", size = 7158012, upload-time = "2025-10-15T23:17:19.982Z" }, + { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" }, + { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" }, + { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" }, + { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" }, + { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" }, + { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" }, + { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" }, + { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" }, + { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" }, + { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" }, + { url = "https://files.pythonhosted.org/packages/fd/30/27654c1dbaf7e4a3531fa1fc77986d04aefa4d6d78259a62c9dc13d7ad36/cryptography-46.0.3-cp314-cp314t-win32.whl", hash = "sha256:8a6e050cb6164d3f830453754094c086ff2d0b2f3a897a1d9820f6139a1f0914", size = 3022339, upload-time = "2025-10-15T23:17:40.888Z" }, + { url = "https://files.pythonhosted.org/packages/f6/30/640f34ccd4d2a1bc88367b54b926b781b5a018d65f404d409aba76a84b1c/cryptography-46.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:760f83faa07f8b64e9c33fc963d790a2edb24efb479e3520c14a45741cd9b2db", size = 3494315, upload-time = "2025-10-15T23:17:42.769Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8b/88cc7e3bd0a8e7b861f26981f7b820e1f46aa9d26cc482d0feba0ecb4919/cryptography-46.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:516ea134e703e9fe26bcd1277a4b59ad30586ea90c365a87781d7887a646fe21", size = 2919331, upload-time = "2025-10-15T23:17:44.468Z" }, + { url = "https://files.pythonhosted.org/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload-time = "2025-10-15T23:17:46.294Z" }, + { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" }, + { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" }, + { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" }, + { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" }, + { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" }, + { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" }, + { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" }, + { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" }, + { url = "https://files.pythonhosted.org/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload-time = "2025-10-15T23:18:08.672Z" }, + { url = "https://files.pythonhosted.org/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload-time = "2025-10-15T23:18:10.632Z" }, + { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" }, + { url = "https://files.pythonhosted.org/packages/06/8a/e60e46adab4362a682cf142c7dcb5bf79b782ab2199b0dcb81f55970807f/cryptography-46.0.3-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7ce938a99998ed3c8aa7e7272dca1a610401ede816d36d0693907d863b10d9ea", size = 3698132, upload-time = "2025-10-15T23:18:17.056Z" }, + { url = "https://files.pythonhosted.org/packages/da/38/f59940ec4ee91e93d3311f7532671a5cef5570eb04a144bf203b58552d11/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:191bb60a7be5e6f54e30ba16fdfae78ad3a342a0599eb4193ba88e3f3d6e185b", size = 4243992, upload-time = "2025-10-15T23:18:18.695Z" }, + { url = "https://files.pythonhosted.org/packages/b0/0c/35b3d92ddebfdfda76bb485738306545817253d0a3ded0bfe80ef8e67aa5/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c70cc23f12726be8f8bc72e41d5065d77e4515efae3690326764ea1b07845cfb", size = 4409944, upload-time = "2025-10-15T23:18:20.597Z" }, + { url = "https://files.pythonhosted.org/packages/99/55/181022996c4063fc0e7666a47049a1ca705abb9c8a13830f074edb347495/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:9394673a9f4de09e28b5356e7fff97d778f8abad85c9d5ac4a4b7e25a0de7717", size = 4242957, upload-time = "2025-10-15T23:18:22.18Z" }, + { url = "https://files.pythonhosted.org/packages/ba/af/72cd6ef29f9c5f731251acadaeb821559fe25f10852f44a63374c9ca08c1/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:94cd0549accc38d1494e1f8de71eca837d0509d0d44bf11d158524b0e12cebf9", size = 4409447, upload-time = "2025-10-15T23:18:24.209Z" }, + { url = "https://files.pythonhosted.org/packages/0d/c3/e90f4a4feae6410f914f8ebac129b9ae7a8c92eb60a638012dde42030a9d/cryptography-46.0.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6b5063083824e5509fdba180721d55909ffacccc8adbec85268b48439423d78c", size = 3438528, upload-time = "2025-10-15T23:18:26.227Z" }, +] + +[[package]] +name = "cyclopts" +version = "4.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "docstring-parser" }, + { name = "rich" }, + { name = "rich-rst" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/08/f20fe40a5db9cd1c42316de5a26209dd008f30d38eea297f94e744dea463/cyclopts-4.2.4.tar.gz", hash = "sha256:27e1d175df2889aba72cd960c4e34c8b0a501c5b0161e849c72d9fee5903ecbb", size = 149362, upload-time = "2025-11-14T21:38:46.722Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/b2/fabcd6020b63b9d9f7a79cfc61b9c03c4e08ccb54f9cf9db9791be5669ef/cyclopts-4.2.4-py3-none-any.whl", hash = "sha256:41054f5e921a4f2b8ab9c839f12a274dec06a19560dc4898ce37cb775ca68ca4", size = 185023, upload-time = "2025-11-14T21:38:45.659Z" }, +] + +[[package]] +name = "datasets" +version = "4.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dill" }, + { name = "filelock" }, + { name = "fsspec", extra = ["http"] }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "multiprocess" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "pyarrow" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "xxhash" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/93/bf/0dae295d6d1ba0b1a200a9dd216838464b5bbd05da01407cb1330b377445/datasets-4.4.1.tar.gz", hash = "sha256:80322699aa8c0bbbdb7caa87906da689c3c2e29523cff698775c67f28fdab1fc", size = 585341, upload-time = "2025-11-05T16:00:38.162Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/5e/6f8d874366788ad5d549e9ba258037d974dda6e004843be1bda794571701/datasets-4.4.1-py3-none-any.whl", hash = "sha256:c1163de5211e42546079ab355cc0250c7e6db16eb209ac5ac6252f801f596c44", size = 511591, upload-time = "2025-11-05T16:00:36.365Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.17" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/ad/71e708ff4ca377c4230530d6a7aa7992592648c122a2cd2b321cf8b35a76/debugpy-1.8.17.tar.gz", hash = "sha256:fd723b47a8c08892b1a16b2c6239a8b96637c62a59b94bb5dab4bac592a58a8e", size = 1644129, upload-time = "2025-09-17T16:33:20.633Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d8/53/3af72b5c159278c4a0cf4cffa518675a0e73bdb7d1cac0239b815502d2ce/debugpy-1.8.17-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:d3fce3f0e3de262a3b67e69916d001f3e767661c6e1ee42553009d445d1cd840", size = 2207154, upload-time = "2025-09-17T16:33:29.457Z" }, + { url = "https://files.pythonhosted.org/packages/8f/6d/204f407df45600e2245b4a39860ed4ba32552330a0b3f5f160ae4cc30072/debugpy-1.8.17-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:c6bdf134457ae0cac6fb68205776be635d31174eeac9541e1d0c062165c6461f", size = 3170322, upload-time = "2025-09-17T16:33:30.837Z" }, + { url = "https://files.pythonhosted.org/packages/f2/13/1b8f87d39cf83c6b713de2620c31205299e6065622e7dd37aff4808dd410/debugpy-1.8.17-cp311-cp311-win32.whl", hash = "sha256:e79a195f9e059edfe5d8bf6f3749b2599452d3e9380484cd261f6b7cd2c7c4da", size = 5155078, upload-time = "2025-09-17T16:33:33.331Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c5/c012c60a2922cc91caa9675d0ddfbb14ba59e1e36228355f41cab6483469/debugpy-1.8.17-cp311-cp311-win_amd64.whl", hash = "sha256:b532282ad4eca958b1b2d7dbcb2b7218e02cb934165859b918e3b6ba7772d3f4", size = 5179011, upload-time = "2025-09-17T16:33:35.711Z" }, + { url = "https://files.pythonhosted.org/packages/08/2b/9d8e65beb2751876c82e1aceb32f328c43ec872711fa80257c7674f45650/debugpy-1.8.17-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:f14467edef672195c6f6b8e27ce5005313cb5d03c9239059bc7182b60c176e2d", size = 2549522, upload-time = "2025-09-17T16:33:38.466Z" }, + { url = "https://files.pythonhosted.org/packages/b4/78/eb0d77f02971c05fca0eb7465b18058ba84bd957062f5eec82f941ac792a/debugpy-1.8.17-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:24693179ef9dfa20dca8605905a42b392be56d410c333af82f1c5dff807a64cc", size = 4309417, upload-time = "2025-09-17T16:33:41.299Z" }, + { url = "https://files.pythonhosted.org/packages/37/42/c40f1d8cc1fed1e75ea54298a382395b8b937d923fcf41ab0797a554f555/debugpy-1.8.17-cp312-cp312-win32.whl", hash = "sha256:6a4e9dacf2cbb60d2514ff7b04b4534b0139facbf2abdffe0639ddb6088e59cf", size = 5277130, upload-time = "2025-09-17T16:33:43.554Z" }, + { url = "https://files.pythonhosted.org/packages/72/22/84263b205baad32b81b36eac076de0cdbe09fe2d0637f5b32243dc7c925b/debugpy-1.8.17-cp312-cp312-win_amd64.whl", hash = "sha256:e8f8f61c518952fb15f74a302e068b48d9c4691768ade433e4adeea961993464", size = 5319053, upload-time = "2025-09-17T16:33:53.033Z" }, + { url = "https://files.pythonhosted.org/packages/50/76/597e5cb97d026274ba297af8d89138dfd9e695767ba0e0895edb20963f40/debugpy-1.8.17-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:857c1dd5d70042502aef1c6d1c2801211f3ea7e56f75e9c335f434afb403e464", size = 2538386, upload-time = "2025-09-17T16:33:54.594Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/ce5c34fcdfec493701f9d1532dba95b21b2f6394147234dce21160bd923f/debugpy-1.8.17-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:3bea3b0b12f3946e098cce9b43c3c46e317b567f79570c3f43f0b96d00788088", size = 4292100, upload-time = "2025-09-17T16:33:56.353Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/7873cf2146577ef71d2a20bf553f12df865922a6f87b9e8ee1df04f01785/debugpy-1.8.17-cp313-cp313-win32.whl", hash = "sha256:e34ee844c2f17b18556b5bbe59e1e2ff4e86a00282d2a46edab73fd7f18f4a83", size = 5277002, upload-time = "2025-09-17T16:33:58.231Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/18c79a1cee5ff539a94ec4aa290c1c069a5580fd5cfd2fb2e282f8e905da/debugpy-1.8.17-cp313-cp313-win_amd64.whl", hash = "sha256:6c5cd6f009ad4fca8e33e5238210dc1e5f42db07d4b6ab21ac7ffa904a196420", size = 5319047, upload-time = "2025-09-17T16:34:00.586Z" }, + { url = "https://files.pythonhosted.org/packages/de/45/115d55b2a9da6de812696064ceb505c31e952c5d89c4ed1d9bb983deec34/debugpy-1.8.17-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:045290c010bcd2d82bc97aa2daf6837443cd52f6328592698809b4549babcee1", size = 2536899, upload-time = "2025-09-17T16:34:02.657Z" }, + { url = "https://files.pythonhosted.org/packages/5a/73/2aa00c7f1f06e997ef57dc9b23d61a92120bec1437a012afb6d176585197/debugpy-1.8.17-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:b69b6bd9dba6a03632534cdf67c760625760a215ae289f7489a452af1031fe1f", size = 4268254, upload-time = "2025-09-17T16:34:04.486Z" }, + { url = "https://files.pythonhosted.org/packages/86/b5/ed3e65c63c68a6634e3ba04bd10255c8e46ec16ebed7d1c79e4816d8a760/debugpy-1.8.17-cp314-cp314-win32.whl", hash = "sha256:5c59b74aa5630f3a5194467100c3b3d1c77898f9ab27e3f7dc5d40fc2f122670", size = 5277203, upload-time = "2025-09-17T16:34:06.65Z" }, + { url = "https://files.pythonhosted.org/packages/b0/26/394276b71c7538445f29e792f589ab7379ae70fd26ff5577dfde71158e96/debugpy-1.8.17-cp314-cp314-win_amd64.whl", hash = "sha256:893cba7bb0f55161de4365584b025f7064e1f88913551bcd23be3260b231429c", size = 5318493, upload-time = "2025-09-17T16:34:08.483Z" }, + { url = "https://files.pythonhosted.org/packages/b0/d0/89247ec250369fc76db477720a26b2fce7ba079ff1380e4ab4529d2fe233/debugpy-1.8.17-py2.py3-none-any.whl", hash = "sha256:60c7dca6571efe660ccb7a9508d73ca14b8796c4ed484c2002abba714226cfef", size = 5283210, upload-time = "2025-09-17T16:34:25.835Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[package]] +name = "dill" +version = "0.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/12/80/630b4b88364e9a8c8c5797f4602d0f76ef820909ee32f0bacb9f90654042/dill-0.4.0.tar.gz", hash = "sha256:0633f1d2df477324f53a895b02c901fb961bdbf65a17122586ea7019292cbcf0", size = 186976, upload-time = "2025-04-16T00:41:48.867Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/3d/9373ad9c56321fdab5b41197068e1d8c25883b3fea29dd361f9b55116869/dill-0.4.0-py3-none-any.whl", hash = "sha256:44f54bf6412c2c8464c14e8243eb163690a9800dbe2c367330883b19c7561049", size = 119668, upload-time = "2025-04-16T00:41:47.671Z" }, +] + +[[package]] +name = "distro" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" }, +] + +[[package]] +name = "dnspython" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" }, +] + +[[package]] +name = "docstring-parser" +version = "0.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442, upload-time = "2025-07-21T07:35:01.868Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896, upload-time = "2025-07-21T07:35:00.684Z" }, +] + +[[package]] +name = "docutils" +version = "0.22.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d9/02/111134bfeb6e6c7ac4c74594e39a59f6c0195dc4846afbeac3cba60f1927/docutils-0.22.3.tar.gz", hash = "sha256:21486ae730e4ca9f622677b1412b879af1791efcfba517e4c6f60be543fc8cdd", size = 2290153, upload-time = "2025-11-06T02:35:55.655Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/a8/c6a4b901d17399c77cd81fb001ce8961e9f5e04d3daf27e8925cb012e163/docutils-0.22.3-py3-none-any.whl", hash = "sha256:bd772e4aca73aff037958d44f2be5229ded4c09927fcf8690c577b66234d6ceb", size = 633032, upload-time = "2025-11-06T02:35:52.391Z" }, +] + +[[package]] +name = "email-validator" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dnspython" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/22/900cb125c76b7aaa450ce02fd727f452243f2e91a61af068b40adba60ea9/email_validator-2.3.0.tar.gz", hash = "sha256:9fc05c37f2f6cf439ff414f8fc46d917929974a82244c20eb10231ba60c54426", size = 51238, upload-time = "2025-08-26T13:09:06.831Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/15/545e2b6cf2e3be84bc1ed85613edd75b8aea69807a71c26f4ca6a9258e82/email_validator-2.3.0-py3-none-any.whl", hash = "sha256:80f13f623413e6b197ae73bb10bf4eb0908faf509ad8362c5edeb0be7fd450b4", size = 35604, upload-time = "2025-08-26T13:09:05.858Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" }, +] + +[[package]] +name = "fastapi" +version = "0.128.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/52/08/8c8508db6c7b9aae8f7175046af41baad690771c9bcde676419965e338c7/fastapi-0.128.0.tar.gz", hash = "sha256:1cc179e1cef10a6be60ffe429f79b829dce99d8de32d7acb7e6c8dfdf7f2645a", size = 365682, upload-time = "2025-12-27T15:21:13.714Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/05/5cbb59154b093548acd0f4c7c474a118eda06da25aa75c616b72d8fcd92a/fastapi-0.128.0-py3-none-any.whl", hash = "sha256:aebd93f9716ee3b4f4fcfe13ffb7cf308d99c9f3ab5622d8877441072561582d", size = 103094, upload-time = "2025-12-27T15:21:12.154Z" }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" }, +] + +[[package]] +name = "fastmcp" +version = "3.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "authlib" }, + { name = "cyclopts" }, + { name = "exceptiongroup" }, + { name = "httpx" }, + { name = "jsonref" }, + { name = "jsonschema-path" }, + { name = "mcp" }, + { name = "openapi-pydantic" }, + { name = "opentelemetry-api" }, + { name = "packaging" }, + { name = "platformdirs" }, + { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"] }, + { name = "pydantic", extra = ["email"] }, + { name = "pyperclip" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "rich" }, + { name = "uncalled-for" }, + { name = "uvicorn" }, + { name = "watchfiles" }, + { name = "websockets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/32/4f1b2cfd7b50db89114949f90158b1dcc2c92a1917b9f57c0ff24e47a2f4/fastmcp-3.2.0.tar.gz", hash = "sha256:d4830b8ffc3592d3d9c76dc0f398904cf41f04910e41a0de38cc1004e0903bef", size = 26318581, upload-time = "2026-03-30T20:25:37.692Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/67/684fa2d2de1e7504549d4ca457b4f854ccec3cd3be03bd86b33b599fbf58/fastmcp-3.2.0-py3-none-any.whl", hash = "sha256:e71aba3df16f86f546a4a9e513261d3233bcc92bef0dfa647bac3fa33623f681", size = 705550, upload-time = "2026-03-30T20:25:35.499Z" }, +] + +[[package]] +name = "fastuuid" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/7d/d9daedf0f2ebcacd20d599928f8913e9d2aea1d56d2d355a93bfa2b611d7/fastuuid-0.14.0.tar.gz", hash = "sha256:178947fc2f995b38497a74172adee64fdeb8b7ec18f2a5934d037641ba265d26", size = 18232, upload-time = "2025-10-19T22:19:22.402Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/98/f3/12481bda4e5b6d3e698fbf525df4443cc7dce746f246b86b6fcb2fba1844/fastuuid-0.14.0-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:73946cb950c8caf65127d4e9a325e2b6be0442a224fd51ba3b6ac44e1912ce34", size = 516386, upload-time = "2025-10-19T22:42:40.176Z" }, + { url = "https://files.pythonhosted.org/packages/59/19/2fc58a1446e4d72b655648eb0879b04e88ed6fa70d474efcf550f640f6ec/fastuuid-0.14.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:12ac85024637586a5b69645e7ed986f7535106ed3013640a393a03e461740cb7", size = 264569, upload-time = "2025-10-19T22:25:50.977Z" }, + { url = "https://files.pythonhosted.org/packages/78/29/3c74756e5b02c40cfcc8b1d8b5bac4edbd532b55917a6bcc9113550e99d1/fastuuid-0.14.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:05a8dde1f395e0c9b4be515b7a521403d1e8349443e7641761af07c7ad1624b1", size = 254366, upload-time = "2025-10-19T22:29:49.166Z" }, + { url = "https://files.pythonhosted.org/packages/52/96/d761da3fccfa84f0f353ce6e3eb8b7f76b3aa21fd25e1b00a19f9c80a063/fastuuid-0.14.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09378a05020e3e4883dfdab438926f31fea15fd17604908f3d39cbeb22a0b4dc", size = 278978, upload-time = "2025-10-19T22:35:41.306Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c2/f84c90167cc7765cb82b3ff7808057608b21c14a38531845d933a4637307/fastuuid-0.14.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbb0c4b15d66b435d2538f3827f05e44e2baafcc003dd7d8472dc67807ab8fd8", size = 279692, upload-time = "2025-10-19T22:25:36.997Z" }, + { url = "https://files.pythonhosted.org/packages/af/7b/4bacd03897b88c12348e7bd77943bac32ccf80ff98100598fcff74f75f2e/fastuuid-0.14.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cd5a7f648d4365b41dbf0e38fe8da4884e57bed4e77c83598e076ac0c93995e7", size = 303384, upload-time = "2025-10-19T22:29:46.578Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a2/584f2c29641df8bd810d00c1f21d408c12e9ad0c0dafdb8b7b29e5ddf787/fastuuid-0.14.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c0a94245afae4d7af8c43b3159d5e3934c53f47140be0be624b96acd672ceb73", size = 460921, upload-time = "2025-10-19T22:36:42.006Z" }, + { url = "https://files.pythonhosted.org/packages/24/68/c6b77443bb7764c760e211002c8638c0c7cce11cb584927e723215ba1398/fastuuid-0.14.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:2b29e23c97e77c3a9514d70ce343571e469098ac7f5a269320a0f0b3e193ab36", size = 480575, upload-time = "2025-10-19T22:28:18.975Z" }, + { url = "https://files.pythonhosted.org/packages/5a/87/93f553111b33f9bb83145be12868c3c475bf8ea87c107063d01377cc0e8e/fastuuid-0.14.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1e690d48f923c253f28151b3a6b4e335f2b06bf669c68a02665bc150b7839e94", size = 452317, upload-time = "2025-10-19T22:25:32.75Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8c/a04d486ca55b5abb7eaa65b39df8d891b7b1635b22db2163734dc273579a/fastuuid-0.14.0-cp311-cp311-win32.whl", hash = "sha256:a6f46790d59ab38c6aa0e35c681c0484b50dc0acf9e2679c005d61e019313c24", size = 154804, upload-time = "2025-10-19T22:24:15.615Z" }, + { url = "https://files.pythonhosted.org/packages/9c/b2/2d40bf00820de94b9280366a122cbaa60090c8cf59e89ac3938cf5d75895/fastuuid-0.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:e150eab56c95dc9e3fefc234a0eedb342fac433dacc273cd4d150a5b0871e1fa", size = 156099, upload-time = "2025-10-19T22:24:31.646Z" }, + { url = "https://files.pythonhosted.org/packages/02/a2/e78fcc5df65467f0d207661b7ef86c5b7ac62eea337c0c0fcedbeee6fb13/fastuuid-0.14.0-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:77e94728324b63660ebf8adb27055e92d2e4611645bf12ed9d88d30486471d0a", size = 510164, upload-time = "2025-10-19T22:31:45.635Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b3/c846f933f22f581f558ee63f81f29fa924acd971ce903dab1a9b6701816e/fastuuid-0.14.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:caa1f14d2102cb8d353096bc6ef6c13b2c81f347e6ab9d6fbd48b9dea41c153d", size = 261837, upload-time = "2025-10-19T22:38:38.53Z" }, + { url = "https://files.pythonhosted.org/packages/54/ea/682551030f8c4fa9a769d9825570ad28c0c71e30cf34020b85c1f7ee7382/fastuuid-0.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d23ef06f9e67163be38cece704170486715b177f6baae338110983f99a72c070", size = 251370, upload-time = "2025-10-19T22:40:26.07Z" }, + { url = "https://files.pythonhosted.org/packages/14/dd/5927f0a523d8e6a76b70968e6004966ee7df30322f5fc9b6cdfb0276646a/fastuuid-0.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0c9ec605ace243b6dbe3bd27ebdd5d33b00d8d1d3f580b39fdd15cd96fd71796", size = 277766, upload-time = "2025-10-19T22:37:23.779Z" }, + { url = "https://files.pythonhosted.org/packages/16/6e/c0fb547eef61293153348f12e0f75a06abb322664b34a1573a7760501336/fastuuid-0.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:808527f2407f58a76c916d6aa15d58692a4a019fdf8d4c32ac7ff303b7d7af09", size = 278105, upload-time = "2025-10-19T22:26:56.821Z" }, + { url = "https://files.pythonhosted.org/packages/2d/b1/b9c75e03b768f61cf2e84ee193dc18601aeaf89a4684b20f2f0e9f52b62c/fastuuid-0.14.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2fb3c0d7fef6674bbeacdd6dbd386924a7b60b26de849266d1ff6602937675c8", size = 301564, upload-time = "2025-10-19T22:30:31.604Z" }, + { url = "https://files.pythonhosted.org/packages/fc/fa/f7395fdac07c7a54f18f801744573707321ca0cee082e638e36452355a9d/fastuuid-0.14.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab3f5d36e4393e628a4df337c2c039069344db5f4b9d2a3c9cea48284f1dd741", size = 459659, upload-time = "2025-10-19T22:31:32.341Z" }, + { url = "https://files.pythonhosted.org/packages/66/49/c9fd06a4a0b1f0f048aacb6599e7d96e5d6bc6fa680ed0d46bf111929d1b/fastuuid-0.14.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:b9a0ca4f03b7e0b01425281ffd44e99d360e15c895f1907ca105854ed85e2057", size = 478430, upload-time = "2025-10-19T22:26:22.962Z" }, + { url = "https://files.pythonhosted.org/packages/be/9c/909e8c95b494e8e140e8be6165d5fc3f61fdc46198c1554df7b3e1764471/fastuuid-0.14.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3acdf655684cc09e60fb7e4cf524e8f42ea760031945aa8086c7eae2eeeabeb8", size = 450894, upload-time = "2025-10-19T22:27:01.647Z" }, + { url = "https://files.pythonhosted.org/packages/90/eb/d29d17521976e673c55ef7f210d4cdd72091a9ec6755d0fd4710d9b3c871/fastuuid-0.14.0-cp312-cp312-win32.whl", hash = "sha256:9579618be6280700ae36ac42c3efd157049fe4dd40ca49b021280481c78c3176", size = 154374, upload-time = "2025-10-19T22:29:19.879Z" }, + { url = "https://files.pythonhosted.org/packages/cc/fc/f5c799a6ea6d877faec0472d0b27c079b47c86b1cdc577720a5386483b36/fastuuid-0.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:d9e4332dc4ba054434a9594cbfaf7823b57993d7d8e7267831c3e059857cf397", size = 156550, upload-time = "2025-10-19T22:27:49.658Z" }, + { url = "https://files.pythonhosted.org/packages/a5/83/ae12dd39b9a39b55d7f90abb8971f1a5f3c321fd72d5aa83f90dc67fe9ed/fastuuid-0.14.0-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:77a09cb7427e7af74c594e409f7731a0cf887221de2f698e1ca0ebf0f3139021", size = 510720, upload-time = "2025-10-19T22:42:34.633Z" }, + { url = "https://files.pythonhosted.org/packages/53/b0/a4b03ff5d00f563cc7546b933c28cb3f2a07344b2aec5834e874f7d44143/fastuuid-0.14.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:9bd57289daf7b153bfa3e8013446aa144ce5e8c825e9e366d455155ede5ea2dc", size = 262024, upload-time = "2025-10-19T22:30:25.482Z" }, + { url = "https://files.pythonhosted.org/packages/9c/6d/64aee0a0f6a58eeabadd582e55d0d7d70258ffdd01d093b30c53d668303b/fastuuid-0.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ac60fc860cdf3c3f327374db87ab8e064c86566ca8c49d2e30df15eda1b0c2d5", size = 251679, upload-time = "2025-10-19T22:36:14.096Z" }, + { url = "https://files.pythonhosted.org/packages/60/f5/a7e9cda8369e4f7919d36552db9b2ae21db7915083bc6336f1b0082c8b2e/fastuuid-0.14.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab32f74bd56565b186f036e33129da77db8be09178cd2f5206a5d4035fb2a23f", size = 277862, upload-time = "2025-10-19T22:36:23.302Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d3/8ce11827c783affffd5bd4d6378b28eb6cc6d2ddf41474006b8d62e7448e/fastuuid-0.14.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33e678459cf4addaedd9936bbb038e35b3f6b2061330fd8f2f6a1d80414c0f87", size = 278278, upload-time = "2025-10-19T22:29:43.809Z" }, + { url = "https://files.pythonhosted.org/packages/a2/51/680fb6352d0bbade04036da46264a8001f74b7484e2fd1f4da9e3db1c666/fastuuid-0.14.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1e3cc56742f76cd25ecb98e4b82a25f978ccffba02e4bdce8aba857b6d85d87b", size = 301788, upload-time = "2025-10-19T22:36:06.825Z" }, + { url = "https://files.pythonhosted.org/packages/fa/7c/2014b5785bd8ebdab04ec857635ebd84d5ee4950186a577db9eff0fb8ff6/fastuuid-0.14.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cb9a030f609194b679e1660f7e32733b7a0f332d519c5d5a6a0a580991290022", size = 459819, upload-time = "2025-10-19T22:35:31.623Z" }, + { url = "https://files.pythonhosted.org/packages/01/d2/524d4ceeba9160e7a9bc2ea3e8f4ccf1ad78f3bde34090ca0c51f09a5e91/fastuuid-0.14.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:09098762aad4f8da3a888eb9ae01c84430c907a297b97166b8abc07b640f2995", size = 478546, upload-time = "2025-10-19T22:26:03.023Z" }, + { url = "https://files.pythonhosted.org/packages/bc/17/354d04951ce114bf4afc78e27a18cfbd6ee319ab1829c2d5fb5e94063ac6/fastuuid-0.14.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:1383fff584fa249b16329a059c68ad45d030d5a4b70fb7c73a08d98fd53bcdab", size = 450921, upload-time = "2025-10-19T22:31:02.151Z" }, + { url = "https://files.pythonhosted.org/packages/fb/be/d7be8670151d16d88f15bb121c5b66cdb5ea6a0c2a362d0dcf30276ade53/fastuuid-0.14.0-cp313-cp313-win32.whl", hash = "sha256:a0809f8cc5731c066c909047f9a314d5f536c871a7a22e815cc4967c110ac9ad", size = 154559, upload-time = "2025-10-19T22:36:36.011Z" }, + { url = "https://files.pythonhosted.org/packages/22/1d/5573ef3624ceb7abf4a46073d3554e37191c868abc3aecd5289a72f9810a/fastuuid-0.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:0df14e92e7ad3276327631c9e7cec09e32572ce82089c55cb1bb8df71cf394ed", size = 156539, upload-time = "2025-10-19T22:33:35.898Z" }, + { url = "https://files.pythonhosted.org/packages/16/c9/8c7660d1fe3862e3f8acabd9be7fc9ad71eb270f1c65cce9a2b7a31329ab/fastuuid-0.14.0-cp314-cp314-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:b852a870a61cfc26c884af205d502881a2e59cc07076b60ab4a951cc0c94d1ad", size = 510600, upload-time = "2025-10-19T22:43:44.17Z" }, + { url = "https://files.pythonhosted.org/packages/4c/f4/a989c82f9a90d0ad995aa957b3e572ebef163c5299823b4027986f133dfb/fastuuid-0.14.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c7502d6f54cd08024c3ea9b3514e2d6f190feb2f46e6dbcd3747882264bb5f7b", size = 262069, upload-time = "2025-10-19T22:43:38.38Z" }, + { url = "https://files.pythonhosted.org/packages/da/6c/a1a24f73574ac995482b1326cf7ab41301af0fabaa3e37eeb6b3df00e6e2/fastuuid-0.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ca61b592120cf314cfd66e662a5b54a578c5a15b26305e1b8b618a6f22df714", size = 251543, upload-time = "2025-10-19T22:32:22.537Z" }, + { url = "https://files.pythonhosted.org/packages/1a/20/2a9b59185ba7a6c7b37808431477c2d739fcbdabbf63e00243e37bd6bf49/fastuuid-0.14.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa75b6657ec129d0abded3bec745e6f7ab642e6dba3a5272a68247e85f5f316f", size = 277798, upload-time = "2025-10-19T22:33:53.821Z" }, + { url = "https://files.pythonhosted.org/packages/ef/33/4105ca574f6ded0af6a797d39add041bcfb468a1255fbbe82fcb6f592da2/fastuuid-0.14.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8a0dfea3972200f72d4c7df02c8ac70bad1bb4c58d7e0ec1e6f341679073a7f", size = 278283, upload-time = "2025-10-19T22:29:02.812Z" }, + { url = "https://files.pythonhosted.org/packages/fe/8c/fca59f8e21c4deb013f574eae05723737ddb1d2937ce87cb2a5d20992dc3/fastuuid-0.14.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1bf539a7a95f35b419f9ad105d5a8a35036df35fdafae48fb2fd2e5f318f0d75", size = 301627, upload-time = "2025-10-19T22:35:54.985Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e2/f78c271b909c034d429218f2798ca4e89eeda7983f4257d7865976ddbb6c/fastuuid-0.14.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:9a133bf9cc78fdbd1179cb58a59ad0100aa32d8675508150f3658814aeefeaa4", size = 459778, upload-time = "2025-10-19T22:28:00.999Z" }, + { url = "https://files.pythonhosted.org/packages/1e/f0/5ff209d865897667a2ff3e7a572267a9ced8f7313919f6d6043aed8b1caa/fastuuid-0.14.0-cp314-cp314-musllinux_1_1_i686.whl", hash = "sha256:f54d5b36c56a2d5e1a31e73b950b28a0d83eb0c37b91d10408875a5a29494bad", size = 478605, upload-time = "2025-10-19T22:36:21.764Z" }, + { url = "https://files.pythonhosted.org/packages/e0/c8/2ce1c78f983a2c4987ea865d9516dbdfb141a120fd3abb977ae6f02ba7ca/fastuuid-0.14.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:ec27778c6ca3393ef662e2762dba8af13f4ec1aaa32d08d77f71f2a70ae9feb8", size = 450837, upload-time = "2025-10-19T22:34:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/df/60/dad662ec9a33b4a5fe44f60699258da64172c39bd041da2994422cdc40fe/fastuuid-0.14.0-cp314-cp314-win32.whl", hash = "sha256:e23fc6a83f112de4be0cc1990e5b127c27663ae43f866353166f87df58e73d06", size = 154532, upload-time = "2025-10-19T22:35:18.217Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f6/da4db31001e854025ffd26bc9ba0740a9cbba2c3259695f7c5834908b336/fastuuid-0.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:df61342889d0f5e7a32f7284e55ef95103f2110fee433c2ae7c2c0956d76ac8a", size = 156457, upload-time = "2025-10-19T22:33:44.579Z" }, +] + +[[package]] +name = "filelock" +version = "3.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/46/0028a82567109b5ef6e4d2a1f04a583fb513e6cf9527fcdd09afd817deeb/filelock-3.20.0.tar.gz", hash = "sha256:711e943b4ec6be42e1d4e6690b48dc175c822967466bb31c0c293f34334c13f4", size = 18922, upload-time = "2025-10-08T18:03:50.056Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/91/7216b27286936c16f5b4d0c530087e4a54eead683e6b0b73dd0c64844af6/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2", size = 16054, upload-time = "2025-10-08T18:03:48.35Z" }, +] + +[[package]] +name = "frozendict" +version = "2.4.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/b2/2a3d1374b7780999d3184e171e25439a8358c47b481f68be883c14086b4c/frozendict-2.4.7.tar.gz", hash = "sha256:e478fb2a1391a56c8a6e10cc97c4a9002b410ecd1ac28c18d780661762e271bd", size = 317082, upload-time = "2025-11-11T22:40:14.251Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/74/f94141b38a51a553efef7f510fc213894161ae49b88bffd037f8d2a7cb2f/frozendict-2.4.7-py3-none-any.whl", hash = "sha256:972af65924ea25cf5b4d9326d549e69a9a4918d8a76a9d3a7cd174d98b237550", size = 16264, upload-time = "2025-11-11T22:40:12.836Z" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" }, + { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" }, + { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" }, + { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" }, + { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" }, + { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" }, + { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" }, + { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" }, + { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" }, + { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" }, + { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" }, + { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" }, + { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" }, + { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" }, + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" }, + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" }, + { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" }, + { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" }, + { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" }, + { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" }, + { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" }, + { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" }, + { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" }, + { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" }, + { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" }, + { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" }, + { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + +[[package]] +name = "fsspec" +version = "2025.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/de/e0/bab50af11c2d75c9c4a2a26a5254573c0bd97cea152254401510950486fa/fsspec-2025.9.0.tar.gz", hash = "sha256:19fd429483d25d28b65ec68f9f4adc16c17ea2c7c7bf54ec61360d478fb19c19", size = 304847, upload-time = "2025-09-02T19:10:49.215Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/71/70db47e4f6ce3e5c37a607355f80da8860a33226be640226ac52cb05ef2e/fsspec-2025.9.0-py3-none-any.whl", hash = "sha256:530dc2a2af60a414a832059574df4a6e10cce927f6f4a78209390fe38955cfb7", size = 199289, upload-time = "2025-09-02T19:10:47.708Z" }, +] + +[package.optional-dependencies] +http = [ + { name = "aiohttp" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "hf-xet" +version = "1.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", hash = "sha256:8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113", size = 670477, upload-time = "2026-03-31T22:40:07.874Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/43/724d307b34e353da0abd476e02f72f735cdd2bc86082dee1b32ea0bfee1d/hf_xet-1.4.3-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:7551659ba4f1e1074e9623996f28c3873682530aee0a846b7f2f066239228144", size = 3800935, upload-time = "2026-03-31T22:39:49.618Z" }, + { url = "https://files.pythonhosted.org/packages/2b/d2/8bee5996b699262edb87dbb54118d287c0e1b2fc78af7cdc41857ba5e3c4/hf_xet-1.4.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:bee693ada985e7045997f05f081d0e12c4c08bd7626dc397f8a7c487e6c04f7f", size = 3558942, upload-time = "2026-03-31T22:39:47.938Z" }, + { url = "https://files.pythonhosted.org/packages/c3/a1/e993d09cbe251196fb60812b09a58901c468127b7259d2bf0f68bf6088eb/hf_xet-1.4.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21644b404bb0100fe3857892f752c4d09642586fd988e61501c95bbf44b393a3", size = 4207657, upload-time = "2026-03-31T22:39:39.69Z" }, + { url = "https://files.pythonhosted.org/packages/64/44/9eb6d21e5c34c63e5e399803a6932fa983cabdf47c0ecbcfe7ea97684b8c/hf_xet-1.4.3-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:987f09cfe418237812896a6736b81b1af02a3a6dcb4b4944425c4c4fca7a7cf8", size = 3986765, upload-time = "2026-03-31T22:39:37.936Z" }, + { url = "https://files.pythonhosted.org/packages/ea/7b/8ad6f16fdb82f5f7284a34b5ec48645bd575bdcd2f6f0d1644775909c486/hf_xet-1.4.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:60cf7fc43a99da0a853345cf86d23738c03983ee5249613a6305d3e57a5dca74", size = 4188162, upload-time = "2026-03-31T22:39:58.382Z" }, + { url = "https://files.pythonhosted.org/packages/1b/c4/39d6e136cbeea9ca5a23aad4b33024319222adbdc059ebcda5fc7d9d5ff4/hf_xet-1.4.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2815a49a7a59f3e2edf0cf113ae88e8cb2ca2a221bf353fb60c609584f4884d4", size = 4424525, upload-time = "2026-03-31T22:40:00.225Z" }, + { url = "https://files.pythonhosted.org/packages/46/f2/adc32dae6bdbc367853118b9878139ac869419a4ae7ba07185dc31251b76/hf_xet-1.4.3-cp313-cp313t-win_amd64.whl", hash = "sha256:42ee323265f1e6a81b0e11094564fb7f7e0ec75b5105ffd91ae63f403a11931b", size = 3671610, upload-time = "2026-03-31T22:40:10.42Z" }, + { url = "https://files.pythonhosted.org/packages/e2/19/25d897dcc3f81953e0c2cde9ec186c7a0fee413eb0c9a7a9130d87d94d3a/hf_xet-1.4.3-cp313-cp313t-win_arm64.whl", hash = "sha256:27c976ba60079fb8217f485b9c5c7fcd21c90b0367753805f87cb9f3cdc4418a", size = 3528529, upload-time = "2026-03-31T22:40:09.106Z" }, + { url = "https://files.pythonhosted.org/packages/ec/36/3e8f85ca9fe09b8de2b2e10c63b3b3353d7dda88a0b3d426dffbe7b8313b/hf_xet-1.4.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:5251d5ece3a81815bae9abab41cf7ddb7bcb8f56411bce0827f4a3071c92fdc6", size = 3801019, upload-time = "2026-03-31T22:39:56.651Z" }, + { url = "https://files.pythonhosted.org/packages/b5/9c/defb6cb1de28bccb7bd8d95f6e60f72a3d3fa4cb3d0329c26fb9a488bfe7/hf_xet-1.4.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1feb0f3abeacee143367c326a128a2e2b60868ec12a36c225afb1d6c5a05e6d2", size = 3558746, upload-time = "2026-03-31T22:39:54.766Z" }, + { url = "https://files.pythonhosted.org/packages/c1/bd/8d001191893178ff8e826e46ad5299446e62b93cd164e17b0ffea08832ec/hf_xet-1.4.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8b301fc150290ca90b4fccd079829b84bb4786747584ae08b94b4577d82fb791", size = 4207692, upload-time = "2026-03-31T22:39:46.246Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/6790b402803250e9936435613d3a78b9aaeee7973439f0918848dde58309/hf_xet-1.4.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:d972fbe95ddc0d3c0fc49b31a8a69f47db35c1e3699bf316421705741aab6653", size = 3986281, upload-time = "2026-03-31T22:39:44.648Z" }, + { url = "https://files.pythonhosted.org/packages/51/56/ea62552fe53db652a9099eda600b032d75554d0e86c12a73824bfedef88b/hf_xet-1.4.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c5b48db1ee344a805a1b9bd2cda9b6b65fe77ed3787bd6e87ad5521141d317cd", size = 4187414, upload-time = "2026-03-31T22:40:04.951Z" }, + { url = "https://files.pythonhosted.org/packages/7d/f5/bc1456d4638061bea997e6d2db60a1a613d7b200e0755965ec312dc1ef79/hf_xet-1.4.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:22bdc1f5fb8b15bf2831440b91d1c9bbceeb7e10c81a12e8d75889996a5c9da8", size = 4424368, upload-time = "2026-03-31T22:40:06.347Z" }, + { url = "https://files.pythonhosted.org/packages/e4/76/ab597bae87e1f06d18d3ecb8ed7f0d3c9a37037fc32ce76233d369273c64/hf_xet-1.4.3-cp314-cp314t-win_amd64.whl", hash = "sha256:0392c79b7cf48418cd61478c1a925246cf10639f4cd9d94368d8ca1e8df9ea07", size = 3672280, upload-time = "2026-03-31T22:40:16.401Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/2e462d34e23a09a74d73785dbed71cc5dbad82a72eee2ad60a72a554155d/hf_xet-1.4.3-cp314-cp314t-win_arm64.whl", hash = "sha256:681c92a07796325778a79d76c67011764ecc9042a8c3579332b61b63ae512075", size = 3528945, upload-time = "2026-03-31T22:40:14.995Z" }, + { url = "https://files.pythonhosted.org/packages/ac/9f/9c23e4a447b8f83120798f9279d0297a4d1360bdbf59ef49ebec78fe2545/hf_xet-1.4.3-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d0da85329eaf196e03e90b84c2d0aca53bd4573d097a75f99609e80775f98025", size = 3805048, upload-time = "2026-03-31T22:39:53.105Z" }, + { url = "https://files.pythonhosted.org/packages/0b/f8/7aacb8e5f4a7899d39c787b5984e912e6c18b11be136ef13947d7a66d265/hf_xet-1.4.3-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:e23717ce4186b265f69afa66e6f0069fe7efbf331546f5c313d00e123dc84583", size = 3562178, upload-time = "2026-03-31T22:39:51.295Z" }, + { url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08", size = 4212320, upload-time = "2026-03-31T22:39:42.922Z" }, + { url = "https://files.pythonhosted.org/packages/53/60/46d493db155d2ee2801b71fb1b0fd67696359047fdd8caee2c914cc50c79/hf_xet-1.4.3-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:39f2d2e9654cd9b4319885733993807aab6de9dfbd34c42f0b78338d6617421f", size = 3991546, upload-time = "2026-03-31T22:39:41.335Z" }, + { url = "https://files.pythonhosted.org/packages/bc/f5/067363e1c96c6b17256910830d1b54099d06287e10f4ec6ec4e7e08371fc/hf_xet-1.4.3-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:49ad8a8cead2b56051aa84d7fce3e1335efe68df3cf6c058f22a65513885baac", size = 4193200, upload-time = "2026-03-31T22:40:01.936Z" }, + { url = "https://files.pythonhosted.org/packages/42/4b/53951592882d9c23080c7644542fda34a3813104e9e11fa1a7d82d419cb8/hf_xet-1.4.3-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7716d62015477a70ea272d2d68cd7cad140f61c52ee452e133e139abfe2c17ba", size = 4429392, upload-time = "2026-03-31T22:40:03.492Z" }, + { url = "https://files.pythonhosted.org/packages/8a/21/75a6c175b4e79662ad8e62f46a40ce341d8d6b206b06b4320d07d55b188c/hf_xet-1.4.3-cp37-abi3-win_amd64.whl", hash = "sha256:6b591fcad34e272a5b02607485e4f2a1334aebf1bc6d16ce8eb1eb8978ac2021", size = 3677359, upload-time = "2026-03-31T22:40:13.619Z" }, + { url = "https://files.pythonhosted.org/packages/8a/7c/44314ecd0e89f8b2b51c9d9e5e7a60a9c1c82024ac471d415860557d3cd8/hf_xet-1.4.3-cp37-abi3-win_arm64.whl", hash = "sha256:7c2c7e20bcfcc946dc67187c203463f5e932e395845d098cc2a93f5b67ca0b47", size = 3533664, upload-time = "2026-03-31T22:40:12.152Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httptools" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/08/17e07e8d89ab8f343c134616d72eebfe03798835058e2ab579dcc8353c06/httptools-0.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:474d3b7ab469fefcca3697a10d11a32ee2b9573250206ba1e50d5980910da657", size = 206521, upload-time = "2025-10-10T03:54:31.002Z" }, + { url = "https://files.pythonhosted.org/packages/aa/06/c9c1b41ff52f16aee526fd10fbda99fa4787938aa776858ddc4a1ea825ec/httptools-0.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3c3b7366bb6c7b96bd72d0dbe7f7d5eead261361f013be5f6d9590465ea1c70", size = 110375, upload-time = "2025-10-10T03:54:31.941Z" }, + { url = "https://files.pythonhosted.org/packages/cc/cc/10935db22fda0ee34c76f047590ca0a8bd9de531406a3ccb10a90e12ea21/httptools-0.7.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:379b479408b8747f47f3b253326183d7c009a3936518cdb70db58cffd369d9df", size = 456621, upload-time = "2025-10-10T03:54:33.176Z" }, + { url = "https://files.pythonhosted.org/packages/0e/84/875382b10d271b0c11aa5d414b44f92f8dd53e9b658aec338a79164fa548/httptools-0.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cad6b591a682dcc6cf1397c3900527f9affef1e55a06c4547264796bbd17cf5e", size = 454954, upload-time = "2025-10-10T03:54:34.226Z" }, + { url = "https://files.pythonhosted.org/packages/30/e1/44f89b280f7e46c0b1b2ccee5737d46b3bb13136383958f20b580a821ca0/httptools-0.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eb844698d11433d2139bbeeb56499102143beb582bd6c194e3ba69c22f25c274", size = 440175, upload-time = "2025-10-10T03:54:35.942Z" }, + { url = "https://files.pythonhosted.org/packages/6f/7e/b9287763159e700e335028bc1824359dc736fa9b829dacedace91a39b37e/httptools-0.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f65744d7a8bdb4bda5e1fa23e4ba16832860606fcc09d674d56e425e991539ec", size = 440310, upload-time = "2025-10-10T03:54:37.1Z" }, + { url = "https://files.pythonhosted.org/packages/b3/07/5b614f592868e07f5c94b1f301b5e14a21df4e8076215a3bccb830a687d8/httptools-0.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:135fbe974b3718eada677229312e97f3b31f8a9c8ffa3ae6f565bf808d5b6bcb", size = 86875, upload-time = "2025-10-10T03:54:38.421Z" }, + { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280, upload-time = "2025-10-10T03:54:39.274Z" }, + { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004, upload-time = "2025-10-10T03:54:40.403Z" }, + { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" }, + { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440, upload-time = "2025-10-10T03:54:42.452Z" }, + { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186, upload-time = "2025-10-10T03:54:43.937Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192, upload-time = "2025-10-10T03:54:45.003Z" }, + { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694, upload-time = "2025-10-10T03:54:45.923Z" }, + { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889, upload-time = "2025-10-10T03:54:47.089Z" }, + { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180, upload-time = "2025-10-10T03:54:48.052Z" }, + { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596, upload-time = "2025-10-10T03:54:48.919Z" }, + { url = "https://files.pythonhosted.org/packages/6d/70/023d7ce117993107be88d2cbca566a7c1323ccbaf0af7eabf2064fe356f6/httptools-0.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69d4f9705c405ae3ee83d6a12283dc9feba8cc6aaec671b412917e644ab4fa66", size = 473268, upload-time = "2025-10-10T03:54:49.993Z" }, + { url = "https://files.pythonhosted.org/packages/32/4d/9dd616c38da088e3f436e9a616e1d0cc66544b8cdac405cc4e81c8679fc7/httptools-0.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44c8f4347d4b31269c8a9205d8a5ee2df5322b09bbbd30f8f862185bb6b05346", size = 455517, upload-time = "2025-10-10T03:54:51.066Z" }, + { url = "https://files.pythonhosted.org/packages/1d/3a/a6c595c310b7df958e739aae88724e24f9246a514d909547778d776799be/httptools-0.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:465275d76db4d554918aba40bf1cbebe324670f3dfc979eaffaa5d108e2ed650", size = 458337, upload-time = "2025-10-10T03:54:52.196Z" }, + { url = "https://files.pythonhosted.org/packages/fd/82/88e8d6d2c51edc1cc391b6e044c6c435b6aebe97b1abc33db1b0b24cd582/httptools-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:322d00c2068d125bd570f7bf78b2d367dad02b919d8581d7476d8b75b294e3e6", size = 85743, upload-time = "2025-10-10T03:54:53.448Z" }, + { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619, upload-time = "2025-10-10T03:54:54.321Z" }, + { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714, upload-time = "2025-10-10T03:54:55.163Z" }, + { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909, upload-time = "2025-10-10T03:54:56.056Z" }, + { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831, upload-time = "2025-10-10T03:54:57.219Z" }, + { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631, upload-time = "2025-10-10T03:54:58.219Z" }, + { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910, upload-time = "2025-10-10T03:54:59.366Z" }, + { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205, upload-time = "2025-10-10T03:55:00.389Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "httpx-sse" +version = "0.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" }, +] + +[[package]] +name = "huggingface-hub" +version = "1.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, + { name = "httpx" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "tqdm" }, + { name = "typer" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/56/52/1b54cb569509c725a32c1315261ac9fd0e6b91bbbf74d86fca10d3376164/huggingface_hub-1.12.0.tar.gz", hash = "sha256:7c3fe85e24b652334e5d456d7a812cd9a071e75630fac4365d9165ab5e4a34b6", size = 763091, upload-time = "2026-04-24T13:32:08.674Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/2b/ef03ddb96bd1123503c2bd6932001020292deea649e9bf4caa2cb65a85bf/huggingface_hub-1.12.0-py3-none-any.whl", hash = "sha256:d74939969585ee35748bd66de09baf84099d461bda7287cd9043bfb99b0e424d", size = 646806, upload-time = "2026-04-24T13:32:06.717Z" }, +] + +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, +] + +[[package]] +name = "ijson" +version = "3.4.0.post0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/30/7ab4b9e88e7946f6beef419f74edcc541df3ea562c7882257b4eaa82417d/ijson-3.4.0.post0.tar.gz", hash = "sha256:9aa02dc70bb245670a6ca7fba737b992aeeb4895360980622f7e568dbf23e41e", size = 67216, upload-time = "2025-10-10T05:29:25.62Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/ac/3d57249d4acba66a33eaef794edb5b2a2222ca449ae08800f8abe9286645/ijson-3.4.0.post0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0b473112e72c0c506da425da3278367b6680f340ecc093084693a1e819d28435", size = 88278, upload-time = "2025-10-10T05:27:55.403Z" }, + { url = "https://files.pythonhosted.org/packages/12/fb/2d068d23d1a665f500282ceb6f2473952a95fc7107d739fd629b4ab41959/ijson-3.4.0.post0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:043f9b7cf9cc744263a78175e769947733710d2412d25180df44b1086b23ebd5", size = 59898, upload-time = "2025-10-10T05:27:56.361Z" }, + { url = "https://files.pythonhosted.org/packages/26/3d/8b14589dfb0e5dbb7bcf9063e53d3617c041cf315ff3dfa60945382237ce/ijson-3.4.0.post0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b55e49045f4c8031f3673f56662fd828dc9e8d65bd3b03a9420dda0d370e64ba", size = 59945, upload-time = "2025-10-10T05:27:57.581Z" }, + { url = "https://files.pythonhosted.org/packages/77/57/086a75094397d4b7584698a540a279689e12905271af78cdfc903bf9eaf8/ijson-3.4.0.post0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:11f13b73194ea2a5a8b4a2863f25b0b4624311f10db3a75747b510c4958179b0", size = 131318, upload-time = "2025-10-10T05:27:58.453Z" }, + { url = "https://files.pythonhosted.org/packages/df/35/7f61e9ce4a9ff1306ec581eb851f8a660439126d92ee595c6dc8084aac97/ijson-3.4.0.post0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:659acb2843433e080c271ecedf7d19c71adde1ee5274fc7faa2fec0a793f9f1c", size = 137990, upload-time = "2025-10-10T05:27:59.328Z" }, + { url = "https://files.pythonhosted.org/packages/59/bf/590bbc3c3566adce5e2f43ba5894520cbaf19a3e7f38c1250926ba67eee4/ijson-3.4.0.post0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:deda4cfcaafa72ca3fa845350045b1d0fef9364ec9f413241bb46988afbe6ee6", size = 134416, upload-time = "2025-10-10T05:28:00.317Z" }, + { url = "https://files.pythonhosted.org/packages/24/c1/fb719049851979df71f3e039d6f1a565d349c9cb1b29c0f8775d9db141b4/ijson-3.4.0.post0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47352563e8c594360bacee2e0753e97025f0861234722d02faace62b1b6d2b2a", size = 138034, upload-time = "2025-10-10T05:28:01.627Z" }, + { url = "https://files.pythonhosted.org/packages/10/ce/ccda891f572876aaf2c43f0b2079e31d5b476c3ae53196187eab1a788eff/ijson-3.4.0.post0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5a48b9486242d1295abe7fd0fbb6308867da5ca3f69b55c77922a93c2b6847aa", size = 132510, upload-time = "2025-10-10T05:28:03.141Z" }, + { url = "https://files.pythonhosted.org/packages/11/b5/ca8e64ab7cf5252f358e467be767630f085b5bbcd3c04333a3a5f36c3dd3/ijson-3.4.0.post0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9c0886234d1fae15cf4581a430bdba03d79251c1ab3b07e30aa31b13ef28d01c", size = 134907, upload-time = "2025-10-10T05:28:04.438Z" }, + { url = "https://files.pythonhosted.org/packages/93/14/63a4d5dc548690f29f0c2fc9cabd5ecbb37532547439c05f5b3b9ce73021/ijson-3.4.0.post0-cp311-cp311-win32.whl", hash = "sha256:fecae19b5187d92900c73debb3a979b0b3290a53f85df1f8f3c5ba7d1e9fb9cb", size = 52006, upload-time = "2025-10-10T05:28:05.424Z" }, + { url = "https://files.pythonhosted.org/packages/fa/bf/932740899e572a97f9be0c6cd64ebda557eae7701ac216fc284aba21786d/ijson-3.4.0.post0-cp311-cp311-win_amd64.whl", hash = "sha256:b39dbf87071f23a23c8077eea2ae7cfeeca9ff9ffec722dfc8b5f352e4dd729c", size = 54410, upload-time = "2025-10-10T05:28:06.264Z" }, + { url = "https://files.pythonhosted.org/packages/7d/fe/3b6af0025288e769dbfa30485dae1b3bd3f33f00390f3ee532cbb1c33e9b/ijson-3.4.0.post0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b607a500fca26101be47d2baf7cddb457b819ab60a75ce51ed1092a40da8b2f9", size = 87847, upload-time = "2025-10-10T05:28:07.229Z" }, + { url = "https://files.pythonhosted.org/packages/6e/a5/95ee2ca82f3b1a57892452f6e5087607d56c620beb8ce625475194568698/ijson-3.4.0.post0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4827d9874a6a81625412c59f7ca979a84d01f7f6bfb3c6d4dc4c46d0382b14e0", size = 59815, upload-time = "2025-10-10T05:28:08.448Z" }, + { url = "https://files.pythonhosted.org/packages/51/8d/5a704ab3c17c55c21c86423458db8610626ca99cc9086a74dfeb7ee9054c/ijson-3.4.0.post0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d4d4afec780881edb2a0d2dd40b1cdbe246e630022d5192f266172a0307986a7", size = 59648, upload-time = "2025-10-10T05:28:09.307Z" }, + { url = "https://files.pythonhosted.org/packages/25/56/ca5d6ca145d007f30b44e747f3c163bc08710ce004af0deaad4a2301339b/ijson-3.4.0.post0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432fb60ffb952926f9438e0539011e2dfcd108f8426ee826ccc6173308c3ff2c", size = 138279, upload-time = "2025-10-10T05:28:10.489Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d3/22e3cc806fcdda7ad4c8482ed74db7a017d4a1d49b4300c7bc07052fb561/ijson-3.4.0.post0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:54a0e3e05d9a0c95ecba73d9579f146cf6d5c5874116c849dba2d39a5f30380e", size = 149110, upload-time = "2025-10-10T05:28:12.263Z" }, + { url = "https://files.pythonhosted.org/packages/3e/04/efb30f413648b9267f5a33920ac124d7ebef3bc4063af8f6ffc8ca11ddcb/ijson-3.4.0.post0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05807edc0bcbd222dc6ea32a2b897f0c81dc7f12c8580148bc82f6d7f5e7ec7b", size = 149026, upload-time = "2025-10-10T05:28:13.557Z" }, + { url = "https://files.pythonhosted.org/packages/2d/cf/481165f7046ade32488719300a3994a437020bc41cfbb54334356348f513/ijson-3.4.0.post0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a5269af16f715855d9864937f9dd5c348ca1ac49cee6a2c7a1b7091c159e874f", size = 150012, upload-time = "2025-10-10T05:28:14.859Z" }, + { url = "https://files.pythonhosted.org/packages/0f/24/642e3289917ecf860386e26dfde775f9962d26ab7f6c2e364ed3ca3c25d8/ijson-3.4.0.post0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b200df83c901f5bfa416d069ac71077aa1608f854a4c50df1b84ced560e9c9ec", size = 142193, upload-time = "2025-10-10T05:28:16.131Z" }, + { url = "https://files.pythonhosted.org/packages/0f/f5/fd2f038abe95e553e1c3ee207cda19db9196eb416e63c7c89699a8cf0db7/ijson-3.4.0.post0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6458bd8e679cdff459a0a5e555b107c3bbacb1f382da3fe0f40e392871eb518d", size = 150904, upload-time = "2025-10-10T05:28:17.401Z" }, + { url = "https://files.pythonhosted.org/packages/49/35/24259d22519987928164e6cb8fe3486e1df0899b2999ada4b0498639b463/ijson-3.4.0.post0-cp312-cp312-win32.whl", hash = "sha256:55f7f656b5986326c978cbb3a9eea9e33f3ef6ecc4535b38f1d452c731da39ab", size = 52358, upload-time = "2025-10-10T05:28:18.315Z" }, + { url = "https://files.pythonhosted.org/packages/a1/2b/6f7ade27a8ff5758fc41006dadd2de01730def84fe3e60553b329c59e0d4/ijson-3.4.0.post0-cp312-cp312-win_amd64.whl", hash = "sha256:e15833dcf6f6d188fdc624a31cd0520c3ba21b6855dc304bc7c1a8aeca02d4ac", size = 54789, upload-time = "2025-10-10T05:28:19.552Z" }, + { url = "https://files.pythonhosted.org/packages/1b/20/aaec6977f9d538bbadd760c7fa0f6a0937742abdcc920ec6478a8576e55f/ijson-3.4.0.post0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:114ed248166ac06377e87a245a158d6b98019d2bdd3bb93995718e0bd996154f", size = 87863, upload-time = "2025-10-10T05:28:20.786Z" }, + { url = "https://files.pythonhosted.org/packages/5b/29/06bf56a866e2fe21453a1ad8f3a5d7bca3c723f73d96329656dfee969783/ijson-3.4.0.post0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ffb21203736b08fe27cb30df6a4f802fafb9ef7646c5ff7ef79569b63ea76c57", size = 59806, upload-time = "2025-10-10T05:28:21.596Z" }, + { url = "https://files.pythonhosted.org/packages/ba/ae/e1d0fda91ba7a444b75f0d60cb845fdb1f55d3111351529dcbf4b1c276fe/ijson-3.4.0.post0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:07f20ecd748602ac7f18c617637e53bd73ded7f3b22260bba3abe401a7fc284e", size = 59643, upload-time = "2025-10-10T05:28:22.45Z" }, + { url = "https://files.pythonhosted.org/packages/4d/24/5a24533be2726396cc1724dc237bada09b19715b5bfb0e7b9400db0901ad/ijson-3.4.0.post0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:27aa193d47ffc6bc4e45453896ad98fb089a367e8283b973f1fe5c0198b60b4e", size = 138082, upload-time = "2025-10-10T05:28:23.319Z" }, + { url = "https://files.pythonhosted.org/packages/05/60/026c3efcec23c329657e878cbc0a9a25b42e7eb3971e8c2377cb3284e2b7/ijson-3.4.0.post0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ccddb2894eb7af162ba43b9475ac5825d15d568832f82eb8783036e5d2aebd42", size = 149145, upload-time = "2025-10-10T05:28:24.279Z" }, + { url = "https://files.pythonhosted.org/packages/ed/c2/036499909b7a1bc0bcd85305e4348ad171aeb9df57581287533bdb3497e9/ijson-3.4.0.post0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:61ab0b8c5bf707201dc67e02c116f4b6545c4afd7feb2264b989d242d9c4348a", size = 149046, upload-time = "2025-10-10T05:28:25.186Z" }, + { url = "https://files.pythonhosted.org/packages/ba/75/e7736073ad96867c129f9e799e3e65086badd89dbf3911f76d9b3bf8a115/ijson-3.4.0.post0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:254cfb8c124af68327a0e7a49b50bbdacafd87c4690a3d62c96eb01020a685ef", size = 150356, upload-time = "2025-10-10T05:28:26.135Z" }, + { url = "https://files.pythonhosted.org/packages/9d/1b/1c1575d2cda136985561fcf774fe6c54412cd0fa08005342015af0403193/ijson-3.4.0.post0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:04ac9ca54db20f82aeda6379b5f4f6112fdb150d09ebce04affeab98a17b4ed3", size = 142322, upload-time = "2025-10-10T05:28:27.125Z" }, + { url = "https://files.pythonhosted.org/packages/28/4d/aba9871feb624df8494435d1a9ddc7b6a4f782c6044bfc0d770a4b59f145/ijson-3.4.0.post0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a603d7474bf35e7b3a8e49c8dabfc4751841931301adff3f3318171c4e407f32", size = 151386, upload-time = "2025-10-10T05:28:28.274Z" }, + { url = "https://files.pythonhosted.org/packages/3f/9a/791baa83895fb6e492bce2c7a0ea6427b6a41fe854349e62a37d0c9deaf0/ijson-3.4.0.post0-cp313-cp313-win32.whl", hash = "sha256:ec5bb1520cb212ebead7dba048bb9b70552c3440584f83b01b0abc96862e2a09", size = 52352, upload-time = "2025-10-10T05:28:29.191Z" }, + { url = "https://files.pythonhosted.org/packages/a9/0c/061f51493e1da21116d74ee8f6a6b9ae06ca5fa2eb53c3b38b64f9a9a5ae/ijson-3.4.0.post0-cp313-cp313-win_amd64.whl", hash = "sha256:3505dff18bdeb8b171eb28af6df34857e2be80dc01e2e3b624e77215ad58897f", size = 54783, upload-time = "2025-10-10T05:28:30.048Z" }, + { url = "https://files.pythonhosted.org/packages/c7/89/4344e176f2c5f5ef3251c9bfa4ddd5b4cf3f9601fd6ec3f677a3ba0b9c71/ijson-3.4.0.post0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:45a0b1c833ed2620eaf8da958f06ac8351c59e5e470e078400d23814670ed708", size = 92342, upload-time = "2025-10-10T05:28:31.389Z" }, + { url = "https://files.pythonhosted.org/packages/d4/b1/85012c586a6645f9fb8bfa3ef62ed2f303c8d73fc7c2f705111582925980/ijson-3.4.0.post0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7809ec8c8f40228edaaa089f33e811dff4c5b8509702652870d3f286c9682e27", size = 62028, upload-time = "2025-10-10T05:28:32.849Z" }, + { url = "https://files.pythonhosted.org/packages/65/ea/7b7e2815c101d78b33e74d64ddb70cccc377afccd5dda76e566ed3fcb56f/ijson-3.4.0.post0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cf4a34c2cfe852aee75c89c05b0a4531c49dc0be27eeed221afd6fbf9c3e149c", size = 61773, upload-time = "2025-10-10T05:28:34.016Z" }, + { url = "https://files.pythonhosted.org/packages/59/7d/2175e599cb77a64f528629bad3ce95dfdf2aa6171d313c1fc00bbfaf0d22/ijson-3.4.0.post0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a39d5d36067604b26b78de70b8951c90e9272450642661fe531a8f7a6936a7fa", size = 198562, upload-time = "2025-10-10T05:28:34.878Z" }, + { url = "https://files.pythonhosted.org/packages/13/97/82247c501c92405bb2fc44ab5efb497335bcb9cf0f5d3a0b04a800737bd8/ijson-3.4.0.post0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83fc738d81c9ea686b452996110b8a6678296c481e0546857db24785bff8da92", size = 216212, upload-time = "2025-10-10T05:28:36.208Z" }, + { url = "https://files.pythonhosted.org/packages/95/ca/b956f507bb02e05ce109fd11ab6a2c054f8b686cc5affe41afe50630984d/ijson-3.4.0.post0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b2a81aee91633868f5b40280e2523f7c5392e920a5082f47c5e991e516b483f6", size = 206618, upload-time = "2025-10-10T05:28:37.243Z" }, + { url = "https://files.pythonhosted.org/packages/3e/12/e827840ab81d86a9882e499097934df53294f05155f1acfcb9a211ac1142/ijson-3.4.0.post0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:56169e298c5a2e7196aaa55da78ddc2415876a74fe6304f81b1eb0d3273346f7", size = 210689, upload-time = "2025-10-10T05:28:38.252Z" }, + { url = "https://files.pythonhosted.org/packages/1b/3b/59238d9422c31a4aefa22ebeb8e599e706158a0ab03669ef623be77a499a/ijson-3.4.0.post0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eeb9540f0b1a575cbb5968166706946458f98c16e7accc6f2fe71efa29864241", size = 199927, upload-time = "2025-10-10T05:28:39.233Z" }, + { url = "https://files.pythonhosted.org/packages/b6/0f/ec01c36c128c37edb8a5ae8f3de3256009f886338d459210dfe121ee4ba9/ijson-3.4.0.post0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ba3478ff0bb49d7ba88783f491a99b6e3fa929c930ab062d2bb7837e6a38fe88", size = 204455, upload-time = "2025-10-10T05:28:40.644Z" }, + { url = "https://files.pythonhosted.org/packages/c8/cf/5560e1db96c6d10a5313be76bf5a1754266cbfb5cc13ff64d107829e07b1/ijson-3.4.0.post0-cp313-cp313t-win32.whl", hash = "sha256:b005ce84e82f28b00bf777a464833465dfe3efa43a0a26c77b5ac40723e1a728", size = 54566, upload-time = "2025-10-10T05:28:41.663Z" }, + { url = "https://files.pythonhosted.org/packages/22/5a/cbb69144c3b25dd56f5421ff7dc0cf3051355579062024772518e4f4b3c5/ijson-3.4.0.post0-cp313-cp313t-win_amd64.whl", hash = "sha256:fe9c84c9b1c8798afa407be1cea1603401d99bfc7c34497e19f4f5e5ddc9b441", size = 57298, upload-time = "2025-10-10T05:28:42.881Z" }, + { url = "https://files.pythonhosted.org/packages/af/0b/a4ce8524fd850302bbf5d9f38d07c0fa981fdbe44951d2fcd036935b67dd/ijson-3.4.0.post0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da6a21b88cbf5ecbc53371283988d22c9643aa71ae2873bbeaefd2dea3b6160b", size = 88361, upload-time = "2025-10-10T05:28:43.73Z" }, + { url = "https://files.pythonhosted.org/packages/be/90/a5e5f33e46f28174a9c8142d12dcb3d26ce358d9a2230b9b15f5c987b3a5/ijson-3.4.0.post0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:cf24a48a1c3ca9d44a04feb59ccefeb9aa52bb49b9cb70ad30518c25cce74bb7", size = 59960, upload-time = "2025-10-10T05:28:44.585Z" }, + { url = "https://files.pythonhosted.org/packages/83/e2/551dd7037dda759aa0ce53f0d3d7be03b03c6b05c0b0a5d5ab7a47e6b4b1/ijson-3.4.0.post0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d14427d366f95f21adcb97d0ed1f6d30f6fdc04d0aa1e4de839152c50c2b8d65", size = 59957, upload-time = "2025-10-10T05:28:45.748Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b9/3006384f85cc26cf83dbbd542d362cc336f1e1ddd491e32147cfa46ea8ae/ijson-3.4.0.post0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:339d49f6c5d24051c85d9226be96d2d56e633cb8b7d09dd8099de8d8b51a97e2", size = 139967, upload-time = "2025-10-10T05:28:47.229Z" }, + { url = "https://files.pythonhosted.org/packages/77/3b/b5234add8115cbfe8635b6c152fb527327f45e4c0f0bf2e93844b36b5217/ijson-3.4.0.post0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7206afcb396aaef66c2b066997b4e9d9042c4b7d777f4d994e9cec6d322c2fe6", size = 149196, upload-time = "2025-10-10T05:28:48.226Z" }, + { url = "https://files.pythonhosted.org/packages/a2/d2/c4ae543e37d7a9fba09740c221976a63705dbad23a9cda9022fc9fa0f3de/ijson-3.4.0.post0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c8dd327da225887194fe8b93f2b3c9c256353e14a6b9eefc940ed17fde38f5b8", size = 148516, upload-time = "2025-10-10T05:28:49.237Z" }, + { url = "https://files.pythonhosted.org/packages/0d/a1/914b5fb1c26af2474cd04841626e0e95576499a4ca940661fb105ee12dd2/ijson-3.4.0.post0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4810546e66128af51fd4a0c9a640e84e8508e9c15c4f247d8a3e3253b20e1465", size = 149770, upload-time = "2025-10-10T05:28:50.501Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c1/51c3584102d0d85d4aa10cc88dbbe431ecb9fe98160a9e2fad62a4456aed/ijson-3.4.0.post0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:103a0838061297d063bca81d724b0958b616f372bd893bbc278320152252c652", size = 143688, upload-time = "2025-10-10T05:28:51.823Z" }, + { url = "https://files.pythonhosted.org/packages/47/3d/a54f13d766332620bded8ee76bcdd274509ecc53cf99573450f95b3ad910/ijson-3.4.0.post0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:40007c977e230e04118b27322f25a72ae342a3d61464b2057fcd9b21eeb7427a", size = 150688, upload-time = "2025-10-10T05:28:52.757Z" }, + { url = "https://files.pythonhosted.org/packages/72/49/43d97cccf3266da7c044bd42e5083340ad1fd97fbb16d1bcd6791fd8918f/ijson-3.4.0.post0-cp314-cp314-win32.whl", hash = "sha256:f932969fc1fd4449ca141cf5f47ff357656a154a361f28d9ebca0badc5b02297", size = 52882, upload-time = "2025-10-10T05:28:53.708Z" }, + { url = "https://files.pythonhosted.org/packages/e9/f0/008f1ed4e0fc6f6dc7a5a82ecf08a59bb212514e158954374d440d700e6c/ijson-3.4.0.post0-cp314-cp314-win_amd64.whl", hash = "sha256:3ed19b1e4349240773a8ce4a4bfa450892d4a57949c02c515cd6be5a46b7696a", size = 55568, upload-time = "2025-10-10T05:28:54.79Z" }, + { url = "https://files.pythonhosted.org/packages/69/1c/8a199fded709e762aced89bb7086973c837e432dd714bbad78a6ac789c23/ijson-3.4.0.post0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:226447e40ca9340a39ed07d68ea02ee14b52cb4fe649425b256c1f0073531c83", size = 92345, upload-time = "2025-10-10T05:28:55.657Z" }, + { url = "https://files.pythonhosted.org/packages/be/60/04e97f6a403203bd2eb8849570bdce5719d696b5fb96aa2a62566fe7a1d9/ijson-3.4.0.post0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c88f0669d45d4b1aa017c9b68d378e7cd15d188dfb6f0209adc78b7f45590a7", size = 62029, upload-time = "2025-10-10T05:28:56.561Z" }, + { url = "https://files.pythonhosted.org/packages/2a/97/e88295f9456ba939d90d4603af28fcabda3b443ef55e709e9381df3daa58/ijson-3.4.0.post0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:56b3089dc28c12492d92cc4896d2be585a89ecae34e25d08c1df88f21815cb50", size = 61776, upload-time = "2025-10-10T05:28:57.401Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9f/0e9c236e720c2de887ab0d7cad8a15d2aa55fb449f792437fc99899957a9/ijson-3.4.0.post0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c117321cfa7b749cc1213f9b4c80dc958f0a206df98ec038ae4bcbbdb8463a15", size = 199808, upload-time = "2025-10-10T05:28:58.62Z" }, + { url = "https://files.pythonhosted.org/packages/0e/70/c21de30e7013e074924cd82057acfc5760e7b2cc41180f80770621b0ad36/ijson-3.4.0.post0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8311f48db6a33116db5c81682f08b6e2405501a4b4e460193ae69fec3cd1f87a", size = 217152, upload-time = "2025-10-10T05:28:59.656Z" }, + { url = "https://files.pythonhosted.org/packages/64/78/63a0bcc0707037df4e22bb836451279d850592258c859685a402c27f5d6d/ijson-3.4.0.post0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:91c61a3e63e04da648737e6b4abd537df1b46fb8cdf3219b072e790bb3c1a46b", size = 207663, upload-time = "2025-10-10T05:29:00.73Z" }, + { url = "https://files.pythonhosted.org/packages/7d/85/834e9838d69893cb7567e1210be044444213c78f7414aaf1cd241df16078/ijson-3.4.0.post0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1709171023ce82651b2f132575c2e6282e47f64ad67bd3260da476418d0e7895", size = 211157, upload-time = "2025-10-10T05:29:01.87Z" }, + { url = "https://files.pythonhosted.org/packages/2e/9b/9fda503799ebc30397710552e5dedc1d98d9ea6a694e5717415892623a94/ijson-3.4.0.post0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:5f0a72b1e3c0f78551670c12b2fdc1bf05f2796254d9c2055ba319bec2216020", size = 200231, upload-time = "2025-10-10T05:29:02.883Z" }, + { url = "https://files.pythonhosted.org/packages/15/f3/6419d1d5795a16591233d3aa3747b084e82c0c1d7184bdad9be638174560/ijson-3.4.0.post0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b982a3597b0439ce9c8f4cfc929d86c6ed43907908be1e8463a34dc35fe5b258", size = 204825, upload-time = "2025-10-10T05:29:04.242Z" }, + { url = "https://files.pythonhosted.org/packages/1f/8d/a520e6902129c55fa94428ea0a22e8547540d5e7ca30f18b39594a5feea2/ijson-3.4.0.post0-cp314-cp314t-win32.whl", hash = "sha256:4e39bfdc36b0b460ef15a06550a6a385c64c81f7ac205ccff39bd45147918912", size = 55559, upload-time = "2025-10-10T05:29:05.681Z" }, + { url = "https://files.pythonhosted.org/packages/20/67/0ac6dd0045957ba1270b7b1860864f7d8cea4062e70b1083134c587e5768/ijson-3.4.0.post0-cp314-cp314t-win_amd64.whl", hash = "sha256:17e45262a5ddef39894013fb1548ee7094e444c8389eb1a97f86708b19bea03e", size = 58238, upload-time = "2025-10-10T05:29:06.656Z" }, + { url = "https://files.pythonhosted.org/packages/43/66/27cfcea16e85b95e33814eae2052dab187206b8820cdd90aa39d32ffb441/ijson-3.4.0.post0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:add9242f886eae844a7410b84aee2bbb8bdc83c624f227cb1fdb2d0476a96cb1", size = 57029, upload-time = "2025-10-10T05:29:19.733Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1b/df3f1561c6629241fb2f8bd7ea1da14e3c2dd16fe9d7cbc97120870ed09c/ijson-3.4.0.post0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:69718ed41710dfcaa7564b0af42abc05875d4f7aaa24627c808867ef32634bc7", size = 56523, upload-time = "2025-10-10T05:29:20.641Z" }, + { url = "https://files.pythonhosted.org/packages/39/0a/6c6a3221ddecf62b696fde0e864415237e05b9a36ab6685a606b8fb3b5a2/ijson-3.4.0.post0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:636b6eca96c6c43c04629c6b37fad0181662eaacf9877c71c698485637f752f9", size = 70546, upload-time = "2025-10-10T05:29:21.526Z" }, + { url = "https://files.pythonhosted.org/packages/42/cb/edf69755e86a3a9f8b418efd60239cb308af46c7c8e12f869423f51c9851/ijson-3.4.0.post0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb5e73028f6e63d27b3d286069fe350ed80a4ccc493b022b590fea4bb086710d", size = 70532, upload-time = "2025-10-10T05:29:22.718Z" }, + { url = "https://files.pythonhosted.org/packages/96/7e/c8730ea39b8712622cd5a1bdff676098208400e37bb92052ba52f93e2aa1/ijson-3.4.0.post0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:461acf4320219459dabe5ed90a45cb86c9ba8cc6d6db9dad0d9427d42f57794c", size = 67927, upload-time = "2025-10-10T05:29:23.596Z" }, + { url = "https://files.pythonhosted.org/packages/ec/f2/53b6e9bdd2a91202066764eaa74b572ba4dede0fe47a5a26f4de34b7541a/ijson-3.4.0.post0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:a0fedf09c0f6ffa2a99e7e7fd9c5f3caf74e655c1ee015a0797383e99382ebc3", size = 54657, upload-time = "2025-10-10T05:29:24.482Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "8.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "inspect-ai" +version = "0.3.149" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aioboto3" }, + { name = "aiohttp" }, + { name = "anyio" }, + { name = "beautifulsoup4" }, + { name = "boto3" }, + { name = "click" }, + { name = "debugpy" }, + { name = "docstring-parser" }, + { name = "frozendict" }, + { name = "fsspec" }, + { name = "httpx" }, + { name = "ijson" }, + { name = "jsonlines" }, + { name = "jsonpatch" }, + { name = "jsonpath-ng" }, + { name = "jsonref" }, + { name = "jsonschema" }, + { name = "mmh3" }, + { name = "nest-asyncio" }, + { name = "numpy" }, + { name = "platformdirs" }, + { name = "psutil" }, + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "rich" }, + { name = "s3fs" }, + { name = "semver" }, + { name = "shortuuid" }, + { name = "sniffio" }, + { name = "tenacity" }, + { name = "textual" }, + { name = "typing-extensions" }, + { name = "universal-pathlib" }, + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b5/d1/b17afd9539ee1801915b6847e50baff081f3ccaff1fdd820281481db5471/inspect_ai-0.3.149.tar.gz", hash = "sha256:b6e31c96e42558a500eb2036827d5436ea664c8375fd38329049bbb2c5575702", size = 43279176, upload-time = "2025-11-23T18:57:10.337Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/be/a2882fbd0915b8c56836d720e70d27b60d2594ef2485c1b6acf531912e57/inspect_ai-0.3.149-py3-none-any.whl", hash = "sha256:365142efe459bdc3f945d4742ba8e2750ddd6679d0f9ec42c7357f7222a7c4ad", size = 34604776, upload-time = "2025-11-23T18:57:04.701Z" }, +] + +[[package]] +name = "jaraco-classes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" }, +] + +[[package]] +name = "jaraco-context" +version = "6.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "backports-tarfile", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/ad/f3777b81bf0b6e7bc7514a1656d3e637b2e8e15fab2ce3235730b3e7a4e6/jaraco_context-6.0.1.tar.gz", hash = "sha256:9bae4ea555cf0b14938dc0aee7c9f32ed303aa20a3b73e7dc80111628792d1b3", size = 13912, upload-time = "2024-08-20T03:39:27.358Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/db/0c52c4cf5e4bd9f5d7135ec7669a3a767af21b3a308e1ed3674881e52b62/jaraco.context-6.0.1-py3-none-any.whl", hash = "sha256:f797fc481b490edb305122c9181830a3a5b76d84ef6d1aef2fb9b47ab956f9e4", size = 6825, upload-time = "2024-08-20T03:39:25.966Z" }, +] + +[[package]] +name = "jaraco-functools" +version = "4.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f7/ed/1aa2d585304ec07262e1a83a9889880701079dde796ac7b1d1826f40c63d/jaraco_functools-4.3.0.tar.gz", hash = "sha256:cfd13ad0dd2c47a3600b439ef72d8615d482cedcff1632930d6f28924d92f294", size = 19755, upload-time = "2025-08-18T20:05:09.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b4/09/726f168acad366b11e420df31bf1c702a54d373a83f968d94141a8c3fde0/jaraco_functools-4.3.0-py3-none-any.whl", hash = "sha256:227ff8ed6f7b8f62c56deff101545fa7543cf2c8e7b82a7c2116e672f29c26e8", size = 10408, upload-time = "2025-08-18T20:05:08.69Z" }, +] + +[[package]] +name = "jeepney" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "jiter" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/45/9d/e0660989c1370e25848bb4c52d061c71837239738ad937e83edca174c273/jiter-0.12.0.tar.gz", hash = "sha256:64dfcd7d5c168b38d3f9f8bba7fc639edb3418abcc74f22fdbe6b8938293f30b", size = 168294, upload-time = "2025-11-09T20:49:23.302Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/f9/eaca4633486b527ebe7e681c431f529b63fe2709e7c5242fc0f43f77ce63/jiter-0.12.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d8f8a7e317190b2c2d60eb2e8aa835270b008139562d70fe732e1c0020ec53c9", size = 316435, upload-time = "2025-11-09T20:47:02.087Z" }, + { url = "https://files.pythonhosted.org/packages/10/c1/40c9f7c22f5e6ff715f28113ebaba27ab85f9af2660ad6e1dd6425d14c19/jiter-0.12.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2218228a077e784c6c8f1a8e5d6b8cb1dea62ce25811c356364848554b2056cd", size = 320548, upload-time = "2025-11-09T20:47:03.409Z" }, + { url = "https://files.pythonhosted.org/packages/6b/1b/efbb68fe87e7711b00d2cfd1f26bb4bfc25a10539aefeaa7727329ffb9cb/jiter-0.12.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9354ccaa2982bf2188fd5f57f79f800ef622ec67beb8329903abf6b10da7d423", size = 351915, upload-time = "2025-11-09T20:47:05.171Z" }, + { url = "https://files.pythonhosted.org/packages/15/2d/c06e659888c128ad1e838123d0638f0efad90cc30860cb5f74dd3f2fc0b3/jiter-0.12.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2607185ea89b4af9a604d4c7ec40e45d3ad03ee66998b031134bc510232bb7", size = 368966, upload-time = "2025-11-09T20:47:06.508Z" }, + { url = "https://files.pythonhosted.org/packages/6b/20/058db4ae5fb07cf6a4ab2e9b9294416f606d8e467fb74c2184b2a1eeacba/jiter-0.12.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3a585a5e42d25f2e71db5f10b171f5e5ea641d3aa44f7df745aa965606111cc2", size = 482047, upload-time = "2025-11-09T20:47:08.382Z" }, + { url = "https://files.pythonhosted.org/packages/49/bb/dc2b1c122275e1de2eb12905015d61e8316b2f888bdaac34221c301495d6/jiter-0.12.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd9e21d34edff5a663c631f850edcb786719c960ce887a5661e9c828a53a95d9", size = 380835, upload-time = "2025-11-09T20:47:09.81Z" }, + { url = "https://files.pythonhosted.org/packages/23/7d/38f9cd337575349de16da575ee57ddb2d5a64d425c9367f5ef9e4612e32e/jiter-0.12.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a612534770470686cd5431478dc5a1b660eceb410abade6b1b74e320ca98de6", size = 364587, upload-time = "2025-11-09T20:47:11.529Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a3/b13e8e61e70f0bb06085099c4e2462647f53cc2ca97614f7fedcaa2bb9f3/jiter-0.12.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3985aea37d40a908f887b34d05111e0aae822943796ebf8338877fee2ab67725", size = 390492, upload-time = "2025-11-09T20:47:12.993Z" }, + { url = "https://files.pythonhosted.org/packages/07/71/e0d11422ed027e21422f7bc1883c61deba2d9752b720538430c1deadfbca/jiter-0.12.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b1207af186495f48f72529f8d86671903c8c10127cac6381b11dddc4aaa52df6", size = 522046, upload-time = "2025-11-09T20:47:14.6Z" }, + { url = "https://files.pythonhosted.org/packages/9f/59/b968a9aa7102a8375dbbdfbd2aeebe563c7e5dddf0f47c9ef1588a97e224/jiter-0.12.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ef2fb241de583934c9915a33120ecc06d94aa3381a134570f59eed784e87001e", size = 513392, upload-time = "2025-11-09T20:47:16.011Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e4/7df62002499080dbd61b505c5cb351aa09e9959d176cac2aa8da6f93b13b/jiter-0.12.0-cp311-cp311-win32.whl", hash = "sha256:453b6035672fecce8007465896a25b28a6b59cfe8fbc974b2563a92f5a92a67c", size = 206096, upload-time = "2025-11-09T20:47:17.344Z" }, + { url = "https://files.pythonhosted.org/packages/bb/60/1032b30ae0572196b0de0e87dce3b6c26a1eff71aad5fe43dee3082d32e0/jiter-0.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:ca264b9603973c2ad9435c71a8ec8b49f8f715ab5ba421c85a51cde9887e421f", size = 204899, upload-time = "2025-11-09T20:47:19.365Z" }, + { url = "https://files.pythonhosted.org/packages/49/d5/c145e526fccdb834063fb45c071df78b0cc426bbaf6de38b0781f45d956f/jiter-0.12.0-cp311-cp311-win_arm64.whl", hash = "sha256:cb00ef392e7d684f2754598c02c409f376ddcef857aae796d559e6cacc2d78a5", size = 188070, upload-time = "2025-11-09T20:47:20.75Z" }, + { url = "https://files.pythonhosted.org/packages/92/c9/5b9f7b4983f1b542c64e84165075335e8a236fa9e2ea03a0c79780062be8/jiter-0.12.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:305e061fa82f4680607a775b2e8e0bcb071cd2205ac38e6ef48c8dd5ebe1cf37", size = 314449, upload-time = "2025-11-09T20:47:22.999Z" }, + { url = "https://files.pythonhosted.org/packages/98/6e/e8efa0e78de00db0aee82c0cf9e8b3f2027efd7f8a71f859d8f4be8e98ef/jiter-0.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5c1860627048e302a528333c9307c818c547f214d8659b0705d2195e1a94b274", size = 319855, upload-time = "2025-11-09T20:47:24.779Z" }, + { url = "https://files.pythonhosted.org/packages/20/26/894cd88e60b5d58af53bec5c6759d1292bd0b37a8b5f60f07abf7a63ae5f/jiter-0.12.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df37577a4f8408f7e0ec3205d2a8f87672af8f17008358063a4d6425b6081ce3", size = 350171, upload-time = "2025-11-09T20:47:26.469Z" }, + { url = "https://files.pythonhosted.org/packages/f5/27/a7b818b9979ac31b3763d25f3653ec3a954044d5e9f5d87f2f247d679fd1/jiter-0.12.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:75fdd787356c1c13a4f40b43c2156276ef7a71eb487d98472476476d803fb2cf", size = 365590, upload-time = "2025-11-09T20:47:27.918Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7e/e46195801a97673a83746170b17984aa8ac4a455746354516d02ca5541b4/jiter-0.12.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1eb5db8d9c65b112aacf14fcd0faae9913d07a8afea5ed06ccdd12b724e966a1", size = 479462, upload-time = "2025-11-09T20:47:29.654Z" }, + { url = "https://files.pythonhosted.org/packages/ca/75/f833bfb009ab4bd11b1c9406d333e3b4357709ed0570bb48c7c06d78c7dd/jiter-0.12.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:73c568cc27c473f82480abc15d1301adf333a7ea4f2e813d6a2c7d8b6ba8d0df", size = 378983, upload-time = "2025-11-09T20:47:31.026Z" }, + { url = "https://files.pythonhosted.org/packages/71/b3/7a69d77943cc837d30165643db753471aff5df39692d598da880a6e51c24/jiter-0.12.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4321e8a3d868919bcb1abb1db550d41f2b5b326f72df29e53b2df8b006eb9403", size = 361328, upload-time = "2025-11-09T20:47:33.286Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ac/a78f90caf48d65ba70d8c6efc6f23150bc39dc3389d65bbec2a95c7bc628/jiter-0.12.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0a51bad79f8cc9cac2b4b705039f814049142e0050f30d91695a2d9a6611f126", size = 386740, upload-time = "2025-11-09T20:47:34.703Z" }, + { url = "https://files.pythonhosted.org/packages/39/b6/5d31c2cc8e1b6a6bcf3c5721e4ca0a3633d1ab4754b09bc7084f6c4f5327/jiter-0.12.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2a67b678f6a5f1dd6c36d642d7db83e456bc8b104788262aaefc11a22339f5a9", size = 520875, upload-time = "2025-11-09T20:47:36.058Z" }, + { url = "https://files.pythonhosted.org/packages/30/b5/4df540fae4e9f68c54b8dab004bd8c943a752f0b00efd6e7d64aa3850339/jiter-0.12.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efe1a211fe1fd14762adea941e3cfd6c611a136e28da6c39272dbb7a1bbe6a86", size = 511457, upload-time = "2025-11-09T20:47:37.932Z" }, + { url = "https://files.pythonhosted.org/packages/07/65/86b74010e450a1a77b2c1aabb91d4a91dd3cd5afce99f34d75fd1ac64b19/jiter-0.12.0-cp312-cp312-win32.whl", hash = "sha256:d779d97c834b4278276ec703dc3fc1735fca50af63eb7262f05bdb4e62203d44", size = 204546, upload-time = "2025-11-09T20:47:40.47Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c7/6659f537f9562d963488e3e55573498a442503ced01f7e169e96a6110383/jiter-0.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:e8269062060212b373316fe69236096aaf4c49022d267c6736eebd66bbbc60bb", size = 205196, upload-time = "2025-11-09T20:47:41.794Z" }, + { url = "https://files.pythonhosted.org/packages/21/f4/935304f5169edadfec7f9c01eacbce4c90bb9a82035ac1de1f3bd2d40be6/jiter-0.12.0-cp312-cp312-win_arm64.whl", hash = "sha256:06cb970936c65de926d648af0ed3d21857f026b1cf5525cb2947aa5e01e05789", size = 186100, upload-time = "2025-11-09T20:47:43.007Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a6/97209693b177716e22576ee1161674d1d58029eb178e01866a0422b69224/jiter-0.12.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:6cc49d5130a14b732e0612bc76ae8db3b49898732223ef8b7599aa8d9810683e", size = 313658, upload-time = "2025-11-09T20:47:44.424Z" }, + { url = "https://files.pythonhosted.org/packages/06/4d/125c5c1537c7d8ee73ad3d530a442d6c619714b95027143f1b61c0b4dfe0/jiter-0.12.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:37f27a32ce36364d2fa4f7fdc507279db604d27d239ea2e044c8f148410defe1", size = 318605, upload-time = "2025-11-09T20:47:45.973Z" }, + { url = "https://files.pythonhosted.org/packages/99/bf/a840b89847885064c41a5f52de6e312e91fa84a520848ee56c97e4fa0205/jiter-0.12.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbc0944aa3d4b4773e348cda635252824a78f4ba44328e042ef1ff3f6080d1cf", size = 349803, upload-time = "2025-11-09T20:47:47.535Z" }, + { url = "https://files.pythonhosted.org/packages/8a/88/e63441c28e0db50e305ae23e19c1d8fae012d78ed55365da392c1f34b09c/jiter-0.12.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:da25c62d4ee1ffbacb97fac6dfe4dcd6759ebdc9015991e92a6eae5816287f44", size = 365120, upload-time = "2025-11-09T20:47:49.284Z" }, + { url = "https://files.pythonhosted.org/packages/0a/7c/49b02714af4343970eb8aca63396bc1c82fa01197dbb1e9b0d274b550d4e/jiter-0.12.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:048485c654b838140b007390b8182ba9774621103bd4d77c9c3f6f117474ba45", size = 479918, upload-time = "2025-11-09T20:47:50.807Z" }, + { url = "https://files.pythonhosted.org/packages/69/ba/0a809817fdd5a1db80490b9150645f3aae16afad166960bcd562be194f3b/jiter-0.12.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:635e737fbb7315bef0037c19b88b799143d2d7d3507e61a76751025226b3ac87", size = 379008, upload-time = "2025-11-09T20:47:52.211Z" }, + { url = "https://files.pythonhosted.org/packages/5f/c3/c9fc0232e736c8877d9e6d83d6eeb0ba4e90c6c073835cc2e8f73fdeef51/jiter-0.12.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e017c417b1ebda911bd13b1e40612704b1f5420e30695112efdbed8a4b389ed", size = 361785, upload-time = "2025-11-09T20:47:53.512Z" }, + { url = "https://files.pythonhosted.org/packages/96/61/61f69b7e442e97ca6cd53086ddc1cf59fb830549bc72c0a293713a60c525/jiter-0.12.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:89b0bfb8b2bf2351fba36bb211ef8bfceba73ef58e7f0c68fb67b5a2795ca2f9", size = 386108, upload-time = "2025-11-09T20:47:54.893Z" }, + { url = "https://files.pythonhosted.org/packages/e9/2e/76bb3332f28550c8f1eba3bf6e5efe211efda0ddbbaf24976bc7078d42a5/jiter-0.12.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:f5aa5427a629a824a543672778c9ce0c5e556550d1569bb6ea28a85015287626", size = 519937, upload-time = "2025-11-09T20:47:56.253Z" }, + { url = "https://files.pythonhosted.org/packages/84/d6/fa96efa87dc8bff2094fb947f51f66368fa56d8d4fc9e77b25d7fbb23375/jiter-0.12.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ed53b3d6acbcb0fd0b90f20c7cb3b24c357fe82a3518934d4edfa8c6898e498c", size = 510853, upload-time = "2025-11-09T20:47:58.32Z" }, + { url = "https://files.pythonhosted.org/packages/8a/28/93f67fdb4d5904a708119a6ab58a8f1ec226ff10a94a282e0215402a8462/jiter-0.12.0-cp313-cp313-win32.whl", hash = "sha256:4747de73d6b8c78f2e253a2787930f4fffc68da7fa319739f57437f95963c4de", size = 204699, upload-time = "2025-11-09T20:47:59.686Z" }, + { url = "https://files.pythonhosted.org/packages/c4/1f/30b0eb087045a0abe2a5c9c0c0c8da110875a1d3be83afd4a9a4e548be3c/jiter-0.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:e25012eb0c456fcc13354255d0338cd5397cce26c77b2832b3c4e2e255ea5d9a", size = 204258, upload-time = "2025-11-09T20:48:01.01Z" }, + { url = "https://files.pythonhosted.org/packages/2c/f4/2b4daf99b96bce6fc47971890b14b2a36aef88d7beb9f057fafa032c6141/jiter-0.12.0-cp313-cp313-win_arm64.whl", hash = "sha256:c97b92c54fe6110138c872add030a1f99aea2401ddcdaa21edf74705a646dd60", size = 185503, upload-time = "2025-11-09T20:48:02.35Z" }, + { url = "https://files.pythonhosted.org/packages/39/ca/67bb15a7061d6fe20b9b2a2fd783e296a1e0f93468252c093481a2f00efa/jiter-0.12.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:53839b35a38f56b8be26a7851a48b89bc47e5d88e900929df10ed93b95fea3d6", size = 317965, upload-time = "2025-11-09T20:48:03.783Z" }, + { url = "https://files.pythonhosted.org/packages/18/af/1788031cd22e29c3b14bc6ca80b16a39a0b10e611367ffd480c06a259831/jiter-0.12.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94f669548e55c91ab47fef8bddd9c954dab1938644e715ea49d7e117015110a4", size = 345831, upload-time = "2025-11-09T20:48:05.55Z" }, + { url = "https://files.pythonhosted.org/packages/05/17/710bf8472d1dff0d3caf4ced6031060091c1320f84ee7d5dcbed1f352417/jiter-0.12.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:351d54f2b09a41600ffea43d081522d792e81dcfb915f6d2d242744c1cc48beb", size = 361272, upload-time = "2025-11-09T20:48:06.951Z" }, + { url = "https://files.pythonhosted.org/packages/fb/f1/1dcc4618b59761fef92d10bcbb0b038b5160be653b003651566a185f1a5c/jiter-0.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2a5e90604620f94bf62264e7c2c038704d38217b7465b863896c6d7c902b06c7", size = 204604, upload-time = "2025-11-09T20:48:08.328Z" }, + { url = "https://files.pythonhosted.org/packages/d9/32/63cb1d9f1c5c6632a783c0052cde9ef7ba82688f7065e2f0d5f10a7e3edb/jiter-0.12.0-cp313-cp313t-win_arm64.whl", hash = "sha256:88ef757017e78d2860f96250f9393b7b577b06a956ad102c29c8237554380db3", size = 185628, upload-time = "2025-11-09T20:48:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/a8/99/45c9f0dbe4a1416b2b9a8a6d1236459540f43d7fb8883cff769a8db0612d/jiter-0.12.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c46d927acd09c67a9fb1416df45c5a04c27e83aae969267e98fba35b74e99525", size = 312478, upload-time = "2025-11-09T20:48:10.898Z" }, + { url = "https://files.pythonhosted.org/packages/4c/a7/54ae75613ba9e0f55fcb0bc5d1f807823b5167cc944e9333ff322e9f07dd/jiter-0.12.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:774ff60b27a84a85b27b88cd5583899c59940bcc126caca97eb2a9df6aa00c49", size = 318706, upload-time = "2025-11-09T20:48:12.266Z" }, + { url = "https://files.pythonhosted.org/packages/59/31/2aa241ad2c10774baf6c37f8b8e1f39c07db358f1329f4eb40eba179c2a2/jiter-0.12.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5433fab222fb072237df3f637d01b81f040a07dcac1cb4a5c75c7aa9ed0bef1", size = 351894, upload-time = "2025-11-09T20:48:13.673Z" }, + { url = "https://files.pythonhosted.org/packages/54/4f/0f2759522719133a9042781b18cc94e335b6d290f5e2d3e6899d6af933e3/jiter-0.12.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f8c593c6e71c07866ec6bfb790e202a833eeec885022296aff6b9e0b92d6a70e", size = 365714, upload-time = "2025-11-09T20:48:15.083Z" }, + { url = "https://files.pythonhosted.org/packages/dc/6f/806b895f476582c62a2f52c453151edd8a0fde5411b0497baaa41018e878/jiter-0.12.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:90d32894d4c6877a87ae00c6b915b609406819dce8bc0d4e962e4de2784e567e", size = 478989, upload-time = "2025-11-09T20:48:16.706Z" }, + { url = "https://files.pythonhosted.org/packages/86/6c/012d894dc6e1033acd8db2b8346add33e413ec1c7c002598915278a37f79/jiter-0.12.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:798e46eed9eb10c3adbbacbd3bdb5ecd4cf7064e453d00dbef08802dae6937ff", size = 378615, upload-time = "2025-11-09T20:48:18.614Z" }, + { url = "https://files.pythonhosted.org/packages/87/30/d718d599f6700163e28e2c71c0bbaf6dace692e7df2592fd793ac9276717/jiter-0.12.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3f1368f0a6719ea80013a4eb90ba72e75d7ea67cfc7846db2ca504f3df0169a", size = 364745, upload-time = "2025-11-09T20:48:20.117Z" }, + { url = "https://files.pythonhosted.org/packages/8f/85/315b45ce4b6ddc7d7fceca24068543b02bdc8782942f4ee49d652e2cc89f/jiter-0.12.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:65f04a9d0b4406f7e51279710b27484af411896246200e461d80d3ba0caa901a", size = 386502, upload-time = "2025-11-09T20:48:21.543Z" }, + { url = "https://files.pythonhosted.org/packages/74/0b/ce0434fb40c5b24b368fe81b17074d2840748b4952256bab451b72290a49/jiter-0.12.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:fd990541982a24281d12b67a335e44f117e4c6cbad3c3b75c7dea68bf4ce3a67", size = 519845, upload-time = "2025-11-09T20:48:22.964Z" }, + { url = "https://files.pythonhosted.org/packages/e8/a3/7a7a4488ba052767846b9c916d208b3ed114e3eb670ee984e4c565b9cf0d/jiter-0.12.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:b111b0e9152fa7df870ecaebb0bd30240d9f7fff1f2003bcb4ed0f519941820b", size = 510701, upload-time = "2025-11-09T20:48:24.483Z" }, + { url = "https://files.pythonhosted.org/packages/c3/16/052ffbf9d0467b70af24e30f91e0579e13ded0c17bb4a8eb2aed3cb60131/jiter-0.12.0-cp314-cp314-win32.whl", hash = "sha256:a78befb9cc0a45b5a5a0d537b06f8544c2ebb60d19d02c41ff15da28a9e22d42", size = 205029, upload-time = "2025-11-09T20:48:25.749Z" }, + { url = "https://files.pythonhosted.org/packages/e4/18/3cf1f3f0ccc789f76b9a754bdb7a6977e5d1d671ee97a9e14f7eb728d80e/jiter-0.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:e1fe01c082f6aafbe5c8faf0ff074f38dfb911d53f07ec333ca03f8f6226debf", size = 204960, upload-time = "2025-11-09T20:48:27.415Z" }, + { url = "https://files.pythonhosted.org/packages/02/68/736821e52ecfdeeb0f024b8ab01b5a229f6b9293bbdb444c27efade50b0f/jiter-0.12.0-cp314-cp314-win_arm64.whl", hash = "sha256:d72f3b5a432a4c546ea4bedc84cce0c3404874f1d1676260b9c7f048a9855451", size = 185529, upload-time = "2025-11-09T20:48:29.125Z" }, + { url = "https://files.pythonhosted.org/packages/30/61/12ed8ee7a643cce29ac97c2281f9ce3956eb76b037e88d290f4ed0d41480/jiter-0.12.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e6ded41aeba3603f9728ed2b6196e4df875348ab97b28fc8afff115ed42ba7a7", size = 318974, upload-time = "2025-11-09T20:48:30.87Z" }, + { url = "https://files.pythonhosted.org/packages/2d/c6/f3041ede6d0ed5e0e79ff0de4c8f14f401bbf196f2ef3971cdbe5fd08d1d/jiter-0.12.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a947920902420a6ada6ad51892082521978e9dd44a802663b001436e4b771684", size = 345932, upload-time = "2025-11-09T20:48:32.658Z" }, + { url = "https://files.pythonhosted.org/packages/d5/5d/4d94835889edd01ad0e2dbfc05f7bdfaed46292e7b504a6ac7839aa00edb/jiter-0.12.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:add5e227e0554d3a52cf390a7635edaffdf4f8fce4fdbcef3cc2055bb396a30c", size = 367243, upload-time = "2025-11-09T20:48:34.093Z" }, + { url = "https://files.pythonhosted.org/packages/fd/76/0051b0ac2816253a99d27baf3dda198663aff882fa6ea7deeb94046da24e/jiter-0.12.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f9b1cda8fcb736250d7e8711d4580ebf004a46771432be0ae4796944b5dfa5d", size = 479315, upload-time = "2025-11-09T20:48:35.507Z" }, + { url = "https://files.pythonhosted.org/packages/70/ae/83f793acd68e5cb24e483f44f482a1a15601848b9b6f199dacb970098f77/jiter-0.12.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:deeb12a2223fe0135c7ff1356a143d57f95bbf1f4a66584f1fc74df21d86b993", size = 380714, upload-time = "2025-11-09T20:48:40.014Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/4808a88338ad2c228b1126b93fcd8ba145e919e886fe910d578230dabe3b/jiter-0.12.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c596cc0f4cb574877550ce4ecd51f8037469146addd676d7c1a30ebe6391923f", size = 365168, upload-time = "2025-11-09T20:48:41.462Z" }, + { url = "https://files.pythonhosted.org/packages/0c/d4/04619a9e8095b42aef436b5aeb4c0282b4ff1b27d1db1508df9f5dc82750/jiter-0.12.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5ab4c823b216a4aeab3fdbf579c5843165756bd9ad87cc6b1c65919c4715f783", size = 387893, upload-time = "2025-11-09T20:48:42.921Z" }, + { url = "https://files.pythonhosted.org/packages/17/ea/d3c7e62e4546fdc39197fa4a4315a563a89b95b6d54c0d25373842a59cbe/jiter-0.12.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:e427eee51149edf962203ff8db75a7514ab89be5cb623fb9cea1f20b54f1107b", size = 520828, upload-time = "2025-11-09T20:48:44.278Z" }, + { url = "https://files.pythonhosted.org/packages/cc/0b/c6d3562a03fd767e31cb119d9041ea7958c3c80cb3d753eafb19b3b18349/jiter-0.12.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:edb868841f84c111255ba5e80339d386d937ec1fdce419518ce1bd9370fac5b6", size = 511009, upload-time = "2025-11-09T20:48:45.726Z" }, + { url = "https://files.pythonhosted.org/packages/aa/51/2cb4468b3448a8385ebcd15059d325c9ce67df4e2758d133ab9442b19834/jiter-0.12.0-cp314-cp314t-win32.whl", hash = "sha256:8bbcfe2791dfdb7c5e48baf646d37a6a3dcb5a97a032017741dea9f817dca183", size = 205110, upload-time = "2025-11-09T20:48:47.033Z" }, + { url = "https://files.pythonhosted.org/packages/b2/c5/ae5ec83dec9c2d1af805fd5fe8f74ebded9c8670c5210ec7820ce0dbeb1e/jiter-0.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2fa940963bf02e1d8226027ef461e36af472dea85d36054ff835aeed944dd873", size = 205223, upload-time = "2025-11-09T20:48:49.076Z" }, + { url = "https://files.pythonhosted.org/packages/97/9a/3c5391907277f0e55195550cf3fa8e293ae9ee0c00fb402fec1e38c0c82f/jiter-0.12.0-cp314-cp314t-win_arm64.whl", hash = "sha256:506c9708dd29b27288f9f8f1140c3cb0e3d8ddb045956d7757b1fa0e0f39a473", size = 185564, upload-time = "2025-11-09T20:48:50.376Z" }, + { url = "https://files.pythonhosted.org/packages/fe/54/5339ef1ecaa881c6948669956567a64d2670941925f245c434f494ffb0e5/jiter-0.12.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:4739a4657179ebf08f85914ce50332495811004cc1747852e8b2041ed2aab9b8", size = 311144, upload-time = "2025-11-09T20:49:10.503Z" }, + { url = "https://files.pythonhosted.org/packages/27/74/3446c652bffbd5e81ab354e388b1b5fc1d20daac34ee0ed11ff096b1b01a/jiter-0.12.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:41da8def934bf7bec16cb24bd33c0ca62126d2d45d81d17b864bd5ad721393c3", size = 305877, upload-time = "2025-11-09T20:49:12.269Z" }, + { url = "https://files.pythonhosted.org/packages/a1/f4/ed76ef9043450f57aac2d4fbeb27175aa0eb9c38f833be6ef6379b3b9a86/jiter-0.12.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c44ee814f499c082e69872d426b624987dbc5943ab06e9bbaa4f81989fdb79e", size = 340419, upload-time = "2025-11-09T20:49:13.803Z" }, + { url = "https://files.pythonhosted.org/packages/21/01/857d4608f5edb0664aa791a3d45702e1a5bcfff9934da74035e7b9803846/jiter-0.12.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cd2097de91cf03eaa27b3cbdb969addf83f0179c6afc41bbc4513705e013c65d", size = 347212, upload-time = "2025-11-09T20:49:15.643Z" }, + { url = "https://files.pythonhosted.org/packages/cb/f5/12efb8ada5f5c9edc1d4555fe383c1fb2eac05ac5859258a72d61981d999/jiter-0.12.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:e8547883d7b96ef2e5fe22b88f8a4c8725a56e7f4abafff20fd5272d634c7ecb", size = 309974, upload-time = "2025-11-09T20:49:17.187Z" }, + { url = "https://files.pythonhosted.org/packages/85/15/d6eb3b770f6a0d332675141ab3962fd4a7c270ede3515d9f3583e1d28276/jiter-0.12.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:89163163c0934854a668ed783a2546a0617f71706a2551a4a0666d91ab365d6b", size = 304233, upload-time = "2025-11-09T20:49:18.734Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3e/e7e06743294eea2cf02ced6aa0ff2ad237367394e37a0e2b4a1108c67a36/jiter-0.12.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d96b264ab7d34bbb2312dedc47ce07cd53f06835eacbc16dde3761f47c3a9e7f", size = 338537, upload-time = "2025-11-09T20:49:20.317Z" }, + { url = "https://files.pythonhosted.org/packages/2f/9c/6753e6522b8d0ef07d3a3d239426669e984fb0eba15a315cdbc1253904e4/jiter-0.12.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c24e864cb30ab82311c6425655b0cdab0a98c5d973b065c66a3f020740c2324c", size = 346110, upload-time = "2025-11-09T20:49:21.817Z" }, +] + +[[package]] +name = "jmespath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843, upload-time = "2022-06-17T18:00:12.224Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" }, +] + +[[package]] +name = "jsonlines" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/35/87/bcda8e46c88d0e34cad2f09ee2d0c7f5957bccdb9791b0b934ec84d84be4/jsonlines-4.0.0.tar.gz", hash = "sha256:0c6d2c09117550c089995247f605ae4cf77dd1533041d366351f6f298822ea74", size = 11359, upload-time = "2023-09-01T12:34:44.187Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/62/d9ba6323b9202dd2fe166beab8a86d29465c41a0288cbe229fac60c1ab8d/jsonlines-4.0.0-py3-none-any.whl", hash = "sha256:185b334ff2ca5a91362993f42e83588a360cf95ce4b71a73548502bda52a7c55", size = 8701, upload-time = "2023-09-01T12:34:42.563Z" }, +] + +[[package]] +name = "jsonpatch" +version = "1.33" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonpointer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/78/18813351fe5d63acad16aec57f94ec2b70a09e53ca98145589e185423873/jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c", size = 21699, upload-time = "2023-06-26T12:07:29.144Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/07/02e16ed01e04a374e644b575638ec7987ae846d25ad97bcc9945a3ee4b0e/jsonpatch-1.33-py2.py3-none-any.whl", hash = "sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade", size = 12898, upload-time = "2023-06-16T21:01:28.466Z" }, +] + +[[package]] +name = "jsonpath-ng" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ply" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/86/08646239a313f895186ff0a4573452038eed8c86f54380b3ebac34d32fb2/jsonpath-ng-1.7.0.tar.gz", hash = "sha256:f6f5f7fd4e5ff79c785f1573b394043b39849fb2bb47bcead935d12b00beab3c", size = 37838, upload-time = "2024-10-11T15:41:42.404Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/5a/73ecb3d82f8615f32ccdadeb9356726d6cae3a4bbc840b437ceb95708063/jsonpath_ng-1.7.0-py3-none-any.whl", hash = "sha256:f3d7f9e848cba1b6da28c55b1c26ff915dc9e0b1ba7e752a53d6da8d5cbd00b6", size = 30105, upload-time = "2024-11-20T17:58:30.418Z" }, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114, upload-time = "2024-06-10T19:24:42.462Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595, upload-time = "2024-06-10T19:24:40.698Z" }, +] + +[[package]] +name = "jsonref" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", hash = "sha256:32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552", size = 8814, upload-time = "2023-01-16T16:10:04.455Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", hash = "sha256:590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9", size = 9425, upload-time = "2023-01-16T16:10:02.255Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" }, +] + +[[package]] +name = "jsonschema-path" +version = "0.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pathable" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6e/45/41ebc679c2a4fced6a722f624c18d658dee42612b83ea24c1caf7c0eb3a8/jsonschema_path-0.3.4.tar.gz", hash = "sha256:8365356039f16cc65fddffafda5f58766e34bebab7d6d105616ab52bc4297001", size = 11159, upload-time = "2025-01-24T14:33:16.547Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/58/3485da8cb93d2f393bce453adeef16896751f14ba3e2024bc21dc9597646/jsonschema_path-0.3.4-py3-none-any.whl", hash = "sha256:f502191fdc2b22050f9a81c9237be9d27145b9001c55842bece5e94e382e52f8", size = 14810, upload-time = "2025-01-24T14:33:14.652Z" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/27/d10de45e8ad4ce872372c4a3a37b7b35b6b064f6f023a5c14ffcced4d59d/jupyter_client-8.7.0.tar.gz", hash = "sha256:3357212d9cbe01209e59190f67a3a7e1f387a4f4e88d1e0433ad84d7b262531d", size = 344691, upload-time = "2025-12-09T18:37:01.953Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/f5/fddaec430367be9d62a7ed125530e133bfd4a1c0350fe221149ee0f2b526/jupyter_client-8.7.0-py3-none-any.whl", hash = "sha256:3671a94fd25e62f5f2f554f5e95389c2294d89822378a5f2dd24353e1494a9e0", size = 106215, upload-time = "2025-12-09T18:37:00.024Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, +] + +[[package]] +name = "keyring" +version = "25.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.12'" }, + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney", marker = "sys_platform == 'linux'" }, + { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" }, + { name = "secretstorage", marker = "sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" }, +] + +[[package]] +name = "linkify-it-py" +version = "2.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "uc-micro-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" }, +] + +[[package]] +name = "litellm" +version = "1.83.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "click" }, + { name = "fastuuid" }, + { name = "httpx" }, + { name = "importlib-metadata" }, + { name = "jinja2" }, + { name = "jsonschema" }, + { name = "openai" }, + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "tiktoken" }, + { name = "tokenizers" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/92/6ce9737554994ca8e536e5f4f6a87cc7c4774b656c9eb9add071caf7d54b/litellm-1.83.0.tar.gz", hash = "sha256:860bebc76c4bb27b4cf90b4a77acd66dba25aced37e3db98750de8a1766bfb7a", size = 17333062, upload-time = "2026-03-31T05:08:25.331Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/2c/a670cc050fcd6f45c6199eb99e259c73aea92edba8d5c2fc1b3686d36217/litellm-1.83.0-py3-none-any.whl", hash = "sha256:88c536d339248f3987571493015784671ba3f193a328e1ea6780dbebaa2094a8", size = 15610306, upload-time = "2026-03-31T05:08:21.987Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" }, +] + +[package.optional-dependencies] +linkify = [ + { name = "linkify-it-py" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" }, + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "mcp" +version = "1.27.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "httpx" }, + { name = "httpx-sse" }, + { name = "jsonschema" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "pyjwt", extra = ["crypto"] }, + { name = "python-multipart" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "sse-starlette" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, + { name = "uvicorn", marker = "sys_platform != 'emscripten'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8b/eb/c0cfc62075dc6e1ec1c64d352ae09ac051d9334311ed226f1f425312848a/mcp-1.27.0.tar.gz", hash = "sha256:d3dc35a7eec0d458c1da4976a48f982097ddaab87e278c5511d5a4a56e852b83", size = 607509, upload-time = "2026-04-02T14:48:08.88Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/46/f6b4ad632c67ef35209a66127e4bddc95759649dd595f71f13fba11bdf9a/mcp-1.27.0-py3-none-any.whl", hash = "sha256:5ce1fa81614958e267b21fb2aa34e0aea8e2c6ede60d52aba45fd47246b4d741", size = 215967, upload-time = "2026-04-02T14:48:07.24Z" }, +] + +[[package]] +name = "mdit-py-plugins" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "mistune" +version = "3.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9d/55/d01f0c4b45ade6536c51170b9043db8b2ec6ddf4a35c7ea3f5f559ac935b/mistune-3.2.0.tar.gz", hash = "sha256:708487c8a8cdd99c9d90eb3ed4c3ed961246ff78ac82f03418f5183ab70e398a", size = 95467, upload-time = "2025-12-23T11:36:34.994Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/f7/4a5e785ec9fbd65146a27b6b70b6cdc161a66f2024e4b04ac06a67f5578b/mistune-3.2.0-py3-none-any.whl", hash = "sha256:febdc629a3c78616b94393c6580551e0e34cc289987ec6c35ed3f4be42d0eee1", size = 53598, upload-time = "2025-12-23T11:36:33.211Z" }, +] + +[[package]] +name = "ml-intern" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "apscheduler" }, + { name = "datasets" }, + { name = "fastapi" }, + { name = "fastmcp" }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "litellm" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "prompt-toolkit" }, + { name = "pydantic" }, + { name = "pymongo" }, + { name = "python-dotenv" }, + { name = "python-multipart" }, + { name = "requests" }, + { name = "rich" }, + { name = "thefuzz" }, + { name = "uvicorn", extra = ["standard"] }, + { name = "websockets" }, + { name = "whoosh" }, +] + +[package.optional-dependencies] +all = [ + { name = "datasets" }, + { name = "inspect-ai" }, + { name = "pandas" }, + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "ruff" }, + { name = "tenacity" }, +] +dev = [ + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "ruff" }, +] +eval = [ + { name = "datasets" }, + { name = "inspect-ai" }, + { name = "pandas" }, + { name = "tenacity" }, +] + +[package.metadata] +requires-dist = [ + { name = "apscheduler", specifier = ">=3.10,<4" }, + { name = "datasets", specifier = ">=4.4.1" }, + { name = "datasets", marker = "extra == 'eval'", specifier = ">=4.3.0" }, + { name = "fastapi", specifier = ">=0.115.0" }, + { name = "fastmcp", specifier = ">=3.2.0" }, + { name = "httpx", specifier = ">=0.27.0" }, + { name = "huggingface-hub", specifier = ">=1.12.0" }, + { name = "inspect-ai", marker = "extra == 'eval'", specifier = ">=0.3.149" }, + { name = "litellm", specifier = ">=1.83.0" }, + { name = "ml-intern", extras = ["eval", "dev"], marker = "extra == 'all'" }, + { name = "nbconvert", specifier = ">=7.16.6" }, + { name = "nbformat", specifier = ">=5.10.4" }, + { name = "pandas", marker = "extra == 'eval'", specifier = ">=2.3.3" }, + { name = "prompt-toolkit", specifier = ">=3.0.0" }, + { name = "pydantic", specifier = ">=2.12.3" }, + { name = "pymongo", specifier = ">=4.17.0" }, + { name = "pytest", marker = "extra == 'dev'", specifier = ">=9.0.2" }, + { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=1.2.0" }, + { name = "python-dotenv", specifier = ">=1.2.1" }, + { name = "python-multipart", specifier = ">=0.0.20" }, + { name = "requests", specifier = ">=2.33.0" }, + { name = "rich", specifier = ">=13.0.0" }, + { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.15.12" }, + { name = "tenacity", marker = "extra == 'eval'", specifier = ">=8.0.0" }, + { name = "thefuzz", specifier = ">=0.22.1" }, + { name = "uvicorn", extras = ["standard"], specifier = ">=0.32.0" }, + { name = "websockets", specifier = ">=13.0" }, + { name = "whoosh", specifier = ">=2.7.4" }, +] +provides-extras = ["eval", "dev", "all"] + +[[package]] +name = "mmh3" +version = "5.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/af/f28c2c2f51f31abb4725f9a64bc7863d5f491f6539bd26aee2a1d21a649e/mmh3-5.2.0.tar.gz", hash = "sha256:1efc8fec8478e9243a78bb993422cf79f8ff85cb4cf6b79647480a31e0d950a8", size = 33582, upload-time = "2025-07-29T07:43:48.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/87/399567b3796e134352e11a8b973cd470c06b2ecfad5468fe580833be442b/mmh3-5.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7901c893e704ee3c65f92d39b951f8f34ccf8e8566768c58103fb10e55afb8c1", size = 56107, upload-time = "2025-07-29T07:41:57.07Z" }, + { url = "https://files.pythonhosted.org/packages/c3/09/830af30adf8678955b247d97d3d9543dd2fd95684f3cd41c0cd9d291da9f/mmh3-5.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4a5f5536b1cbfa72318ab3bfc8a8188b949260baed186b75f0abc75b95d8c051", size = 40635, upload-time = "2025-07-29T07:41:57.903Z" }, + { url = "https://files.pythonhosted.org/packages/07/14/eaba79eef55b40d653321765ac5e8f6c9ac38780b8a7c2a2f8df8ee0fb72/mmh3-5.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cedac4f4054b8f7859e5aed41aaa31ad03fce6851901a7fdc2af0275ac533c10", size = 40078, upload-time = "2025-07-29T07:41:58.772Z" }, + { url = "https://files.pythonhosted.org/packages/bb/26/83a0f852e763f81b2265d446b13ed6d49ee49e1fc0c47b9655977e6f3d81/mmh3-5.2.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eb756caf8975882630ce4e9fbbeb9d3401242a72528230422c9ab3a0d278e60c", size = 97262, upload-time = "2025-07-29T07:41:59.678Z" }, + { url = "https://files.pythonhosted.org/packages/00/7d/b7133b10d12239aeaebf6878d7eaf0bf7d3738c44b4aba3c564588f6d802/mmh3-5.2.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:097e13c8b8a66c5753c6968b7640faefe85d8e38992703c1f666eda6ef4c3762", size = 103118, upload-time = "2025-07-29T07:42:01.197Z" }, + { url = "https://files.pythonhosted.org/packages/7b/3e/62f0b5dce2e22fd5b7d092aba285abd7959ea2b17148641e029f2eab1ffa/mmh3-5.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7c0c7845566b9686480e6a7e9044db4afb60038d5fabd19227443f0104eeee4", size = 106072, upload-time = "2025-07-29T07:42:02.601Z" }, + { url = "https://files.pythonhosted.org/packages/66/84/ea88bb816edfe65052c757a1c3408d65c4201ddbd769d4a287b0f1a628b2/mmh3-5.2.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:61ac226af521a572700f863d6ecddc6ece97220ce7174e311948ff8c8919a363", size = 112925, upload-time = "2025-07-29T07:42:03.632Z" }, + { url = "https://files.pythonhosted.org/packages/2e/13/c9b1c022807db575fe4db806f442d5b5784547e2e82cff36133e58ea31c7/mmh3-5.2.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:582f9dbeefe15c32a5fa528b79b088b599a1dfe290a4436351c6090f90ddebb8", size = 120583, upload-time = "2025-07-29T07:42:04.991Z" }, + { url = "https://files.pythonhosted.org/packages/8a/5f/0e2dfe1a38f6a78788b7eb2b23432cee24623aeabbc907fed07fc17d6935/mmh3-5.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2ebfc46b39168ab1cd44670a32ea5489bcbc74a25795c61b6d888c5c2cf654ed", size = 99127, upload-time = "2025-07-29T07:42:05.929Z" }, + { url = "https://files.pythonhosted.org/packages/77/27/aefb7d663b67e6a0c4d61a513c83e39ba2237e8e4557fa7122a742a23de5/mmh3-5.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1556e31e4bd0ac0c17eaf220be17a09c171d7396919c3794274cb3415a9d3646", size = 98544, upload-time = "2025-07-29T07:42:06.87Z" }, + { url = "https://files.pythonhosted.org/packages/ab/97/a21cc9b1a7c6e92205a1b5fa030cdf62277d177570c06a239eca7bd6dd32/mmh3-5.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:81df0dae22cd0da87f1c978602750f33d17fb3d21fb0f326c89dc89834fea79b", size = 106262, upload-time = "2025-07-29T07:42:07.804Z" }, + { url = "https://files.pythonhosted.org/packages/43/18/db19ae82ea63c8922a880e1498a75342311f8aa0c581c4dd07711473b5f7/mmh3-5.2.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:eba01ec3bd4a49b9ac5ca2bc6a73ff5f3af53374b8556fcc2966dd2af9eb7779", size = 109824, upload-time = "2025-07-29T07:42:08.735Z" }, + { url = "https://files.pythonhosted.org/packages/9f/f5/41dcf0d1969125fc6f61d8618b107c79130b5af50b18a4651210ea52ab40/mmh3-5.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e9a011469b47b752e7d20de296bb34591cdfcbe76c99c2e863ceaa2aa61113d2", size = 97255, upload-time = "2025-07-29T07:42:09.706Z" }, + { url = "https://files.pythonhosted.org/packages/32/b3/cce9eaa0efac1f0e735bb178ef9d1d2887b4927fe0ec16609d5acd492dda/mmh3-5.2.0-cp311-cp311-win32.whl", hash = "sha256:bc44fc2b886243d7c0d8daeb37864e16f232e5b56aaec27cc781d848264cfd28", size = 40779, upload-time = "2025-07-29T07:42:10.546Z" }, + { url = "https://files.pythonhosted.org/packages/7c/e9/3fa0290122e6d5a7041b50ae500b8a9f4932478a51e48f209a3879fe0b9b/mmh3-5.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:8ebf241072cf2777a492d0e09252f8cc2b3edd07dfdb9404b9757bffeb4f2cee", size = 41549, upload-time = "2025-07-29T07:42:11.399Z" }, + { url = "https://files.pythonhosted.org/packages/3a/54/c277475b4102588e6f06b2e9095ee758dfe31a149312cdbf62d39a9f5c30/mmh3-5.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:b5f317a727bba0e633a12e71228bc6a4acb4f471a98b1c003163b917311ea9a9", size = 39336, upload-time = "2025-07-29T07:42:12.209Z" }, + { url = "https://files.pythonhosted.org/packages/bf/6a/d5aa7edb5c08e0bd24286c7d08341a0446f9a2fbbb97d96a8a6dd81935ee/mmh3-5.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:384eda9361a7bf83a85e09447e1feafe081034af9dd428893701b959230d84be", size = 56141, upload-time = "2025-07-29T07:42:13.456Z" }, + { url = "https://files.pythonhosted.org/packages/08/49/131d0fae6447bc4a7299ebdb1a6fb9d08c9f8dcf97d75ea93e8152ddf7ab/mmh3-5.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c9da0d568569cc87315cb063486d761e38458b8ad513fedd3dc9263e1b81bcd", size = 40681, upload-time = "2025-07-29T07:42:14.306Z" }, + { url = "https://files.pythonhosted.org/packages/8f/6f/9221445a6bcc962b7f5ff3ba18ad55bba624bacdc7aa3fc0a518db7da8ec/mmh3-5.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86d1be5d63232e6eb93c50881aea55ff06eb86d8e08f9b5417c8c9b10db9db96", size = 40062, upload-time = "2025-07-29T07:42:15.08Z" }, + { url = "https://files.pythonhosted.org/packages/1e/d4/6bb2d0fef81401e0bb4c297d1eb568b767de4ce6fc00890bc14d7b51ecc4/mmh3-5.2.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bf7bee43e17e81671c447e9c83499f53d99bf440bc6d9dc26a841e21acfbe094", size = 97333, upload-time = "2025-07-29T07:42:16.436Z" }, + { url = "https://files.pythonhosted.org/packages/44/e0/ccf0daff8134efbb4fbc10a945ab53302e358c4b016ada9bf97a6bdd50c1/mmh3-5.2.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7aa18cdb58983ee660c9c400b46272e14fa253c675ed963d3812487f8ca42037", size = 103310, upload-time = "2025-07-29T07:42:17.796Z" }, + { url = "https://files.pythonhosted.org/packages/02/63/1965cb08a46533faca0e420e06aff8bbaf9690a6f0ac6ae6e5b2e4544687/mmh3-5.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae9d032488fcec32d22be6542d1a836f00247f40f320844dbb361393b5b22773", size = 106178, upload-time = "2025-07-29T07:42:19.281Z" }, + { url = "https://files.pythonhosted.org/packages/c2/41/c883ad8e2c234013f27f92061200afc11554ea55edd1bcf5e1accd803a85/mmh3-5.2.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1861fb6b1d0453ed7293200139c0a9011eeb1376632e048e3766945b13313c5", size = 113035, upload-time = "2025-07-29T07:42:20.356Z" }, + { url = "https://files.pythonhosted.org/packages/df/b5/1ccade8b1fa625d634a18bab7bf08a87457e09d5ec8cf83ca07cbea9d400/mmh3-5.2.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:99bb6a4d809aa4e528ddfe2c85dd5239b78b9dd14be62cca0329db78505e7b50", size = 120784, upload-time = "2025-07-29T07:42:21.377Z" }, + { url = "https://files.pythonhosted.org/packages/77/1c/919d9171fcbdcdab242e06394464ccf546f7d0f3b31e0d1e3a630398782e/mmh3-5.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1f8d8b627799f4e2fcc7c034fed8f5f24dc7724ff52f69838a3d6d15f1ad4765", size = 99137, upload-time = "2025-07-29T07:42:22.344Z" }, + { url = "https://files.pythonhosted.org/packages/66/8a/1eebef5bd6633d36281d9fc83cf2e9ba1ba0e1a77dff92aacab83001cee4/mmh3-5.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b5995088dd7023d2d9f310a0c67de5a2b2e06a570ecfd00f9ff4ab94a67cde43", size = 98664, upload-time = "2025-07-29T07:42:23.269Z" }, + { url = "https://files.pythonhosted.org/packages/13/41/a5d981563e2ee682b21fb65e29cc0f517a6734a02b581359edd67f9d0360/mmh3-5.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1a5f4d2e59d6bba8ef01b013c472741835ad961e7c28f50c82b27c57748744a4", size = 106459, upload-time = "2025-07-29T07:42:24.238Z" }, + { url = "https://files.pythonhosted.org/packages/24/31/342494cd6ab792d81e083680875a2c50fa0c5df475ebf0b67784f13e4647/mmh3-5.2.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fd6e6c3d90660d085f7e73710eab6f5545d4854b81b0135a3526e797009dbda3", size = 110038, upload-time = "2025-07-29T07:42:25.629Z" }, + { url = "https://files.pythonhosted.org/packages/28/44/efda282170a46bb4f19c3e2b90536513b1d821c414c28469a227ca5a1789/mmh3-5.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c4a2f3d83879e3de2eb8cbf562e71563a8ed15ee9b9c2e77ca5d9f73072ac15c", size = 97545, upload-time = "2025-07-29T07:42:27.04Z" }, + { url = "https://files.pythonhosted.org/packages/68/8f/534ae319c6e05d714f437e7206f78c17e66daca88164dff70286b0e8ea0c/mmh3-5.2.0-cp312-cp312-win32.whl", hash = "sha256:2421b9d665a0b1ad724ec7332fb5a98d075f50bc51a6ff854f3a1882bd650d49", size = 40805, upload-time = "2025-07-29T07:42:28.032Z" }, + { url = "https://files.pythonhosted.org/packages/b8/f6/f6abdcfefcedab3c964868048cfe472764ed358c2bf6819a70dd4ed4ed3a/mmh3-5.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:72d80005b7634a3a2220f81fbeb94775ebd12794623bb2e1451701ea732b4aa3", size = 41597, upload-time = "2025-07-29T07:42:28.894Z" }, + { url = "https://files.pythonhosted.org/packages/15/fd/f7420e8cbce45c259c770cac5718badf907b302d3a99ec587ba5ce030237/mmh3-5.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:3d6bfd9662a20c054bc216f861fa330c2dac7c81e7fb8307b5e32ab5b9b4d2e0", size = 39350, upload-time = "2025-07-29T07:42:29.794Z" }, + { url = "https://files.pythonhosted.org/packages/d8/fa/27f6ab93995ef6ad9f940e96593c5dd24744d61a7389532b0fec03745607/mmh3-5.2.0-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:e79c00eba78f7258e5b354eccd4d7907d60317ced924ea4a5f2e9d83f5453065", size = 40874, upload-time = "2025-07-29T07:42:30.662Z" }, + { url = "https://files.pythonhosted.org/packages/11/9c/03d13bcb6a03438bc8cac3d2e50f80908d159b31a4367c2e1a7a077ded32/mmh3-5.2.0-cp313-cp313-android_21_x86_64.whl", hash = "sha256:956127e663d05edbeec54df38885d943dfa27406594c411139690485128525de", size = 42012, upload-time = "2025-07-29T07:42:31.539Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/0865d9765408a7d504f1789944e678f74e0888b96a766d578cb80b040999/mmh3-5.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:c3dca4cb5b946ee91b3d6bb700d137b1cd85c20827f89fdf9c16258253489044", size = 39197, upload-time = "2025-07-29T07:42:32.374Z" }, + { url = "https://files.pythonhosted.org/packages/3e/12/76c3207bd186f98b908b6706c2317abb73756d23a4e68ea2bc94825b9015/mmh3-5.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:e651e17bfde5840e9e4174b01e9e080ce49277b70d424308b36a7969d0d1af73", size = 39840, upload-time = "2025-07-29T07:42:33.227Z" }, + { url = "https://files.pythonhosted.org/packages/5d/0d/574b6cce5555c9f2b31ea189ad44986755eb14e8862db28c8b834b8b64dc/mmh3-5.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:9f64bf06f4bf623325fda3a6d02d36cd69199b9ace99b04bb2d7fd9f89688504", size = 40644, upload-time = "2025-07-29T07:42:34.099Z" }, + { url = "https://files.pythonhosted.org/packages/52/82/3731f8640b79c46707f53ed72034a58baad400be908c87b0088f1f89f986/mmh3-5.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ddc63328889bcaee77b743309e5c7d2d52cee0d7d577837c91b6e7cc9e755e0b", size = 56153, upload-time = "2025-07-29T07:42:35.031Z" }, + { url = "https://files.pythonhosted.org/packages/4f/34/e02dca1d4727fd9fdeaff9e2ad6983e1552804ce1d92cc796e5b052159bb/mmh3-5.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bb0fdc451fb6d86d81ab8f23d881b8d6e37fc373a2deae1c02d27002d2ad7a05", size = 40684, upload-time = "2025-07-29T07:42:35.914Z" }, + { url = "https://files.pythonhosted.org/packages/8f/36/3dee40767356e104967e6ed6d102ba47b0b1ce2a89432239b95a94de1b89/mmh3-5.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b29044e1ffdb84fe164d0a7ea05c7316afea93c00f8ed9449cf357c36fc4f814", size = 40057, upload-time = "2025-07-29T07:42:36.755Z" }, + { url = "https://files.pythonhosted.org/packages/31/58/228c402fccf76eb39a0a01b8fc470fecf21965584e66453b477050ee0e99/mmh3-5.2.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:58981d6ea9646dbbf9e59a30890cbf9f610df0e4a57dbfe09215116fd90b0093", size = 97344, upload-time = "2025-07-29T07:42:37.675Z" }, + { url = "https://files.pythonhosted.org/packages/34/82/fc5ce89006389a6426ef28e326fc065b0fbaaed230373b62d14c889f47ea/mmh3-5.2.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7e5634565367b6d98dc4aa2983703526ef556b3688ba3065edb4b9b90ede1c54", size = 103325, upload-time = "2025-07-29T07:42:38.591Z" }, + { url = "https://files.pythonhosted.org/packages/09/8c/261e85777c6aee1ebd53f2f17e210e7481d5b0846cd0b4a5c45f1e3761b8/mmh3-5.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0271ac12415afd3171ab9a3c7cbfc71dee2c68760a7dc9d05bf8ed6ddfa3a7a", size = 106240, upload-time = "2025-07-29T07:42:39.563Z" }, + { url = "https://files.pythonhosted.org/packages/70/73/2f76b3ad8a3d431824e9934403df36c0ddacc7831acf82114bce3c4309c8/mmh3-5.2.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:45b590e31bc552c6f8e2150ff1ad0c28dd151e9f87589e7eaf508fbdd8e8e908", size = 113060, upload-time = "2025-07-29T07:42:40.585Z" }, + { url = "https://files.pythonhosted.org/packages/9f/b9/7ea61a34e90e50a79a9d87aa1c0b8139a7eaf4125782b34b7d7383472633/mmh3-5.2.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bdde97310d59604f2a9119322f61b31546748499a21b44f6715e8ced9308a6c5", size = 120781, upload-time = "2025-07-29T07:42:41.618Z" }, + { url = "https://files.pythonhosted.org/packages/0f/5b/ae1a717db98c7894a37aeedbd94b3f99e6472a836488f36b6849d003485b/mmh3-5.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc9c5f280438cf1c1a8f9abb87dc8ce9630a964120cfb5dd50d1e7ce79690c7a", size = 99174, upload-time = "2025-07-29T07:42:42.587Z" }, + { url = "https://files.pythonhosted.org/packages/e3/de/000cce1d799fceebb6d4487ae29175dd8e81b48e314cba7b4da90bcf55d7/mmh3-5.2.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c903e71fd8debb35ad2a4184c1316b3cb22f64ce517b4e6747f25b0a34e41266", size = 98734, upload-time = "2025-07-29T07:42:43.996Z" }, + { url = "https://files.pythonhosted.org/packages/79/19/0dc364391a792b72fbb22becfdeacc5add85cc043cd16986e82152141883/mmh3-5.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:eed4bba7ff8a0d37106ba931ab03bdd3915fbb025bcf4e1f0aa02bc8114960c5", size = 106493, upload-time = "2025-07-29T07:42:45.07Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b1/bc8c28e4d6e807bbb051fefe78e1156d7f104b89948742ad310612ce240d/mmh3-5.2.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:1fdb36b940e9261aff0b5177c5b74a36936b902f473180f6c15bde26143681a9", size = 110089, upload-time = "2025-07-29T07:42:46.122Z" }, + { url = "https://files.pythonhosted.org/packages/3b/a2/d20f3f5c95e9c511806686c70d0a15479cc3941c5f322061697af1c1ff70/mmh3-5.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7303aab41e97adcf010a09efd8f1403e719e59b7705d5e3cfed3dd7571589290", size = 97571, upload-time = "2025-07-29T07:42:47.18Z" }, + { url = "https://files.pythonhosted.org/packages/7b/23/665296fce4f33488deec39a750ffd245cfc07aafb0e3ef37835f91775d14/mmh3-5.2.0-cp313-cp313-win32.whl", hash = "sha256:03e08c6ebaf666ec1e3d6ea657a2d363bb01effd1a9acfe41f9197decaef0051", size = 40806, upload-time = "2025-07-29T07:42:48.166Z" }, + { url = "https://files.pythonhosted.org/packages/59/b0/92e7103f3b20646e255b699e2d0327ce53a3f250e44367a99dc8be0b7c7a/mmh3-5.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:7fddccd4113e7b736706e17a239a696332360cbaddf25ae75b57ba1acce65081", size = 41600, upload-time = "2025-07-29T07:42:49.371Z" }, + { url = "https://files.pythonhosted.org/packages/99/22/0b2bd679a84574647de538c5b07ccaa435dbccc37815067fe15b90fe8dad/mmh3-5.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa0c966ee727aad5406d516375593c5f058c766b21236ab8985693934bb5085b", size = 39349, upload-time = "2025-07-29T07:42:50.268Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ca/a20db059a8a47048aaf550da14a145b56e9c7386fb8280d3ce2962dcebf7/mmh3-5.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e5015f0bb6eb50008bed2d4b1ce0f2a294698a926111e4bb202c0987b4f89078", size = 39209, upload-time = "2025-07-29T07:42:51.559Z" }, + { url = "https://files.pythonhosted.org/packages/98/dd/e5094799d55c7482d814b979a0fd608027d0af1b274bfb4c3ea3e950bfd5/mmh3-5.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:e0f3ed828d709f5b82d8bfe14f8856120718ec4bd44a5b26102c3030a1e12501", size = 39843, upload-time = "2025-07-29T07:42:52.536Z" }, + { url = "https://files.pythonhosted.org/packages/f4/6b/7844d7f832c85400e7cc89a1348e4e1fdd38c5a38415bb5726bbb8fcdb6c/mmh3-5.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:f35727c5118aba95f0397e18a1a5b8405425581bfe53e821f0fb444cbdc2bc9b", size = 40648, upload-time = "2025-07-29T07:42:53.392Z" }, + { url = "https://files.pythonhosted.org/packages/1f/bf/71f791f48a21ff3190ba5225807cbe4f7223360e96862c376e6e3fb7efa7/mmh3-5.2.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3bc244802ccab5220008cb712ca1508cb6a12f0eb64ad62997156410579a1770", size = 56164, upload-time = "2025-07-29T07:42:54.267Z" }, + { url = "https://files.pythonhosted.org/packages/70/1f/f87e3d34d83032b4f3f0f528c6d95a98290fcacf019da61343a49dccfd51/mmh3-5.2.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ff3d50dc3fe8a98059f99b445dfb62792b5d006c5e0b8f03c6de2813b8376110", size = 40692, upload-time = "2025-07-29T07:42:55.234Z" }, + { url = "https://files.pythonhosted.org/packages/a6/e2/db849eaed07117086f3452feca8c839d30d38b830ac59fe1ce65af8be5ad/mmh3-5.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:37a358cc881fe796e099c1db6ce07ff757f088827b4e8467ac52b7a7ffdca647", size = 40068, upload-time = "2025-07-29T07:42:56.158Z" }, + { url = "https://files.pythonhosted.org/packages/df/6b/209af927207af77425b044e32f77f49105a0b05d82ff88af6971d8da4e19/mmh3-5.2.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b9a87025121d1c448f24f27ff53a5fe7b6ef980574b4a4f11acaabe702420d63", size = 97367, upload-time = "2025-07-29T07:42:57.037Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e0/78adf4104c425606a9ce33fb351f790c76a6c2314969c4a517d1ffc92196/mmh3-5.2.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1ba55d6ca32eeef8b2625e1e4bfc3b3db52bc63014bd7e5df8cc11bf2b036b12", size = 103306, upload-time = "2025-07-29T07:42:58.522Z" }, + { url = "https://files.pythonhosted.org/packages/a3/79/c2b89f91b962658b890104745b1b6c9ce38d50a889f000b469b91eeb1b9e/mmh3-5.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9ff37ba9f15637e424c2ab57a1a590c52897c845b768e4e0a4958084ec87f22", size = 106312, upload-time = "2025-07-29T07:42:59.552Z" }, + { url = "https://files.pythonhosted.org/packages/4b/14/659d4095528b1a209be90934778c5ffe312177d51e365ddcbca2cac2ec7c/mmh3-5.2.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a094319ec0db52a04af9fdc391b4d39a1bc72bc8424b47c4411afb05413a44b5", size = 113135, upload-time = "2025-07-29T07:43:00.745Z" }, + { url = "https://files.pythonhosted.org/packages/8d/6f/cd7734a779389a8a467b5c89a48ff476d6f2576e78216a37551a97e9e42a/mmh3-5.2.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c5584061fd3da584659b13587f26c6cad25a096246a481636d64375d0c1f6c07", size = 120775, upload-time = "2025-07-29T07:43:02.124Z" }, + { url = "https://files.pythonhosted.org/packages/1d/ca/8256e3b96944408940de3f9291d7e38a283b5761fe9614d4808fcf27bd62/mmh3-5.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecbfc0437ddfdced5e7822d1ce4855c9c64f46819d0fdc4482c53f56c707b935", size = 99178, upload-time = "2025-07-29T07:43:03.182Z" }, + { url = "https://files.pythonhosted.org/packages/8a/32/39e2b3cf06b6e2eb042c984dab8680841ac2a0d3ca6e0bea30db1f27b565/mmh3-5.2.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:7b986d506a8e8ea345791897ba5d8ba0d9d8820cd4fc3e52dbe6de19388de2e7", size = 98738, upload-time = "2025-07-29T07:43:04.207Z" }, + { url = "https://files.pythonhosted.org/packages/61/d3/7bbc8e0e8cf65ebbe1b893ffa0467b7ecd1bd07c3bbf6c9db4308ada22ec/mmh3-5.2.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:38d899a156549da8ef6a9f1d6f7ef231228d29f8f69bce2ee12f5fba6d6fd7c5", size = 106510, upload-time = "2025-07-29T07:43:05.656Z" }, + { url = "https://files.pythonhosted.org/packages/10/99/b97e53724b52374e2f3859046f0eb2425192da356cb19784d64bc17bb1cf/mmh3-5.2.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d86651fa45799530885ba4dab3d21144486ed15285e8784181a0ab37a4552384", size = 110053, upload-time = "2025-07-29T07:43:07.204Z" }, + { url = "https://files.pythonhosted.org/packages/ac/62/3688c7d975ed195155671df68788c83fed6f7909b6ec4951724c6860cb97/mmh3-5.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c463d7c1c4cfc9d751efeaadd936bbba07b5b0ed81a012b3a9f5a12f0872bd6e", size = 97546, upload-time = "2025-07-29T07:43:08.226Z" }, + { url = "https://files.pythonhosted.org/packages/ca/3b/c6153250f03f71a8b7634cded82939546cdfba02e32f124ff51d52c6f991/mmh3-5.2.0-cp314-cp314-win32.whl", hash = "sha256:bb4fe46bdc6104fbc28db7a6bacb115ee6368ff993366bbd8a2a7f0076e6f0c0", size = 41422, upload-time = "2025-07-29T07:43:09.216Z" }, + { url = "https://files.pythonhosted.org/packages/74/01/a27d98bab083a435c4c07e9d1d720d4c8a578bf4c270bae373760b1022be/mmh3-5.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:7c7f0b342fd06044bedd0b6e72177ddc0076f54fd89ee239447f8b271d919d9b", size = 42135, upload-time = "2025-07-29T07:43:10.183Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c9/dbba5507e95429b8b380e2ba091eff5c20a70a59560934dff0ad8392b8c8/mmh3-5.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:3193752fc05ea72366c2b63ff24b9a190f422e32d75fdeae71087c08fff26115", size = 39879, upload-time = "2025-07-29T07:43:11.106Z" }, + { url = "https://files.pythonhosted.org/packages/b5/d1/c8c0ef839c17258b9de41b84f663574fabcf8ac2007b7416575e0f65ff6e/mmh3-5.2.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:69fc339d7202bea69ef9bd7c39bfdf9fdabc8e6822a01eba62fb43233c1b3932", size = 57696, upload-time = "2025-07-29T07:43:11.989Z" }, + { url = "https://files.pythonhosted.org/packages/2f/55/95e2b9ff201e89f9fe37036037ab61a6c941942b25cdb7b6a9df9b931993/mmh3-5.2.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:12da42c0a55c9d86ab566395324213c319c73ecb0c239fad4726324212b9441c", size = 41421, upload-time = "2025-07-29T07:43:13.269Z" }, + { url = "https://files.pythonhosted.org/packages/77/79/9be23ad0b7001a4b22752e7693be232428ecc0a35068a4ff5c2f14ef8b20/mmh3-5.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f7f9034c7cf05ddfaac8d7a2e63a3c97a840d4615d0a0e65ba8bdf6f8576e3be", size = 40853, upload-time = "2025-07-29T07:43:14.888Z" }, + { url = "https://files.pythonhosted.org/packages/ac/1b/96b32058eda1c1dee8264900c37c359a7325c1f11f5ff14fd2be8e24eff9/mmh3-5.2.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:11730eeb16dfcf9674fdea9bb6b8e6dd9b40813b7eb839bc35113649eef38aeb", size = 109694, upload-time = "2025-07-29T07:43:15.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/6f/a2ae44cd7dad697b6dea48390cbc977b1e5ca58fda09628cbcb2275af064/mmh3-5.2.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:932a6eec1d2e2c3c9e630d10f7128d80e70e2d47fe6b8c7ea5e1afbd98733e65", size = 117438, upload-time = "2025-07-29T07:43:16.865Z" }, + { url = "https://files.pythonhosted.org/packages/a0/08/bfb75451c83f05224a28afeaf3950c7b793c0b71440d571f8e819cfb149a/mmh3-5.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ca975c51c5028947bbcfc24966517aac06a01d6c921e30f7c5383c195f87991", size = 120409, upload-time = "2025-07-29T07:43:18.207Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ea/8b118b69b2ff8df568f742387d1a159bc654a0f78741b31437dd047ea28e/mmh3-5.2.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5b0b58215befe0f0e120b828f7645e97719bbba9f23b69e268ed0ac7adde8645", size = 125909, upload-time = "2025-07-29T07:43:19.39Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/168cc0b6a30650032e351a3b89b8a47382da541993a03af91e1ba2501234/mmh3-5.2.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29c2b9ce61886809d0492a274a5a53047742dea0f703f9c4d5d223c3ea6377d3", size = 135331, upload-time = "2025-07-29T07:43:20.435Z" }, + { url = "https://files.pythonhosted.org/packages/31/05/e3a9849b1c18a7934c64e831492c99e67daebe84a8c2f2c39a7096a830e3/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a367d4741ac0103f8198c82f429bccb9359f543ca542b06a51f4f0332e8de279", size = 110085, upload-time = "2025-07-29T07:43:21.92Z" }, + { url = "https://files.pythonhosted.org/packages/d9/d5/a96bcc306e3404601418b2a9a370baec92af84204528ba659fdfe34c242f/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:5a5dba98e514fb26241868f6eb90a7f7ca0e039aed779342965ce24ea32ba513", size = 111195, upload-time = "2025-07-29T07:43:23.066Z" }, + { url = "https://files.pythonhosted.org/packages/af/29/0fd49801fec5bff37198684e0849b58e0dab3a2a68382a357cfffb0fafc3/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:941603bfd75a46023807511c1ac2f1b0f39cccc393c15039969806063b27e6db", size = 116919, upload-time = "2025-07-29T07:43:24.178Z" }, + { url = "https://files.pythonhosted.org/packages/2d/04/4f3c32b0a2ed762edca45d8b46568fc3668e34f00fb1e0a3b5451ec1281c/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:132dd943451a7c7546978863d2f5a64977928410782e1a87d583cb60eb89e667", size = 123160, upload-time = "2025-07-29T07:43:25.26Z" }, + { url = "https://files.pythonhosted.org/packages/91/76/3d29eaa38821730633d6a240d36fa8ad2807e9dfd432c12e1a472ed211eb/mmh3-5.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f698733a8a494466432d611a8f0d1e026f5286dee051beea4b3c3146817e35d5", size = 110206, upload-time = "2025-07-29T07:43:26.699Z" }, + { url = "https://files.pythonhosted.org/packages/44/1c/ccf35892684d3a408202e296e56843743e0b4fb1629e59432ea88cdb3909/mmh3-5.2.0-cp314-cp314t-win32.whl", hash = "sha256:6d541038b3fc360ec538fc116de87462627944765a6750308118f8b509a8eec7", size = 41970, upload-time = "2025-07-29T07:43:27.666Z" }, + { url = "https://files.pythonhosted.org/packages/75/b2/b9e4f1e5adb5e21eb104588fcee2cd1eaa8308255173481427d5ecc4284e/mmh3-5.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e912b19cf2378f2967d0c08e86ff4c6c360129887f678e27e4dde970d21b3f4d", size = 43063, upload-time = "2025-07-29T07:43:28.582Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fc/0e61d9a4e29c8679356795a40e48f647b4aad58d71bfc969f0f8f56fb912/mmh3-5.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:e7884931fe5e788163e7b3c511614130c2c59feffdc21112290a194487efb2e9", size = 40455, upload-time = "2025-07-29T07:43:29.563Z" }, +] + +[[package]] +name = "more-itertools" +version = "10.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ea/5d/38b681d3fce7a266dd9ab73c66959406d565b3e85f21d5e66e1181d93721/more_itertools-10.8.0.tar.gz", hash = "sha256:f638ddf8a1a0d134181275fb5d58b086ead7c6a72429ad725c67503f13ba30bd", size = 137431, upload-time = "2025-09-02T15:23:11.018Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/8e/469e5a4a2f5855992e425f3cb33804cc07bf18d48f2db061aec61ce50270/more_itertools-10.8.0-py3-none-any.whl", hash = "sha256:52d4362373dcf7c52546bc4af9a86ee7c4579df9a8dc268be0a2f949d376cc9b", size = 69667, upload-time = "2025-09-02T15:23:09.635Z" }, +] + +[[package]] +name = "multidict" +version = "6.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/80/1e/5492c365f222f907de1039b91f922b93fa4f764c713ee858d235495d8f50/multidict-6.7.0.tar.gz", hash = "sha256:c6e99d9a65ca282e578dfea819cfa9c0a62b2499d8677392e09feaf305e9e6f5", size = 101834, upload-time = "2025-10-06T14:52:30.657Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/9e/5c727587644d67b2ed479041e4b1c58e30afc011e3d45d25bbe35781217c/multidict-6.7.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4d409aa42a94c0b3fa617708ef5276dfe81012ba6753a0370fcc9d0195d0a1fc", size = 76604, upload-time = "2025-10-06T14:48:54.277Z" }, + { url = "https://files.pythonhosted.org/packages/17/e4/67b5c27bd17c085a5ea8f1ec05b8a3e5cba0ca734bfcad5560fb129e70ca/multidict-6.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:14c9e076eede3b54c636f8ce1c9c252b5f057c62131211f0ceeec273810c9721", size = 44715, upload-time = "2025-10-06T14:48:55.445Z" }, + { url = "https://files.pythonhosted.org/packages/4d/e1/866a5d77be6ea435711bef2a4291eed11032679b6b28b56b4776ab06ba3e/multidict-6.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4c09703000a9d0fa3c3404b27041e574cc7f4df4c6563873246d0e11812a94b6", size = 44332, upload-time = "2025-10-06T14:48:56.706Z" }, + { url = "https://files.pythonhosted.org/packages/31/61/0c2d50241ada71ff61a79518db85ada85fdabfcf395d5968dae1cbda04e5/multidict-6.7.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a265acbb7bb33a3a2d626afbe756371dce0279e7b17f4f4eda406459c2b5ff1c", size = 245212, upload-time = "2025-10-06T14:48:58.042Z" }, + { url = "https://files.pythonhosted.org/packages/ac/e0/919666a4e4b57fff1b57f279be1c9316e6cdc5de8a8b525d76f6598fefc7/multidict-6.7.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51cb455de290ae462593e5b1cb1118c5c22ea7f0d3620d9940bf695cea5a4bd7", size = 246671, upload-time = "2025-10-06T14:49:00.004Z" }, + { url = "https://files.pythonhosted.org/packages/a1/cc/d027d9c5a520f3321b65adea289b965e7bcbd2c34402663f482648c716ce/multidict-6.7.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:db99677b4457c7a5c5a949353e125ba72d62b35f74e26da141530fbb012218a7", size = 225491, upload-time = "2025-10-06T14:49:01.393Z" }, + { url = "https://files.pythonhosted.org/packages/75/c4/bbd633980ce6155a28ff04e6a6492dd3335858394d7bb752d8b108708558/multidict-6.7.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f470f68adc395e0183b92a2f4689264d1ea4b40504a24d9882c27375e6662bb9", size = 257322, upload-time = "2025-10-06T14:49:02.745Z" }, + { url = "https://files.pythonhosted.org/packages/4c/6d/d622322d344f1f053eae47e033b0b3f965af01212de21b10bcf91be991fb/multidict-6.7.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0db4956f82723cc1c270de9c6e799b4c341d327762ec78ef82bb962f79cc07d8", size = 254694, upload-time = "2025-10-06T14:49:04.15Z" }, + { url = "https://files.pythonhosted.org/packages/a8/9f/78f8761c2705d4c6d7516faed63c0ebdac569f6db1bef95e0d5218fdc146/multidict-6.7.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3e56d780c238f9e1ae66a22d2adf8d16f485381878250db8d496623cd38b22bd", size = 246715, upload-time = "2025-10-06T14:49:05.967Z" }, + { url = "https://files.pythonhosted.org/packages/78/59/950818e04f91b9c2b95aab3d923d9eabd01689d0dcd889563988e9ea0fd8/multidict-6.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9d14baca2ee12c1a64740d4531356ba50b82543017f3ad6de0deb943c5979abb", size = 243189, upload-time = "2025-10-06T14:49:07.37Z" }, + { url = "https://files.pythonhosted.org/packages/7a/3d/77c79e1934cad2ee74991840f8a0110966d9599b3af95964c0cd79bb905b/multidict-6.7.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:295a92a76188917c7f99cda95858c822f9e4aae5824246bba9b6b44004ddd0a6", size = 237845, upload-time = "2025-10-06T14:49:08.759Z" }, + { url = "https://files.pythonhosted.org/packages/63/1b/834ce32a0a97a3b70f86437f685f880136677ac00d8bce0027e9fd9c2db7/multidict-6.7.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:39f1719f57adbb767ef592a50ae5ebb794220d1188f9ca93de471336401c34d2", size = 246374, upload-time = "2025-10-06T14:49:10.574Z" }, + { url = "https://files.pythonhosted.org/packages/23/ef/43d1c3ba205b5dec93dc97f3fba179dfa47910fc73aaaea4f7ceb41cec2a/multidict-6.7.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0a13fb8e748dfc94749f622de065dd5c1def7e0d2216dba72b1d8069a389c6ff", size = 253345, upload-time = "2025-10-06T14:49:12.331Z" }, + { url = "https://files.pythonhosted.org/packages/6b/03/eaf95bcc2d19ead522001f6a650ef32811aa9e3624ff0ad37c445c7a588c/multidict-6.7.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e3aa16de190d29a0ea1b48253c57d99a68492c8dd8948638073ab9e74dc9410b", size = 246940, upload-time = "2025-10-06T14:49:13.821Z" }, + { url = "https://files.pythonhosted.org/packages/e8/df/ec8a5fd66ea6cd6f525b1fcbb23511b033c3e9bc42b81384834ffa484a62/multidict-6.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a048ce45dcdaaf1defb76b2e684f997fb5abf74437b6cb7b22ddad934a964e34", size = 242229, upload-time = "2025-10-06T14:49:15.603Z" }, + { url = "https://files.pythonhosted.org/packages/8a/a2/59b405d59fd39ec86d1142630e9049243015a5f5291ba49cadf3c090c541/multidict-6.7.0-cp311-cp311-win32.whl", hash = "sha256:a90af66facec4cebe4181b9e62a68be65e45ac9b52b67de9eec118701856e7ff", size = 41308, upload-time = "2025-10-06T14:49:16.871Z" }, + { url = "https://files.pythonhosted.org/packages/32/0f/13228f26f8b882c34da36efa776c3b7348455ec383bab4a66390e42963ae/multidict-6.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:95b5ffa4349df2887518bb839409bcf22caa72d82beec453216802f475b23c81", size = 46037, upload-time = "2025-10-06T14:49:18.457Z" }, + { url = "https://files.pythonhosted.org/packages/84/1f/68588e31b000535a3207fd3c909ebeec4fb36b52c442107499c18a896a2a/multidict-6.7.0-cp311-cp311-win_arm64.whl", hash = "sha256:329aa225b085b6f004a4955271a7ba9f1087e39dcb7e65f6284a988264a63912", size = 43023, upload-time = "2025-10-06T14:49:19.648Z" }, + { url = "https://files.pythonhosted.org/packages/c2/9e/9f61ac18d9c8b475889f32ccfa91c9f59363480613fc807b6e3023d6f60b/multidict-6.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8a3862568a36d26e650a19bb5cbbba14b71789032aebc0423f8cc5f150730184", size = 76877, upload-time = "2025-10-06T14:49:20.884Z" }, + { url = "https://files.pythonhosted.org/packages/38/6f/614f09a04e6184f8824268fce4bc925e9849edfa654ddd59f0b64508c595/multidict-6.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:960c60b5849b9b4f9dcc9bea6e3626143c252c74113df2c1540aebce70209b45", size = 45467, upload-time = "2025-10-06T14:49:22.054Z" }, + { url = "https://files.pythonhosted.org/packages/b3/93/c4f67a436dd026f2e780c433277fff72be79152894d9fc36f44569cab1a6/multidict-6.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2049be98fb57a31b4ccf870bf377af2504d4ae35646a19037ec271e4c07998aa", size = 43834, upload-time = "2025-10-06T14:49:23.566Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f5/013798161ca665e4a422afbc5e2d9e4070142a9ff8905e482139cd09e4d0/multidict-6.7.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0934f3843a1860dd465d38895c17fce1f1cb37295149ab05cd1b9a03afacb2a7", size = 250545, upload-time = "2025-10-06T14:49:24.882Z" }, + { url = "https://files.pythonhosted.org/packages/71/2f/91dbac13e0ba94669ea5119ba267c9a832f0cb65419aca75549fcf09a3dc/multidict-6.7.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3e34f3a1b8131ba06f1a73adab24f30934d148afcd5f5de9a73565a4404384e", size = 258305, upload-time = "2025-10-06T14:49:26.778Z" }, + { url = "https://files.pythonhosted.org/packages/ef/b0/754038b26f6e04488b48ac621f779c341338d78503fb45403755af2df477/multidict-6.7.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:efbb54e98446892590dc2458c19c10344ee9a883a79b5cec4bc34d6656e8d546", size = 242363, upload-time = "2025-10-06T14:49:28.562Z" }, + { url = "https://files.pythonhosted.org/packages/87/15/9da40b9336a7c9fa606c4cf2ed80a649dffeb42b905d4f63a1d7eb17d746/multidict-6.7.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a35c5fc61d4f51eb045061e7967cfe3123d622cd500e8868e7c0c592a09fedc4", size = 268375, upload-time = "2025-10-06T14:49:29.96Z" }, + { url = "https://files.pythonhosted.org/packages/82/72/c53fcade0cc94dfaad583105fd92b3a783af2091eddcb41a6d5a52474000/multidict-6.7.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29fe6740ebccba4175af1b9b87bf553e9c15cd5868ee967e010efcf94e4fd0f1", size = 269346, upload-time = "2025-10-06T14:49:31.404Z" }, + { url = "https://files.pythonhosted.org/packages/0d/e2/9baffdae21a76f77ef8447f1a05a96ec4bc0a24dae08767abc0a2fe680b8/multidict-6.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:123e2a72e20537add2f33a79e605f6191fba2afda4cbb876e35c1a7074298a7d", size = 256107, upload-time = "2025-10-06T14:49:32.974Z" }, + { url = "https://files.pythonhosted.org/packages/3c/06/3f06f611087dc60d65ef775f1fb5aca7c6d61c6db4990e7cda0cef9b1651/multidict-6.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b284e319754366c1aee2267a2036248b24eeb17ecd5dc16022095e747f2f4304", size = 253592, upload-time = "2025-10-06T14:49:34.52Z" }, + { url = "https://files.pythonhosted.org/packages/20/24/54e804ec7945b6023b340c412ce9c3f81e91b3bf5fa5ce65558740141bee/multidict-6.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:803d685de7be4303b5a657b76e2f6d1240e7e0a8aa2968ad5811fa2285553a12", size = 251024, upload-time = "2025-10-06T14:49:35.956Z" }, + { url = "https://files.pythonhosted.org/packages/14/48/011cba467ea0b17ceb938315d219391d3e421dfd35928e5dbdc3f4ae76ef/multidict-6.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c04a328260dfd5db8c39538f999f02779012268f54614902d0afc775d44e0a62", size = 251484, upload-time = "2025-10-06T14:49:37.631Z" }, + { url = "https://files.pythonhosted.org/packages/0d/2f/919258b43bb35b99fa127435cfb2d91798eb3a943396631ef43e3720dcf4/multidict-6.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8a19cdb57cd3df4cd865849d93ee14920fb97224300c88501f16ecfa2604b4e0", size = 263579, upload-time = "2025-10-06T14:49:39.502Z" }, + { url = "https://files.pythonhosted.org/packages/31/22/a0e884d86b5242b5a74cf08e876bdf299e413016b66e55511f7a804a366e/multidict-6.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b2fd74c52accced7e75de26023b7dccee62511a600e62311b918ec5c168fc2a", size = 259654, upload-time = "2025-10-06T14:49:41.32Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e5/17e10e1b5c5f5a40f2fcbb45953c9b215f8a4098003915e46a93f5fcaa8f/multidict-6.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3e8bfdd0e487acf992407a140d2589fe598238eaeffa3da8448d63a63cd363f8", size = 251511, upload-time = "2025-10-06T14:49:46.021Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9a/201bb1e17e7af53139597069c375e7b0dcbd47594604f65c2d5359508566/multidict-6.7.0-cp312-cp312-win32.whl", hash = "sha256:dd32a49400a2c3d52088e120ee00c1e3576cbff7e10b98467962c74fdb762ed4", size = 41895, upload-time = "2025-10-06T14:49:48.718Z" }, + { url = "https://files.pythonhosted.org/packages/46/e2/348cd32faad84eaf1d20cce80e2bb0ef8d312c55bca1f7fa9865e7770aaf/multidict-6.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:92abb658ef2d7ef22ac9f8bb88e8b6c3e571671534e029359b6d9e845923eb1b", size = 46073, upload-time = "2025-10-06T14:49:50.28Z" }, + { url = "https://files.pythonhosted.org/packages/25/ec/aad2613c1910dce907480e0c3aa306905830f25df2e54ccc9dea450cb5aa/multidict-6.7.0-cp312-cp312-win_arm64.whl", hash = "sha256:490dab541a6a642ce1a9d61a4781656b346a55c13038f0b1244653828e3a83ec", size = 43226, upload-time = "2025-10-06T14:49:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/d2/86/33272a544eeb36d66e4d9a920602d1a2f57d4ebea4ef3cdfe5a912574c95/multidict-6.7.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bee7c0588aa0076ce77c0ea5d19a68d76ad81fcd9fe8501003b9a24f9d4000f6", size = 76135, upload-time = "2025-10-06T14:49:54.26Z" }, + { url = "https://files.pythonhosted.org/packages/91/1c/eb97db117a1ebe46d457a3d235a7b9d2e6dcab174f42d1b67663dd9e5371/multidict-6.7.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7ef6b61cad77091056ce0e7ce69814ef72afacb150b7ac6a3e9470def2198159", size = 45117, upload-time = "2025-10-06T14:49:55.82Z" }, + { url = "https://files.pythonhosted.org/packages/f1/d8/6c3442322e41fb1dd4de8bd67bfd11cd72352ac131f6368315617de752f1/multidict-6.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9c0359b1ec12b1d6849c59f9d319610b7f20ef990a6d454ab151aa0e3b9f78ca", size = 43472, upload-time = "2025-10-06T14:49:57.048Z" }, + { url = "https://files.pythonhosted.org/packages/75/3f/e2639e80325af0b6c6febdf8e57cc07043ff15f57fa1ef808f4ccb5ac4cd/multidict-6.7.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cd240939f71c64bd658f186330603aac1a9a81bf6273f523fca63673cb7378a8", size = 249342, upload-time = "2025-10-06T14:49:58.368Z" }, + { url = "https://files.pythonhosted.org/packages/5d/cc/84e0585f805cbeaa9cbdaa95f9a3d6aed745b9d25700623ac89a6ecff400/multidict-6.7.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60a4d75718a5efa473ebd5ab685786ba0c67b8381f781d1be14da49f1a2dc60", size = 257082, upload-time = "2025-10-06T14:49:59.89Z" }, + { url = "https://files.pythonhosted.org/packages/b0/9c/ac851c107c92289acbbf5cfb485694084690c1b17e555f44952c26ddc5bd/multidict-6.7.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53a42d364f323275126aff81fb67c5ca1b7a04fda0546245730a55c8c5f24bc4", size = 240704, upload-time = "2025-10-06T14:50:01.485Z" }, + { url = "https://files.pythonhosted.org/packages/50/cc/5f93e99427248c09da95b62d64b25748a5f5c98c7c2ab09825a1d6af0e15/multidict-6.7.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3b29b980d0ddbecb736735ee5bef69bb2ddca56eff603c86f3f29a1128299b4f", size = 266355, upload-time = "2025-10-06T14:50:02.955Z" }, + { url = "https://files.pythonhosted.org/packages/ec/0c/2ec1d883ceb79c6f7f6d7ad90c919c898f5d1c6ea96d322751420211e072/multidict-6.7.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f8a93b1c0ed2d04b97a5e9336fd2d33371b9a6e29ab7dd6503d63407c20ffbaf", size = 267259, upload-time = "2025-10-06T14:50:04.446Z" }, + { url = "https://files.pythonhosted.org/packages/c6/2d/f0b184fa88d6630aa267680bdb8623fb69cb0d024b8c6f0d23f9a0f406d3/multidict-6.7.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ff96e8815eecacc6645da76c413eb3b3d34cfca256c70b16b286a687d013c32", size = 254903, upload-time = "2025-10-06T14:50:05.98Z" }, + { url = "https://files.pythonhosted.org/packages/06/c9/11ea263ad0df7dfabcad404feb3c0dd40b131bc7f232d5537f2fb1356951/multidict-6.7.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7516c579652f6a6be0e266aec0acd0db80829ca305c3d771ed898538804c2036", size = 252365, upload-time = "2025-10-06T14:50:07.511Z" }, + { url = "https://files.pythonhosted.org/packages/41/88/d714b86ee2c17d6e09850c70c9d310abac3d808ab49dfa16b43aba9d53fd/multidict-6.7.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:040f393368e63fb0f3330e70c26bfd336656bed925e5cbe17c9da839a6ab13ec", size = 250062, upload-time = "2025-10-06T14:50:09.074Z" }, + { url = "https://files.pythonhosted.org/packages/15/fe/ad407bb9e818c2b31383f6131ca19ea7e35ce93cf1310fce69f12e89de75/multidict-6.7.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b3bc26a951007b1057a1c543af845f1c7e3e71cc240ed1ace7bf4484aa99196e", size = 249683, upload-time = "2025-10-06T14:50:10.714Z" }, + { url = "https://files.pythonhosted.org/packages/8c/a4/a89abdb0229e533fb925e7c6e5c40201c2873efebc9abaf14046a4536ee6/multidict-6.7.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7b022717c748dd1992a83e219587aabe45980d88969f01b316e78683e6285f64", size = 261254, upload-time = "2025-10-06T14:50:12.28Z" }, + { url = "https://files.pythonhosted.org/packages/8d/aa/0e2b27bd88b40a4fb8dc53dd74eecac70edaa4c1dd0707eb2164da3675b3/multidict-6.7.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:9600082733859f00d79dee64effc7aef1beb26adb297416a4ad2116fd61374bd", size = 257967, upload-time = "2025-10-06T14:50:14.16Z" }, + { url = "https://files.pythonhosted.org/packages/d0/8e/0c67b7120d5d5f6d874ed85a085f9dc770a7f9d8813e80f44a9fec820bb7/multidict-6.7.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:94218fcec4d72bc61df51c198d098ce2b378e0ccbac41ddbed5ef44092913288", size = 250085, upload-time = "2025-10-06T14:50:15.639Z" }, + { url = "https://files.pythonhosted.org/packages/ba/55/b73e1d624ea4b8fd4dd07a3bb70f6e4c7c6c5d9d640a41c6ffe5cdbd2a55/multidict-6.7.0-cp313-cp313-win32.whl", hash = "sha256:a37bd74c3fa9d00be2d7b8eca074dc56bd8077ddd2917a839bd989612671ed17", size = 41713, upload-time = "2025-10-06T14:50:17.066Z" }, + { url = "https://files.pythonhosted.org/packages/32/31/75c59e7d3b4205075b4c183fa4ca398a2daf2303ddf616b04ae6ef55cffe/multidict-6.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:30d193c6cc6d559db42b6bcec8a5d395d34d60c9877a0b71ecd7c204fcf15390", size = 45915, upload-time = "2025-10-06T14:50:18.264Z" }, + { url = "https://files.pythonhosted.org/packages/31/2a/8987831e811f1184c22bc2e45844934385363ee61c0a2dcfa8f71b87e608/multidict-6.7.0-cp313-cp313-win_arm64.whl", hash = "sha256:ea3334cabe4d41b7ccd01e4d349828678794edbc2d3ae97fc162a3312095092e", size = 43077, upload-time = "2025-10-06T14:50:19.853Z" }, + { url = "https://files.pythonhosted.org/packages/e8/68/7b3a5170a382a340147337b300b9eb25a9ddb573bcdfff19c0fa3f31ffba/multidict-6.7.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ad9ce259f50abd98a1ca0aa6e490b58c316a0fce0617f609723e40804add2c00", size = 83114, upload-time = "2025-10-06T14:50:21.223Z" }, + { url = "https://files.pythonhosted.org/packages/55/5c/3fa2d07c84df4e302060f555bbf539310980362236ad49f50eeb0a1c1eb9/multidict-6.7.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07f5594ac6d084cbb5de2df218d78baf55ef150b91f0ff8a21cc7a2e3a5a58eb", size = 48442, upload-time = "2025-10-06T14:50:22.871Z" }, + { url = "https://files.pythonhosted.org/packages/fc/56/67212d33239797f9bd91962bb899d72bb0f4c35a8652dcdb8ed049bef878/multidict-6.7.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0591b48acf279821a579282444814a2d8d0af624ae0bc600aa4d1b920b6e924b", size = 46885, upload-time = "2025-10-06T14:50:24.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/d1/908f896224290350721597a61a69cd19b89ad8ee0ae1f38b3f5cd12ea2ac/multidict-6.7.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:749a72584761531d2b9467cfbdfd29487ee21124c304c4b6cb760d8777b27f9c", size = 242588, upload-time = "2025-10-06T14:50:25.716Z" }, + { url = "https://files.pythonhosted.org/packages/ab/67/8604288bbd68680eee0ab568fdcb56171d8b23a01bcd5cb0c8fedf6e5d99/multidict-6.7.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b4c3d199f953acd5b446bf7c0de1fe25d94e09e79086f8dc2f48a11a129cdf1", size = 249966, upload-time = "2025-10-06T14:50:28.192Z" }, + { url = "https://files.pythonhosted.org/packages/20/33/9228d76339f1ba51e3efef7da3ebd91964d3006217aae13211653193c3ff/multidict-6.7.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9fb0211dfc3b51efea2f349ec92c114d7754dd62c01f81c3e32b765b70c45c9b", size = 228618, upload-time = "2025-10-06T14:50:29.82Z" }, + { url = "https://files.pythonhosted.org/packages/f8/2d/25d9b566d10cab1c42b3b9e5b11ef79c9111eaf4463b8c257a3bd89e0ead/multidict-6.7.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a027ec240fe73a8d6281872690b988eed307cd7d91b23998ff35ff577ca688b5", size = 257539, upload-time = "2025-10-06T14:50:31.731Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b1/8d1a965e6637fc33de3c0d8f414485c2b7e4af00f42cab3d84e7b955c222/multidict-6.7.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1d964afecdf3a8288789df2f5751dc0a8261138c3768d9af117ed384e538fad", size = 256345, upload-time = "2025-10-06T14:50:33.26Z" }, + { url = "https://files.pythonhosted.org/packages/ba/0c/06b5a8adbdeedada6f4fb8d8f193d44a347223b11939b42953eeb6530b6b/multidict-6.7.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:caf53b15b1b7df9fbd0709aa01409000a2b4dd03a5f6f5cc548183c7c8f8b63c", size = 247934, upload-time = "2025-10-06T14:50:34.808Z" }, + { url = "https://files.pythonhosted.org/packages/8f/31/b2491b5fe167ca044c6eb4b8f2c9f3b8a00b24c432c365358eadac5d7625/multidict-6.7.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:654030da3197d927f05a536a66186070e98765aa5142794c9904555d3a9d8fb5", size = 245243, upload-time = "2025-10-06T14:50:36.436Z" }, + { url = "https://files.pythonhosted.org/packages/61/1a/982913957cb90406c8c94f53001abd9eafc271cb3e70ff6371590bec478e/multidict-6.7.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:2090d3718829d1e484706a2f525e50c892237b2bf9b17a79b059cb98cddc2f10", size = 235878, upload-time = "2025-10-06T14:50:37.953Z" }, + { url = "https://files.pythonhosted.org/packages/be/c0/21435d804c1a1cf7a2608593f4d19bca5bcbd7a81a70b253fdd1c12af9c0/multidict-6.7.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:2d2cfeec3f6f45651b3d408c4acec0ebf3daa9bc8a112a084206f5db5d05b754", size = 243452, upload-time = "2025-10-06T14:50:39.574Z" }, + { url = "https://files.pythonhosted.org/packages/54/0a/4349d540d4a883863191be6eb9a928846d4ec0ea007d3dcd36323bb058ac/multidict-6.7.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:4ef089f985b8c194d341eb2c24ae6e7408c9a0e2e5658699c92f497437d88c3c", size = 252312, upload-time = "2025-10-06T14:50:41.612Z" }, + { url = "https://files.pythonhosted.org/packages/26/64/d5416038dbda1488daf16b676e4dbfd9674dde10a0cc8f4fc2b502d8125d/multidict-6.7.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e93a0617cd16998784bf4414c7e40f17a35d2350e5c6f0bd900d3a8e02bd3762", size = 246935, upload-time = "2025-10-06T14:50:43.972Z" }, + { url = "https://files.pythonhosted.org/packages/9f/8c/8290c50d14e49f35e0bd4abc25e1bc7711149ca9588ab7d04f886cdf03d9/multidict-6.7.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f0feece2ef8ebc42ed9e2e8c78fc4aa3cf455733b507c09ef7406364c94376c6", size = 243385, upload-time = "2025-10-06T14:50:45.648Z" }, + { url = "https://files.pythonhosted.org/packages/ef/a0/f83ae75e42d694b3fbad3e047670e511c138be747bc713cf1b10d5096416/multidict-6.7.0-cp313-cp313t-win32.whl", hash = "sha256:19a1d55338ec1be74ef62440ca9e04a2f001a04d0cc49a4983dc320ff0f3212d", size = 47777, upload-time = "2025-10-06T14:50:47.154Z" }, + { url = "https://files.pythonhosted.org/packages/dc/80/9b174a92814a3830b7357307a792300f42c9e94664b01dee8e457551fa66/multidict-6.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:3da4fb467498df97e986af166b12d01f05d2e04f978a9c1c680ea1988e0bc4b6", size = 53104, upload-time = "2025-10-06T14:50:48.851Z" }, + { url = "https://files.pythonhosted.org/packages/cc/28/04baeaf0428d95bb7a7bea0e691ba2f31394338ba424fb0679a9ed0f4c09/multidict-6.7.0-cp313-cp313t-win_arm64.whl", hash = "sha256:b4121773c49a0776461f4a904cdf6264c88e42218aaa8407e803ca8025872792", size = 45503, upload-time = "2025-10-06T14:50:50.16Z" }, + { url = "https://files.pythonhosted.org/packages/e2/b1/3da6934455dd4b261d4c72f897e3a5728eba81db59959f3a639245891baa/multidict-6.7.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3bab1e4aff7adaa34410f93b1f8e57c4b36b9af0426a76003f441ee1d3c7e842", size = 75128, upload-time = "2025-10-06T14:50:51.92Z" }, + { url = "https://files.pythonhosted.org/packages/14/2c/f069cab5b51d175a1a2cb4ccdf7a2c2dabd58aa5bd933fa036a8d15e2404/multidict-6.7.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b8512bac933afc3e45fb2b18da8e59b78d4f408399a960339598374d4ae3b56b", size = 44410, upload-time = "2025-10-06T14:50:53.275Z" }, + { url = "https://files.pythonhosted.org/packages/42/e2/64bb41266427af6642b6b128e8774ed84c11b80a90702c13ac0a86bb10cc/multidict-6.7.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:79dcf9e477bc65414ebfea98ffd013cb39552b5ecd62908752e0e413d6d06e38", size = 43205, upload-time = "2025-10-06T14:50:54.911Z" }, + { url = "https://files.pythonhosted.org/packages/02/68/6b086fef8a3f1a8541b9236c594f0c9245617c29841f2e0395d979485cde/multidict-6.7.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:31bae522710064b5cbeddaf2e9f32b1abab70ac6ac91d42572502299e9953128", size = 245084, upload-time = "2025-10-06T14:50:56.369Z" }, + { url = "https://files.pythonhosted.org/packages/15/ee/f524093232007cd7a75c1d132df70f235cfd590a7c9eaccd7ff422ef4ae8/multidict-6.7.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a0df7ff02397bb63e2fd22af2c87dfa39e8c7f12947bc524dbdc528282c7e34", size = 252667, upload-time = "2025-10-06T14:50:57.991Z" }, + { url = "https://files.pythonhosted.org/packages/02/a5/eeb3f43ab45878f1895118c3ef157a480db58ede3f248e29b5354139c2c9/multidict-6.7.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a0222514e8e4c514660e182d5156a415c13ef0aabbd71682fc714e327b95e99", size = 233590, upload-time = "2025-10-06T14:50:59.589Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/76d02f8270b97269d7e3dbd45644b1785bda457b474315f8cf999525a193/multidict-6.7.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2397ab4daaf2698eb51a76721e98db21ce4f52339e535725de03ea962b5a3202", size = 264112, upload-time = "2025-10-06T14:51:01.183Z" }, + { url = "https://files.pythonhosted.org/packages/76/0b/c28a70ecb58963847c2a8efe334904cd254812b10e535aefb3bcce513918/multidict-6.7.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8891681594162635948a636c9fe0ff21746aeb3dd5463f6e25d9bea3a8a39ca1", size = 261194, upload-time = "2025-10-06T14:51:02.794Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/2ab26e4209773223159b83aa32721b4021ffb08102f8ac7d689c943fded1/multidict-6.7.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18706cc31dbf402a7945916dd5cddf160251b6dab8a2c5f3d6d5a55949f676b3", size = 248510, upload-time = "2025-10-06T14:51:04.724Z" }, + { url = "https://files.pythonhosted.org/packages/93/cd/06c1fa8282af1d1c46fd55c10a7930af652afdce43999501d4d68664170c/multidict-6.7.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f844a1bbf1d207dd311a56f383f7eda2d0e134921d45751842d8235e7778965d", size = 248395, upload-time = "2025-10-06T14:51:06.306Z" }, + { url = "https://files.pythonhosted.org/packages/99/ac/82cb419dd6b04ccf9e7e61befc00c77614fc8134362488b553402ecd55ce/multidict-6.7.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d4393e3581e84e5645506923816b9cc81f5609a778c7e7534054091acc64d1c6", size = 239520, upload-time = "2025-10-06T14:51:08.091Z" }, + { url = "https://files.pythonhosted.org/packages/fa/f3/a0f9bf09493421bd8716a362e0cd1d244f5a6550f5beffdd6b47e885b331/multidict-6.7.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:fbd18dc82d7bf274b37aa48d664534330af744e03bccf696d6f4c6042e7d19e7", size = 245479, upload-time = "2025-10-06T14:51:10.365Z" }, + { url = "https://files.pythonhosted.org/packages/8d/01/476d38fc73a212843f43c852b0eee266b6971f0e28329c2184a8df90c376/multidict-6.7.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b6234e14f9314731ec45c42fc4554b88133ad53a09092cc48a88e771c125dadb", size = 258903, upload-time = "2025-10-06T14:51:12.466Z" }, + { url = "https://files.pythonhosted.org/packages/49/6d/23faeb0868adba613b817d0e69c5f15531b24d462af8012c4f6de4fa8dc3/multidict-6.7.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:08d4379f9744d8f78d98c8673c06e202ffa88296f009c71bbafe8a6bf847d01f", size = 252333, upload-time = "2025-10-06T14:51:14.48Z" }, + { url = "https://files.pythonhosted.org/packages/1e/cc/48d02ac22b30fa247f7dad82866e4b1015431092f4ba6ebc7e77596e0b18/multidict-6.7.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9fe04da3f79387f450fd0061d4dd2e45a72749d31bf634aecc9e27f24fdc4b3f", size = 243411, upload-time = "2025-10-06T14:51:16.072Z" }, + { url = "https://files.pythonhosted.org/packages/4a/03/29a8bf5a18abf1fe34535c88adbdfa88c9fb869b5a3b120692c64abe8284/multidict-6.7.0-cp314-cp314-win32.whl", hash = "sha256:fbafe31d191dfa7c4c51f7a6149c9fb7e914dcf9ffead27dcfd9f1ae382b3885", size = 40940, upload-time = "2025-10-06T14:51:17.544Z" }, + { url = "https://files.pythonhosted.org/packages/82/16/7ed27b680791b939de138f906d5cf2b4657b0d45ca6f5dd6236fdddafb1a/multidict-6.7.0-cp314-cp314-win_amd64.whl", hash = "sha256:2f67396ec0310764b9222a1728ced1ab638f61aadc6226f17a71dd9324f9a99c", size = 45087, upload-time = "2025-10-06T14:51:18.875Z" }, + { url = "https://files.pythonhosted.org/packages/cd/3c/e3e62eb35a1950292fe39315d3c89941e30a9d07d5d2df42965ab041da43/multidict-6.7.0-cp314-cp314-win_arm64.whl", hash = "sha256:ba672b26069957ee369cfa7fc180dde1fc6f176eaf1e6beaf61fbebbd3d9c000", size = 42368, upload-time = "2025-10-06T14:51:20.225Z" }, + { url = "https://files.pythonhosted.org/packages/8b/40/cd499bd0dbc5f1136726db3153042a735fffd0d77268e2ee20d5f33c010f/multidict-6.7.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:c1dcc7524066fa918c6a27d61444d4ee7900ec635779058571f70d042d86ed63", size = 82326, upload-time = "2025-10-06T14:51:21.588Z" }, + { url = "https://files.pythonhosted.org/packages/13/8a/18e031eca251c8df76daf0288e6790561806e439f5ce99a170b4af30676b/multidict-6.7.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:27e0b36c2d388dc7b6ced3406671b401e84ad7eb0656b8f3a2f46ed0ce483718", size = 48065, upload-time = "2025-10-06T14:51:22.93Z" }, + { url = "https://files.pythonhosted.org/packages/40/71/5e6701277470a87d234e433fb0a3a7deaf3bcd92566e421e7ae9776319de/multidict-6.7.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a7baa46a22e77f0988e3b23d4ede5513ebec1929e34ee9495be535662c0dfe2", size = 46475, upload-time = "2025-10-06T14:51:24.352Z" }, + { url = "https://files.pythonhosted.org/packages/fe/6a/bab00cbab6d9cfb57afe1663318f72ec28289ea03fd4e8236bb78429893a/multidict-6.7.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7bf77f54997a9166a2f5675d1201520586439424c2511723a7312bdb4bcc034e", size = 239324, upload-time = "2025-10-06T14:51:25.822Z" }, + { url = "https://files.pythonhosted.org/packages/2a/5f/8de95f629fc22a7769ade8b41028e3e5a822c1f8904f618d175945a81ad3/multidict-6.7.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e011555abada53f1578d63389610ac8a5400fc70ce71156b0aa30d326f1a5064", size = 246877, upload-time = "2025-10-06T14:51:27.604Z" }, + { url = "https://files.pythonhosted.org/packages/23/b4/38881a960458f25b89e9f4a4fdcb02ac101cfa710190db6e5528841e67de/multidict-6.7.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:28b37063541b897fd6a318007373930a75ca6d6ac7c940dbe14731ffdd8d498e", size = 225824, upload-time = "2025-10-06T14:51:29.664Z" }, + { url = "https://files.pythonhosted.org/packages/1e/39/6566210c83f8a261575f18e7144736059f0c460b362e96e9cf797a24b8e7/multidict-6.7.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05047ada7a2fde2631a0ed706f1fd68b169a681dfe5e4cf0f8e4cb6618bbc2cd", size = 253558, upload-time = "2025-10-06T14:51:31.684Z" }, + { url = "https://files.pythonhosted.org/packages/00/a3/67f18315100f64c269f46e6c0319fa87ba68f0f64f2b8e7fd7c72b913a0b/multidict-6.7.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:716133f7d1d946a4e1b91b1756b23c088881e70ff180c24e864c26192ad7534a", size = 252339, upload-time = "2025-10-06T14:51:33.699Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2a/1cb77266afee2458d82f50da41beba02159b1d6b1f7973afc9a1cad1499b/multidict-6.7.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d1bed1b467ef657f2a0ae62844a607909ef1c6889562de5e1d505f74457d0b96", size = 244895, upload-time = "2025-10-06T14:51:36.189Z" }, + { url = "https://files.pythonhosted.org/packages/dd/72/09fa7dd487f119b2eb9524946ddd36e2067c08510576d43ff68469563b3b/multidict-6.7.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ca43bdfa5d37bd6aee89d85e1d0831fb86e25541be7e9d376ead1b28974f8e5e", size = 241862, upload-time = "2025-10-06T14:51:41.291Z" }, + { url = "https://files.pythonhosted.org/packages/65/92/bc1f8bd0853d8669300f732c801974dfc3702c3eeadae2f60cef54dc69d7/multidict-6.7.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:44b546bd3eb645fd26fb949e43c02a25a2e632e2ca21a35e2e132c8105dc8599", size = 232376, upload-time = "2025-10-06T14:51:43.55Z" }, + { url = "https://files.pythonhosted.org/packages/09/86/ac39399e5cb9d0c2ac8ef6e10a768e4d3bc933ac808d49c41f9dc23337eb/multidict-6.7.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a6ef16328011d3f468e7ebc326f24c1445f001ca1dec335b2f8e66bed3006394", size = 240272, upload-time = "2025-10-06T14:51:45.265Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b6/fed5ac6b8563ec72df6cb1ea8dac6d17f0a4a1f65045f66b6d3bf1497c02/multidict-6.7.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:5aa873cbc8e593d361ae65c68f85faadd755c3295ea2c12040ee146802f23b38", size = 248774, upload-time = "2025-10-06T14:51:46.836Z" }, + { url = "https://files.pythonhosted.org/packages/6b/8d/b954d8c0dc132b68f760aefd45870978deec6818897389dace00fcde32ff/multidict-6.7.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:3d7b6ccce016e29df4b7ca819659f516f0bc7a4b3efa3bb2012ba06431b044f9", size = 242731, upload-time = "2025-10-06T14:51:48.541Z" }, + { url = "https://files.pythonhosted.org/packages/16/9d/a2dac7009125d3540c2f54e194829ea18ac53716c61b655d8ed300120b0f/multidict-6.7.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:171b73bd4ee683d307599b66793ac80981b06f069b62eea1c9e29c9241aa66b0", size = 240193, upload-time = "2025-10-06T14:51:50.355Z" }, + { url = "https://files.pythonhosted.org/packages/39/ca/c05f144128ea232ae2178b008d5011d4e2cea86e4ee8c85c2631b1b94802/multidict-6.7.0-cp314-cp314t-win32.whl", hash = "sha256:b2d7f80c4e1fd010b07cb26820aae86b7e73b681ee4889684fb8d2d4537aab13", size = 48023, upload-time = "2025-10-06T14:51:51.883Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8f/0a60e501584145588be1af5cc829265701ba3c35a64aec8e07cbb71d39bb/multidict-6.7.0-cp314-cp314t-win_amd64.whl", hash = "sha256:09929cab6fcb68122776d575e03c6cc64ee0b8fca48d17e135474b042ce515cd", size = 53507, upload-time = "2025-10-06T14:51:53.672Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ae/3148b988a9c6239903e786eac19c889fab607c31d6efa7fb2147e5680f23/multidict-6.7.0-cp314-cp314t-win_arm64.whl", hash = "sha256:cc41db090ed742f32bd2d2c721861725e6109681eddf835d0a82bd3a5c382827", size = 44804, upload-time = "2025-10-06T14:51:55.415Z" }, + { url = "https://files.pythonhosted.org/packages/b7/da/7d22601b625e241d4f23ef1ebff8acfc60da633c9e7e7922e24d10f592b3/multidict-6.7.0-py3-none-any.whl", hash = "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3", size = 12317, upload-time = "2025-10-06T14:52:29.272Z" }, +] + +[[package]] +name = "multiprocess" +version = "0.70.18" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dill" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/fd/2ae3826f5be24c6ed87266bc4e59c46ea5b059a103f3d7e7eb76a52aeecb/multiprocess-0.70.18.tar.gz", hash = "sha256:f9597128e6b3e67b23956da07cf3d2e5cba79e2f4e0fba8d7903636663ec6d0d", size = 1798503, upload-time = "2025-04-17T03:11:27.742Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/4d/9af0d1279c84618bcd35bf5fd7e371657358c7b0a523e54a9cffb87461f8/multiprocess-0.70.18-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b8940ae30139e04b076da6c5b83e9398585ebdf0f2ad3250673fef5b2ff06d6", size = 144695, upload-time = "2025-04-17T03:11:09.161Z" }, + { url = "https://files.pythonhosted.org/packages/17/bf/87323e79dd0562474fad3373c21c66bc6c3c9963b68eb2a209deb4c8575e/multiprocess-0.70.18-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0929ba95831adb938edbd5fb801ac45e705ecad9d100b3e653946b7716cb6bd3", size = 144742, upload-time = "2025-04-17T03:11:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/dd/74/cb8c831e58dc6d5cf450b17c7db87f14294a1df52eb391da948b5e0a0b94/multiprocess-0.70.18-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4d77f8e4bfe6c6e2e661925bbf9aed4d5ade9a1c6502d5dfc10129b9d1141797", size = 144745, upload-time = "2025-04-17T03:11:11.453Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d8/0cba6cf51a1a31f20471fbc823a716170c73012ddc4fb85d706630ed6e8f/multiprocess-0.70.18-py310-none-any.whl", hash = "sha256:60c194974c31784019c1f459d984e8f33ee48f10fcf42c309ba97b30d9bd53ea", size = 134948, upload-time = "2025-04-17T03:11:20.223Z" }, + { url = "https://files.pythonhosted.org/packages/4b/88/9039f2fed1012ef584751d4ceff9ab4a51e5ae264898f0b7cbf44340a859/multiprocess-0.70.18-py311-none-any.whl", hash = "sha256:5aa6eef98e691281b3ad923be2832bf1c55dd2c859acd73e5ec53a66aae06a1d", size = 144462, upload-time = "2025-04-17T03:11:21.657Z" }, + { url = "https://files.pythonhosted.org/packages/bf/b6/5f922792be93b82ec6b5f270bbb1ef031fd0622847070bbcf9da816502cc/multiprocess-0.70.18-py312-none-any.whl", hash = "sha256:9b78f8e5024b573730bfb654783a13800c2c0f2dfc0c25e70b40d184d64adaa2", size = 150287, upload-time = "2025-04-17T03:11:22.69Z" }, + { url = "https://files.pythonhosted.org/packages/ee/25/7d7e78e750bc1aecfaf0efbf826c69a791d2eeaf29cf20cba93ff4cced78/multiprocess-0.70.18-py313-none-any.whl", hash = "sha256:871743755f43ef57d7910a38433cfe41319e72be1bbd90b79c7a5ac523eb9334", size = 151917, upload-time = "2025-04-17T03:11:24.044Z" }, + { url = "https://files.pythonhosted.org/packages/3b/c3/ca84c19bd14cdfc21c388fdcebf08b86a7a470ebc9f5c3c084fc2dbc50f7/multiprocess-0.70.18-py38-none-any.whl", hash = "sha256:dbf705e52a154fe5e90fb17b38f02556169557c2dd8bb084f2e06c2784d8279b", size = 132636, upload-time = "2025-04-17T03:11:24.936Z" }, + { url = "https://files.pythonhosted.org/packages/6c/28/dd72947e59a6a8c856448a5e74da6201cb5502ddff644fbc790e4bd40b9a/multiprocess-0.70.18-py39-none-any.whl", hash = "sha256:e78ca805a72b1b810c690b6b4cc32579eba34f403094bbbae962b7b5bf9dfcb8", size = 133478, upload-time = "2025-04-17T03:11:26.253Z" }, +] + +[[package]] +name = "nbclient" +version = "0.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/56/91/1c1d5a4b9a9ebba2b4e32b8c852c2975c872aec1fe42ab5e516b2cecd193/nbclient-0.10.4.tar.gz", hash = "sha256:1e54091b16e6da39e297b0ece3e10f6f29f4ac4e8ee515d29f8a7099bd6553c9", size = 62554, upload-time = "2025-12-23T07:45:46.369Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/a0/5b0c2f11142ed1dddec842457d3f65eaf71a0080894eb6f018755b319c3a/nbclient-0.10.4-py3-none-any.whl", hash = "sha256:9162df5a7373d70d606527300a95a975a47c137776cd942e52d9c7e29ff83440", size = 25465, upload-time = "2025-12-23T07:45:44.51Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715, upload-time = "2025-01-28T09:29:14.724Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525, upload-time = "2025-01-28T09:29:12.551Z" }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "numpy" +version = "2.3.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", hash = "sha256:784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0", size = 20584950, upload-time = "2025-11-16T22:52:42.067Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/77/84dd1d2e34d7e2792a236ba180b5e8fcc1e3e414e761ce0253f63d7f572e/numpy-2.3.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de5672f4a7b200c15a4127042170a694d4df43c992948f5e1af57f0174beed10", size = 17034641, upload-time = "2025-11-16T22:49:19.336Z" }, + { url = "https://files.pythonhosted.org/packages/2a/ea/25e26fa5837106cde46ae7d0b667e20f69cbbc0efd64cba8221411ab26ae/numpy-2.3.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:acfd89508504a19ed06ef963ad544ec6664518c863436306153e13e94605c218", size = 12528324, upload-time = "2025-11-16T22:49:22.582Z" }, + { url = "https://files.pythonhosted.org/packages/4d/1a/e85f0eea4cf03d6a0228f5c0256b53f2df4bc794706e7df019fc622e47f1/numpy-2.3.5-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ffe22d2b05504f786c867c8395de703937f934272eb67586817b46188b4ded6d", size = 5356872, upload-time = "2025-11-16T22:49:25.408Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bb/35ef04afd567f4c989c2060cde39211e4ac5357155c1833bcd1166055c61/numpy-2.3.5-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:872a5cf366aec6bb1147336480fef14c9164b154aeb6542327de4970282cd2f5", size = 6893148, upload-time = "2025-11-16T22:49:27.549Z" }, + { url = "https://files.pythonhosted.org/packages/f2/2b/05bbeb06e2dff5eab512dfc678b1cc5ee94d8ac5956a0885c64b6b26252b/numpy-2.3.5-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3095bdb8dd297e5920b010e96134ed91d852d81d490e787beca7e35ae1d89cf7", size = 14557282, upload-time = "2025-11-16T22:49:30.964Z" }, + { url = "https://files.pythonhosted.org/packages/65/fb/2b23769462b34398d9326081fad5655198fcf18966fcb1f1e49db44fbf31/numpy-2.3.5-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8cba086a43d54ca804ce711b2a940b16e452807acebe7852ff327f1ecd49b0d4", size = 16897903, upload-time = "2025-11-16T22:49:34.191Z" }, + { url = "https://files.pythonhosted.org/packages/ac/14/085f4cf05fc3f1e8aa95e85404e984ffca9b2275a5dc2b1aae18a67538b8/numpy-2.3.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6cf9b429b21df6b99f4dee7a1218b8b7ffbbe7df8764dc0bd60ce8a0708fed1e", size = 16341672, upload-time = "2025-11-16T22:49:37.2Z" }, + { url = "https://files.pythonhosted.org/packages/6f/3b/1f73994904142b2aa290449b3bb99772477b5fd94d787093e4f24f5af763/numpy-2.3.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:396084a36abdb603546b119d96528c2f6263921c50df3c8fd7cb28873a237748", size = 18838896, upload-time = "2025-11-16T22:49:39.727Z" }, + { url = "https://files.pythonhosted.org/packages/cd/b9/cf6649b2124f288309ffc353070792caf42ad69047dcc60da85ee85fea58/numpy-2.3.5-cp311-cp311-win32.whl", hash = "sha256:b0c7088a73aef3d687c4deef8452a3ac7c1be4e29ed8bf3b366c8111128ac60c", size = 6563608, upload-time = "2025-11-16T22:49:42.079Z" }, + { url = "https://files.pythonhosted.org/packages/aa/44/9fe81ae1dcc29c531843852e2874080dc441338574ccc4306b39e2ff6e59/numpy-2.3.5-cp311-cp311-win_amd64.whl", hash = "sha256:a414504bef8945eae5f2d7cb7be2d4af77c5d1cb5e20b296c2c25b61dff2900c", size = 13078442, upload-time = "2025-11-16T22:49:43.99Z" }, + { url = "https://files.pythonhosted.org/packages/6d/a7/f99a41553d2da82a20a2f22e93c94f928e4490bb447c9ff3c4ff230581d3/numpy-2.3.5-cp311-cp311-win_arm64.whl", hash = "sha256:0cd00b7b36e35398fa2d16af7b907b65304ef8bb4817a550e06e5012929830fa", size = 10458555, upload-time = "2025-11-16T22:49:47.092Z" }, + { url = "https://files.pythonhosted.org/packages/44/37/e669fe6cbb2b96c62f6bbedc6a81c0f3b7362f6a59230b23caa673a85721/numpy-2.3.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:74ae7b798248fe62021dbf3c914245ad45d1a6b0cb4a29ecb4b31d0bfbc4cc3e", size = 16733873, upload-time = "2025-11-16T22:49:49.84Z" }, + { url = "https://files.pythonhosted.org/packages/c5/65/df0db6c097892c9380851ab9e44b52d4f7ba576b833996e0080181c0c439/numpy-2.3.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee3888d9ff7c14604052b2ca5535a30216aa0a58e948cdd3eeb8d3415f638769", size = 12259838, upload-time = "2025-11-16T22:49:52.863Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e1/1ee06e70eb2136797abe847d386e7c0e830b67ad1d43f364dd04fa50d338/numpy-2.3.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:612a95a17655e213502f60cfb9bf9408efdc9eb1d5f50535cc6eb365d11b42b5", size = 5088378, upload-time = "2025-11-16T22:49:55.055Z" }, + { url = "https://files.pythonhosted.org/packages/6d/9c/1ca85fb86708724275103b81ec4cf1ac1d08f465368acfc8da7ab545bdae/numpy-2.3.5-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3101e5177d114a593d79dd79658650fe28b5a0d8abeb8ce6f437c0e6df5be1a4", size = 6628559, upload-time = "2025-11-16T22:49:57.371Z" }, + { url = "https://files.pythonhosted.org/packages/74/78/fcd41e5a0ce4f3f7b003da85825acddae6d7ecb60cf25194741b036ca7d6/numpy-2.3.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b973c57ff8e184109db042c842423ff4f60446239bd585a5131cc47f06f789d", size = 14250702, upload-time = "2025-11-16T22:49:59.632Z" }, + { url = "https://files.pythonhosted.org/packages/b6/23/2a1b231b8ff672b4c450dac27164a8b2ca7d9b7144f9c02d2396518352eb/numpy-2.3.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d8163f43acde9a73c2a33605353a4f1bc4798745a8b1d73183b28e5b435ae28", size = 16606086, upload-time = "2025-11-16T22:50:02.127Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c5/5ad26fbfbe2012e190cc7d5003e4d874b88bb18861d0829edc140a713021/numpy-2.3.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:51c1e14eb1e154ebd80e860722f9e6ed6ec89714ad2db2d3aa33c31d7c12179b", size = 16025985, upload-time = "2025-11-16T22:50:04.536Z" }, + { url = "https://files.pythonhosted.org/packages/d2/fa/dd48e225c46c819288148d9d060b047fd2a6fb1eb37eae25112ee4cb4453/numpy-2.3.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b46b4ec24f7293f23adcd2d146960559aaf8020213de8ad1909dba6c013bf89c", size = 18542976, upload-time = "2025-11-16T22:50:07.557Z" }, + { url = "https://files.pythonhosted.org/packages/05/79/ccbd23a75862d95af03d28b5c6901a1b7da4803181513d52f3b86ed9446e/numpy-2.3.5-cp312-cp312-win32.whl", hash = "sha256:3997b5b3c9a771e157f9aae01dd579ee35ad7109be18db0e85dbdbe1de06e952", size = 6285274, upload-time = "2025-11-16T22:50:10.746Z" }, + { url = "https://files.pythonhosted.org/packages/2d/57/8aeaf160312f7f489dea47ab61e430b5cb051f59a98ae68b7133ce8fa06a/numpy-2.3.5-cp312-cp312-win_amd64.whl", hash = "sha256:86945f2ee6d10cdfd67bcb4069c1662dd711f7e2a4343db5cecec06b87cf31aa", size = 12782922, upload-time = "2025-11-16T22:50:12.811Z" }, + { url = "https://files.pythonhosted.org/packages/78/a6/aae5cc2ca78c45e64b9ef22f089141d661516856cf7c8a54ba434576900d/numpy-2.3.5-cp312-cp312-win_arm64.whl", hash = "sha256:f28620fe26bee16243be2b7b874da327312240a7cdc38b769a697578d2100013", size = 10194667, upload-time = "2025-11-16T22:50:16.16Z" }, + { url = "https://files.pythonhosted.org/packages/db/69/9cde09f36da4b5a505341180a3f2e6fadc352fd4d2b7096ce9778db83f1a/numpy-2.3.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d0f23b44f57077c1ede8c5f26b30f706498b4862d3ff0a7298b8411dd2f043ff", size = 16728251, upload-time = "2025-11-16T22:50:19.013Z" }, + { url = "https://files.pythonhosted.org/packages/79/fb/f505c95ceddd7027347b067689db71ca80bd5ecc926f913f1a23e65cf09b/numpy-2.3.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa5bc7c5d59d831d9773d1170acac7893ce3a5e130540605770ade83280e7188", size = 12254652, upload-time = "2025-11-16T22:50:21.487Z" }, + { url = "https://files.pythonhosted.org/packages/78/da/8c7738060ca9c31b30e9301ee0cf6c5ffdbf889d9593285a1cead337f9a5/numpy-2.3.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccc933afd4d20aad3c00bcef049cb40049f7f196e0397f1109dba6fed63267b0", size = 5083172, upload-time = "2025-11-16T22:50:24.562Z" }, + { url = "https://files.pythonhosted.org/packages/a4/b4/ee5bb2537fb9430fd2ef30a616c3672b991a4129bb1c7dcc42aa0abbe5d7/numpy-2.3.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afaffc4393205524af9dfa400fa250143a6c3bc646c08c9f5e25a9f4b4d6a903", size = 6622990, upload-time = "2025-11-16T22:50:26.47Z" }, + { url = "https://files.pythonhosted.org/packages/95/03/dc0723a013c7d7c19de5ef29e932c3081df1c14ba582b8b86b5de9db7f0f/numpy-2.3.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c75442b2209b8470d6d5d8b1c25714270686f14c749028d2199c54e29f20b4d", size = 14248902, upload-time = "2025-11-16T22:50:28.861Z" }, + { url = "https://files.pythonhosted.org/packages/f5/10/ca162f45a102738958dcec8023062dad0cbc17d1ab99d68c4e4a6c45fb2b/numpy-2.3.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e06aa0af8c0f05104d56450d6093ee639e15f24ecf62d417329d06e522e017", size = 16597430, upload-time = "2025-11-16T22:50:31.56Z" }, + { url = "https://files.pythonhosted.org/packages/2a/51/c1e29be863588db58175175f057286900b4b3327a1351e706d5e0f8dd679/numpy-2.3.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ed89927b86296067b4f81f108a2271d8926467a8868e554eaf370fc27fa3ccaf", size = 16024551, upload-time = "2025-11-16T22:50:34.242Z" }, + { url = "https://files.pythonhosted.org/packages/83/68/8236589d4dbb87253d28259d04d9b814ec0ecce7cb1c7fed29729f4c3a78/numpy-2.3.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51c55fe3451421f3a6ef9a9c1439e82101c57a2c9eab9feb196a62b1a10b58ce", size = 18533275, upload-time = "2025-11-16T22:50:37.651Z" }, + { url = "https://files.pythonhosted.org/packages/40/56/2932d75b6f13465239e3b7b7e511be27f1b8161ca2510854f0b6e521c395/numpy-2.3.5-cp313-cp313-win32.whl", hash = "sha256:1978155dd49972084bd6ef388d66ab70f0c323ddee6f693d539376498720fb7e", size = 6277637, upload-time = "2025-11-16T22:50:40.11Z" }, + { url = "https://files.pythonhosted.org/packages/0c/88/e2eaa6cffb115b85ed7c7c87775cb8bcf0816816bc98ca8dbfa2ee33fe6e/numpy-2.3.5-cp313-cp313-win_amd64.whl", hash = "sha256:00dc4e846108a382c5869e77c6ed514394bdeb3403461d25a829711041217d5b", size = 12779090, upload-time = "2025-11-16T22:50:42.503Z" }, + { url = "https://files.pythonhosted.org/packages/8f/88/3f41e13a44ebd4034ee17baa384acac29ba6a4fcc2aca95f6f08ca0447d1/numpy-2.3.5-cp313-cp313-win_arm64.whl", hash = "sha256:0472f11f6ec23a74a906a00b48a4dcf3849209696dff7c189714511268d103ae", size = 10194710, upload-time = "2025-11-16T22:50:44.971Z" }, + { url = "https://files.pythonhosted.org/packages/13/cb/71744144e13389d577f867f745b7df2d8489463654a918eea2eeb166dfc9/numpy-2.3.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:414802f3b97f3c1eef41e530aaba3b3c1620649871d8cb38c6eaff034c2e16bd", size = 16827292, upload-time = "2025-11-16T22:50:47.715Z" }, + { url = "https://files.pythonhosted.org/packages/71/80/ba9dc6f2a4398e7f42b708a7fdc841bb638d353be255655498edbf9a15a8/numpy-2.3.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5ee6609ac3604fa7780e30a03e5e241a7956f8e2fcfe547d51e3afa5247ac47f", size = 12378897, upload-time = "2025-11-16T22:50:51.327Z" }, + { url = "https://files.pythonhosted.org/packages/2e/6d/db2151b9f64264bcceccd51741aa39b50150de9b602d98ecfe7e0c4bff39/numpy-2.3.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:86d835afea1eaa143012a2d7a3f45a3adce2d7adc8b4961f0b362214d800846a", size = 5207391, upload-time = "2025-11-16T22:50:54.542Z" }, + { url = "https://files.pythonhosted.org/packages/80/ae/429bacace5ccad48a14c4ae5332f6aa8ab9f69524193511d60ccdfdc65fa/numpy-2.3.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:30bc11310e8153ca664b14c5f1b73e94bd0503681fcf136a163de856f3a50139", size = 6721275, upload-time = "2025-11-16T22:50:56.794Z" }, + { url = "https://files.pythonhosted.org/packages/74/5b/1919abf32d8722646a38cd527bc3771eb229a32724ee6ba340ead9b92249/numpy-2.3.5-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1062fde1dcf469571705945b0f221b73928f34a20c904ffb45db101907c3454e", size = 14306855, upload-time = "2025-11-16T22:50:59.208Z" }, + { url = "https://files.pythonhosted.org/packages/a5/87/6831980559434973bebc30cd9c1f21e541a0f2b0c280d43d3afd909b66d0/numpy-2.3.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce581db493ea1a96c0556360ede6607496e8bf9b3a8efa66e06477267bc831e9", size = 16657359, upload-time = "2025-11-16T22:51:01.991Z" }, + { url = "https://files.pythonhosted.org/packages/dd/91/c797f544491ee99fd00495f12ebb7802c440c1915811d72ac5b4479a3356/numpy-2.3.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:cc8920d2ec5fa99875b670bb86ddeb21e295cb07aa331810d9e486e0b969d946", size = 16093374, upload-time = "2025-11-16T22:51:05.291Z" }, + { url = "https://files.pythonhosted.org/packages/74/a6/54da03253afcbe7a72785ec4da9c69fb7a17710141ff9ac5fcb2e32dbe64/numpy-2.3.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9ee2197ef8c4f0dfe405d835f3b6a14f5fee7782b5de51ba06fb65fc9b36e9f1", size = 18594587, upload-time = "2025-11-16T22:51:08.585Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/aff53abbdd41b0ecca94285f325aff42357c6b5abc482a3fcb4994290b18/numpy-2.3.5-cp313-cp313t-win32.whl", hash = "sha256:70b37199913c1bd300ff6e2693316c6f869c7ee16378faf10e4f5e3275b299c3", size = 6405940, upload-time = "2025-11-16T22:51:11.541Z" }, + { url = "https://files.pythonhosted.org/packages/d5/81/50613fec9d4de5480de18d4f8ef59ad7e344d497edbef3cfd80f24f98461/numpy-2.3.5-cp313-cp313t-win_amd64.whl", hash = "sha256:b501b5fa195cc9e24fe102f21ec0a44dffc231d2af79950b451e0d99cea02234", size = 12920341, upload-time = "2025-11-16T22:51:14.312Z" }, + { url = "https://files.pythonhosted.org/packages/bb/ab/08fd63b9a74303947f34f0bd7c5903b9c5532c2d287bead5bdf4c556c486/numpy-2.3.5-cp313-cp313t-win_arm64.whl", hash = "sha256:a80afd79f45f3c4a7d341f13acbe058d1ca8ac017c165d3fa0d3de6bc1a079d7", size = 10262507, upload-time = "2025-11-16T22:51:16.846Z" }, + { url = "https://files.pythonhosted.org/packages/ba/97/1a914559c19e32d6b2e233cf9a6a114e67c856d35b1d6babca571a3e880f/numpy-2.3.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:bf06bc2af43fa8d32d30fae16ad965663e966b1a3202ed407b84c989c3221e82", size = 16735706, upload-time = "2025-11-16T22:51:19.558Z" }, + { url = "https://files.pythonhosted.org/packages/57/d4/51233b1c1b13ecd796311216ae417796b88b0616cfd8a33ae4536330748a/numpy-2.3.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:052e8c42e0c49d2575621c158934920524f6c5da05a1d3b9bab5d8e259e045f0", size = 12264507, upload-time = "2025-11-16T22:51:22.492Z" }, + { url = "https://files.pythonhosted.org/packages/45/98/2fe46c5c2675b8306d0b4a3ec3494273e93e1226a490f766e84298576956/numpy-2.3.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:1ed1ec893cff7040a02c8aa1c8611b94d395590d553f6b53629a4461dc7f7b63", size = 5093049, upload-time = "2025-11-16T22:51:25.171Z" }, + { url = "https://files.pythonhosted.org/packages/ce/0e/0698378989bb0ac5f1660c81c78ab1fe5476c1a521ca9ee9d0710ce54099/numpy-2.3.5-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2dcd0808a421a482a080f89859a18beb0b3d1e905b81e617a188bd80422d62e9", size = 6626603, upload-time = "2025-11-16T22:51:27Z" }, + { url = "https://files.pythonhosted.org/packages/5e/a6/9ca0eecc489640615642a6cbc0ca9e10df70df38c4d43f5a928ff18d8827/numpy-2.3.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727fd05b57df37dc0bcf1a27767a3d9a78cbbc92822445f32cc3436ba797337b", size = 14262696, upload-time = "2025-11-16T22:51:29.402Z" }, + { url = "https://files.pythonhosted.org/packages/c8/f6/07ec185b90ec9d7217a00eeeed7383b73d7e709dae2a9a021b051542a708/numpy-2.3.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fffe29a1ef00883599d1dc2c51aa2e5d80afe49523c261a74933df395c15c520", size = 16597350, upload-time = "2025-11-16T22:51:32.167Z" }, + { url = "https://files.pythonhosted.org/packages/75/37/164071d1dde6a1a84c9b8e5b414fa127981bad47adf3a6b7e23917e52190/numpy-2.3.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f7f0e05112916223d3f438f293abf0727e1181b5983f413dfa2fefc4098245c", size = 16040190, upload-time = "2025-11-16T22:51:35.403Z" }, + { url = "https://files.pythonhosted.org/packages/08/3c/f18b82a406b04859eb026d204e4e1773eb41c5be58410f41ffa511d114ae/numpy-2.3.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2e2eb32ddb9ccb817d620ac1d8dae7c3f641c1e5f55f531a33e8ab97960a75b8", size = 18536749, upload-time = "2025-11-16T22:51:39.698Z" }, + { url = "https://files.pythonhosted.org/packages/40/79/f82f572bf44cf0023a2fe8588768e23e1592585020d638999f15158609e1/numpy-2.3.5-cp314-cp314-win32.whl", hash = "sha256:66f85ce62c70b843bab1fb14a05d5737741e74e28c7b8b5a064de10142fad248", size = 6335432, upload-time = "2025-11-16T22:51:42.476Z" }, + { url = "https://files.pythonhosted.org/packages/a3/2e/235b4d96619931192c91660805e5e49242389742a7a82c27665021db690c/numpy-2.3.5-cp314-cp314-win_amd64.whl", hash = "sha256:e6a0bc88393d65807d751a614207b7129a310ca4fe76a74e5c7da5fa5671417e", size = 12919388, upload-time = "2025-11-16T22:51:45.275Z" }, + { url = "https://files.pythonhosted.org/packages/07/2b/29fd75ce45d22a39c61aad74f3d718e7ab67ccf839ca8b60866054eb15f8/numpy-2.3.5-cp314-cp314-win_arm64.whl", hash = "sha256:aeffcab3d4b43712bb7a60b65f6044d444e75e563ff6180af8f98dd4b905dfd2", size = 10476651, upload-time = "2025-11-16T22:51:47.749Z" }, + { url = "https://files.pythonhosted.org/packages/17/e1/f6a721234ebd4d87084cfa68d081bcba2f5cfe1974f7de4e0e8b9b2a2ba1/numpy-2.3.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17531366a2e3a9e30762c000f2c43a9aaa05728712e25c11ce1dbe700c53ad41", size = 16834503, upload-time = "2025-11-16T22:51:50.443Z" }, + { url = "https://files.pythonhosted.org/packages/5c/1c/baf7ffdc3af9c356e1c135e57ab7cf8d247931b9554f55c467efe2c69eff/numpy-2.3.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d21644de1b609825ede2f48be98dfde4656aefc713654eeee280e37cadc4e0ad", size = 12381612, upload-time = "2025-11-16T22:51:53.609Z" }, + { url = "https://files.pythonhosted.org/packages/74/91/f7f0295151407ddc9ba34e699013c32c3c91944f9b35fcf9281163dc1468/numpy-2.3.5-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:c804e3a5aba5460c73955c955bdbd5c08c354954e9270a2c1565f62e866bdc39", size = 5210042, upload-time = "2025-11-16T22:51:56.213Z" }, + { url = "https://files.pythonhosted.org/packages/2e/3b/78aebf345104ec50dd50a4d06ddeb46a9ff5261c33bcc58b1c4f12f85ec2/numpy-2.3.5-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:cc0a57f895b96ec78969c34f682c602bf8da1a0270b09bc65673df2e7638ec20", size = 6724502, upload-time = "2025-11-16T22:51:58.584Z" }, + { url = "https://files.pythonhosted.org/packages/02/c6/7c34b528740512e57ef1b7c8337ab0b4f0bddf34c723b8996c675bc2bc91/numpy-2.3.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:900218e456384ea676e24ea6a0417f030a3b07306d29d7ad843957b40a9d8d52", size = 14308962, upload-time = "2025-11-16T22:52:01.698Z" }, + { url = "https://files.pythonhosted.org/packages/80/35/09d433c5262bc32d725bafc619e095b6a6651caf94027a03da624146f655/numpy-2.3.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09a1bea522b25109bf8e6f3027bd810f7c1085c64a0c7ce050c1676ad0ba010b", size = 16655054, upload-time = "2025-11-16T22:52:04.267Z" }, + { url = "https://files.pythonhosted.org/packages/7a/ab/6a7b259703c09a88804fa2430b43d6457b692378f6b74b356155283566ac/numpy-2.3.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04822c00b5fd0323c8166d66c701dc31b7fbd252c100acd708c48f763968d6a3", size = 16091613, upload-time = "2025-11-16T22:52:08.651Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/330da2071e8771e60d1038166ff9d73f29da37b01ec3eb43cb1427464e10/numpy-2.3.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d6889ec4ec662a1a37eb4b4fb26b6100841804dac55bd9df579e326cdc146227", size = 18591147, upload-time = "2025-11-16T22:52:11.453Z" }, + { url = "https://files.pythonhosted.org/packages/51/41/851c4b4082402d9ea860c3626db5d5df47164a712cb23b54be028b184c1c/numpy-2.3.5-cp314-cp314t-win32.whl", hash = "sha256:93eebbcf1aafdf7e2ddd44c2923e2672e1010bddc014138b229e49725b4d6be5", size = 6479806, upload-time = "2025-11-16T22:52:14.641Z" }, + { url = "https://files.pythonhosted.org/packages/90/30/d48bde1dfd93332fa557cff1972fbc039e055a52021fbef4c2c4b1eefd17/numpy-2.3.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c8a9958e88b65c3b27e22ca2a076311636850b612d6bbfb76e8d156aacde2aaf", size = 13105760, upload-time = "2025-11-16T22:52:17.975Z" }, + { url = "https://files.pythonhosted.org/packages/2d/fd/4b5eb0b3e888d86aee4d198c23acec7d214baaf17ea93c1adec94c9518b9/numpy-2.3.5-cp314-cp314t-win_arm64.whl", hash = "sha256:6203fdf9f3dc5bdaed7319ad8698e685c7a3be10819f41d32a0723e611733b42", size = 10545459, upload-time = "2025-11-16T22:52:20.55Z" }, + { url = "https://files.pythonhosted.org/packages/c6/65/f9dea8e109371ade9c782b4e4756a82edf9d3366bca495d84d79859a0b79/numpy-2.3.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f0963b55cdd70fad460fa4c1341f12f976bb26cb66021a5580329bd498988310", size = 16910689, upload-time = "2025-11-16T22:52:23.247Z" }, + { url = "https://files.pythonhosted.org/packages/00/4f/edb00032a8fb92ec0a679d3830368355da91a69cab6f3e9c21b64d0bb986/numpy-2.3.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f4255143f5160d0de972d28c8f9665d882b5f61309d8362fdd3e103cf7bf010c", size = 12457053, upload-time = "2025-11-16T22:52:26.367Z" }, + { url = "https://files.pythonhosted.org/packages/16/a4/e8a53b5abd500a63836a29ebe145fc1ab1f2eefe1cfe59276020373ae0aa/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:a4b9159734b326535f4dd01d947f919c6eefd2d9827466a696c44ced82dfbc18", size = 5285635, upload-time = "2025-11-16T22:52:29.266Z" }, + { url = "https://files.pythonhosted.org/packages/a3/2f/37eeb9014d9c8b3e9c55bc599c68263ca44fdbc12a93e45a21d1d56df737/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:2feae0d2c91d46e59fcd62784a3a83b3fb677fead592ce51b5a6fbb4f95965ff", size = 6801770, upload-time = "2025-11-16T22:52:31.421Z" }, + { url = "https://files.pythonhosted.org/packages/7d/e4/68d2f474df2cb671b2b6c2986a02e520671295647dad82484cde80ca427b/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffac52f28a7849ad7576293c0cb7b9f08304e8f7d738a8cb8a90ec4c55a998eb", size = 14391768, upload-time = "2025-11-16T22:52:33.593Z" }, + { url = "https://files.pythonhosted.org/packages/b8/50/94ccd8a2b141cb50651fddd4f6a48874acb3c91c8f0842b08a6afc4b0b21/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63c0e9e7eea69588479ebf4a8a270d5ac22763cc5854e9a7eae952a3908103f7", size = 16729263, upload-time = "2025-11-16T22:52:36.369Z" }, + { url = "https://files.pythonhosted.org/packages/2d/ee/346fa473e666fe14c52fcdd19ec2424157290a032d4c41f98127bfb31ac7/numpy-2.3.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f16417ec91f12f814b10bafe79ef77e70113a2f5f7018640e7425ff979253425", size = 12967213, upload-time = "2025-11-16T22:52:39.38Z" }, +] + +[[package]] +name = "openai" +version = "2.8.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d5/e4/42591e356f1d53c568418dc7e30dcda7be31dd5a4d570bca22acb0525862/openai-2.8.1.tar.gz", hash = "sha256:cb1b79eef6e809f6da326a7ef6038719e35aa944c42d081807bfa1be8060f15f", size = 602490, upload-time = "2025-11-17T22:39:59.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/4f/dbc0c124c40cb390508a82770fb9f6e3ed162560181a85089191a851c59a/openai-2.8.1-py3-none-any.whl", hash = "sha256:c6c3b5a04994734386e8dad3c00a393f56d3b68a27cd2e8acae91a59e4122463", size = 1022688, upload-time = "2025-11-17T22:39:57.675Z" }, +] + +[[package]] +name = "openapi-pydantic" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/2e/58d83848dd1a79cb92ed8e63f6ba901ca282c5f09d04af9423ec26c56fd7/openapi_pydantic-0.5.1.tar.gz", hash = "sha256:ff6835af6bde7a459fb93eb93bb92b8749b754fc6e51b2f1590a19dc3005ee0d", size = 60892, upload-time = "2025-01-08T19:29:27.083Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/cf/03675d8bd8ecbf4445504d8071adab19f5f993676795708e36402ab38263/openapi_pydantic-0.5.1-py3-none-any.whl", hash = "sha256:a3a09ef4586f5bd760a8df7f43028b60cafb6d9f61de2acba9574766255ab146", size = 96381, upload-time = "2025-01-08T19:29:25.275Z" }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.40.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, +] + +[[package]] +name = "pandas" +version = "2.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" }, + { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" }, + { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" }, + { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload-time = "2025-09-29T23:19:48.856Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload-time = "2025-09-29T23:39:08.659Z" }, + { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload-time = "2025-09-29T23:19:59.765Z" }, + { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload-time = "2025-09-29T23:20:14.098Z" }, + { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload-time = "2025-09-29T23:20:26.76Z" }, + { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload-time = "2025-09-29T23:20:41.344Z" }, + { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload-time = "2025-09-29T23:20:54.139Z" }, + { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" }, + { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" }, + { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" }, + { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" }, + { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" }, + { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" }, + { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" }, + { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" }, + { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" }, + { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" }, + { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" }, + { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload-time = "2025-09-29T23:25:52.486Z" }, + { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload-time = "2025-09-29T23:26:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload-time = "2025-09-29T23:27:15.384Z" }, + { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload-time = "2025-09-29T23:27:51.625Z" }, + { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload-time = "2025-09-29T23:28:21.289Z" }, + { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload-time = "2025-09-29T23:28:58.261Z" }, + { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload-time = "2025-09-29T23:32:27.484Z" }, + { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload-time = "2025-09-29T23:29:31.47Z" }, + { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload-time = "2025-09-29T23:29:54.591Z" }, + { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload-time = "2025-09-29T23:30:21.003Z" }, + { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload-time = "2025-09-29T23:30:43.391Z" }, + { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload-time = "2025-09-29T23:31:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[package]] +name = "pathable" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/67/93/8f2c2075b180c12c1e9f6a09d1a985bc2036906b13dff1d8917e395f2048/pathable-0.4.4.tar.gz", hash = "sha256:6905a3cd17804edfac7875b5f6c9142a218c7caef78693c2dbbbfbac186d88b2", size = 8124, upload-time = "2025-01-10T18:43:13.247Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/eb/b6260b31b1a96386c0a880edebe26f89669098acea8e0318bff6adb378fd/pathable-0.4.4-py3-none-any.whl", hash = "sha256:5ae9e94793b6ef5a4cbe0a7ce9dbbefc1eec38df253763fd0aeeacf2762dbbc2", size = 9592, upload-time = "2025-01-10T18:43:11.88Z" }, +] + +[[package]] +name = "pathlib-abc" +version = "0.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/cb/448649d7f25d228bf0be3a04590ab7afa77f15e056f8fa976ed05ec9a78f/pathlib_abc-0.5.2.tar.gz", hash = "sha256:fcd56f147234645e2c59c7ae22808b34c364bb231f685ddd9f96885aed78a94c", size = 33342, upload-time = "2025-10-10T18:37:20.524Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/29/c028a0731e202035f0e2e0bfbf1a3e46ad6c628cbb17f6f1cc9eea5d9ff1/pathlib_abc-0.5.2-py3-none-any.whl", hash = "sha256:4c9d94cf1b23af417ce7c0417b43333b06a106c01000b286c99de230d95eefbb", size = 19070, upload-time = "2025-10-10T18:37:19.437Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/61/33/9611380c2bdb1225fdef633e2a9610622310fed35ab11dac9620972ee088/platformdirs-4.5.0.tar.gz", hash = "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312", size = 21632, upload-time = "2025-10-08T17:44:48.791Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/cb/ac7874b3e5d58441674fb70742e6c374b28b0c7cb988d37d991cde47166c/platformdirs-4.5.0-py3-none-any.whl", hash = "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3", size = 18651, upload-time = "2025-10-08T17:44:47.223Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "ply" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/69/882ee5c9d017149285cab114ebeab373308ef0f874fcdac9beb90e0ac4da/ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3", size = 159130, upload-time = "2018-02-15T19:01:31.097Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/58/35da89ee790598a0700ea49b2a66594140f44dec458c07e8e3d4979137fc/ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce", size = 49567, upload-time = "2018-02-15T19:01:27.172Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + +[[package]] +name = "propcache" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload-time = "2025-10-08T19:46:24.597Z" }, + { url = "https://files.pythonhosted.org/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload-time = "2025-10-08T19:46:25.733Z" }, + { url = "https://files.pythonhosted.org/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload-time = "2025-10-08T19:46:27.304Z" }, + { url = "https://files.pythonhosted.org/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload-time = "2025-10-08T19:46:28.62Z" }, + { url = "https://files.pythonhosted.org/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload-time = "2025-10-08T19:46:30.358Z" }, + { url = "https://files.pythonhosted.org/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload-time = "2025-10-08T19:46:32.607Z" }, + { url = "https://files.pythonhosted.org/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload-time = "2025-10-08T19:46:33.969Z" }, + { url = "https://files.pythonhosted.org/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload-time = "2025-10-08T19:46:35.309Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload-time = "2025-10-08T19:46:36.993Z" }, + { url = "https://files.pythonhosted.org/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload-time = "2025-10-08T19:46:38.398Z" }, + { url = "https://files.pythonhosted.org/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload-time = "2025-10-08T19:46:39.732Z" }, + { url = "https://files.pythonhosted.org/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload-time = "2025-10-08T19:46:41.025Z" }, + { url = "https://files.pythonhosted.org/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload-time = "2025-10-08T19:46:42.693Z" }, + { url = "https://files.pythonhosted.org/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload-time = "2025-10-08T19:46:43.778Z" }, + { url = "https://files.pythonhosted.org/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload-time = "2025-10-08T19:46:44.872Z" }, + { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" }, + { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" }, + { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" }, + { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" }, + { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" }, + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" }, + { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" }, + { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" }, + { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" }, + { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" }, + { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" }, + { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" }, + { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" }, + { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" }, + { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" }, + { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" }, + { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" }, + { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" }, + { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" }, + { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" }, + { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" }, + { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" }, + { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" }, + { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" }, + { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" }, + { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" }, + { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" }, + { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" }, + { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" }, + { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" }, + { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" }, + { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" }, + { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" }, + { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" }, + { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" }, + { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" }, + { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" }, + { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" }, + { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" }, + { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" }, + { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" }, + { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" }, + { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" }, + { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" }, + { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" }, + { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" }, + { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" }, + { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" }, + { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" }, + { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" }, + { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" }, + { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" }, + { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" }, + { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" }, + { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" }, + { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" }, + { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" }, + { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" }, + { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" }, + { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" }, + { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" }, + { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" }, +] + +[[package]] +name = "psutil" +version = "7.1.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/88/bdd0a41e5857d5d703287598cbf08dad90aed56774ea52ae071bae9071b6/psutil-7.1.3.tar.gz", hash = "sha256:6c86281738d77335af7aec228328e944b30930899ea760ecf33a4dba66be5e74", size = 489059, upload-time = "2025-11-02T12:25:54.619Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/93/0c49e776b8734fef56ec9c5c57f923922f2cf0497d62e0f419465f28f3d0/psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0005da714eee687b4b8decd3d6cc7c6db36215c9e74e5ad2264b90c3df7d92dc", size = 239751, upload-time = "2025-11-02T12:25:58.161Z" }, + { url = "https://files.pythonhosted.org/packages/6f/8d/b31e39c769e70780f007969815195a55c81a63efebdd4dbe9e7a113adb2f/psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19644c85dcb987e35eeeaefdc3915d059dac7bd1167cdcdbf27e0ce2df0c08c0", size = 240368, upload-time = "2025-11-02T12:26:00.491Z" }, + { url = "https://files.pythonhosted.org/packages/62/61/23fd4acc3c9eebbf6b6c78bcd89e5d020cfde4acf0a9233e9d4e3fa698b4/psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95ef04cf2e5ba0ab9eaafc4a11eaae91b44f4ef5541acd2ee91d9108d00d59a7", size = 287134, upload-time = "2025-11-02T12:26:02.613Z" }, + { url = "https://files.pythonhosted.org/packages/30/1c/f921a009ea9ceb51aa355cb0cc118f68d354db36eae18174bab63affb3e6/psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1068c303be3a72f8e18e412c5b2a8f6d31750fb152f9cb106b54090296c9d251", size = 289904, upload-time = "2025-11-02T12:26:05.207Z" }, + { url = "https://files.pythonhosted.org/packages/a6/82/62d68066e13e46a5116df187d319d1724b3f437ddd0f958756fc052677f4/psutil-7.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:18349c5c24b06ac5612c0428ec2a0331c26443d259e2a0144a9b24b4395b58fa", size = 249642, upload-time = "2025-11-02T12:26:07.447Z" }, + { url = "https://files.pythonhosted.org/packages/df/ad/c1cd5fe965c14a0392112f68362cfceb5230819dbb5b1888950d18a11d9f/psutil-7.1.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c525ffa774fe4496282fb0b1187725793de3e7c6b29e41562733cae9ada151ee", size = 245518, upload-time = "2025-11-02T12:26:09.719Z" }, + { url = "https://files.pythonhosted.org/packages/2e/bb/6670bded3e3236eb4287c7bcdc167e9fae6e1e9286e437f7111caed2f909/psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b403da1df4d6d43973dc004d19cee3b848e998ae3154cc8097d139b77156c353", size = 239843, upload-time = "2025-11-02T12:26:11.968Z" }, + { url = "https://files.pythonhosted.org/packages/b8/66/853d50e75a38c9a7370ddbeefabdd3d3116b9c31ef94dc92c6729bc36bec/psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad81425efc5e75da3f39b3e636293360ad8d0b49bed7df824c79764fb4ba9b8b", size = 240369, upload-time = "2025-11-02T12:26:14.358Z" }, + { url = "https://files.pythonhosted.org/packages/41/bd/313aba97cb5bfb26916dc29cf0646cbe4dd6a89ca69e8c6edce654876d39/psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f33a3702e167783a9213db10ad29650ebf383946e91bc77f28a5eb083496bc9", size = 288210, upload-time = "2025-11-02T12:26:16.699Z" }, + { url = "https://files.pythonhosted.org/packages/c2/fa/76e3c06e760927a0cfb5705eb38164254de34e9bd86db656d4dbaa228b04/psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fac9cd332c67f4422504297889da5ab7e05fd11e3c4392140f7370f4208ded1f", size = 291182, upload-time = "2025-11-02T12:26:18.848Z" }, + { url = "https://files.pythonhosted.org/packages/0f/1d/5774a91607035ee5078b8fd747686ebec28a962f178712de100d00b78a32/psutil-7.1.3-cp314-cp314t-win_amd64.whl", hash = "sha256:3792983e23b69843aea49c8f5b8f115572c5ab64c153bada5270086a2123c7e7", size = 250466, upload-time = "2025-11-02T12:26:21.183Z" }, + { url = "https://files.pythonhosted.org/packages/00/ca/e426584bacb43a5cb1ac91fae1937f478cd8fbe5e4ff96574e698a2c77cd/psutil-7.1.3-cp314-cp314t-win_arm64.whl", hash = "sha256:31d77fcedb7529f27bb3a0472bea9334349f9a04160e8e6e5020f22c59893264", size = 245756, upload-time = "2025-11-02T12:26:23.148Z" }, + { url = "https://files.pythonhosted.org/packages/ef/94/46b9154a800253e7ecff5aaacdf8ebf43db99de4a2dfa18575b02548654e/psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2bdbcd0e58ca14996a42adf3621a6244f1bb2e2e528886959c72cf1e326677ab", size = 238359, upload-time = "2025-11-02T12:26:25.284Z" }, + { url = "https://files.pythonhosted.org/packages/68/3a/9f93cff5c025029a36d9a92fef47220ab4692ee7f2be0fba9f92813d0cb8/psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:bc31fa00f1fbc3c3802141eede66f3a2d51d89716a194bf2cd6fc68310a19880", size = 239171, upload-time = "2025-11-02T12:26:27.23Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b1/5f49af514f76431ba4eea935b8ad3725cdeb397e9245ab919dbc1d1dc20f/psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3bb428f9f05c1225a558f53e30ccbad9930b11c3fc206836242de1091d3e7dd3", size = 263261, upload-time = "2025-11-02T12:26:29.48Z" }, + { url = "https://files.pythonhosted.org/packages/e0/95/992c8816a74016eb095e73585d747e0a8ea21a061ed3689474fabb29a395/psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56d974e02ca2c8eb4812c3f76c30e28836fffc311d55d979f1465c1feeb2b68b", size = 264635, upload-time = "2025-11-02T12:26:31.74Z" }, + { url = "https://files.pythonhosted.org/packages/55/4c/c3ed1a622b6ae2fd3c945a366e64eb35247a31e4db16cf5095e269e8eb3c/psutil-7.1.3-cp37-abi3-win_amd64.whl", hash = "sha256:f39c2c19fe824b47484b96f9692932248a54c43799a84282cfe58d05a6449efd", size = 247633, upload-time = "2025-11-02T12:26:33.887Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ad/33b2ccec09bf96c2b2ef3f9a6f66baac8253d7565d8839e024a6b905d45d/psutil-7.1.3-cp37-abi3-win_arm64.whl", hash = "sha256:bd0d69cee829226a761e92f28140bec9a5ee9d5b4fb4b0cc589068dbfff559b1", size = 244608, upload-time = "2025-11-02T12:26:36.136Z" }, +] + +[[package]] +name = "py-key-value-aio" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beartype" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/3c/0397c072a38d4bc580994b42e0c90c5f44f679303489e4376289534735e5/py_key_value_aio-0.4.4.tar.gz", hash = "sha256:e3012e6243ed7cc09bb05457bd4d03b1ba5c2b1ca8700096b3927db79ffbbe55", size = 92300, upload-time = "2026-02-16T21:21:43.245Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/69/f1b537ee70b7def42d63124a539ed3026a11a3ffc3086947a1ca6e861868/py_key_value_aio-0.4.4-py3-none-any.whl", hash = "sha256:18e17564ecae61b987f909fc2cd41ee2012c84b4b1dcb8c055cf8b4bc1bf3f5d", size = 152291, upload-time = "2026-02-16T21:21:44.241Z" }, +] + +[package.optional-dependencies] +filetree = [ + { name = "aiofile" }, + { name = "anyio" }, +] +keyring = [ + { name = "keyring" }, +] +memory = [ + { name = "cachetools" }, +] + +[[package]] +name = "pyarrow" +version = "22.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151, upload-time = "2025-10-24T12:30:00.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/b7/18f611a8cdc43417f9394a3ccd3eace2f32183c08b9eddc3d17681819f37/pyarrow-22.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:3e294c5eadfb93d78b0763e859a0c16d4051fc1c5231ae8956d61cb0b5666f5a", size = 34272022, upload-time = "2025-10-24T10:04:28.973Z" }, + { url = "https://files.pythonhosted.org/packages/26/5c/f259e2526c67eb4b9e511741b19870a02363a47a35edbebc55c3178db22d/pyarrow-22.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:69763ab2445f632d90b504a815a2a033f74332997052b721002298ed6de40f2e", size = 35995834, upload-time = "2025-10-24T10:04:35.467Z" }, + { url = "https://files.pythonhosted.org/packages/50/8d/281f0f9b9376d4b7f146913b26fac0aa2829cd1ee7e997f53a27411bbb92/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:b41f37cabfe2463232684de44bad753d6be08a7a072f6a83447eeaf0e4d2a215", size = 45030348, upload-time = "2025-10-24T10:04:43.366Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e5/53c0a1c428f0976bf22f513d79c73000926cb00b9c138d8e02daf2102e18/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:35ad0f0378c9359b3f297299c3309778bb03b8612f987399a0333a560b43862d", size = 47699480, upload-time = "2025-10-24T10:04:51.486Z" }, + { url = "https://files.pythonhosted.org/packages/95/e1/9dbe4c465c3365959d183e6345d0a8d1dc5b02ca3f8db4760b3bc834cf25/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8382ad21458075c2e66a82a29d650f963ce51c7708c7c0ff313a8c206c4fd5e8", size = 48011148, upload-time = "2025-10-24T10:04:59.585Z" }, + { url = "https://files.pythonhosted.org/packages/c5/b4/7caf5d21930061444c3cf4fa7535c82faf5263e22ce43af7c2759ceb5b8b/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1a812a5b727bc09c3d7ea072c4eebf657c2f7066155506ba31ebf4792f88f016", size = 50276964, upload-time = "2025-10-24T10:05:08.175Z" }, + { url = "https://files.pythonhosted.org/packages/ae/f3/cec89bd99fa3abf826f14d4e53d3d11340ce6f6af4d14bdcd54cd83b6576/pyarrow-22.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:ec5d40dd494882704fb876c16fa7261a69791e784ae34e6b5992e977bd2e238c", size = 28106517, upload-time = "2025-10-24T10:05:14.314Z" }, + { url = "https://files.pythonhosted.org/packages/af/63/ba23862d69652f85b615ca14ad14f3bcfc5bf1b99ef3f0cd04ff93fdad5a/pyarrow-22.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bea79263d55c24a32b0d79c00a1c58bb2ee5f0757ed95656b01c0fb310c5af3d", size = 34211578, upload-time = "2025-10-24T10:05:21.583Z" }, + { url = "https://files.pythonhosted.org/packages/b1/d0/f9ad86fe809efd2bcc8be32032fa72e8b0d112b01ae56a053006376c5930/pyarrow-22.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:12fe549c9b10ac98c91cf791d2945e878875d95508e1a5d14091a7aaa66d9cf8", size = 35989906, upload-time = "2025-10-24T10:05:29.485Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a8/f910afcb14630e64d673f15904ec27dd31f1e009b77033c365c84e8c1e1d/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:334f900ff08ce0423407af97e6c26ad5d4e3b0763645559ece6fbf3747d6a8f5", size = 45021677, upload-time = "2025-10-24T10:05:38.274Z" }, + { url = "https://files.pythonhosted.org/packages/13/95/aec81f781c75cd10554dc17a25849c720d54feafb6f7847690478dcf5ef8/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c6c791b09c57ed76a18b03f2631753a4960eefbbca80f846da8baefc6491fcfe", size = 47726315, upload-time = "2025-10-24T10:05:47.314Z" }, + { url = "https://files.pythonhosted.org/packages/bb/d4/74ac9f7a54cfde12ee42734ea25d5a3c9a45db78f9def949307a92720d37/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c3200cb41cdbc65156e5f8c908d739b0dfed57e890329413da2748d1a2cd1a4e", size = 47990906, upload-time = "2025-10-24T10:05:58.254Z" }, + { url = "https://files.pythonhosted.org/packages/2e/71/fedf2499bf7a95062eafc989ace56572f3343432570e1c54e6599d5b88da/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ac93252226cf288753d8b46280f4edf3433bf9508b6977f8dd8526b521a1bbb9", size = 50306783, upload-time = "2025-10-24T10:06:08.08Z" }, + { url = "https://files.pythonhosted.org/packages/68/ed/b202abd5a5b78f519722f3d29063dda03c114711093c1995a33b8e2e0f4b/pyarrow-22.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:44729980b6c50a5f2bfcc2668d36c569ce17f8b17bccaf470c4313dcbbf13c9d", size = 27972883, upload-time = "2025-10-24T10:06:14.204Z" }, + { url = "https://files.pythonhosted.org/packages/a6/d6/d0fac16a2963002fc22c8fa75180a838737203d558f0ed3b564c4a54eef5/pyarrow-22.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6e95176209257803a8b3d0394f21604e796dadb643d2f7ca21b66c9c0b30c9a", size = 34204629, upload-time = "2025-10-24T10:06:20.274Z" }, + { url = "https://files.pythonhosted.org/packages/c6/9c/1d6357347fbae062ad3f17082f9ebc29cc733321e892c0d2085f42a2212b/pyarrow-22.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:001ea83a58024818826a9e3f89bf9310a114f7e26dfe404a4c32686f97bd7901", size = 35985783, upload-time = "2025-10-24T10:06:27.301Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c0/782344c2ce58afbea010150df07e3a2f5fdad299cd631697ae7bd3bac6e3/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ce20fe000754f477c8a9125543f1936ea5b8867c5406757c224d745ed033e691", size = 45020999, upload-time = "2025-10-24T10:06:35.387Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8b/5362443737a5307a7b67c1017c42cd104213189b4970bf607e05faf9c525/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e0a15757fccb38c410947df156f9749ae4a3c89b2393741a50521f39a8cf202a", size = 47724601, upload-time = "2025-10-24T10:06:43.551Z" }, + { url = "https://files.pythonhosted.org/packages/69/4d/76e567a4fc2e190ee6072967cb4672b7d9249ac59ae65af2d7e3047afa3b/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cedb9dd9358e4ea1d9bce3665ce0797f6adf97ff142c8e25b46ba9cdd508e9b6", size = 48001050, upload-time = "2025-10-24T10:06:52.284Z" }, + { url = "https://files.pythonhosted.org/packages/01/5e/5653f0535d2a1aef8223cee9d92944cb6bccfee5cf1cd3f462d7cb022790/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:252be4a05f9d9185bb8c18e83764ebcfea7185076c07a7a662253af3a8c07941", size = 50307877, upload-time = "2025-10-24T10:07:02.405Z" }, + { url = "https://files.pythonhosted.org/packages/2d/f8/1d0bd75bf9328a3b826e24a16e5517cd7f9fbf8d34a3184a4566ef5a7f29/pyarrow-22.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:a4893d31e5ef780b6edcaf63122df0f8d321088bb0dee4c8c06eccb1ca28d145", size = 27977099, upload-time = "2025-10-24T10:08:07.259Z" }, + { url = "https://files.pythonhosted.org/packages/90/81/db56870c997805bf2b0f6eeeb2d68458bf4654652dccdcf1bf7a42d80903/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:f7fe3dbe871294ba70d789be16b6e7e52b418311e166e0e3cba9522f0f437fb1", size = 34336685, upload-time = "2025-10-24T10:07:11.47Z" }, + { url = "https://files.pythonhosted.org/packages/1c/98/0727947f199aba8a120f47dfc229eeb05df15bcd7a6f1b669e9f882afc58/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:ba95112d15fd4f1105fb2402c4eab9068f0554435e9b7085924bcfaac2cc306f", size = 36032158, upload-time = "2025-10-24T10:07:18.626Z" }, + { url = "https://files.pythonhosted.org/packages/96/b4/9babdef9c01720a0785945c7cf550e4acd0ebcd7bdd2e6f0aa7981fa85e2/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c064e28361c05d72eed8e744c9605cbd6d2bb7481a511c74071fd9b24bc65d7d", size = 44892060, upload-time = "2025-10-24T10:07:26.002Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ca/2f8804edd6279f78a37062d813de3f16f29183874447ef6d1aadbb4efa0f/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6f9762274496c244d951c819348afbcf212714902742225f649cf02823a6a10f", size = 47504395, upload-time = "2025-10-24T10:07:34.09Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f0/77aa5198fd3943682b2e4faaf179a674f0edea0d55d326d83cb2277d9363/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a9d9ffdc2ab696f6b15b4d1f7cec6658e1d788124418cb30030afbae31c64746", size = 48066216, upload-time = "2025-10-24T10:07:43.528Z" }, + { url = "https://files.pythonhosted.org/packages/79/87/a1937b6e78b2aff18b706d738c9e46ade5bfcf11b294e39c87706a0089ac/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ec1a15968a9d80da01e1d30349b2b0d7cc91e96588ee324ce1b5228175043e95", size = 50288552, upload-time = "2025-10-24T10:07:53.519Z" }, + { url = "https://files.pythonhosted.org/packages/60/ae/b5a5811e11f25788ccfdaa8f26b6791c9807119dffcf80514505527c384c/pyarrow-22.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bba208d9c7decf9961998edf5c65e3ea4355d5818dd6cd0f6809bec1afb951cc", size = 28262504, upload-time = "2025-10-24T10:08:00.932Z" }, + { url = "https://files.pythonhosted.org/packages/bd/b0/0fa4d28a8edb42b0a7144edd20befd04173ac79819547216f8a9f36f9e50/pyarrow-22.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9bddc2cade6561f6820d4cd73f99a0243532ad506bc510a75a5a65a522b2d74d", size = 34224062, upload-time = "2025-10-24T10:08:14.101Z" }, + { url = "https://files.pythonhosted.org/packages/0f/a8/7a719076b3c1be0acef56a07220c586f25cd24de0e3f3102b438d18ae5df/pyarrow-22.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e70ff90c64419709d38c8932ea9fe1cc98415c4f87ea8da81719e43f02534bc9", size = 35990057, upload-time = "2025-10-24T10:08:21.842Z" }, + { url = "https://files.pythonhosted.org/packages/89/3c/359ed54c93b47fb6fe30ed16cdf50e3f0e8b9ccfb11b86218c3619ae50a8/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:92843c305330aa94a36e706c16209cd4df274693e777ca47112617db7d0ef3d7", size = 45068002, upload-time = "2025-10-24T10:08:29.034Z" }, + { url = "https://files.pythonhosted.org/packages/55/fc/4945896cc8638536ee787a3bd6ce7cec8ec9acf452d78ec39ab328efa0a1/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6dda1ddac033d27421c20d7a7943eec60be44e0db4e079f33cc5af3b8280ccde", size = 47737765, upload-time = "2025-10-24T10:08:38.559Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5e/7cb7edeb2abfaa1f79b5d5eb89432356155c8426f75d3753cbcb9592c0fd/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:84378110dd9a6c06323b41b56e129c504d157d1a983ce8f5443761eb5256bafc", size = 48048139, upload-time = "2025-10-24T10:08:46.784Z" }, + { url = "https://files.pythonhosted.org/packages/88/c6/546baa7c48185f5e9d6e59277c4b19f30f48c94d9dd938c2a80d4d6b067c/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:854794239111d2b88b40b6ef92aa478024d1e5074f364033e73e21e3f76b25e0", size = 50314244, upload-time = "2025-10-24T10:08:55.771Z" }, + { url = "https://files.pythonhosted.org/packages/3c/79/755ff2d145aafec8d347bf18f95e4e81c00127f06d080135dfc86aea417c/pyarrow-22.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:b883fe6fd85adad7932b3271c38ac289c65b7337c2c132e9569f9d3940620730", size = 28757501, upload-time = "2025-10-24T10:09:59.891Z" }, + { url = "https://files.pythonhosted.org/packages/0e/d2/237d75ac28ced3147912954e3c1a174df43a95f4f88e467809118a8165e0/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7a820d8ae11facf32585507c11f04e3f38343c1e784c9b5a8b1da5c930547fe2", size = 34355506, upload-time = "2025-10-24T10:09:02.953Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/733dfffe6d3069740f98e57ff81007809067d68626c5faef293434d11bd6/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:c6ec3675d98915bf1ec8b3c7986422682f7232ea76cad276f4c8abd5b7319b70", size = 36047312, upload-time = "2025-10-24T10:09:10.334Z" }, + { url = "https://files.pythonhosted.org/packages/7c/2b/29d6e3782dc1f299727462c1543af357a0f2c1d3c160ce199950d9ca51eb/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3e739edd001b04f654b166204fc7a9de896cf6007eaff33409ee9e50ceaff754", size = 45081609, upload-time = "2025-10-24T10:09:18.61Z" }, + { url = "https://files.pythonhosted.org/packages/8d/42/aa9355ecc05997915af1b7b947a7f66c02dcaa927f3203b87871c114ba10/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7388ac685cab5b279a41dfe0a6ccd99e4dbf322edfb63e02fc0443bf24134e91", size = 47703663, upload-time = "2025-10-24T10:09:27.369Z" }, + { url = "https://files.pythonhosted.org/packages/ee/62/45abedde480168e83a1de005b7b7043fd553321c1e8c5a9a114425f64842/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f633074f36dbc33d5c05b5dc75371e5660f1dbf9c8b1d95669def05e5425989c", size = 48066543, upload-time = "2025-10-24T10:09:34.908Z" }, + { url = "https://files.pythonhosted.org/packages/84/e9/7878940a5b072e4f3bf998770acafeae13b267f9893af5f6d4ab3904b67e/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4c19236ae2402a8663a2c8f21f1870a03cc57f0bef7e4b6eb3238cc82944de80", size = 50288838, upload-time = "2025-10-24T10:09:44.394Z" }, + { url = "https://files.pythonhosted.org/packages/7b/03/f335d6c52b4a4761bcc83499789a1e2e16d9d201a58c327a9b5cc9a41bd9/pyarrow-22.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0c34fe18094686194f204a3b1787a27456897d8a2d62caf84b61e8dfbc0252ae", size = 29185594, upload-time = "2025-10-24T10:09:53.111Z" }, +] + +[[package]] +name = "pycparser" +version = "2.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" }, +] + +[[package]] +name = "pydantic" +version = "2.12.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/96/ad/a17bc283d7d81837c061c49e3eaa27a45991759a1b7eae1031921c6bd924/pydantic-2.12.4.tar.gz", hash = "sha256:0f8cb9555000a4b5b617f66bfd2566264c4984b27589d3b845685983e8ea85ac", size = 821038, upload-time = "2025-11-05T10:50:08.59Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/2f/e68750da9b04856e2a7ec56fc6f034a5a79775e9b9a81882252789873798/pydantic-2.12.4-py3-none-any.whl", hash = "sha256:92d3d202a745d46f9be6df459ac5a064fdaa3c1c4cd8adcfa332ccf3c05f871e", size = 463400, upload-time = "2025-11-05T10:50:06.732Z" }, +] + +[package.optional-dependencies] +email = [ + { name = "email-validator" }, +] + +[[package]] +name = "pydantic-core" +version = "2.41.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" }, + { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" }, + { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" }, + { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" }, + { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" }, + { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" }, + { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" }, + { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" }, + { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" }, + { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" }, + { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" }, + { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" }, + { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" }, + { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" }, + { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" }, + { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" }, + { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" }, + { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" }, + { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" }, + { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" }, + { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" }, + { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" }, + { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" }, + { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" }, + { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" }, + { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" }, + { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" }, + { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" }, + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" }, + { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, + { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, + { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" }, + { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" }, + { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" }, + { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" }, + { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" }, + { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" }, + { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, + { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" }, + { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" }, + { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" }, + { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" }, + { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" }, +] + +[[package]] +name = "pydantic-settings" +version = "2.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/ac7e0aae12027748076d72a8764ff1c9d82ca75a7a52622e67ed3f765c54/pydantic_settings-2.12.0.tar.gz", hash = "sha256:005538ef951e3c2a68e1c08b292b5f2e71490def8589d4221b95dab00dafcfd0", size = 194184, upload-time = "2025-11-10T14:25:47.013Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, +] + +[[package]] +name = "pyjwt" +version = "2.10.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785, upload-time = "2024-11-28T03:43:29.933Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997, upload-time = "2024-11-28T03:43:27.893Z" }, +] + +[package.optional-dependencies] +crypto = [ + { name = "cryptography" }, +] + +[[package]] +name = "pymongo" +version = "4.17.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dnspython" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ca/64/50be6fbac9c79fe2e4c17401a467da2d8764d82833d83cec325afe5cab32/pymongo-4.17.0.tar.gz", hash = "sha256:70ffa08ba641468cc068cf46c06b34f01a8ce3489f6411309fcb5ceabe6b2fc0", size = 2523370, upload-time = "2026-04-20T16:39:53.524Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c4/e2/336d86f221cf1b56b2ed9330d4a3b98f9f38f0b37829ae9a9184617d5419/pymongo-4.17.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4141e6c6a339789b2974efa00ecd9409101672d77a0e3ee2cc3839eedf8ec4df", size = 874668, upload-time = "2026-04-20T16:37:41.39Z" }, + { url = "https://files.pythonhosted.org/packages/34/8e/75d3c6c935d187ab59c61e9c15d9aab3f274b563eaf1706e8cae5f508dec/pymongo-4.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e68c76b84e0c132d9dbf9307f12ff8185702328187a87b9aca8c941303873433", size = 875294, upload-time = "2026-04-20T16:37:43.432Z" }, + { url = "https://files.pythonhosted.org/packages/5f/ec/62e855744489dbcd54fd778aae4d80fa4c4819e8fb228ca0cf6f21a03997/pymongo-4.17.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ba2195d4f386f839a52a23ea1cfd60ffaaba78a3d7841db51b7e433001139918", size = 1496233, upload-time = "2026-04-20T16:37:45.518Z" }, + { url = "https://files.pythonhosted.org/packages/82/e8/93e4e5e5ce8fdf8929dabeefe24aafa5ce046028eed0dfa8eeb936e72c49/pymongo-4.17.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8446ff4bfcb6ec2a2e50998c860986a1e992136f998b7f53e7a717fb8aa5a0b9", size = 1522927, upload-time = "2026-04-20T16:37:47.492Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ca/425dc1d21e0f17bdea0072fc463f662f7fa06d2852af52975c9eced3c07c/pymongo-4.17.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2a0d5ac205728c86e0a02192f1aa5f865b0d7d51f8df6101c01a69a7fc620d72", size = 1583468, upload-time = "2026-04-20T16:37:49.221Z" }, + { url = "https://files.pythonhosted.org/packages/b3/9d/f08b07eeffda1a43c1759f0fa625e88ae12360996eb56d42aad832fa7dff/pymongo-4.17.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:485c8a8eaa4c739f00a331fc73757898ee7c092c214a79e63866ff76aaf282ff", size = 1572787, upload-time = "2026-04-20T16:37:51.061Z" }, + { url = "https://files.pythonhosted.org/packages/e9/c2/6855a07aafa7b894929af23675b6fb9634800ce43122b76a62f6eeb8da2a/pymongo-4.17.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b2dfcc795f5b9fedbe179a11fdf6051581479d196582a3fe819a92a00e9b9969", size = 1526184, upload-time = "2026-04-20T16:37:53.358Z" }, + { url = "https://files.pythonhosted.org/packages/4e/05/c952bac7db71c1942ea3559fcd308b49754cc5004b455935fb4000d1f37b/pymongo-4.17.0-cp311-cp311-win32.whl", hash = "sha256:c2292144505fb12156b981bd440f3dc994a883da06ac726c0c8692ccdbc1c510", size = 852621, upload-time = "2026-04-20T16:37:55.28Z" }, + { url = "https://files.pythonhosted.org/packages/11/c0/c04da9f4c0c6252404598f4e394b862a58a9e866822a70ae261c8a018fdf/pymongo-4.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:2e190827834fce70ecdf9d46796c6dbc0ce08ea87dc2ff5bc6f3f5579b605cb9", size = 867852, upload-time = "2026-04-20T16:37:57.233Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b2/c7b4870fbeef471e947d3e014676f5910d02e0197074d692ebcf24ec049a/pymongo-4.17.0-cp311-cp311-win_arm64.whl", hash = "sha256:a8f9c40a09bb7d4b9fc8b1da65ecf6efa79bda5cb2756f39d9b6940fac1d19ae", size = 855019, upload-time = "2026-04-20T16:37:58.983Z" }, + { url = "https://files.pythonhosted.org/packages/98/90/60bcb508840135d5ee46b51b1a950f548338aa8145a8366dbe6639ae51ac/pymongo-4.17.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53ffa94b2340dbf6b055e09a0090618c60482c158ecfc9565642fc996bf0944", size = 930529, upload-time = "2026-04-20T16:38:00.936Z" }, + { url = "https://files.pythonhosted.org/packages/a6/e9/313840f1e52c6dfac47f704428cbfbce59956ebe7633bffc92b03f74f0ad/pymongo-4.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6fe0de9d0f6791abce3471230b32b4817bf89d27b1182b6a550e1ec0fa72aa9a", size = 930665, upload-time = "2026-04-20T16:38:02.915Z" }, + { url = "https://files.pythonhosted.org/packages/78/35/9d3565ea45b1606f635c1e2cd2563c28d66caafdc50f7ad7d979fcd1b363/pymongo-4.17.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e537e95514dae1aaa718f481ec03151a0f0394bcd05f1322896d8fc1330cb729", size = 1762369, upload-time = "2026-04-20T16:38:05.375Z" }, + { url = "https://files.pythonhosted.org/packages/95/ee/149b0d4b1a11c38bff6f14c23d5814c9b0843fd6dc38ad40596bdb1a62d2/pymongo-4.17.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:37a8385c29881b43eab31f584100fa0eaddedd5607adf010147ba1810118be90", size = 1798044, upload-time = "2026-04-20T16:38:07.195Z" }, + { url = "https://files.pythonhosted.org/packages/7b/d4/4cee4a7b8d8f6f0550ef6cd2fea42455c5ed619a220cb6ba4fb40d6a5bc8/pymongo-4.17.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f3ee3d241ed77a4fc99ce3cff3b289c3ebce37f61fdd7349d3592c23b82c8784", size = 1878567, upload-time = "2026-04-20T16:38:09.121Z" }, + { url = "https://files.pythonhosted.org/packages/45/ef/7fe366c84952619ee2f69973566c214775e083dd4df465751912153e4b72/pymongo-4.17.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9eb5d63a3c518cb0804ed678f5e2b875af032d89a7cf57a57360322cf6a4d222", size = 1864881, upload-time = "2026-04-20T16:38:10.896Z" }, + { url = "https://files.pythonhosted.org/packages/2f/35/b577d82c6d1be7aee7ac7e249bc86f7847998345042e5f8360de238e177b/pymongo-4.17.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e97e03fa13327c87e3fdc5656acd01e71817f0c1dc3221cd8f30de136bf4ec3", size = 1800349, upload-time = "2026-04-20T16:38:13.589Z" }, + { url = "https://files.pythonhosted.org/packages/b8/69/dafcf04f66e130ddd91aeb92e7a692480eda46dcd04ec1dbe82c06619e10/pymongo-4.17.0-cp312-cp312-win32.whl", hash = "sha256:6877214bff5f06f6884a9fc8d9016a4a7a5f51f537f5c51ac3a576f93e7dfb32", size = 900518, upload-time = "2026-04-20T16:38:15.541Z" }, + { url = "https://files.pythonhosted.org/packages/11/35/5c9262a459f988b4eb2605f70815240b77a0d4131136c4326d18f1822b89/pymongo-4.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:9828485f72f63c7d802e0ec41f71906f633c2692621ab3af55ca990186b091b1", size = 920335, upload-time = "2026-04-20T16:38:17.665Z" }, + { url = "https://files.pythonhosted.org/packages/8d/da/e9c7265ee176faccf4e52c4797837e794d93569a1046f6b19a4acc36e5ad/pymongo-4.17.0-cp312-cp312-win_arm64.whl", hash = "sha256:1195370a77baf003b59b10e91ecc4706297197f0dd9d29c840cc556dc08f7cee", size = 903289, upload-time = "2026-04-20T16:38:19.33Z" }, + { url = "https://files.pythonhosted.org/packages/2a/6b/c1206879708b94e82fcd8b9653440ec271f79a3674d122192df383047f5a/pymongo-4.17.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:809ec74de3b9148ae43fa8df9faf53470f511c8d384f13b99d6f671f2a379f15", size = 985829, upload-time = "2026-04-20T16:38:21.031Z" }, + { url = "https://files.pythonhosted.org/packages/cb/cf/bb044ed85160e5c40f568c7c4f4e8ea16f40764ff5d302e5befbe8f6f814/pymongo-4.17.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a431b737816bf4cddd4fa0fcef04e424ad36b7692734a64150f872fb8f3208be", size = 985899, upload-time = "2026-04-20T16:38:23.409Z" }, + { url = "https://files.pythonhosted.org/packages/74/0a/f6dfd5ea3901e5d6888da8de8ba728971a1d447debab681cfc56f90d1208/pymongo-4.17.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e4fab10f8403169ce92f3cea921609d9ee81107306caae06c08f592d4b8ad2b5", size = 2028569, upload-time = "2026-04-20T16:38:25.343Z" }, + { url = "https://files.pythonhosted.org/packages/4a/c5/081f59a1c02ae8c0dc73ae58e563838c44eec81aeafa7d0b93a637841c9b/pymongo-4.17.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20323b0b1c1d33770ad1fc68d429c757734ce9ad3594421c3d6618f10572b1b9", size = 2072916, upload-time = "2026-04-20T16:38:27.291Z" }, + { url = "https://files.pythonhosted.org/packages/31/42/6e41d434297ffe8b30d9c3717916591a4a7be9075a0dcc2fafdfaaaa62ed/pymongo-4.17.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5a5de048e6da5c18e27cc2437e8c15b3b0cdc8385c15b41178b0caa3322a09c2", size = 2173234, upload-time = "2026-04-20T16:38:29.474Z" }, + { url = "https://files.pythonhosted.org/packages/3d/cf/1e4a7db352ef9485831c7268dfe8402f0117b32a9ad54b16e810699e3617/pymongo-4.17.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:dff3de1294fbbc1db0ba6b511f77b8e540601d092538a31312e99c8a91a78b1e", size = 2156784, upload-time = "2026-04-20T16:38:32.134Z" }, + { url = "https://files.pythonhosted.org/packages/12/10/6195be29962a61ebb5f4bd9e4c7519890b172f7968a0a0d880398c6ddb02/pymongo-4.17.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:faf03e4c2aafd6de626dbd30ba246d369ae33f47f10629d1bbe40f72115027a6", size = 2074446, upload-time = "2026-04-20T16:38:34.004Z" }, + { url = "https://files.pythonhosted.org/packages/37/48/33410b8819837ed370c738587306bdf060b59cef11823be212f4a07703c5/pymongo-4.17.0-cp313-cp313-win32.whl", hash = "sha256:c9786665926a09630c5d420c79762cfadbff35a9438bcbc4c81a9fb5ab9228b7", size = 948435, upload-time = "2026-04-20T16:38:35.922Z" }, + { url = "https://files.pythonhosted.org/packages/6f/77/c0ed522f798a286b99acaa7914ed8d9c80ab091f97f57c59ffed72906e5e/pymongo-4.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:5960519b4d7168f1ecdd3ea10c81b2aedeb9423651aca953cfbc8e76705d3b38", size = 972847, upload-time = "2026-04-20T16:38:37.888Z" }, + { url = "https://files.pythonhosted.org/packages/97/f0/c39480a2db385fde23861d0c8acda41cdaf1d43e46579db72c5c013a2e81/pymongo-4.17.0-cp313-cp313-win_arm64.whl", hash = "sha256:0ff6bd2f735ab5356541e3e57d5b7dbfbc3f2ee1ccb10b6b0f82d58af69d1d8e", size = 951575, upload-time = "2026-04-20T16:38:40.544Z" }, + { url = "https://files.pythonhosted.org/packages/da/49/2b0250762a89737ed6f9cea238331baca061b89a8ddd10dd17fee52c3970/pymongo-4.17.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ff5aa3f1c7e3f08eb0e7a016c91ba468b1850ccfd63d9b1f12f56350f4974cef", size = 1040945, upload-time = "2026-04-20T16:38:42.783Z" }, + { url = "https://files.pythonhosted.org/packages/89/1c/7a9b5447a08be20e84b6e5b17330917e8d6d9507daa3cd099a9309f11ad7/pymongo-4.17.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e816db649ba5d7de0568cf3a9f287a9dc9aad21cf0ca667ab156a7ef47fca0b0", size = 1041187, upload-time = "2026-04-20T16:38:45.358Z" }, + { url = "https://files.pythonhosted.org/packages/78/a1/71704f61632dfc90407a5834fe5f6132854937c4a3648f6c05c351d85a45/pymongo-4.17.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:12c4fded3a9f1d6a687e36ebd384ac6d00b9b00de1969aa74048e7051ec2a713", size = 2294806, upload-time = "2026-04-20T16:38:47.734Z" }, + { url = "https://files.pythonhosted.org/packages/ad/b9/aff42be75108b96c2469b1d9329b912c15108f3e7ef32fdc86da8423c330/pymongo-4.17.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2db66aa8dd253a0fc1fad3b0d23d5b3993f7ebde02fbbd7727128debf2853675", size = 2348231, upload-time = "2026-04-20T16:38:50.371Z" }, + { url = "https://files.pythonhosted.org/packages/f2/30/44c115b8ba1479942c15fd9480eb29a7da0ba68acd56983423ba0deb4a94/pymongo-4.17.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3987e96e7c7be4083d42e8ac2cc6c0d5b78db9973c90fce42ae800b616ca6b20", size = 2467614, upload-time = "2026-04-20T16:38:52.665Z" }, + { url = "https://files.pythonhosted.org/packages/d2/84/21ee95c8bf0ca7acae7ec7eb365d740bf8fc0156c194baf2c3bdfcb85ec0/pymongo-4.17.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:cee36b3c0d0354f880fa7a7fdcdaf2bb5e542c2281e25c1bfadf8cfe21eba7d2", size = 2445970, upload-time = "2026-04-20T16:38:55.175Z" }, + { url = "https://files.pythonhosted.org/packages/06/89/081d7f1809d5ca09d1e47e49f2111b245f5694de3a7af32cd3a353a6f43f/pymongo-4.17.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:320b34457b20bbcc79997801f95d25ce00472915ca5241167242b42c4359e027", size = 2348605, upload-time = "2026-04-20T16:38:57.557Z" }, + { url = "https://files.pythonhosted.org/packages/ea/c3/0d949f9d3f2a341c1f635c398c16615e96f89f51ff424ed81e914cf1a4de/pymongo-4.17.0-cp314-cp314-win32.whl", hash = "sha256:df4a644af9ae132d4bfdb2e9516ea51a615fd881caddfbfbd071cf1354844479", size = 1004119, upload-time = "2026-04-20T16:39:00.309Z" }, + { url = "https://files.pythonhosted.org/packages/f7/55/5c3a3db1048054c695c75c5964cc8bedc2247fdb5a75ef6fab4ec8bb013e/pymongo-4.17.0-cp314-cp314-win_amd64.whl", hash = "sha256:c797f8a80957134f6dd9690367a0f8f5906d672119af2c6aa55f0c527b656bed", size = 1032314, upload-time = "2026-04-20T16:39:02.665Z" }, + { url = "https://files.pythonhosted.org/packages/e0/19/e235f39906134cb0ffd5574c5a59c355ef5380f0499644ab94994afbb109/pymongo-4.17.0-cp314-cp314-win_arm64.whl", hash = "sha256:68fca71e05ee5da23a8d73cee8379dfb3d26e609a377cae731d742771ed96946", size = 1007627, upload-time = "2026-04-20T16:39:04.678Z" }, + { url = "https://files.pythonhosted.org/packages/1e/e0/c4c1a86791415b14c684fa0908f9da96de91594a3fd1fa1b8dc689fbb800/pymongo-4.17.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b4384700cffc3f1dd98e088bc0072dedf6d7d68a230bb4b972665cf69c071c1e", size = 1099151, upload-time = "2026-04-20T16:39:06.969Z" }, + { url = "https://files.pythonhosted.org/packages/81/4b/69c67f3e23fd9b23b9bedc7ebd23754881cc9d5c5d5b2a9811e96b07f475/pymongo-4.17.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:93641192644fa1ee0f34030e774fd31022a27ad11ba22cb1716142231524f8bd", size = 1099346, upload-time = "2026-04-20T16:39:08.996Z" }, + { url = "https://files.pythonhosted.org/packages/a2/19/a5208f62f9508a26d73acc69bd3821b8c8adae253679a3c26d2f9652f0d5/pymongo-4.17.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:75bc3aa5b94fdb7138d357ec6ca61cd97e0c79f4f7f0bd3efe9639b15cc50942", size = 2619034, upload-time = "2026-04-20T16:39:11.049Z" }, + { url = "https://files.pythonhosted.org/packages/77/27/426cba1ec5973082a56d4150798529bfdf4151c31391ed1fbbecb23ef2ac/pymongo-4.17.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50e8f8e23c6df7c6d6929f5e734980b227706e73ee847517c9ba5af90f7fc466", size = 2689939, upload-time = "2026-04-20T16:39:13.617Z" }, + { url = "https://files.pythonhosted.org/packages/ef/2e/f70993d1255e33f6ee59a4ec4371cc65bff7a7e3fda7d55c3386f25287e8/pymongo-4.17.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:15d3f3d732aecac1f8d481bde4029755615639bd3076f258a2147210aec8515a", size = 2824994, upload-time = "2026-04-20T16:39:16.057Z" }, + { url = "https://files.pythonhosted.org/packages/b3/eb/87b0e988ba889e1fcc3430c2cfc166b251872c813e92b43174298bee17ff/pymongo-4.17.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c5f62862d0f87be481fa1fe8cb811994486773c94a2b61e509285e3f2890763", size = 2801745, upload-time = "2026-04-20T16:39:18.476Z" }, + { url = "https://files.pythonhosted.org/packages/67/4c/3f83412d086f682d4d468761d66ddc49cf161e786ea74073045eb4491c60/pymongo-4.17.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:64837adbbd72073301af51bb0fc80e3d7707fe5527cea1033ba0320f0b2f881b", size = 2684636, upload-time = "2026-04-20T16:39:20.878Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d8/b75f6f4ab6c8beb50b0270a4f1e2530b5774f5e116563440e1677ca1820f/pymongo-4.17.0-cp314-cp314t-win32.whl", hash = "sha256:b93b22eedc62598cf5ee9d8c8007a8e9121c50fd88137012d8985500e9dc3151", size = 1056356, upload-time = "2026-04-20T16:39:22.996Z" }, + { url = "https://files.pythonhosted.org/packages/e4/5e/648c8a238eef18a25ed8a169ea6542d4a860bbec3e95b3d9badac2935c71/pymongo-4.17.0-cp314-cp314t-win_amd64.whl", hash = "sha256:3689ea34f6b647c7d1e7bdc60fcfb214b2789ed1359a7fb96569c69f50e5f18f", size = 1090964, upload-time = "2026-04-20T16:39:24.989Z" }, + { url = "https://files.pythonhosted.org/packages/dc/cb/d9780b66939c4fc1f024bcc7be23a2abcfe06a9745ca8fa76dc73395482e/pymongo-4.17.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9543d8f84c2e5608565c08ac679774811e6730770d8a645439b073422a4276fb", size = 1058526, upload-time = "2026-04-20T16:39:27.924Z" }, +] + +[[package]] +name = "pyperclip" +version = "1.11.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/52/d87eba7cb129b81563019d1679026e7a112ef76855d6159d24754dbd2a51/pyperclip-1.11.0.tar.gz", hash = "sha256:244035963e4428530d9e3a6101a1ef97209c6825edab1567beac148ccc1db1b6", size = 12185, upload-time = "2025-09-26T14:40:37.245Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/80/fc9d01d5ed37ba4c42ca2b55b4339ae6e200b456be3a1aaddf4a9fa99b8c/pyperclip-1.11.0-py3-none-any.whl", hash = "sha256:299403e9ff44581cb9ba2ffeed69c7aa96a008622ad0c46cb575ca75b5b84273", size = 11063, upload-time = "2025-09-26T14:40:36.069Z" }, +] + +[[package]] +name = "pytest" +version = "9.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" }, +] + +[[package]] +name = "pytest-asyncio" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" }, +] + +[[package]] +name = "python-multipart" +version = "0.0.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158, upload-time = "2024-12-16T19:45:46.972Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546, upload-time = "2024-12-16T19:45:44.423Z" }, +] + +[[package]] +name = "pytz" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" }, +] + +[[package]] +name = "pywin32" +version = "311" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031, upload-time = "2025-07-14T20:13:13.266Z" }, + { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308, upload-time = "2025-07-14T20:13:15.147Z" }, + { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930, upload-time = "2025-07-14T20:13:16.945Z" }, + { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" }, + { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" }, + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" }, + { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" }, + { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" }, + { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" }, +] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/5d/305323ba86b284e6fcb0d842d6adaa2999035f70f8c38a9b6d21ad28c3d4/pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86", size = 1333328, upload-time = "2025-09-08T23:07:45.946Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a0/fc7e78a23748ad5443ac3275943457e8452da67fda347e05260261108cbc/pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581", size = 908803, upload-time = "2025-09-08T23:07:47.551Z" }, + { url = "https://files.pythonhosted.org/packages/7e/22/37d15eb05f3bdfa4abea6f6d96eb3bb58585fbd3e4e0ded4e743bc650c97/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f", size = 668836, upload-time = "2025-09-08T23:07:49.436Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c4/2a6fe5111a01005fc7af3878259ce17684fabb8852815eda6225620f3c59/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e", size = 857038, upload-time = "2025-09-08T23:07:51.234Z" }, + { url = "https://files.pythonhosted.org/packages/cb/eb/bfdcb41d0db9cd233d6fb22dc131583774135505ada800ebf14dfb0a7c40/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e", size = 1657531, upload-time = "2025-09-08T23:07:52.795Z" }, + { url = "https://files.pythonhosted.org/packages/ab/21/e3180ca269ed4a0de5c34417dfe71a8ae80421198be83ee619a8a485b0c7/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2", size = 2034786, upload-time = "2025-09-08T23:07:55.047Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b1/5e21d0b517434b7f33588ff76c177c5a167858cc38ef740608898cd329f2/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394", size = 1894220, upload-time = "2025-09-08T23:07:57.172Z" }, + { url = "https://files.pythonhosted.org/packages/03/f2/44913a6ff6941905efc24a1acf3d3cb6146b636c546c7406c38c49c403d4/pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f", size = 567155, upload-time = "2025-09-08T23:07:59.05Z" }, + { url = "https://files.pythonhosted.org/packages/23/6d/d8d92a0eb270a925c9b4dd039c0b4dc10abc2fcbc48331788824ef113935/pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97", size = 633428, upload-time = "2025-09-08T23:08:00.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/14/01afebc96c5abbbd713ecfc7469cfb1bc801c819a74ed5c9fad9a48801cb/pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07", size = 559497, upload-time = "2025-09-08T23:08:02.15Z" }, + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, + { url = "https://files.pythonhosted.org/packages/4c/c6/c4dcdecdbaa70969ee1fdced6d7b8f60cfabe64d25361f27ac4665a70620/pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066", size = 836265, upload-time = "2025-09-08T23:09:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/3e/79/f38c92eeaeb03a2ccc2ba9866f0439593bb08c5e3b714ac1d553e5c96e25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604", size = 800208, upload-time = "2025-09-08T23:09:51.073Z" }, + { url = "https://files.pythonhosted.org/packages/49/0e/3f0d0d335c6b3abb9b7b723776d0b21fa7f3a6c819a0db6097059aada160/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c", size = 567747, upload-time = "2025-09-08T23:09:52.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/cf/f2b3784d536250ffd4be70e049f3b60981235d70c6e8ce7e3ef21e1adb25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271", size = 747371, upload-time = "2025-09-08T23:09:54.563Z" }, + { url = "https://files.pythonhosted.org/packages/01/1b/5dbe84eefc86f48473947e2f41711aded97eecef1231f4558f1f02713c12/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355", size = 544862, upload-time = "2025-09-08T23:09:56.509Z" }, +] + +[[package]] +name = "rapidfuzz" +version = "3.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d3/28/9d808fe62375b9aab5ba92fa9b29371297b067c2790b2d7cda648b1e2f8d/rapidfuzz-3.14.3.tar.gz", hash = "sha256:2491937177868bc4b1e469087601d53f925e8d270ccc21e07404b4b5814b7b5f", size = 57863900, upload-time = "2025-11-01T11:54:52.321Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/25/5b0a33ad3332ee1213068c66f7c14e9e221be90bab434f0cb4defa9d6660/rapidfuzz-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:dea2d113e260a5da0c4003e0a5e9fdf24a9dc2bb9eaa43abd030a1e46ce7837d", size = 1953885, upload-time = "2025-11-01T11:52:47.75Z" }, + { url = "https://files.pythonhosted.org/packages/2d/ab/f1181f500c32c8fcf7c966f5920c7e56b9b1d03193386d19c956505c312d/rapidfuzz-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e6c31a4aa68cfa75d7eede8b0ed24b9e458447db604c2db53f358be9843d81d3", size = 1390200, upload-time = "2025-11-01T11:52:49.491Z" }, + { url = "https://files.pythonhosted.org/packages/14/2a/0f2de974ececad873865c6bb3ea3ad07c976ac293d5025b2d73325aac1d4/rapidfuzz-3.14.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02821366d928e68ddcb567fed8723dad7ea3a979fada6283e6914d5858674850", size = 1389319, upload-time = "2025-11-01T11:52:51.224Z" }, + { url = "https://files.pythonhosted.org/packages/ed/69/309d8f3a0bb3031fd9b667174cc4af56000645298af7c2931be5c3d14bb4/rapidfuzz-3.14.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cfe8df315ab4e6db4e1be72c5170f8e66021acde22cd2f9d04d2058a9fd8162e", size = 3178495, upload-time = "2025-11-01T11:52:53.005Z" }, + { url = "https://files.pythonhosted.org/packages/10/b7/f9c44a99269ea5bf6fd6a40b84e858414b6e241288b9f2b74af470d222b1/rapidfuzz-3.14.3-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:769f31c60cd79420188fcdb3c823227fc4a6deb35cafec9d14045c7f6743acae", size = 1228443, upload-time = "2025-11-01T11:52:54.991Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0a/3b3137abac7f19c9220e14cd7ce993e35071a7655e7ef697785a3edfea1a/rapidfuzz-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:54fa03062124e73086dae66a3451c553c1e20a39c077fd704dc7154092c34c63", size = 2411998, upload-time = "2025-11-01T11:52:56.629Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b6/983805a844d44670eaae63831024cdc97ada4e9c62abc6b20703e81e7f9b/rapidfuzz-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:834d1e818005ed0d4ae38f6b87b86fad9b0a74085467ece0727d20e15077c094", size = 2530120, upload-time = "2025-11-01T11:52:58.298Z" }, + { url = "https://files.pythonhosted.org/packages/b4/cc/2c97beb2b1be2d7595d805682472f1b1b844111027d5ad89b65e16bdbaaa/rapidfuzz-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:948b00e8476a91f510dd1ec07272efc7d78c275d83b630455559671d4e33b678", size = 4283129, upload-time = "2025-11-01T11:53:00.188Z" }, + { url = "https://files.pythonhosted.org/packages/4d/03/2f0e5e94941045aefe7eafab72320e61285c07b752df9884ce88d6b8b835/rapidfuzz-3.14.3-cp311-cp311-win32.whl", hash = "sha256:43d0305c36f504232f18ea04e55f2059bb89f169d3119c4ea96a0e15b59e2a91", size = 1724224, upload-time = "2025-11-01T11:53:02.149Z" }, + { url = "https://files.pythonhosted.org/packages/cf/99/5fa23e204435803875daefda73fd61baeabc3c36b8fc0e34c1705aab8c7b/rapidfuzz-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:ef6bf930b947bd0735c550683939a032090f1d688dfd8861d6b45307b96fd5c5", size = 1544259, upload-time = "2025-11-01T11:53:03.66Z" }, + { url = "https://files.pythonhosted.org/packages/48/35/d657b85fcc615a42661b98ac90ce8e95bd32af474603a105643963749886/rapidfuzz-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:f3eb0ff3b75d6fdccd40b55e7414bb859a1cda77c52762c9c82b85569f5088e7", size = 814734, upload-time = "2025-11-01T11:53:05.008Z" }, + { url = "https://files.pythonhosted.org/packages/fa/8e/3c215e860b458cfbedb3ed73bc72e98eb7e0ed72f6b48099604a7a3260c2/rapidfuzz-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:685c93ea961d135893b5984a5a9851637d23767feabe414ec974f43babbd8226", size = 1945306, upload-time = "2025-11-01T11:53:06.452Z" }, + { url = "https://files.pythonhosted.org/packages/36/d9/31b33512015c899f4a6e6af64df8dfe8acddf4c8b40a4b3e0e6e1bcd00e5/rapidfuzz-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fa7c8f26f009f8c673fbfb443792f0cf8cf50c4e18121ff1e285b5e08a94fbdb", size = 1390788, upload-time = "2025-11-01T11:53:08.721Z" }, + { url = "https://files.pythonhosted.org/packages/a9/67/2ee6f8de6e2081ccd560a571d9c9063184fe467f484a17fa90311a7f4a2e/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57f878330c8d361b2ce76cebb8e3e1dc827293b6abf404e67d53260d27b5d941", size = 1374580, upload-time = "2025-11-01T11:53:10.164Z" }, + { url = "https://files.pythonhosted.org/packages/30/83/80d22997acd928eda7deadc19ccd15883904622396d6571e935993e0453a/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c5f545f454871e6af05753a0172849c82feaf0f521c5ca62ba09e1b382d6382", size = 3154947, upload-time = "2025-11-01T11:53:12.093Z" }, + { url = "https://files.pythonhosted.org/packages/5b/cf/9f49831085a16384695f9fb096b99662f589e30b89b4a589a1ebc1a19d34/rapidfuzz-3.14.3-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:07aa0b5d8863e3151e05026a28e0d924accf0a7a3b605da978f0359bb804df43", size = 1223872, upload-time = "2025-11-01T11:53:13.664Z" }, + { url = "https://files.pythonhosted.org/packages/c8/0f/41ee8034e744b871c2e071ef0d360686f5ccfe5659f4fd96c3ec406b3c8b/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73b07566bc7e010e7b5bd490fb04bb312e820970180df6b5655e9e6224c137db", size = 2392512, upload-time = "2025-11-01T11:53:15.109Z" }, + { url = "https://files.pythonhosted.org/packages/da/86/280038b6b0c2ccec54fb957c732ad6b41cc1fd03b288d76545b9cf98343f/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6de00eb84c71476af7d3110cf25d8fe7c792d7f5fa86764ef0b4ca97e78ca3ed", size = 2521398, upload-time = "2025-11-01T11:53:17.146Z" }, + { url = "https://files.pythonhosted.org/packages/fa/7b/05c26f939607dca0006505e3216248ae2de631e39ef94dd63dbbf0860021/rapidfuzz-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d7843a1abf0091773a530636fdd2a49a41bcae22f9910b86b4f903e76ddc82dc", size = 4259416, upload-time = "2025-11-01T11:53:19.34Z" }, + { url = "https://files.pythonhosted.org/packages/40/eb/9e3af4103d91788f81111af1b54a28de347cdbed8eaa6c91d5e98a889aab/rapidfuzz-3.14.3-cp312-cp312-win32.whl", hash = "sha256:dea97ac3ca18cd3ba8f3d04b5c1fe4aa60e58e8d9b7793d3bd595fdb04128d7a", size = 1709527, upload-time = "2025-11-01T11:53:20.949Z" }, + { url = "https://files.pythonhosted.org/packages/b8/63/d06ecce90e2cf1747e29aeab9f823d21e5877a4c51b79720b2d3be7848f8/rapidfuzz-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:b5100fd6bcee4d27f28f4e0a1c6b5127bc8ba7c2a9959cad9eab0bf4a7ab3329", size = 1538989, upload-time = "2025-11-01T11:53:22.428Z" }, + { url = "https://files.pythonhosted.org/packages/fc/6d/beee32dcda64af8128aab3ace2ccb33d797ed58c434c6419eea015fec779/rapidfuzz-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:4e49c9e992bc5fc873bd0fff7ef16a4405130ec42f2ce3d2b735ba5d3d4eb70f", size = 811161, upload-time = "2025-11-01T11:53:23.811Z" }, + { url = "https://files.pythonhosted.org/packages/e4/4f/0d94d09646853bd26978cb3a7541b6233c5760687777fa97da8de0d9a6ac/rapidfuzz-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dbcb726064b12f356bf10fffdb6db4b6dce5390b23627c08652b3f6e49aa56ae", size = 1939646, upload-time = "2025-11-01T11:53:25.292Z" }, + { url = "https://files.pythonhosted.org/packages/b6/eb/f96aefc00f3bbdbab9c0657363ea8437a207d7545ac1c3789673e05d80bd/rapidfuzz-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1704fc70d214294e554a2421b473779bcdeef715881c5e927dc0f11e1692a0ff", size = 1385512, upload-time = "2025-11-01T11:53:27.594Z" }, + { url = "https://files.pythonhosted.org/packages/26/34/71c4f7749c12ee223dba90017a5947e8f03731a7cc9f489b662a8e9e643d/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc65e72790ddfd310c2c8912b45106e3800fefe160b0c2ef4d6b6fec4e826457", size = 1373571, upload-time = "2025-11-01T11:53:29.096Z" }, + { url = "https://files.pythonhosted.org/packages/32/00/ec8597a64f2be301ce1ee3290d067f49f6a7afb226b67d5f15b56d772ba5/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e38c1305cffae8472572a0584d4ffc2f130865586a81038ca3965301f7c97c", size = 3156759, upload-time = "2025-11-01T11:53:30.777Z" }, + { url = "https://files.pythonhosted.org/packages/61/d5/b41eeb4930501cc899d5a9a7b5c9a33d85a670200d7e81658626dcc0ecc0/rapidfuzz-3.14.3-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:e195a77d06c03c98b3fc06b8a28576ba824392ce40de8c708f96ce04849a052e", size = 1222067, upload-time = "2025-11-01T11:53:32.334Z" }, + { url = "https://files.pythonhosted.org/packages/2a/7d/6d9abb4ffd1027c6ed837b425834f3bed8344472eb3a503ab55b3407c721/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1b7ef2f4b8583a744338a18f12c69693c194fb6777c0e9ada98cd4d9e8f09d10", size = 2394775, upload-time = "2025-11-01T11:53:34.24Z" }, + { url = "https://files.pythonhosted.org/packages/15/ce/4f3ab4c401c5a55364da1ffff8cc879fc97b4e5f4fa96033827da491a973/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:a2135b138bcdcb4c3742d417f215ac2d8c2b87bde15b0feede231ae95f09ec41", size = 2526123, upload-time = "2025-11-01T11:53:35.779Z" }, + { url = "https://files.pythonhosted.org/packages/c1/4b/54f804975376a328f57293bd817c12c9036171d15cf7292032e3f5820b2d/rapidfuzz-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:33a325ed0e8e1aa20c3e75f8ab057a7b248fdea7843c2a19ade0008906c14af0", size = 4262874, upload-time = "2025-11-01T11:53:37.866Z" }, + { url = "https://files.pythonhosted.org/packages/e9/b6/958db27d8a29a50ee6edd45d33debd3ce732e7209183a72f57544cd5fe22/rapidfuzz-3.14.3-cp313-cp313-win32.whl", hash = "sha256:8383b6d0d92f6cd008f3c9216535be215a064b2cc890398a678b56e6d280cb63", size = 1707972, upload-time = "2025-11-01T11:53:39.442Z" }, + { url = "https://files.pythonhosted.org/packages/07/75/fde1f334b0cec15b5946d9f84d73250fbfcc73c236b4bc1b25129d90876b/rapidfuzz-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:e6b5e3036976f0fde888687d91be86d81f9ac5f7b02e218913c38285b756be6c", size = 1537011, upload-time = "2025-11-01T11:53:40.92Z" }, + { url = "https://files.pythonhosted.org/packages/2e/d7/d83fe001ce599dc7ead57ba1debf923dc961b6bdce522b741e6b8c82f55c/rapidfuzz-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:7ba009977601d8b0828bfac9a110b195b3e4e79b350dcfa48c11269a9f1918a0", size = 810744, upload-time = "2025-11-01T11:53:42.723Z" }, + { url = "https://files.pythonhosted.org/packages/92/13/a486369e63ff3c1a58444d16b15c5feb943edd0e6c28a1d7d67cb8946b8f/rapidfuzz-3.14.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a0a28add871425c2fe94358c6300bbeb0bc2ed828ca003420ac6825408f5a424", size = 1967702, upload-time = "2025-11-01T11:53:44.554Z" }, + { url = "https://files.pythonhosted.org/packages/f1/82/efad25e260b7810f01d6b69122685e355bed78c94a12784bac4e0beb2afb/rapidfuzz-3.14.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:010e12e2411a4854b0434f920e72b717c43f8ec48d57e7affe5c42ecfa05dd0e", size = 1410702, upload-time = "2025-11-01T11:53:46.066Z" }, + { url = "https://files.pythonhosted.org/packages/ba/1a/34c977b860cde91082eae4a97ae503f43e0d84d4af301d857679b66f9869/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cfc3d57abd83c734d1714ec39c88a34dd69c85474918ebc21296f1e61eb5ca8", size = 1382337, upload-time = "2025-11-01T11:53:47.62Z" }, + { url = "https://files.pythonhosted.org/packages/88/74/f50ea0e24a5880a9159e8fd256b84d8f4634c2f6b4f98028bdd31891d907/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89acb8cbb52904f763e5ac238083b9fc193bed8d1f03c80568b20e4cef43a519", size = 3165563, upload-time = "2025-11-01T11:53:49.216Z" }, + { url = "https://files.pythonhosted.org/packages/e8/7a/e744359404d7737049c26099423fc54bcbf303de5d870d07d2fb1410f567/rapidfuzz-3.14.3-cp313-cp313t-manylinux_2_31_armv7l.whl", hash = "sha256:7d9af908c2f371bfb9c985bd134e295038e3031e666e4b2ade1e7cb7f5af2f1a", size = 1214727, upload-time = "2025-11-01T11:53:50.883Z" }, + { url = "https://files.pythonhosted.org/packages/d3/2e/87adfe14ce75768ec6c2b8acd0e05e85e84be4be5e3d283cdae360afc4fe/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1f1925619627f8798f8c3a391d81071336942e5fe8467bc3c567f982e7ce2897", size = 2403349, upload-time = "2025-11-01T11:53:52.322Z" }, + { url = "https://files.pythonhosted.org/packages/70/17/6c0b2b2bff9c8b12e12624c07aa22e922b0c72a490f180fa9183d1ef2c75/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:152555187360978119e98ce3e8263d70dd0c40c7541193fc302e9b7125cf8f58", size = 2507596, upload-time = "2025-11-01T11:53:53.835Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d1/87852a7cbe4da7b962174c749a47433881a63a817d04f3e385ea9babcd9e/rapidfuzz-3.14.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:52619d25a09546b8db078981ca88939d72caa6b8701edd8b22e16482a38e799f", size = 4273595, upload-time = "2025-11-01T11:53:55.961Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ab/1d0354b7d1771a28fa7fe089bc23acec2bdd3756efa2419f463e3ed80e16/rapidfuzz-3.14.3-cp313-cp313t-win32.whl", hash = "sha256:489ce98a895c98cad284f0a47960c3e264c724cb4cfd47a1430fa091c0c25204", size = 1757773, upload-time = "2025-11-01T11:53:57.628Z" }, + { url = "https://files.pythonhosted.org/packages/0b/0c/71ef356adc29e2bdf74cd284317b34a16b80258fa0e7e242dd92cc1e6d10/rapidfuzz-3.14.3-cp313-cp313t-win_amd64.whl", hash = "sha256:656e52b054d5b5c2524169240e50cfa080b04b1c613c5f90a2465e84888d6f15", size = 1576797, upload-time = "2025-11-01T11:53:59.455Z" }, + { url = "https://files.pythonhosted.org/packages/fe/d2/0e64fc27bb08d4304aa3d11154eb5480bcf5d62d60140a7ee984dc07468a/rapidfuzz-3.14.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c7e40c0a0af02ad6e57e89f62bef8604f55a04ecae90b0ceeda591bbf5923317", size = 829940, upload-time = "2025-11-01T11:54:01.1Z" }, + { url = "https://files.pythonhosted.org/packages/32/6f/1b88aaeade83abc5418788f9e6b01efefcd1a69d65ded37d89cd1662be41/rapidfuzz-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:442125473b247227d3f2de807a11da6c08ccf536572d1be943f8e262bae7e4ea", size = 1942086, upload-time = "2025-11-01T11:54:02.592Z" }, + { url = "https://files.pythonhosted.org/packages/a0/2c/b23861347436cb10f46c2bd425489ec462790faaa360a54a7ede5f78de88/rapidfuzz-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ec0c8c0c3d4f97ced46b2e191e883f8c82dbbf6d5ebc1842366d7eff13cd5a6", size = 1386993, upload-time = "2025-11-01T11:54:04.12Z" }, + { url = "https://files.pythonhosted.org/packages/83/86/5d72e2c060aa1fbdc1f7362d938f6b237dff91f5b9fc5dd7cc297e112250/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2dc37bc20272f388b8c3a4eba4febc6e77e50a8f450c472def4751e7678f55e4", size = 1379126, upload-time = "2025-11-01T11:54:05.777Z" }, + { url = "https://files.pythonhosted.org/packages/c9/bc/ef2cee3e4d8b3fc22705ff519f0d487eecc756abdc7c25d53686689d6cf2/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dee362e7e79bae940a5e2b3f6d09c6554db6a4e301cc68343886c08be99844f1", size = 3159304, upload-time = "2025-11-01T11:54:07.351Z" }, + { url = "https://files.pythonhosted.org/packages/a0/36/dc5f2f62bbc7bc90be1f75eeaf49ed9502094bb19290dfb4747317b17f12/rapidfuzz-3.14.3-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:4b39921df948388a863f0e267edf2c36302983459b021ab928d4b801cbe6a421", size = 1218207, upload-time = "2025-11-01T11:54:09.641Z" }, + { url = "https://files.pythonhosted.org/packages/df/7e/8f4be75c1bc62f47edf2bbbe2370ee482fae655ebcc4718ac3827ead3904/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:beda6aa9bc44d1d81242e7b291b446be352d3451f8217fcb068fc2933927d53b", size = 2401245, upload-time = "2025-11-01T11:54:11.543Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/f7c92759e1bb188dd05b80d11c630ba59b8d7856657baf454ff56059c2ab/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6a014ba09657abfcfeed64b7d09407acb29af436d7fc075b23a298a7e4a6b41c", size = 2518308, upload-time = "2025-11-01T11:54:13.134Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ac/85820f70fed5ecb5f1d9a55f1e1e2090ef62985ef41db289b5ac5ec56e28/rapidfuzz-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:32eeafa3abce138bb725550c0e228fc7eaeec7059aa8093d9cbbec2b58c2371a", size = 4265011, upload-time = "2025-11-01T11:54:15.087Z" }, + { url = "https://files.pythonhosted.org/packages/46/a9/616930721ea9835c918af7cde22bff17f9db3639b0c1a7f96684be7f5630/rapidfuzz-3.14.3-cp314-cp314-win32.whl", hash = "sha256:adb44d996fc610c7da8c5048775b21db60dd63b1548f078e95858c05c86876a3", size = 1742245, upload-time = "2025-11-01T11:54:17.19Z" }, + { url = "https://files.pythonhosted.org/packages/06/8a/f2fa5e9635b1ccafda4accf0e38246003f69982d7c81f2faa150014525a4/rapidfuzz-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:f3d15d8527e2b293e38ce6e437631af0708df29eafd7c9fc48210854c94472f9", size = 1584856, upload-time = "2025-11-01T11:54:18.764Z" }, + { url = "https://files.pythonhosted.org/packages/ef/97/09e20663917678a6d60d8e0e29796db175b1165e2079830430342d5298be/rapidfuzz-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:576e4b9012a67e0bf54fccb69a7b6c94d4e86a9540a62f1a5144977359133583", size = 833490, upload-time = "2025-11-01T11:54:20.753Z" }, + { url = "https://files.pythonhosted.org/packages/03/1b/6b6084576ba87bf21877c77218a0c97ba98cb285b0c02eaaee3acd7c4513/rapidfuzz-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:cec3c0da88562727dd5a5a364bd9efeb535400ff0bfb1443156dd139a1dd7b50", size = 1968658, upload-time = "2025-11-01T11:54:22.25Z" }, + { url = "https://files.pythonhosted.org/packages/38/c0/fb02a0db80d95704b0a6469cc394e8c38501abf7e1c0b2afe3261d1510c2/rapidfuzz-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d1fa009f8b1100e4880868137e7bf0501422898f7674f2adcd85d5a67f041296", size = 1410742, upload-time = "2025-11-01T11:54:23.863Z" }, + { url = "https://files.pythonhosted.org/packages/a4/72/3fbf12819fc6afc8ec75a45204013b40979d068971e535a7f3512b05e765/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b86daa7419b5e8b180690efd1fdbac43ff19230803282521c5b5a9c83977655", size = 1382810, upload-time = "2025-11-01T11:54:25.571Z" }, + { url = "https://files.pythonhosted.org/packages/0f/18/0f1991d59bb7eee28922a00f79d83eafa8c7bfb4e8edebf4af2a160e7196/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7bd1816db05d6c5ffb3a4df0a2b7b56fb8c81ef584d08e37058afa217da91b1", size = 3166349, upload-time = "2025-11-01T11:54:27.195Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f0/baa958b1989c8f88c78bbb329e969440cf330b5a01a982669986495bb980/rapidfuzz-3.14.3-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:33da4bbaf44e9755b0ce192597f3bde7372fe2e381ab305f41b707a95ac57aa7", size = 1214994, upload-time = "2025-11-01T11:54:28.821Z" }, + { url = "https://files.pythonhosted.org/packages/e4/a0/cd12ec71f9b2519a3954febc5740291cceabc64c87bc6433afcb36259f3b/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3fecce764cf5a991ee2195a844196da840aba72029b2612f95ac68a8b74946bf", size = 2403919, upload-time = "2025-11-01T11:54:30.393Z" }, + { url = "https://files.pythonhosted.org/packages/0b/ce/019bd2176c1644098eced4f0595cb4b3ef52e4941ac9a5854f209d0a6e16/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:ecd7453e02cf072258c3a6b8e930230d789d5d46cc849503729f9ce475d0e785", size = 2508346, upload-time = "2025-11-01T11:54:32.048Z" }, + { url = "https://files.pythonhosted.org/packages/23/f8/be16c68e2c9e6c4f23e8f4adbb7bccc9483200087ed28ff76c5312da9b14/rapidfuzz-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea188aa00e9bcae8c8411f006a5f2f06c4607a02f24eab0d8dc58566aa911f35", size = 4274105, upload-time = "2025-11-01T11:54:33.701Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d1/5ab148e03f7e6ec8cd220ccf7af74d3aaa4de26dd96df58936beb7cba820/rapidfuzz-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:7ccbf68100c170e9a0581accbe9291850936711548c6688ce3bfb897b8c589ad", size = 1793465, upload-time = "2025-11-01T11:54:35.331Z" }, + { url = "https://files.pythonhosted.org/packages/cd/97/433b2d98e97abd9fff1c470a109b311669f44cdec8d0d5aa250aceaed1fb/rapidfuzz-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9ec02e62ae765a318d6de38df609c57fc6dacc65c0ed1fd489036834fd8a620c", size = 1623491, upload-time = "2025-11-01T11:54:38.085Z" }, + { url = "https://files.pythonhosted.org/packages/e2/f6/e2176eb94f94892441bce3ddc514c179facb65db245e7ce3356965595b19/rapidfuzz-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:e805e52322ae29aa945baf7168b6c898120fbc16d2b8f940b658a5e9e3999253", size = 851487, upload-time = "2025-11-01T11:54:40.176Z" }, + { url = "https://files.pythonhosted.org/packages/c9/33/b5bd6475c7c27164b5becc9b0e3eb978f1e3640fea590dd3dced6006ee83/rapidfuzz-3.14.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7cf174b52cb3ef5d49e45d0a1133b7e7d0ecf770ed01f97ae9962c5c91d97d23", size = 1888499, upload-time = "2025-11-01T11:54:42.094Z" }, + { url = "https://files.pythonhosted.org/packages/30/d2/89d65d4db4bb931beade9121bc71ad916b5fa9396e807d11b33731494e8e/rapidfuzz-3.14.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:442cba39957a008dfc5bdef21a9c3f4379e30ffb4e41b8555dbaf4887eca9300", size = 1336747, upload-time = "2025-11-01T11:54:43.957Z" }, + { url = "https://files.pythonhosted.org/packages/85/33/cd87d92b23f0b06e8914a61cea6850c6d495ca027f669fab7a379041827a/rapidfuzz-3.14.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1faa0f8f76ba75fd7b142c984947c280ef6558b5067af2ae9b8729b0a0f99ede", size = 1352187, upload-time = "2025-11-01T11:54:45.518Z" }, + { url = "https://files.pythonhosted.org/packages/22/20/9d30b4a1ab26aac22fff17d21dec7e9089ccddfe25151d0a8bb57001dc3d/rapidfuzz-3.14.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e6eefec45625c634926a9fd46c9e4f31118ac8f3156fff9494422cee45207e6", size = 3101472, upload-time = "2025-11-01T11:54:47.255Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ad/fa2d3e5c29a04ead7eaa731c7cd1f30f9ec3c77b3a578fdf90280797cbcb/rapidfuzz-3.14.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56fefb4382bb12250f164250240b9dd7772e41c5c8ae976fd598a32292449cc5", size = 1511361, upload-time = "2025-11-01T11:54:49.057Z" }, +] + +[[package]] +name = "referencing" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload-time = "2025-01-25T08:48:16.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775, upload-time = "2025-01-25T08:48:14.241Z" }, +] + +[[package]] +name = "regex" +version = "2025.11.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/a9/546676f25e573a4cf00fe8e119b78a37b6a8fe2dc95cda877b30889c9c45/regex-2025.11.3.tar.gz", hash = "sha256:1fedc720f9bb2494ce31a58a1631f9c82df6a09b49c19517ea5cc280b4541e01", size = 414669, upload-time = "2025-11-03T21:34:22.089Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/90/4fb5056e5f03a7048abd2b11f598d464f0c167de4f2a51aa868c376b8c70/regex-2025.11.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eadade04221641516fa25139273505a1c19f9bf97589a05bc4cfcd8b4a618031", size = 488081, upload-time = "2025-11-03T21:31:11.946Z" }, + { url = "https://files.pythonhosted.org/packages/85/23/63e481293fac8b069d84fba0299b6666df720d875110efd0338406b5d360/regex-2025.11.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:feff9e54ec0dd3833d659257f5c3f5322a12eee58ffa360984b716f8b92983f4", size = 290554, upload-time = "2025-11-03T21:31:13.387Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9d/b101d0262ea293a0066b4522dfb722eb6a8785a8c3e084396a5f2c431a46/regex-2025.11.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3b30bc921d50365775c09a7ed446359e5c0179e9e2512beec4a60cbcef6ddd50", size = 288407, upload-time = "2025-11-03T21:31:14.809Z" }, + { url = "https://files.pythonhosted.org/packages/0c/64/79241c8209d5b7e00577ec9dca35cd493cc6be35b7d147eda367d6179f6d/regex-2025.11.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f99be08cfead2020c7ca6e396c13543baea32343b7a9a5780c462e323bd8872f", size = 793418, upload-time = "2025-11-03T21:31:16.556Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e2/23cd5d3573901ce8f9757c92ca4db4d09600b865919b6d3e7f69f03b1afd/regex-2025.11.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dd329a1b61c0ee95ba95385fb0c07ea0d3fe1a21e1349fa2bec272636217118", size = 860448, upload-time = "2025-11-03T21:31:18.12Z" }, + { url = "https://files.pythonhosted.org/packages/2a/4c/aecf31beeaa416d0ae4ecb852148d38db35391aac19c687b5d56aedf3a8b/regex-2025.11.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c5238d32f3c5269d9e87be0cf096437b7622b6920f5eac4fd202468aaeb34d2", size = 907139, upload-time = "2025-11-03T21:31:20.753Z" }, + { url = "https://files.pythonhosted.org/packages/61/22/b8cb00df7d2b5e0875f60628594d44dba283e951b1ae17c12f99e332cc0a/regex-2025.11.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10483eefbfb0adb18ee9474498c9a32fcf4e594fbca0543bb94c48bac6183e2e", size = 800439, upload-time = "2025-11-03T21:31:22.069Z" }, + { url = "https://files.pythonhosted.org/packages/02/a8/c4b20330a5cdc7a8eb265f9ce593f389a6a88a0c5f280cf4d978f33966bc/regex-2025.11.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:78c2d02bb6e1da0720eedc0bad578049cad3f71050ef8cd065ecc87691bed2b0", size = 782965, upload-time = "2025-11-03T21:31:23.598Z" }, + { url = "https://files.pythonhosted.org/packages/b4/4c/ae3e52988ae74af4b04d2af32fee4e8077f26e51b62ec2d12d246876bea2/regex-2025.11.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e6b49cd2aad93a1790ce9cffb18964f6d3a4b0b3dbdbd5de094b65296fce6e58", size = 854398, upload-time = "2025-11-03T21:31:25.008Z" }, + { url = "https://files.pythonhosted.org/packages/06/d1/a8b9cf45874eda14b2e275157ce3b304c87e10fb38d9fc26a6e14eb18227/regex-2025.11.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:885b26aa3ee56433b630502dc3d36ba78d186a00cc535d3806e6bfd9ed3c70ab", size = 845897, upload-time = "2025-11-03T21:31:26.427Z" }, + { url = "https://files.pythonhosted.org/packages/ea/fe/1830eb0236be93d9b145e0bd8ab499f31602fe0999b1f19e99955aa8fe20/regex-2025.11.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ddd76a9f58e6a00f8772e72cff8ebcff78e022be95edf018766707c730593e1e", size = 788906, upload-time = "2025-11-03T21:31:28.078Z" }, + { url = "https://files.pythonhosted.org/packages/66/47/dc2577c1f95f188c1e13e2e69d8825a5ac582ac709942f8a03af42ed6e93/regex-2025.11.3-cp311-cp311-win32.whl", hash = "sha256:3e816cc9aac1cd3cc9a4ec4d860f06d40f994b5c7b4d03b93345f44e08cc68bf", size = 265812, upload-time = "2025-11-03T21:31:29.72Z" }, + { url = "https://files.pythonhosted.org/packages/50/1e/15f08b2f82a9bbb510621ec9042547b54d11e83cb620643ebb54e4eb7d71/regex-2025.11.3-cp311-cp311-win_amd64.whl", hash = "sha256:087511f5c8b7dfbe3a03f5d5ad0c2a33861b1fc387f21f6f60825a44865a385a", size = 277737, upload-time = "2025-11-03T21:31:31.422Z" }, + { url = "https://files.pythonhosted.org/packages/f4/fc/6500eb39f5f76c5e47a398df82e6b535a5e345f839581012a418b16f9cc3/regex-2025.11.3-cp311-cp311-win_arm64.whl", hash = "sha256:1ff0d190c7f68ae7769cd0313fe45820ba07ffebfddfaa89cc1eb70827ba0ddc", size = 270290, upload-time = "2025-11-03T21:31:33.041Z" }, + { url = "https://files.pythonhosted.org/packages/e8/74/18f04cb53e58e3fb107439699bd8375cf5a835eec81084e0bddbd122e4c2/regex-2025.11.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bc8ab71e2e31b16e40868a40a69007bc305e1109bd4658eb6cad007e0bf67c41", size = 489312, upload-time = "2025-11-03T21:31:34.343Z" }, + { url = "https://files.pythonhosted.org/packages/78/3f/37fcdd0d2b1e78909108a876580485ea37c91e1acf66d3bb8e736348f441/regex-2025.11.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:22b29dda7e1f7062a52359fca6e58e548e28c6686f205e780b02ad8ef710de36", size = 291256, upload-time = "2025-11-03T21:31:35.675Z" }, + { url = "https://files.pythonhosted.org/packages/bf/26/0a575f58eb23b7ebd67a45fccbc02ac030b737b896b7e7a909ffe43ffd6a/regex-2025.11.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a91e4a29938bc1a082cc28fdea44be420bf2bebe2665343029723892eb073e1", size = 288921, upload-time = "2025-11-03T21:31:37.07Z" }, + { url = "https://files.pythonhosted.org/packages/ea/98/6a8dff667d1af907150432cf5abc05a17ccd32c72a3615410d5365ac167a/regex-2025.11.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:08b884f4226602ad40c5d55f52bf91a9df30f513864e0054bad40c0e9cf1afb7", size = 798568, upload-time = "2025-11-03T21:31:38.784Z" }, + { url = "https://files.pythonhosted.org/packages/64/15/92c1db4fa4e12733dd5a526c2dd2b6edcbfe13257e135fc0f6c57f34c173/regex-2025.11.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3e0b11b2b2433d1c39c7c7a30e3f3d0aeeea44c2a8d0bae28f6b95f639927a69", size = 864165, upload-time = "2025-11-03T21:31:40.559Z" }, + { url = "https://files.pythonhosted.org/packages/f9/e7/3ad7da8cdee1ce66c7cd37ab5ab05c463a86ffeb52b1a25fe7bd9293b36c/regex-2025.11.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:87eb52a81ef58c7ba4d45c3ca74e12aa4b4e77816f72ca25258a85b3ea96cb48", size = 912182, upload-time = "2025-11-03T21:31:42.002Z" }, + { url = "https://files.pythonhosted.org/packages/84/bd/9ce9f629fcb714ffc2c3faf62b6766ecb7a585e1e885eb699bcf130a5209/regex-2025.11.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a12ab1f5c29b4e93db518f5e3872116b7e9b1646c9f9f426f777b50d44a09e8c", size = 803501, upload-time = "2025-11-03T21:31:43.815Z" }, + { url = "https://files.pythonhosted.org/packages/7c/0f/8dc2e4349d8e877283e6edd6c12bdcebc20f03744e86f197ab6e4492bf08/regex-2025.11.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7521684c8c7c4f6e88e35ec89680ee1aa8358d3f09d27dfbdf62c446f5d4c695", size = 787842, upload-time = "2025-11-03T21:31:45.353Z" }, + { url = "https://files.pythonhosted.org/packages/f9/73/cff02702960bc185164d5619c0c62a2f598a6abff6695d391b096237d4ab/regex-2025.11.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7fe6e5440584e94cc4b3f5f4d98a25e29ca12dccf8873679a635638349831b98", size = 858519, upload-time = "2025-11-03T21:31:46.814Z" }, + { url = "https://files.pythonhosted.org/packages/61/83/0e8d1ae71e15bc1dc36231c90b46ee35f9d52fab2e226b0e039e7ea9c10a/regex-2025.11.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:8e026094aa12b43f4fd74576714e987803a315c76edb6b098b9809db5de58f74", size = 850611, upload-time = "2025-11-03T21:31:48.289Z" }, + { url = "https://files.pythonhosted.org/packages/c8/f5/70a5cdd781dcfaa12556f2955bf170cd603cb1c96a1827479f8faea2df97/regex-2025.11.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:435bbad13e57eb5606a68443af62bed3556de2f46deb9f7d4237bc2f1c9fb3a0", size = 789759, upload-time = "2025-11-03T21:31:49.759Z" }, + { url = "https://files.pythonhosted.org/packages/59/9b/7c29be7903c318488983e7d97abcf8ebd3830e4c956c4c540005fcfb0462/regex-2025.11.3-cp312-cp312-win32.whl", hash = "sha256:3839967cf4dc4b985e1570fd8d91078f0c519f30491c60f9ac42a8db039be204", size = 266194, upload-time = "2025-11-03T21:31:51.53Z" }, + { url = "https://files.pythonhosted.org/packages/1a/67/3b92df89f179d7c367be654ab5626ae311cb28f7d5c237b6bb976cd5fbbb/regex-2025.11.3-cp312-cp312-win_amd64.whl", hash = "sha256:e721d1b46e25c481dc5ded6f4b3f66c897c58d2e8cfdf77bbced84339108b0b9", size = 277069, upload-time = "2025-11-03T21:31:53.151Z" }, + { url = "https://files.pythonhosted.org/packages/d7/55/85ba4c066fe5094d35b249c3ce8df0ba623cfd35afb22d6764f23a52a1c5/regex-2025.11.3-cp312-cp312-win_arm64.whl", hash = "sha256:64350685ff08b1d3a6fff33f45a9ca183dc1d58bbfe4981604e70ec9801bbc26", size = 270330, upload-time = "2025-11-03T21:31:54.514Z" }, + { url = "https://files.pythonhosted.org/packages/e1/a7/dda24ebd49da46a197436ad96378f17df30ceb40e52e859fc42cac45b850/regex-2025.11.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c1e448051717a334891f2b9a620fe36776ebf3dd8ec46a0b877c8ae69575feb4", size = 489081, upload-time = "2025-11-03T21:31:55.9Z" }, + { url = "https://files.pythonhosted.org/packages/19/22/af2dc751aacf88089836aa088a1a11c4f21a04707eb1b0478e8e8fb32847/regex-2025.11.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9b5aca4d5dfd7fbfbfbdaf44850fcc7709a01146a797536a8f84952e940cca76", size = 291123, upload-time = "2025-11-03T21:31:57.758Z" }, + { url = "https://files.pythonhosted.org/packages/a3/88/1a3ea5672f4b0a84802ee9891b86743438e7c04eb0b8f8c4e16a42375327/regex-2025.11.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:04d2765516395cf7dda331a244a3282c0f5ae96075f728629287dfa6f76ba70a", size = 288814, upload-time = "2025-11-03T21:32:01.12Z" }, + { url = "https://files.pythonhosted.org/packages/fb/8c/f5987895bf42b8ddeea1b315c9fedcfe07cadee28b9c98cf50d00adcb14d/regex-2025.11.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d9903ca42bfeec4cebedba8022a7c97ad2aab22e09573ce9976ba01b65e4361", size = 798592, upload-time = "2025-11-03T21:32:03.006Z" }, + { url = "https://files.pythonhosted.org/packages/99/2a/6591ebeede78203fa77ee46a1c36649e02df9eaa77a033d1ccdf2fcd5d4e/regex-2025.11.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:639431bdc89d6429f6721625e8129413980ccd62e9d3f496be618a41d205f160", size = 864122, upload-time = "2025-11-03T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/94/d6/be32a87cf28cf8ed064ff281cfbd49aefd90242a83e4b08b5a86b38e8eb4/regex-2025.11.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f117efad42068f9715677c8523ed2be1518116d1c49b1dd17987716695181efe", size = 912272, upload-time = "2025-11-03T21:32:06.148Z" }, + { url = "https://files.pythonhosted.org/packages/62/11/9bcef2d1445665b180ac7f230406ad80671f0fc2a6ffb93493b5dd8cd64c/regex-2025.11.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4aecb6f461316adf9f1f0f6a4a1a3d79e045f9b71ec76055a791affa3b285850", size = 803497, upload-time = "2025-11-03T21:32:08.162Z" }, + { url = "https://files.pythonhosted.org/packages/e5/a7/da0dc273d57f560399aa16d8a68ae7f9b57679476fc7ace46501d455fe84/regex-2025.11.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3b3a5f320136873cc5561098dfab677eea139521cb9a9e8db98b7e64aef44cbc", size = 787892, upload-time = "2025-11-03T21:32:09.769Z" }, + { url = "https://files.pythonhosted.org/packages/da/4b/732a0c5a9736a0b8d6d720d4945a2f1e6f38f87f48f3173559f53e8d5d82/regex-2025.11.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:75fa6f0056e7efb1f42a1c34e58be24072cb9e61a601340cc1196ae92326a4f9", size = 858462, upload-time = "2025-11-03T21:32:11.769Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f5/a2a03df27dc4c2d0c769220f5110ba8c4084b0bfa9ab0f9b4fcfa3d2b0fc/regex-2025.11.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:dbe6095001465294f13f1adcd3311e50dd84e5a71525f20a10bd16689c61ce0b", size = 850528, upload-time = "2025-11-03T21:32:13.906Z" }, + { url = "https://files.pythonhosted.org/packages/d6/09/e1cd5bee3841c7f6eb37d95ca91cdee7100b8f88b81e41c2ef426910891a/regex-2025.11.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:454d9b4ae7881afbc25015b8627c16d88a597479b9dea82b8c6e7e2e07240dc7", size = 789866, upload-time = "2025-11-03T21:32:15.748Z" }, + { url = "https://files.pythonhosted.org/packages/eb/51/702f5ea74e2a9c13d855a6a85b7f80c30f9e72a95493260193c07f3f8d74/regex-2025.11.3-cp313-cp313-win32.whl", hash = "sha256:28ba4d69171fc6e9896337d4fc63a43660002b7da53fc15ac992abcf3410917c", size = 266189, upload-time = "2025-11-03T21:32:17.493Z" }, + { url = "https://files.pythonhosted.org/packages/8b/00/6e29bb314e271a743170e53649db0fdb8e8ff0b64b4f425f5602f4eb9014/regex-2025.11.3-cp313-cp313-win_amd64.whl", hash = "sha256:bac4200befe50c670c405dc33af26dad5a3b6b255dd6c000d92fe4629f9ed6a5", size = 277054, upload-time = "2025-11-03T21:32:19.042Z" }, + { url = "https://files.pythonhosted.org/packages/25/f1/b156ff9f2ec9ac441710764dda95e4edaf5f36aca48246d1eea3f1fd96ec/regex-2025.11.3-cp313-cp313-win_arm64.whl", hash = "sha256:2292cd5a90dab247f9abe892ac584cb24f0f54680c73fcb4a7493c66c2bf2467", size = 270325, upload-time = "2025-11-03T21:32:21.338Z" }, + { url = "https://files.pythonhosted.org/packages/20/28/fd0c63357caefe5680b8ea052131acbd7f456893b69cc2a90cc3e0dc90d4/regex-2025.11.3-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1eb1ebf6822b756c723e09f5186473d93236c06c579d2cc0671a722d2ab14281", size = 491984, upload-time = "2025-11-03T21:32:23.466Z" }, + { url = "https://files.pythonhosted.org/packages/df/ec/7014c15626ab46b902b3bcc4b28a7bae46d8f281fc7ea9c95e22fcaaa917/regex-2025.11.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1e00ec2970aab10dc5db34af535f21fcf32b4a31d99e34963419636e2f85ae39", size = 292673, upload-time = "2025-11-03T21:32:25.034Z" }, + { url = "https://files.pythonhosted.org/packages/23/ab/3b952ff7239f20d05f1f99e9e20188513905f218c81d52fb5e78d2bf7634/regex-2025.11.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a4cb042b615245d5ff9b3794f56be4138b5adc35a4166014d31d1814744148c7", size = 291029, upload-time = "2025-11-03T21:32:26.528Z" }, + { url = "https://files.pythonhosted.org/packages/21/7e/3dc2749fc684f455f162dcafb8a187b559e2614f3826877d3844a131f37b/regex-2025.11.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:44f264d4bf02f3176467d90b294d59bf1db9fe53c141ff772f27a8b456b2a9ed", size = 807437, upload-time = "2025-11-03T21:32:28.363Z" }, + { url = "https://files.pythonhosted.org/packages/1b/0b/d529a85ab349c6a25d1ca783235b6e3eedf187247eab536797021f7126c6/regex-2025.11.3-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7be0277469bf3bd7a34a9c57c1b6a724532a0d235cd0dc4e7f4316f982c28b19", size = 873368, upload-time = "2025-11-03T21:32:30.4Z" }, + { url = "https://files.pythonhosted.org/packages/7d/18/2d868155f8c9e3e9d8f9e10c64e9a9f496bb8f7e037a88a8bed26b435af6/regex-2025.11.3-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d31e08426ff4b5b650f68839f5af51a92a5b51abd8554a60c2fbc7c71f25d0b", size = 914921, upload-time = "2025-11-03T21:32:32.123Z" }, + { url = "https://files.pythonhosted.org/packages/2d/71/9d72ff0f354fa783fe2ba913c8734c3b433b86406117a8db4ea2bf1c7a2f/regex-2025.11.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e43586ce5bd28f9f285a6e729466841368c4a0353f6fd08d4ce4630843d3648a", size = 812708, upload-time = "2025-11-03T21:32:34.305Z" }, + { url = "https://files.pythonhosted.org/packages/e7/19/ce4bf7f5575c97f82b6e804ffb5c4e940c62609ab2a0d9538d47a7fdf7d4/regex-2025.11.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:0f9397d561a4c16829d4e6ff75202c1c08b68a3bdbfe29dbfcdb31c9830907c6", size = 795472, upload-time = "2025-11-03T21:32:36.364Z" }, + { url = "https://files.pythonhosted.org/packages/03/86/fd1063a176ffb7b2315f9a1b08d17b18118b28d9df163132615b835a26ee/regex-2025.11.3-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:dd16e78eb18ffdb25ee33a0682d17912e8cc8a770e885aeee95020046128f1ce", size = 868341, upload-time = "2025-11-03T21:32:38.042Z" }, + { url = "https://files.pythonhosted.org/packages/12/43/103fb2e9811205e7386366501bc866a164a0430c79dd59eac886a2822950/regex-2025.11.3-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:ffcca5b9efe948ba0661e9df0fa50d2bc4b097c70b9810212d6b62f05d83b2dd", size = 854666, upload-time = "2025-11-03T21:32:40.079Z" }, + { url = "https://files.pythonhosted.org/packages/7d/22/e392e53f3869b75804762c7c848bd2dd2abf2b70fb0e526f58724638bd35/regex-2025.11.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c56b4d162ca2b43318ac671c65bd4d563e841a694ac70e1a976ac38fcf4ca1d2", size = 799473, upload-time = "2025-11-03T21:32:42.148Z" }, + { url = "https://files.pythonhosted.org/packages/4f/f9/8bd6b656592f925b6845fcbb4d57603a3ac2fb2373344ffa1ed70aa6820a/regex-2025.11.3-cp313-cp313t-win32.whl", hash = "sha256:9ddc42e68114e161e51e272f667d640f97e84a2b9ef14b7477c53aac20c2d59a", size = 268792, upload-time = "2025-11-03T21:32:44.13Z" }, + { url = "https://files.pythonhosted.org/packages/e5/87/0e7d603467775ff65cd2aeabf1b5b50cc1c3708556a8b849a2fa4dd1542b/regex-2025.11.3-cp313-cp313t-win_amd64.whl", hash = "sha256:7a7c7fdf755032ffdd72c77e3d8096bdcb0eb92e89e17571a196f03d88b11b3c", size = 280214, upload-time = "2025-11-03T21:32:45.853Z" }, + { url = "https://files.pythonhosted.org/packages/8d/d0/2afc6f8e94e2b64bfb738a7c2b6387ac1699f09f032d363ed9447fd2bb57/regex-2025.11.3-cp313-cp313t-win_arm64.whl", hash = "sha256:df9eb838c44f570283712e7cff14c16329a9f0fb19ca492d21d4b7528ee6821e", size = 271469, upload-time = "2025-11-03T21:32:48.026Z" }, + { url = "https://files.pythonhosted.org/packages/31/e9/f6e13de7e0983837f7b6d238ad9458800a874bf37c264f7923e63409944c/regex-2025.11.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9697a52e57576c83139d7c6f213d64485d3df5bf84807c35fa409e6c970801c6", size = 489089, upload-time = "2025-11-03T21:32:50.027Z" }, + { url = "https://files.pythonhosted.org/packages/a3/5c/261f4a262f1fa65141c1b74b255988bd2fa020cc599e53b080667d591cfc/regex-2025.11.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e18bc3f73bd41243c9b38a6d9f2366cd0e0137a9aebe2d8ff76c5b67d4c0a3f4", size = 291059, upload-time = "2025-11-03T21:32:51.682Z" }, + { url = "https://files.pythonhosted.org/packages/8e/57/f14eeb7f072b0e9a5a090d1712741fd8f214ec193dba773cf5410108bb7d/regex-2025.11.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:61a08bcb0ec14ff4e0ed2044aad948d0659604f824cbd50b55e30b0ec6f09c73", size = 288900, upload-time = "2025-11-03T21:32:53.569Z" }, + { url = "https://files.pythonhosted.org/packages/3c/6b/1d650c45e99a9b327586739d926a1cd4e94666b1bd4af90428b36af66dc7/regex-2025.11.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9c30003b9347c24bcc210958c5d167b9e4f9be786cb380a7d32f14f9b84674f", size = 799010, upload-time = "2025-11-03T21:32:55.222Z" }, + { url = "https://files.pythonhosted.org/packages/99/ee/d66dcbc6b628ce4e3f7f0cbbb84603aa2fc0ffc878babc857726b8aab2e9/regex-2025.11.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4e1e592789704459900728d88d41a46fe3969b82ab62945560a31732ffc19a6d", size = 864893, upload-time = "2025-11-03T21:32:57.239Z" }, + { url = "https://files.pythonhosted.org/packages/bf/2d/f238229f1caba7ac87a6c4153d79947fb0261415827ae0f77c304260c7d3/regex-2025.11.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6538241f45eb5a25aa575dbba1069ad786f68a4f2773a29a2bd3dd1f9de787be", size = 911522, upload-time = "2025-11-03T21:32:59.274Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3d/22a4eaba214a917c80e04f6025d26143690f0419511e0116508e24b11c9b/regex-2025.11.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bce22519c989bb72a7e6b36a199384c53db7722fe669ba891da75907fe3587db", size = 803272, upload-time = "2025-11-03T21:33:01.393Z" }, + { url = "https://files.pythonhosted.org/packages/84/b1/03188f634a409353a84b5ef49754b97dbcc0c0f6fd6c8ede505a8960a0a4/regex-2025.11.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:66d559b21d3640203ab9075797a55165d79017520685fb407b9234d72ab63c62", size = 787958, upload-time = "2025-11-03T21:33:03.379Z" }, + { url = "https://files.pythonhosted.org/packages/99/6a/27d072f7fbf6fadd59c64d210305e1ff865cc3b78b526fd147db768c553b/regex-2025.11.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:669dcfb2e38f9e8c69507bace46f4889e3abbfd9b0c29719202883c0a603598f", size = 859289, upload-time = "2025-11-03T21:33:05.374Z" }, + { url = "https://files.pythonhosted.org/packages/9a/70/1b3878f648e0b6abe023172dacb02157e685564853cc363d9961bcccde4e/regex-2025.11.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:32f74f35ff0f25a5021373ac61442edcb150731fbaa28286bbc8bb1582c89d02", size = 850026, upload-time = "2025-11-03T21:33:07.131Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d5/68e25559b526b8baab8e66839304ede68ff6727237a47727d240006bd0ff/regex-2025.11.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e6c7a21dffba883234baefe91bc3388e629779582038f75d2a5be918e250f0ed", size = 789499, upload-time = "2025-11-03T21:33:09.141Z" }, + { url = "https://files.pythonhosted.org/packages/fc/df/43971264857140a350910d4e33df725e8c94dd9dee8d2e4729fa0d63d49e/regex-2025.11.3-cp314-cp314-win32.whl", hash = "sha256:795ea137b1d809eb6836b43748b12634291c0ed55ad50a7d72d21edf1cd565c4", size = 271604, upload-time = "2025-11-03T21:33:10.9Z" }, + { url = "https://files.pythonhosted.org/packages/01/6f/9711b57dc6894a55faf80a4c1b5aa4f8649805cb9c7aef46f7d27e2b9206/regex-2025.11.3-cp314-cp314-win_amd64.whl", hash = "sha256:9f95fbaa0ee1610ec0fc6b26668e9917a582ba80c52cc6d9ada15e30aa9ab9ad", size = 280320, upload-time = "2025-11-03T21:33:12.572Z" }, + { url = "https://files.pythonhosted.org/packages/f1/7e/f6eaa207d4377481f5e1775cdeb5a443b5a59b392d0065f3417d31d80f87/regex-2025.11.3-cp314-cp314-win_arm64.whl", hash = "sha256:dfec44d532be4c07088c3de2876130ff0fbeeacaa89a137decbbb5f665855a0f", size = 273372, upload-time = "2025-11-03T21:33:14.219Z" }, + { url = "https://files.pythonhosted.org/packages/c3/06/49b198550ee0f5e4184271cee87ba4dfd9692c91ec55289e6282f0f86ccf/regex-2025.11.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ba0d8a5d7f04f73ee7d01d974d47c5834f8a1b0224390e4fe7c12a3a92a78ecc", size = 491985, upload-time = "2025-11-03T21:33:16.555Z" }, + { url = "https://files.pythonhosted.org/packages/ce/bf/abdafade008f0b1c9da10d934034cb670432d6cf6cbe38bbb53a1cfd6cf8/regex-2025.11.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:442d86cf1cfe4faabf97db7d901ef58347efd004934da045c745e7b5bd57ac49", size = 292669, upload-time = "2025-11-03T21:33:18.32Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ef/0c357bb8edbd2ad8e273fcb9e1761bc37b8acbc6e1be050bebd6475f19c1/regex-2025.11.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:fd0a5e563c756de210bb964789b5abe4f114dacae9104a47e1a649b910361536", size = 291030, upload-time = "2025-11-03T21:33:20.048Z" }, + { url = "https://files.pythonhosted.org/packages/79/06/edbb67257596649b8fb088d6aeacbcb248ac195714b18a65e018bf4c0b50/regex-2025.11.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf3490bcbb985a1ae97b2ce9ad1c0f06a852d5b19dde9b07bdf25bf224248c95", size = 807674, upload-time = "2025-11-03T21:33:21.797Z" }, + { url = "https://files.pythonhosted.org/packages/f4/d9/ad4deccfce0ea336296bd087f1a191543bb99ee1c53093dcd4c64d951d00/regex-2025.11.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3809988f0a8b8c9dcc0f92478d6501fac7200b9ec56aecf0ec21f4a2ec4b6009", size = 873451, upload-time = "2025-11-03T21:33:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/13/75/a55a4724c56ef13e3e04acaab29df26582f6978c000ac9cd6810ad1f341f/regex-2025.11.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f4ff94e58e84aedb9c9fce66d4ef9f27a190285b451420f297c9a09f2b9abee9", size = 914980, upload-time = "2025-11-03T21:33:25.999Z" }, + { url = "https://files.pythonhosted.org/packages/67/1e/a1657ee15bd9116f70d4a530c736983eed997b361e20ecd8f5ca3759d5c5/regex-2025.11.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eb542fd347ce61e1321b0a6b945d5701528dca0cd9759c2e3bb8bd57e47964d", size = 812852, upload-time = "2025-11-03T21:33:27.852Z" }, + { url = "https://files.pythonhosted.org/packages/b8/6f/f7516dde5506a588a561d296b2d0044839de06035bb486b326065b4c101e/regex-2025.11.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6c2d5919075a1f2e413c00b056ea0c2f065b3f5fe83c3d07d325ab92dce51d6", size = 795566, upload-time = "2025-11-03T21:33:32.364Z" }, + { url = "https://files.pythonhosted.org/packages/d9/dd/3d10b9e170cc16fb34cb2cef91513cf3df65f440b3366030631b2984a264/regex-2025.11.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3f8bf11a4827cc7ce5a53d4ef6cddd5ad25595d3c1435ef08f76825851343154", size = 868463, upload-time = "2025-11-03T21:33:34.459Z" }, + { url = "https://files.pythonhosted.org/packages/f5/8e/935e6beff1695aa9085ff83195daccd72acc82c81793df480f34569330de/regex-2025.11.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:22c12d837298651e5550ac1d964e4ff57c3f56965fc1812c90c9fb2028eaf267", size = 854694, upload-time = "2025-11-03T21:33:36.793Z" }, + { url = "https://files.pythonhosted.org/packages/92/12/10650181a040978b2f5720a6a74d44f841371a3d984c2083fc1752e4acf6/regex-2025.11.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:62ba394a3dda9ad41c7c780f60f6e4a70988741415ae96f6d1bf6c239cf01379", size = 799691, upload-time = "2025-11-03T21:33:39.079Z" }, + { url = "https://files.pythonhosted.org/packages/67/90/8f37138181c9a7690e7e4cb388debbd389342db3c7381d636d2875940752/regex-2025.11.3-cp314-cp314t-win32.whl", hash = "sha256:4bf146dca15cdd53224a1bf46d628bd7590e4a07fbb69e720d561aea43a32b38", size = 274583, upload-time = "2025-11-03T21:33:41.302Z" }, + { url = "https://files.pythonhosted.org/packages/8f/cd/867f5ec442d56beb56f5f854f40abcfc75e11d10b11fdb1869dd39c63aaf/regex-2025.11.3-cp314-cp314t-win_amd64.whl", hash = "sha256:adad1a1bcf1c9e76346e091d22d23ac54ef28e1365117d99521631078dfec9de", size = 284286, upload-time = "2025-11-03T21:33:43.324Z" }, + { url = "https://files.pythonhosted.org/packages/20/31/32c0c4610cbc070362bf1d2e4ea86d1ea29014d400a6d6c2486fcfd57766/regex-2025.11.3-cp314-cp314t-win_arm64.whl", hash = "sha256:c54f768482cef41e219720013cd05933b6f971d9562544d691c68699bf2b6801", size = 274741, upload-time = "2025-11-03T21:33:45.557Z" }, +] + +[[package]] +name = "requests" +version = "2.33.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" }, +] + +[[package]] +name = "rich" +version = "14.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" }, +] + +[[package]] +name = "rich-rst" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "rich" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bc/6d/a506aaa4a9eaa945ed8ab2b7347859f53593864289853c5d6d62b77246e0/rich_rst-1.3.2.tar.gz", hash = "sha256:a1196fdddf1e364b02ec68a05e8ff8f6914fee10fbca2e6b6735f166bb0da8d4", size = 14936, upload-time = "2025-10-14T16:49:45.332Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/2f/b4530fbf948867702d0a3f27de4a6aab1d156f406d72852ab902c4d04de9/rich_rst-1.3.2-py3-none-any.whl", hash = "sha256:a99b4907cbe118cf9d18b0b44de272efa61f15117c61e39ebdc431baf5df722a", size = 12567, upload-time = "2025-10-14T16:49:42.953Z" }, +] + +[[package]] +name = "rpds-py" +version = "0.29.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/98/33/23b3b3419b6a3e0f559c7c0d2ca8fc1b9448382b25245033788785921332/rpds_py-0.29.0.tar.gz", hash = "sha256:fe55fe686908f50154d1dc599232016e50c243b438c3b7432f24e2895b0e5359", size = 69359, upload-time = "2025-11-16T14:50:39.532Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/ab/7fb95163a53ab122c74a7c42d2d2f012819af2cf3deb43fb0d5acf45cc1a/rpds_py-0.29.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:9b9c764a11fd637e0322a488560533112837f5334ffeb48b1be20f6d98a7b437", size = 372344, upload-time = "2025-11-16T14:47:57.279Z" }, + { url = "https://files.pythonhosted.org/packages/b3/45/f3c30084c03b0d0f918cb4c5ae2c20b0a148b51ba2b3f6456765b629bedd/rpds_py-0.29.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3fd2164d73812026ce970d44c3ebd51e019d2a26a4425a5dcbdfa93a34abc383", size = 363041, upload-time = "2025-11-16T14:47:58.908Z" }, + { url = "https://files.pythonhosted.org/packages/e3/e9/4d044a1662608c47a87cbb37b999d4d5af54c6d6ebdda93a4d8bbf8b2a10/rpds_py-0.29.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a097b7f7f7274164566ae90a221fd725363c0e9d243e2e9ed43d195ccc5495c", size = 391775, upload-time = "2025-11-16T14:48:00.197Z" }, + { url = "https://files.pythonhosted.org/packages/50/c9/7616d3ace4e6731aeb6e3cd85123e03aec58e439044e214b9c5c60fd8eb1/rpds_py-0.29.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7cdc0490374e31cedefefaa1520d5fe38e82fde8748cbc926e7284574c714d6b", size = 405624, upload-time = "2025-11-16T14:48:01.496Z" }, + { url = "https://files.pythonhosted.org/packages/c2/e2/6d7d6941ca0843609fd2d72c966a438d6f22617baf22d46c3d2156c31350/rpds_py-0.29.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:89ca2e673ddd5bde9b386da9a0aac0cab0e76f40c8f0aaf0d6311b6bbf2aa311", size = 527894, upload-time = "2025-11-16T14:48:03.167Z" }, + { url = "https://files.pythonhosted.org/packages/8d/f7/aee14dc2db61bb2ae1e3068f134ca9da5f28c586120889a70ff504bb026f/rpds_py-0.29.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a5d9da3ff5af1ca1249b1adb8ef0573b94c76e6ae880ba1852f033bf429d4588", size = 412720, upload-time = "2025-11-16T14:48:04.413Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e2/2293f236e887c0360c2723d90c00d48dee296406994d6271faf1712e94ec/rpds_py-0.29.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8238d1d310283e87376c12f658b61e1ee23a14c0e54c7c0ce953efdbdc72deed", size = 392945, upload-time = "2025-11-16T14:48:06.252Z" }, + { url = "https://files.pythonhosted.org/packages/14/cd/ceea6147acd3bd1fd028d1975228f08ff19d62098078d5ec3eed49703797/rpds_py-0.29.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:2d6fb2ad1c36f91c4646989811e84b1ea5e0c3cf9690b826b6e32b7965853a63", size = 406385, upload-time = "2025-11-16T14:48:07.575Z" }, + { url = "https://files.pythonhosted.org/packages/52/36/fe4dead19e45eb77a0524acfdbf51e6cda597b26fc5b6dddbff55fbbb1a5/rpds_py-0.29.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:534dc9df211387547267ccdb42253aa30527482acb38dd9b21c5c115d66a96d2", size = 423943, upload-time = "2025-11-16T14:48:10.175Z" }, + { url = "https://files.pythonhosted.org/packages/a1/7b/4551510803b582fa4abbc8645441a2d15aa0c962c3b21ebb380b7e74f6a1/rpds_py-0.29.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d456e64724a075441e4ed648d7f154dc62e9aabff29bcdf723d0c00e9e1d352f", size = 574204, upload-time = "2025-11-16T14:48:11.499Z" }, + { url = "https://files.pythonhosted.org/packages/64/ba/071ccdd7b171e727a6ae079f02c26f75790b41555f12ca8f1151336d2124/rpds_py-0.29.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a738f2da2f565989401bd6fd0b15990a4d1523c6d7fe83f300b7e7d17212feca", size = 600587, upload-time = "2025-11-16T14:48:12.822Z" }, + { url = "https://files.pythonhosted.org/packages/03/09/96983d48c8cf5a1e03c7d9cc1f4b48266adfb858ae48c7c2ce978dbba349/rpds_py-0.29.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a110e14508fd26fd2e472bb541f37c209409876ba601cf57e739e87d8a53cf95", size = 562287, upload-time = "2025-11-16T14:48:14.108Z" }, + { url = "https://files.pythonhosted.org/packages/40/f0/8c01aaedc0fa92156f0391f39ea93b5952bc0ec56b897763858f95da8168/rpds_py-0.29.0-cp311-cp311-win32.whl", hash = "sha256:923248a56dd8d158389a28934f6f69ebf89f218ef96a6b216a9be6861804d3f4", size = 221394, upload-time = "2025-11-16T14:48:15.374Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a5/a8b21c54c7d234efdc83dc034a4d7cd9668e3613b6316876a29b49dece71/rpds_py-0.29.0-cp311-cp311-win_amd64.whl", hash = "sha256:539eb77eb043afcc45314d1be09ea6d6cafb3addc73e0547c171c6d636957f60", size = 235713, upload-time = "2025-11-16T14:48:16.636Z" }, + { url = "https://files.pythonhosted.org/packages/a7/1f/df3c56219523947b1be402fa12e6323fe6d61d883cf35d6cb5d5bb6db9d9/rpds_py-0.29.0-cp311-cp311-win_arm64.whl", hash = "sha256:bdb67151ea81fcf02d8f494703fb728d4d34d24556cbff5f417d74f6f5792e7c", size = 229157, upload-time = "2025-11-16T14:48:17.891Z" }, + { url = "https://files.pythonhosted.org/packages/3c/50/bc0e6e736d94e420df79be4deb5c9476b63165c87bb8f19ef75d100d21b3/rpds_py-0.29.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a0891cfd8db43e085c0ab93ab7e9b0c8fee84780d436d3b266b113e51e79f954", size = 376000, upload-time = "2025-11-16T14:48:19.141Z" }, + { url = "https://files.pythonhosted.org/packages/3e/3a/46676277160f014ae95f24de53bed0e3b7ea66c235e7de0b9df7bd5d68ba/rpds_py-0.29.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3897924d3f9a0361472d884051f9a2460358f9a45b1d85a39a158d2f8f1ad71c", size = 360575, upload-time = "2025-11-16T14:48:20.443Z" }, + { url = "https://files.pythonhosted.org/packages/75/ba/411d414ed99ea1afdd185bbabeeaac00624bd1e4b22840b5e9967ade6337/rpds_py-0.29.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2a21deb8e0d1571508c6491ce5ea5e25669b1dd4adf1c9d64b6314842f708b5d", size = 392159, upload-time = "2025-11-16T14:48:22.12Z" }, + { url = "https://files.pythonhosted.org/packages/8f/b1/e18aa3a331f705467a48d0296778dc1fea9d7f6cf675bd261f9a846c7e90/rpds_py-0.29.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9efe71687d6427737a0a2de9ca1c0a216510e6cd08925c44162be23ed7bed2d5", size = 410602, upload-time = "2025-11-16T14:48:23.563Z" }, + { url = "https://files.pythonhosted.org/packages/2f/6c/04f27f0c9f2299274c76612ac9d2c36c5048bb2c6c2e52c38c60bf3868d9/rpds_py-0.29.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:40f65470919dc189c833e86b2c4bd21bd355f98436a2cef9e0a9a92aebc8e57e", size = 515808, upload-time = "2025-11-16T14:48:24.949Z" }, + { url = "https://files.pythonhosted.org/packages/83/56/a8412aa464fb151f8bc0d91fb0bb888adc9039bd41c1c6ba8d94990d8cf8/rpds_py-0.29.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:def48ff59f181130f1a2cb7c517d16328efac3ec03951cca40c1dc2049747e83", size = 416015, upload-time = "2025-11-16T14:48:26.782Z" }, + { url = "https://files.pythonhosted.org/packages/04/4c/f9b8a05faca3d9e0a6397c90d13acb9307c9792b2bff621430c58b1d6e76/rpds_py-0.29.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad7bd570be92695d89285a4b373006930715b78d96449f686af422debb4d3949", size = 395325, upload-time = "2025-11-16T14:48:28.055Z" }, + { url = "https://files.pythonhosted.org/packages/34/60/869f3bfbf8ed7b54f1ad9a5543e0fdffdd40b5a8f587fe300ee7b4f19340/rpds_py-0.29.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:5a572911cd053137bbff8e3a52d31c5d2dba51d3a67ad902629c70185f3f2181", size = 410160, upload-time = "2025-11-16T14:48:29.338Z" }, + { url = "https://files.pythonhosted.org/packages/91/aa/e5b496334e3aba4fe4c8a80187b89f3c1294c5c36f2a926da74338fa5a73/rpds_py-0.29.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d583d4403bcbf10cffc3ab5cee23d7643fcc960dff85973fd3c2d6c86e8dbb0c", size = 425309, upload-time = "2025-11-16T14:48:30.691Z" }, + { url = "https://files.pythonhosted.org/packages/85/68/4e24a34189751ceb6d66b28f18159922828dd84155876551f7ca5b25f14f/rpds_py-0.29.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:070befbb868f257d24c3bb350dbd6e2f645e83731f31264b19d7231dd5c396c7", size = 574644, upload-time = "2025-11-16T14:48:31.964Z" }, + { url = "https://files.pythonhosted.org/packages/8c/cf/474a005ea4ea9c3b4f17b6108b6b13cebfc98ebaff11d6e1b193204b3a93/rpds_py-0.29.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:fc935f6b20b0c9f919a8ff024739174522abd331978f750a74bb68abd117bd19", size = 601605, upload-time = "2025-11-16T14:48:33.252Z" }, + { url = "https://files.pythonhosted.org/packages/f4/b1/c56f6a9ab8c5f6bb5c65c4b5f8229167a3a525245b0773f2c0896686b64e/rpds_py-0.29.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8c5a8ecaa44ce2d8d9d20a68a2483a74c07f05d72e94a4dff88906c8807e77b0", size = 564593, upload-time = "2025-11-16T14:48:34.643Z" }, + { url = "https://files.pythonhosted.org/packages/b3/13/0494cecce4848f68501e0a229432620b4b57022388b071eeff95f3e1e75b/rpds_py-0.29.0-cp312-cp312-win32.whl", hash = "sha256:ba5e1aeaf8dd6d8f6caba1f5539cddda87d511331714b7b5fc908b6cfc3636b7", size = 223853, upload-time = "2025-11-16T14:48:36.419Z" }, + { url = "https://files.pythonhosted.org/packages/1f/6a/51e9aeb444a00cdc520b032a28b07e5f8dc7bc328b57760c53e7f96997b4/rpds_py-0.29.0-cp312-cp312-win_amd64.whl", hash = "sha256:b5f6134faf54b3cb83375db0f113506f8b7770785be1f95a631e7e2892101977", size = 239895, upload-time = "2025-11-16T14:48:37.956Z" }, + { url = "https://files.pythonhosted.org/packages/d1/d4/8bce56cdad1ab873e3f27cb31c6a51d8f384d66b022b820525b879f8bed1/rpds_py-0.29.0-cp312-cp312-win_arm64.whl", hash = "sha256:b016eddf00dca7944721bf0cd85b6af7f6c4efaf83ee0b37c4133bd39757a8c7", size = 230321, upload-time = "2025-11-16T14:48:39.71Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d9/c5de60d9d371bbb186c3e9bf75f4fc5665e11117a25a06a6b2e0afb7380e/rpds_py-0.29.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1585648d0760b88292eecab5181f5651111a69d90eff35d6b78aa32998886a61", size = 375710, upload-time = "2025-11-16T14:48:41.063Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b3/0860cdd012291dc21272895ce107f1e98e335509ba986dd83d72658b82b9/rpds_py-0.29.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:521807963971a23996ddaf764c682b3e46459b3c58ccd79fefbe16718db43154", size = 360582, upload-time = "2025-11-16T14:48:42.423Z" }, + { url = "https://files.pythonhosted.org/packages/92/8a/a18c2f4a61b3407e56175f6aab6deacdf9d360191a3d6f38566e1eaf7266/rpds_py-0.29.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a8896986efaa243ab713c69e6491a4138410f0fe36f2f4c71e18bd5501e8014", size = 391172, upload-time = "2025-11-16T14:48:43.75Z" }, + { url = "https://files.pythonhosted.org/packages/fd/49/e93354258508c50abc15cdcd5fcf7ac4117f67bb6233ad7859f75e7372a0/rpds_py-0.29.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1d24564a700ef41480a984c5ebed62b74e6ce5860429b98b1fede76049e953e6", size = 409586, upload-time = "2025-11-16T14:48:45.498Z" }, + { url = "https://files.pythonhosted.org/packages/5a/8d/a27860dae1c19a6bdc901f90c81f0d581df1943355802961a57cdb5b6cd1/rpds_py-0.29.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e6596b93c010d386ae46c9fba9bfc9fc5965fa8228edeac51576299182c2e31c", size = 516339, upload-time = "2025-11-16T14:48:47.308Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ad/a75e603161e79b7110c647163d130872b271c6b28712c803c65d492100f7/rpds_py-0.29.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5cc58aac218826d054c7da7f95821eba94125d88be673ff44267bb89d12a5866", size = 416201, upload-time = "2025-11-16T14:48:48.615Z" }, + { url = "https://files.pythonhosted.org/packages/b9/42/555b4ee17508beafac135c8b450816ace5a96194ce97fefc49d58e5652ea/rpds_py-0.29.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de73e40ebc04dd5d9556f50180395322193a78ec247e637e741c1b954810f295", size = 395095, upload-time = "2025-11-16T14:48:50.027Z" }, + { url = "https://files.pythonhosted.org/packages/cd/f0/c90b671b9031e800ec45112be42ea9f027f94f9ac25faaac8770596a16a1/rpds_py-0.29.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:295ce5ac7f0cf69a651ea75c8f76d02a31f98e5698e82a50a5f4d4982fbbae3b", size = 410077, upload-time = "2025-11-16T14:48:51.515Z" }, + { url = "https://files.pythonhosted.org/packages/3d/80/9af8b640b81fe21e6f718e9dec36c0b5f670332747243130a5490f292245/rpds_py-0.29.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1ea59b23ea931d494459c8338056fe7d93458c0bf3ecc061cd03916505369d55", size = 424548, upload-time = "2025-11-16T14:48:53.237Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0b/b5647446e991736e6a495ef510e6710df91e880575a586e763baeb0aa770/rpds_py-0.29.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f49d41559cebd608042fdcf54ba597a4a7555b49ad5c1c0c03e0af82692661cd", size = 573661, upload-time = "2025-11-16T14:48:54.769Z" }, + { url = "https://files.pythonhosted.org/packages/f7/b3/1b1c9576839ff583d1428efbf59f9ee70498d8ce6c0b328ac02f1e470879/rpds_py-0.29.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:05a2bd42768ea988294ca328206efbcc66e220d2d9b7836ee5712c07ad6340ea", size = 600937, upload-time = "2025-11-16T14:48:56.247Z" }, + { url = "https://files.pythonhosted.org/packages/6c/7b/b6cfca2f9fee4c4494ce54f7fb1b9f578867495a9aa9fc0d44f5f735c8e0/rpds_py-0.29.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:33ca7bdfedd83339ca55da3a5e1527ee5870d4b8369456b5777b197756f3ca22", size = 564496, upload-time = "2025-11-16T14:48:57.691Z" }, + { url = "https://files.pythonhosted.org/packages/b9/fb/ba29ec7f0f06eb801bac5a23057a9ff7670623b5e8013bd59bec4aa09de8/rpds_py-0.29.0-cp313-cp313-win32.whl", hash = "sha256:20c51ae86a0bb9accc9ad4e6cdeec58d5ebb7f1b09dd4466331fc65e1766aae7", size = 223126, upload-time = "2025-11-16T14:48:59.058Z" }, + { url = "https://files.pythonhosted.org/packages/3c/6b/0229d3bed4ddaa409e6d90b0ae967ed4380e4bdd0dad6e59b92c17d42457/rpds_py-0.29.0-cp313-cp313-win_amd64.whl", hash = "sha256:6410e66f02803600edb0b1889541f4b5cc298a5ccda0ad789cc50ef23b54813e", size = 239771, upload-time = "2025-11-16T14:49:00.872Z" }, + { url = "https://files.pythonhosted.org/packages/e4/38/d2868f058b164f8efd89754d85d7b1c08b454f5c07ac2e6cc2e9bd4bd05b/rpds_py-0.29.0-cp313-cp313-win_arm64.whl", hash = "sha256:56838e1cd9174dc23c5691ee29f1d1be9eab357f27efef6bded1328b23e1ced2", size = 229994, upload-time = "2025-11-16T14:49:02.673Z" }, + { url = "https://files.pythonhosted.org/packages/52/91/5de91c5ec7d41759beec9b251630824dbb8e32d20c3756da1a9a9d309709/rpds_py-0.29.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:37d94eadf764d16b9a04307f2ab1d7af6dc28774bbe0535c9323101e14877b4c", size = 365886, upload-time = "2025-11-16T14:49:04.133Z" }, + { url = "https://files.pythonhosted.org/packages/85/7c/415d8c1b016d5f47ecec5145d9d6d21002d39dce8761b30f6c88810b455a/rpds_py-0.29.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d472cf73efe5726a067dce63eebe8215b14beabea7c12606fd9994267b3cfe2b", size = 355262, upload-time = "2025-11-16T14:49:05.543Z" }, + { url = "https://files.pythonhosted.org/packages/3d/14/bf83e2daa4f980e4dc848aed9299792a8b84af95e12541d9e7562f84a6ef/rpds_py-0.29.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:72fdfd5ff8992e4636621826371e3ac5f3e3b8323e9d0e48378e9c13c3dac9d0", size = 384826, upload-time = "2025-11-16T14:49:07.301Z" }, + { url = "https://files.pythonhosted.org/packages/33/b8/53330c50a810ae22b4fbba5e6cf961b68b9d72d9bd6780a7c0a79b070857/rpds_py-0.29.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2549d833abdf8275c901313b9e8ff8fba57e50f6a495035a2a4e30621a2f7cc4", size = 394234, upload-time = "2025-11-16T14:49:08.782Z" }, + { url = "https://files.pythonhosted.org/packages/cc/32/01e2e9645cef0e584f518cfde4567563e57db2257244632b603f61b40e50/rpds_py-0.29.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4448dad428f28a6a767c3e3b80cde3446a22a0efbddaa2360f4bb4dc836d0688", size = 520008, upload-time = "2025-11-16T14:49:10.253Z" }, + { url = "https://files.pythonhosted.org/packages/98/c3/0d1b95a81affae2b10f950782e33a1fd2edd6ce2a479966cac98c9a66f57/rpds_py-0.29.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:115f48170fd4296a33938d8c11f697f5f26e0472e43d28f35624764173a60e4d", size = 409569, upload-time = "2025-11-16T14:49:12.478Z" }, + { url = "https://files.pythonhosted.org/packages/fa/60/aa3b8678f3f009f675b99174fa2754302a7fbfe749162e8043d111de2d88/rpds_py-0.29.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e5bb73ffc029820f4348e9b66b3027493ae00bca6629129cd433fd7a76308ee", size = 385188, upload-time = "2025-11-16T14:49:13.88Z" }, + { url = "https://files.pythonhosted.org/packages/92/02/5546c1c8aa89c18d40c1fcffdcc957ba730dee53fb7c3ca3a46f114761d2/rpds_py-0.29.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:b1581fcde18fcdf42ea2403a16a6b646f8eb1e58d7f90a0ce693da441f76942e", size = 398587, upload-time = "2025-11-16T14:49:15.339Z" }, + { url = "https://files.pythonhosted.org/packages/6c/e0/ad6eeaf47e236eba052fa34c4073078b9e092bd44da6bbb35aaae9580669/rpds_py-0.29.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16e9da2bda9eb17ea318b4c335ec9ac1818e88922cbe03a5743ea0da9ecf74fb", size = 416641, upload-time = "2025-11-16T14:49:16.832Z" }, + { url = "https://files.pythonhosted.org/packages/1a/93/0acedfd50ad9cdd3879c615a6dc8c5f1ce78d2fdf8b87727468bb5bb4077/rpds_py-0.29.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:28fd300326dd21198f311534bdb6d7e989dd09b3418b3a91d54a0f384c700967", size = 566683, upload-time = "2025-11-16T14:49:18.342Z" }, + { url = "https://files.pythonhosted.org/packages/62/53/8c64e0f340a9e801459fc6456821abc15b3582cb5dc3932d48705a9d9ac7/rpds_py-0.29.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:2aba991e041d031c7939e1358f583ae405a7bf04804ca806b97a5c0e0af1ea5e", size = 592730, upload-time = "2025-11-16T14:49:19.767Z" }, + { url = "https://files.pythonhosted.org/packages/85/ef/3109b6584f8c4b0d2490747c916df833c127ecfa82be04d9a40a376f2090/rpds_py-0.29.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f437026dbbc3f08c99cc41a5b2570c6e1a1ddbe48ab19a9b814254128d4ea7a", size = 557361, upload-time = "2025-11-16T14:49:21.574Z" }, + { url = "https://files.pythonhosted.org/packages/ff/3b/61586475e82d57f01da2c16edb9115a618afe00ce86fe1b58936880b15af/rpds_py-0.29.0-cp313-cp313t-win32.whl", hash = "sha256:6e97846e9800a5d0fe7be4d008f0c93d0feeb2700da7b1f7528dabafb31dfadb", size = 211227, upload-time = "2025-11-16T14:49:23.03Z" }, + { url = "https://files.pythonhosted.org/packages/3b/3a/12dc43f13594a54ea0c9d7e9d43002116557330e3ad45bc56097ddf266e2/rpds_py-0.29.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f49196aec7c4b406495f60e6f947ad71f317a765f956d74bbd83996b9edc0352", size = 225248, upload-time = "2025-11-16T14:49:24.841Z" }, + { url = "https://files.pythonhosted.org/packages/89/b1/0b1474e7899371d9540d3bbb2a499a3427ae1fc39c998563fe9035a1073b/rpds_py-0.29.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:394d27e4453d3b4d82bb85665dc1fcf4b0badc30fc84282defed71643b50e1a1", size = 363731, upload-time = "2025-11-16T14:49:26.683Z" }, + { url = "https://files.pythonhosted.org/packages/28/12/3b7cf2068d0a334ed1d7b385a9c3c8509f4c2bcba3d4648ea71369de0881/rpds_py-0.29.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:55d827b2ae95425d3be9bc9a5838b6c29d664924f98146557f7715e331d06df8", size = 354343, upload-time = "2025-11-16T14:49:28.24Z" }, + { url = "https://files.pythonhosted.org/packages/eb/73/5afcf8924bc02a749416eda64e17ac9c9b28f825f4737385295a0e99b0c1/rpds_py-0.29.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc31a07ed352e5462d3ee1b22e89285f4ce97d5266f6d1169da1142e78045626", size = 385406, upload-time = "2025-11-16T14:49:29.943Z" }, + { url = "https://files.pythonhosted.org/packages/c8/37/5db736730662508535221737a21563591b6f43c77f2e388951c42f143242/rpds_py-0.29.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c4695dd224212f6105db7ea62197144230b808d6b2bba52238906a2762f1d1e7", size = 396162, upload-time = "2025-11-16T14:49:31.833Z" }, + { url = "https://files.pythonhosted.org/packages/70/0d/491c1017d14f62ce7bac07c32768d209a50ec567d76d9f383b4cfad19b80/rpds_py-0.29.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcae1770b401167f8b9e1e3f566562e6966ffa9ce63639916248a9e25fa8a244", size = 517719, upload-time = "2025-11-16T14:49:33.804Z" }, + { url = "https://files.pythonhosted.org/packages/d7/25/b11132afcb17cd5d82db173f0c8dab270ffdfaba43e5ce7a591837ae9649/rpds_py-0.29.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:90f30d15f45048448b8da21c41703b31c61119c06c216a1bf8c245812a0f0c17", size = 409498, upload-time = "2025-11-16T14:49:35.222Z" }, + { url = "https://files.pythonhosted.org/packages/0f/7d/e6543cedfb2e6403a1845710a5ab0e0ccf8fc288e0b5af9a70bfe2c12053/rpds_py-0.29.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:44a91e0ab77bdc0004b43261a4b8cd6d6b451e8d443754cfda830002b5745b32", size = 382743, upload-time = "2025-11-16T14:49:36.704Z" }, + { url = "https://files.pythonhosted.org/packages/75/11/a4ebc9f654293ae9fefb83b2b6be7f3253e85ea42a5db2f77d50ad19aaeb/rpds_py-0.29.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:4aa195e5804d32c682e453b34474f411ca108e4291c6a0f824ebdc30a91c973c", size = 400317, upload-time = "2025-11-16T14:49:39.132Z" }, + { url = "https://files.pythonhosted.org/packages/52/18/97677a60a81c7f0e5f64e51fb3f8271c5c8fcabf3a2df18e97af53d7c2bf/rpds_py-0.29.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7971bdb7bf4ee0f7e6f67fa4c7fbc6019d9850cc977d126904392d363f6f8318", size = 416979, upload-time = "2025-11-16T14:49:40.575Z" }, + { url = "https://files.pythonhosted.org/packages/f0/69/28ab391a9968f6c746b2a2db181eaa4d16afaa859fedc9c2f682d19f7e18/rpds_py-0.29.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8ae33ad9ce580c7a47452c3b3f7d8a9095ef6208e0a0c7e4e2384f9fc5bf8212", size = 567288, upload-time = "2025-11-16T14:49:42.24Z" }, + { url = "https://files.pythonhosted.org/packages/3b/d3/0c7afdcdb830eee94f5611b64e71354ffe6ac8df82d00c2faf2bfffd1d4e/rpds_py-0.29.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:c661132ab2fb4eeede2ef69670fd60da5235209874d001a98f1542f31f2a8a94", size = 593157, upload-time = "2025-11-16T14:49:43.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ac/a0fcbc2feed4241cf26d32268c195eb88ddd4bd862adfc9d4b25edfba535/rpds_py-0.29.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:bb78b3a0d31ac1bde132c67015a809948db751cb4e92cdb3f0b242e430b6ed0d", size = 554741, upload-time = "2025-11-16T14:49:45.557Z" }, + { url = "https://files.pythonhosted.org/packages/0f/f1/fcc24137c470df8588674a677f33719d5800ec053aaacd1de8a5d5d84d9e/rpds_py-0.29.0-cp314-cp314-win32.whl", hash = "sha256:f475f103488312e9bd4000bc890a95955a07b2d0b6e8884aef4be56132adbbf1", size = 215508, upload-time = "2025-11-16T14:49:47.562Z" }, + { url = "https://files.pythonhosted.org/packages/7b/c7/1d169b2045512eac019918fc1021ea07c30e84a4343f9f344e3e0aa8c788/rpds_py-0.29.0-cp314-cp314-win_amd64.whl", hash = "sha256:b9cf2359a4fca87cfb6801fae83a76aedf66ee1254a7a151f1341632acf67f1b", size = 228125, upload-time = "2025-11-16T14:49:49.064Z" }, + { url = "https://files.pythonhosted.org/packages/be/36/0cec88aaba70ec4a6e381c444b0d916738497d27f0c30406e3d9fcbd3bc2/rpds_py-0.29.0-cp314-cp314-win_arm64.whl", hash = "sha256:9ba8028597e824854f0f1733d8b964e914ae3003b22a10c2c664cb6927e0feb9", size = 221992, upload-time = "2025-11-16T14:49:50.777Z" }, + { url = "https://files.pythonhosted.org/packages/b1/fa/a2e524631717c9c0eb5d90d30f648cfba6b731047821c994acacb618406c/rpds_py-0.29.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:e71136fd0612556b35c575dc2726ae04a1669e6a6c378f2240312cf5d1a2ab10", size = 366425, upload-time = "2025-11-16T14:49:52.691Z" }, + { url = "https://files.pythonhosted.org/packages/a2/a4/6d43ebe0746ff694a30233f63f454aed1677bd50ab7a59ff6b2bb5ac61f2/rpds_py-0.29.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:76fe96632d53f3bf0ea31ede2f53bbe3540cc2736d4aec3b3801b0458499ef3a", size = 355282, upload-time = "2025-11-16T14:49:54.292Z" }, + { url = "https://files.pythonhosted.org/packages/fa/a7/52fd8270e0320b09eaf295766ae81dd175f65394687906709b3e75c71d06/rpds_py-0.29.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9459a33f077130dbb2c7c3cea72ee9932271fb3126404ba2a2661e4fe9eb7b79", size = 384968, upload-time = "2025-11-16T14:49:55.857Z" }, + { url = "https://files.pythonhosted.org/packages/f4/7d/e6bc526b7a14e1ef80579a52c1d4ad39260a058a51d66c6039035d14db9d/rpds_py-0.29.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5c9546cfdd5d45e562cc0444b6dddc191e625c62e866bf567a2c69487c7ad28a", size = 394714, upload-time = "2025-11-16T14:49:57.343Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3f/f0ade3954e7db95c791e7eaf978aa7e08a756d2046e8bdd04d08146ed188/rpds_py-0.29.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12597d11d97b8f7e376c88929a6e17acb980e234547c92992f9f7c058f1a7310", size = 520136, upload-time = "2025-11-16T14:49:59.162Z" }, + { url = "https://files.pythonhosted.org/packages/87/b3/07122ead1b97009715ab9d4082be6d9bd9546099b2b03fae37c3116f72be/rpds_py-0.29.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28de03cf48b8a9e6ec10318f2197b83946ed91e2891f651a109611be4106ac4b", size = 409250, upload-time = "2025-11-16T14:50:00.698Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c6/dcbee61fd1dc892aedcb1b489ba661313101aa82ec84b1a015d4c63ebfda/rpds_py-0.29.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd7951c964069039acc9d67a8ff1f0a7f34845ae180ca542b17dc1456b1f1808", size = 384940, upload-time = "2025-11-16T14:50:02.312Z" }, + { url = "https://files.pythonhosted.org/packages/47/11/914ecb6f3574cf9bf8b38aced4063e0f787d6e1eb30b181a7efbc6c1da9a/rpds_py-0.29.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:c07d107b7316088f1ac0177a7661ca0c6670d443f6fe72e836069025e6266761", size = 399392, upload-time = "2025-11-16T14:50:03.829Z" }, + { url = "https://files.pythonhosted.org/packages/f5/fd/2f4bd9433f58f816434bb934313584caa47dbc6f03ce5484df8ac8980561/rpds_py-0.29.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1de2345af363d25696969befc0c1688a6cb5e8b1d32b515ef84fc245c6cddba3", size = 416796, upload-time = "2025-11-16T14:50:05.558Z" }, + { url = "https://files.pythonhosted.org/packages/79/a5/449f0281af33efa29d5c71014399d74842342ae908d8cd38260320167692/rpds_py-0.29.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:00e56b12d2199ca96068057e1ae7f9998ab6e99cda82431afafd32f3ec98cca9", size = 566843, upload-time = "2025-11-16T14:50:07.243Z" }, + { url = "https://files.pythonhosted.org/packages/ab/32/0a6a1ccee2e37fcb1b7ba9afde762b77182dbb57937352a729c6cd3cf2bb/rpds_py-0.29.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3919a3bbecee589300ed25000b6944174e07cd20db70552159207b3f4bbb45b8", size = 593956, upload-time = "2025-11-16T14:50:09.029Z" }, + { url = "https://files.pythonhosted.org/packages/4a/3d/eb820f95dce4306f07a495ede02fb61bef36ea201d9137d4fcd5ab94ec1e/rpds_py-0.29.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7fa2ccc312bbd91e43aa5e0869e46bc03278a3dddb8d58833150a18b0f0283a", size = 557288, upload-time = "2025-11-16T14:50:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/e9/f8/b8ff786f40470462a252918e0836e0db903c28e88e3eec66bc4a7856ee5d/rpds_py-0.29.0-cp314-cp314t-win32.whl", hash = "sha256:97c817863ffc397f1e6a6e9d2d89fe5408c0a9922dac0329672fb0f35c867ea5", size = 211382, upload-time = "2025-11-16T14:50:12.827Z" }, + { url = "https://files.pythonhosted.org/packages/c9/7f/1a65ae870bc9d0576aebb0c501ea5dccf1ae2178fe2821042150ebd2e707/rpds_py-0.29.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2023473f444752f0f82a58dfcbee040d0a1b3d1b3c2ec40e884bd25db6d117d2", size = 225919, upload-time = "2025-11-16T14:50:14.734Z" }, + { url = "https://files.pythonhosted.org/packages/f2/ac/b97e80bf107159e5b9ba9c91df1ab95f69e5e41b435f27bdd737f0d583ac/rpds_py-0.29.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:acd82a9e39082dc5f4492d15a6b6c8599aa21db5c35aaf7d6889aea16502c07d", size = 373963, upload-time = "2025-11-16T14:50:16.205Z" }, + { url = "https://files.pythonhosted.org/packages/40/5a/55e72962d5d29bd912f40c594e68880d3c7a52774b0f75542775f9250712/rpds_py-0.29.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:715b67eac317bf1c7657508170a3e011a1ea6ccb1c9d5f296e20ba14196be6b3", size = 364644, upload-time = "2025-11-16T14:50:18.22Z" }, + { url = "https://files.pythonhosted.org/packages/99/2a/6b6524d0191b7fc1351c3c0840baac42250515afb48ae40c7ed15499a6a2/rpds_py-0.29.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3b1b87a237cb2dba4db18bcfaaa44ba4cd5936b91121b62292ff21df577fc43", size = 393847, upload-time = "2025-11-16T14:50:20.012Z" }, + { url = "https://files.pythonhosted.org/packages/1c/b8/c5692a7df577b3c0c7faed7ac01ee3c608b81750fc5d89f84529229b6873/rpds_py-0.29.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1c3c3e8101bb06e337c88eb0c0ede3187131f19d97d43ea0e1c5407ea74c0cbf", size = 407281, upload-time = "2025-11-16T14:50:21.64Z" }, + { url = "https://files.pythonhosted.org/packages/f0/57/0546c6f84031b7ea08b76646a8e33e45607cc6bd879ff1917dc077bb881e/rpds_py-0.29.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2b8e54d6e61f3ecd3abe032065ce83ea63417a24f437e4a3d73d2f85ce7b7cfe", size = 529213, upload-time = "2025-11-16T14:50:23.219Z" }, + { url = "https://files.pythonhosted.org/packages/fa/c1/01dd5f444233605555bc11fe5fed6a5c18f379f02013870c176c8e630a23/rpds_py-0.29.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3fbd4e9aebf110473a420dea85a238b254cf8a15acb04b22a5a6b5ce8925b760", size = 413808, upload-time = "2025-11-16T14:50:25.262Z" }, + { url = "https://files.pythonhosted.org/packages/aa/0a/60f98b06156ea2a7af849fb148e00fbcfdb540909a5174a5ed10c93745c7/rpds_py-0.29.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80fdf53d36e6c72819993e35d1ebeeb8e8fc688d0c6c2b391b55e335b3afba5a", size = 394600, upload-time = "2025-11-16T14:50:26.956Z" }, + { url = "https://files.pythonhosted.org/packages/37/f1/dc9312fc9bec040ece08396429f2bd9e0977924ba7a11c5ad7056428465e/rpds_py-0.29.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:ea7173df5d86f625f8dde6d5929629ad811ed8decda3b60ae603903839ac9ac0", size = 408634, upload-time = "2025-11-16T14:50:28.989Z" }, + { url = "https://files.pythonhosted.org/packages/ed/41/65024c9fd40c89bb7d604cf73beda4cbdbcebe92d8765345dd65855b6449/rpds_py-0.29.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:76054d540061eda273274f3d13a21a4abdde90e13eaefdc205db37c05230efce", size = 426064, upload-time = "2025-11-16T14:50:30.674Z" }, + { url = "https://files.pythonhosted.org/packages/a2/e0/cf95478881fc88ca2fdbf56381d7df36567cccc39a05394beac72182cd62/rpds_py-0.29.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:9f84c549746a5be3bc7415830747a3a0312573afc9f95785eb35228bb17742ec", size = 575871, upload-time = "2025-11-16T14:50:33.428Z" }, + { url = "https://files.pythonhosted.org/packages/ea/c0/df88097e64339a0218b57bd5f9ca49898e4c394db756c67fccc64add850a/rpds_py-0.29.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:0ea962671af5cb9a260489e311fa22b2e97103e3f9f0caaea6f81390af96a9ed", size = 601702, upload-time = "2025-11-16T14:50:36.051Z" }, + { url = "https://files.pythonhosted.org/packages/87/f4/09ffb3ebd0cbb9e2c7c9b84d252557ecf434cd71584ee1e32f66013824df/rpds_py-0.29.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:f7728653900035fb7b8d06e1e5900545d8088efc9d5d4545782da7df03ec803f", size = 564054, upload-time = "2025-11-16T14:50:37.733Z" }, +] + +[[package]] +name = "ruff" +version = "0.15.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/99/43/3291f1cc9106f4c63bdce7a8d0df5047fe8422a75b091c16b5e9355e0b11/ruff-0.15.12.tar.gz", hash = "sha256:ecea26adb26b4232c0c2ca19ccbc0083a68344180bba2a600605538ce51a40a6", size = 4643852, upload-time = "2026-04-24T18:17:14.305Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/6e/e78ffb61d4686f3d96ba3df2c801161843746dcbcbb17a1e927d4829312b/ruff-0.15.12-py3-none-linux_armv6l.whl", hash = "sha256:f86f176e188e94d6bdbc09f09bfd9dc729059ad93d0e7390b5a73efe19f8861c", size = 10640713, upload-time = "2026-04-24T18:17:22.841Z" }, + { url = "https://files.pythonhosted.org/packages/ae/08/a317bc231fb9e7b93e4ef3089501e51922ff88d6936ce5cf870c4fe55419/ruff-0.15.12-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e3bcd123364c3770b8e1b7baaf343cc99a35f197c5c6e8af79015c666c423a6c", size = 11069267, upload-time = "2026-04-24T18:17:30.105Z" }, + { url = "https://files.pythonhosted.org/packages/aa/a4/f828e9718d3dce1f5f11c39c4f65afd32783c8b2aebb2e3d259e492c47bd/ruff-0.15.12-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fe87510d000220aa1ed530d4448a7c696a0cae1213e5ec30e5874287b66557b5", size = 10397182, upload-time = "2026-04-24T18:17:07.177Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/3310fc6d1b5e1fdea22bf3b1b807c7e187b581021b0d7d4514cccdb5fb71/ruff-0.15.12-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:84a1630093121375a3e2a95b4a6dc7b59e2b4ee76216e32d81aae550a832d002", size = 10758012, upload-time = "2026-04-24T18:16:55.759Z" }, + { url = "https://files.pythonhosted.org/packages/11/c1/a606911aee04c324ddaa883ae418f3569792fd3c4a10c50e0dd0a2311e1e/ruff-0.15.12-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fb129f40f114f089ebe0ca56c0d251cf2061b17651d464bb6478dc01e69f11f5", size = 10447479, upload-time = "2026-04-24T18:16:51.677Z" }, + { url = "https://files.pythonhosted.org/packages/9d/68/4201e8444f0894f21ab4aeeaee68aa4f10b51613514a20d80bd628d57e88/ruff-0.15.12-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b0c862b172d695db7598426b8af465e7e9ac00a3ea2a3630ee67eb82e366aaa6", size = 11234040, upload-time = "2026-04-24T18:17:16.529Z" }, + { url = "https://files.pythonhosted.org/packages/34/ff/8a6d6cf4ccc23fd67060874e832c18919d1557a0611ebef03fdb01fff11e/ruff-0.15.12-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2849ea9f3484c3aca43a82f484210370319e7170df4dfe4843395ddf6c57bc33", size = 12087377, upload-time = "2026-04-24T18:17:04.944Z" }, + { url = "https://files.pythonhosted.org/packages/85/f6/c669cf73f5152f623d34e69866a46d5e6185816b19fcd5b6dd8a2d299922/ruff-0.15.12-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e77c7e51c07fe396826d5969a5b846d9cd4c402535835fb6e21ce8b28fef847", size = 11367784, upload-time = "2026-04-24T18:17:25.409Z" }, + { url = "https://files.pythonhosted.org/packages/e8/39/c61d193b8a1daaa8977f7dea9e8d8ba866e02ea7b65d32f6861693aa4c12/ruff-0.15.12-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:83b2f4f2f3b1026b5fb449b467d9264bf22067b600f7b6f41fc5958909f449d0", size = 11344088, upload-time = "2026-04-24T18:17:12.258Z" }, + { url = "https://files.pythonhosted.org/packages/c2/8d/49afab3645e31e12c590acb6d3b5b69d7aab5b81926dbaf7461f9441f37a/ruff-0.15.12-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:9ba3b8f1afd7e2e43d8943e55f249e13f9682fde09711644a6e7290eb4f3e339", size = 11271770, upload-time = "2026-04-24T18:17:02.457Z" }, + { url = "https://files.pythonhosted.org/packages/46/06/33f41fe94403e2b755481cdfb9b7ef3e4e0ed031c4581124658d935d52b4/ruff-0.15.12-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e852ba9fdc890655e1d78f2df1499efbe0e54126bd405362154a75e2bde159c5", size = 10719355, upload-time = "2026-04-24T18:17:27.648Z" }, + { url = "https://files.pythonhosted.org/packages/0d/59/18aa4e014debbf559670e4048e39260a85c7fcee84acfd761ac01e7b8d35/ruff-0.15.12-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:dd8aed930da53780d22fc70bdf84452c843cf64f8cb4eb38984319c24c5cd5fd", size = 10462758, upload-time = "2026-04-24T18:17:32.347Z" }, + { url = "https://files.pythonhosted.org/packages/25/e7/cc9f16fd0f3b5fddcbd7ec3d6ae30c8f3fde1047f32a4093a98d633c6570/ruff-0.15.12-py3-none-musllinux_1_2_i686.whl", hash = "sha256:01da3988d225628b709493d7dc67c3b9b12c0210016b08690ef9bd27970b262b", size = 10953498, upload-time = "2026-04-24T18:17:20.674Z" }, + { url = "https://files.pythonhosted.org/packages/72/7a/a9ba7f98c7a575978698f4230c5e8cc54bbc761af34f560818f933dafa0c/ruff-0.15.12-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:9cae0f92bd5700d1213188b31cd3bdd2b315361296d10b96b8e2337d3d11f53e", size = 11447765, upload-time = "2026-04-24T18:17:09.755Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f9/0ae446942c846b8266059ad8a30702a35afae55f5cdc54c5adf8d7afdc27/ruff-0.15.12-py3-none-win32.whl", hash = "sha256:d0185894e038d7043ba8fd6aee7499ece6462dc0ea9f1e260c7451807c714c20", size = 10657277, upload-time = "2026-04-24T18:17:18.591Z" }, + { url = "https://files.pythonhosted.org/packages/33/f1/9614e03e1cdcbf9437570b5400ced8a720b5db22b28d8e0f1bda429f660d/ruff-0.15.12-py3-none-win_amd64.whl", hash = "sha256:c87a162d61ab3adca47c03f7f717c68672edec7d1b5499e652331780fe74950d", size = 11837758, upload-time = "2026-04-24T18:17:00.113Z" }, + { url = "https://files.pythonhosted.org/packages/c0/98/6beb4b351e472e5f4c4613f7c35a5290b8be2497e183825310c4c3a3984b/ruff-0.15.12-py3-none-win_arm64.whl", hash = "sha256:a538f7a82d061cee7be55542aca1d86d1393d55d81d4fcc314370f4340930d4f", size = 11120821, upload-time = "2026-04-24T18:16:57.979Z" }, +] + +[[package]] +name = "s3fs" +version = "2025.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiobotocore" }, + { name = "aiohttp" }, + { name = "fsspec" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ee/f3/8e6371436666aedfd16e63ff68a51b8a8fcf5f33a0eee33c35e0b2476b27/s3fs-2025.9.0.tar.gz", hash = "sha256:6d44257ef19ea64968d0720744c4af7a063a05f5c1be0e17ce943bef7302bc30", size = 77823, upload-time = "2025-09-02T19:18:21.781Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/b3/ca7d58ca25b1bb6df57e6cbd0ca8d6437a4b9ce1cd35adc8a6b2949c113b/s3fs-2025.9.0-py3-none-any.whl", hash = "sha256:c33c93d48f66ed440dbaf6600be149cdf8beae4b6f8f0201a209c5801aeb7e30", size = 30319, upload-time = "2025-09-02T19:18:20.563Z" }, +] + +[[package]] +name = "s3transfer" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "botocore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/62/74/8d69dcb7a9efe8baa2046891735e5dfe433ad558ae23d9e3c14c633d1d58/s3transfer-0.14.0.tar.gz", hash = "sha256:eff12264e7c8b4985074ccce27a3b38a485bb7f7422cc8046fee9be4983e4125", size = 151547, upload-time = "2025-09-09T19:23:31.089Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/f0/ae7ca09223a81a1d890b2557186ea015f6e0502e9b8cb8e1813f1d8cfa4e/s3transfer-0.14.0-py3-none-any.whl", hash = "sha256:ea3b790c7077558ed1f02a3072fb3cb992bbbd253392f4b6e9e8976941c7d456", size = 85712, upload-time = "2025-09-09T19:23:30.041Z" }, +] + +[[package]] +name = "secretstorage" +version = "3.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "jeepney" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/32/8a/ed6747b1cc723c81f526d4c12c1b1d43d07190e1e8258dbf934392fc850e/secretstorage-3.4.1.tar.gz", hash = "sha256:a799acf5be9fb93db609ebaa4ab6e8f1f3ed5ae640e0fa732bfea59e9c3b50e8", size = 19871, upload-time = "2025-11-11T11:30:23.798Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b0/6d/24ebb101484f1911a6be6695b76ce43219caa110ebbe07d8c3a5f3106cca/secretstorage-3.4.1-py3-none-any.whl", hash = "sha256:c55d57b4da3de568d8c3af89dad244ab24c35ca1da8625fc1b550edf005ebc41", size = 15301, upload-time = "2025-11-11T11:30:22.618Z" }, +] + +[[package]] +name = "semver" +version = "3.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/d1/d3159231aec234a59dd7d601e9dd9fe96f3afff15efd33c1070019b26132/semver-3.0.4.tar.gz", hash = "sha256:afc7d8c584a5ed0a11033af086e8af226a9c0b206f313e0301f8dd7b6b589602", size = 269730, upload-time = "2025-01-24T13:19:27.617Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/24/4d91e05817e92e3a61c8a21e08fd0f390f5301f1c448b137c57c4bc6e543/semver-3.0.4-py3-none-any.whl", hash = "sha256:9c824d87ba7f7ab4a1890799cec8596f15c1241cb473404ea1cb0c55e4b04746", size = 17912, upload-time = "2025-01-24T13:19:24.949Z" }, +] + +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, +] + +[[package]] +name = "shortuuid" +version = "1.0.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/e2/bcf761f3bff95856203f9559baf3741c416071dd200c0fc19fad7f078f86/shortuuid-1.0.13.tar.gz", hash = "sha256:3bb9cf07f606260584b1df46399c0b87dd84773e7b25912b7e391e30797c5e72", size = 9662, upload-time = "2024-03-11T20:11:06.879Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/44/21d6bf170bf40b41396480d8d49ad640bca3f2b02139cd52aa1e272830a5/shortuuid-1.0.13-py3-none-any.whl", hash = "sha256:a482a497300b49b4953e15108a7913244e1bb0d41f9d332f5e9925dba33a3c5a", size = 10529, upload-time = "2024-03-11T20:11:04.807Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "soupsieve" +version = "2.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472, upload-time = "2025-08-27T15:39:51.78Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679, upload-time = "2025-08-27T15:39:50.179Z" }, +] + +[[package]] +name = "sse-starlette" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/db/3c/fa6517610dc641262b77cc7bf994ecd17465812c1b0585fe33e11be758ab/sse_starlette-3.0.3.tar.gz", hash = "sha256:88cfb08747e16200ea990c8ca876b03910a23b547ab3bd764c0d8eb81019b971", size = 21943, upload-time = "2025-10-30T18:44:20.117Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/a0/984525d19ca5c8a6c33911a0c164b11490dd0f90ff7fd689f704f84e9a11/sse_starlette-3.0.3-py3-none-any.whl", hash = "sha256:af5bf5a6f3933df1d9c7f8539633dc8444ca6a97ab2e2a7cd3b6e431ac03a431", size = 11765, upload-time = "2025-10-30T18:44:18.834Z" }, +] + +[[package]] +name = "starlette" +version = "0.50.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ba/b8/73a0e6a6e079a9d9cfa64113d771e421640b6f679a52eeb9b32f72d871a1/starlette-0.50.0.tar.gz", hash = "sha256:a2a17b22203254bcbc2e1f926d2d55f3f9497f769416b3190768befe598fa3ca", size = 2646985, upload-time = "2025-11-01T15:25:27.516Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/52/1064f510b141bd54025f9b55105e26d1fa970b9be67ad766380a3c9b74b0/starlette-0.50.0-py3-none-any.whl", hash = "sha256:9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca", size = 74033, upload-time = "2025-11-01T15:25:25.461Z" }, +] + +[[package]] +name = "tenacity" +version = "9.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036, upload-time = "2025-04-02T08:25:09.966Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248, upload-time = "2025-04-02T08:25:07.678Z" }, +] + +[[package]] +name = "textual" +version = "6.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py", extra = ["linkify"] }, + { name = "mdit-py-plugins" }, + { name = "platformdirs" }, + { name = "pygments" }, + { name = "rich" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f6/2f/f0b408f227edca21d1996c1cd0b65309f0cbff44264aa40aded3ff9ce2e1/textual-6.6.0.tar.gz", hash = "sha256:53345166d6b0f9fd028ed0217d73b8f47c3a26679a18ba3b67616dcacb470eec", size = 1579327, upload-time = "2025-11-10T17:50:00.038Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/53/b3/95ab646b0c908823d71e49ab8b5949ec9f33346cee3897d1af6be28a8d91/textual-6.6.0-py3-none-any.whl", hash = "sha256:5a9484bd15ee8a6fd8ac4ed4849fb25ee56bed2cecc7b8a83c4cd7d5f19515e5", size = 712606, upload-time = "2025-11-10T17:49:58.391Z" }, +] + +[[package]] +name = "thefuzz" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "rapidfuzz" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/81/4b/d3eb25831590d6d7d38c2f2e3561d3ba41d490dc89cd91d9e65e7c812508/thefuzz-0.22.1.tar.gz", hash = "sha256:7138039a7ecf540da323792d8592ef9902b1d79eb78c147d4f20664de79f3680", size = 19993, upload-time = "2024-01-19T19:18:23.135Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/4f/1695e70ceb3604f19eda9908e289c687ea81c4fecef4d90a9d1d0f2f7ae9/thefuzz-0.22.1-py3-none-any.whl", hash = "sha256:59729b33556850b90e1093c4cf9e618af6f2e4c985df193fdf3c5b5cf02ca481", size = 8245, upload-time = "2024-01-19T19:18:20.362Z" }, +] + +[[package]] +name = "tiktoken" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "regex" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", hash = "sha256:b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931", size = 37806, upload-time = "2025-10-06T20:22:45.419Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/46/21ea696b21f1d6d1efec8639c204bdf20fde8bafb351e1355c72c5d7de52/tiktoken-0.12.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6e227c7f96925003487c33b1b32265fad2fbcec2b7cf4817afb76d416f40f6bb", size = 1051565, upload-time = "2025-10-06T20:21:44.566Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d9/35c5d2d9e22bb2a5f74ba48266fb56c63d76ae6f66e02feb628671c0283e/tiktoken-0.12.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c06cf0fcc24c2cb2adb5e185c7082a82cba29c17575e828518c2f11a01f445aa", size = 995284, upload-time = "2025-10-06T20:21:45.622Z" }, + { url = "https://files.pythonhosted.org/packages/01/84/961106c37b8e49b9fdcf33fe007bb3a8fdcc380c528b20cc7fbba80578b8/tiktoken-0.12.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:f18f249b041851954217e9fd8e5c00b024ab2315ffda5ed77665a05fa91f42dc", size = 1129201, upload-time = "2025-10-06T20:21:47.074Z" }, + { url = "https://files.pythonhosted.org/packages/6a/d0/3d9275198e067f8b65076a68894bb52fd253875f3644f0a321a720277b8a/tiktoken-0.12.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:47a5bc270b8c3db00bb46ece01ef34ad050e364b51d406b6f9730b64ac28eded", size = 1152444, upload-time = "2025-10-06T20:21:48.139Z" }, + { url = "https://files.pythonhosted.org/packages/78/db/a58e09687c1698a7c592e1038e01c206569b86a0377828d51635561f8ebf/tiktoken-0.12.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:508fa71810c0efdcd1b898fda574889ee62852989f7c1667414736bcb2b9a4bd", size = 1195080, upload-time = "2025-10-06T20:21:49.246Z" }, + { url = "https://files.pythonhosted.org/packages/9e/1b/a9e4d2bf91d515c0f74afc526fd773a812232dd6cda33ebea7f531202325/tiktoken-0.12.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a1af81a6c44f008cba48494089dd98cccb8b313f55e961a52f5b222d1e507967", size = 1255240, upload-time = "2025-10-06T20:21:50.274Z" }, + { url = "https://files.pythonhosted.org/packages/9d/15/963819345f1b1fb0809070a79e9dd96938d4ca41297367d471733e79c76c/tiktoken-0.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:3e68e3e593637b53e56f7237be560f7a394451cb8c11079755e80ae64b9e6def", size = 879422, upload-time = "2025-10-06T20:21:51.734Z" }, + { url = "https://files.pythonhosted.org/packages/a4/85/be65d39d6b647c79800fd9d29241d081d4eeb06271f383bb87200d74cf76/tiktoken-0.12.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b97f74aca0d78a1ff21b8cd9e9925714c15a9236d6ceacf5c7327c117e6e21e8", size = 1050728, upload-time = "2025-10-06T20:21:52.756Z" }, + { url = "https://files.pythonhosted.org/packages/4a/42/6573e9129bc55c9bf7300b3a35bef2c6b9117018acca0dc760ac2d93dffe/tiktoken-0.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2b90f5ad190a4bb7c3eb30c5fa32e1e182ca1ca79f05e49b448438c3e225a49b", size = 994049, upload-time = "2025-10-06T20:21:53.782Z" }, + { url = "https://files.pythonhosted.org/packages/66/c5/ed88504d2f4a5fd6856990b230b56d85a777feab84e6129af0822f5d0f70/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:65b26c7a780e2139e73acc193e5c63ac754021f160df919add909c1492c0fb37", size = 1129008, upload-time = "2025-10-06T20:21:54.832Z" }, + { url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad", size = 1152665, upload-time = "2025-10-06T20:21:56.129Z" }, + { url = "https://files.pythonhosted.org/packages/a3/fe/26df24ce53ffde419a42f5f53d755b995c9318908288c17ec3f3448313a3/tiktoken-0.12.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:35a2f8ddd3824608b3d650a000c1ef71f730d0c56486845705a8248da00f9fe5", size = 1194230, upload-time = "2025-10-06T20:21:57.546Z" }, + { url = "https://files.pythonhosted.org/packages/20/cc/b064cae1a0e9fac84b0d2c46b89f4e57051a5f41324e385d10225a984c24/tiktoken-0.12.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:83d16643edb7fa2c99eff2ab7733508aae1eebb03d5dfc46f5565862810f24e3", size = 1254688, upload-time = "2025-10-06T20:21:58.619Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/b8523105c590c5b8349f2587e2fdfe51a69544bd5a76295fc20f2374f470/tiktoken-0.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffc5288f34a8bc02e1ea7047b8d041104791d2ddbf42d1e5fa07822cbffe16bd", size = 878694, upload-time = "2025-10-06T20:21:59.876Z" }, + { url = "https://files.pythonhosted.org/packages/00/61/441588ee21e6b5cdf59d6870f86beb9789e532ee9718c251b391b70c68d6/tiktoken-0.12.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:775c2c55de2310cc1bc9a3ad8826761cbdc87770e586fd7b6da7d4589e13dab3", size = 1050802, upload-time = "2025-10-06T20:22:00.96Z" }, + { url = "https://files.pythonhosted.org/packages/1f/05/dcf94486d5c5c8d34496abe271ac76c5b785507c8eae71b3708f1ad9b45a/tiktoken-0.12.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a01b12f69052fbe4b080a2cfb867c4de12c704b56178edf1d1d7b273561db160", size = 993995, upload-time = "2025-10-06T20:22:02.788Z" }, + { url = "https://files.pythonhosted.org/packages/a0/70/5163fe5359b943f8db9946b62f19be2305de8c3d78a16f629d4165e2f40e/tiktoken-0.12.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:01d99484dc93b129cd0964f9d34eee953f2737301f18b3c7257bf368d7615baa", size = 1128948, upload-time = "2025-10-06T20:22:03.814Z" }, + { url = "https://files.pythonhosted.org/packages/0c/da/c028aa0babf77315e1cef357d4d768800c5f8a6de04d0eac0f377cb619fa/tiktoken-0.12.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:4a1a4fcd021f022bfc81904a911d3df0f6543b9e7627b51411da75ff2fe7a1be", size = 1151986, upload-time = "2025-10-06T20:22:05.173Z" }, + { url = "https://files.pythonhosted.org/packages/a0/5a/886b108b766aa53e295f7216b509be95eb7d60b166049ce2c58416b25f2a/tiktoken-0.12.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:981a81e39812d57031efdc9ec59fa32b2a5a5524d20d4776574c4b4bd2e9014a", size = 1194222, upload-time = "2025-10-06T20:22:06.265Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f8/4db272048397636ac7a078d22773dd2795b1becee7bc4922fe6207288d57/tiktoken-0.12.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9baf52f84a3f42eef3ff4e754a0db79a13a27921b457ca9832cf944c6be4f8f3", size = 1255097, upload-time = "2025-10-06T20:22:07.403Z" }, + { url = "https://files.pythonhosted.org/packages/8e/32/45d02e2e0ea2be3a9ed22afc47d93741247e75018aac967b713b2941f8ea/tiktoken-0.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:b8a0cd0c789a61f31bf44851defbd609e8dd1e2c8589c614cc1060940ef1f697", size = 879117, upload-time = "2025-10-06T20:22:08.418Z" }, + { url = "https://files.pythonhosted.org/packages/ce/76/994fc868f88e016e6d05b0da5ac24582a14c47893f4474c3e9744283f1d5/tiktoken-0.12.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d5f89ea5680066b68bcb797ae85219c72916c922ef0fcdd3480c7d2315ffff16", size = 1050309, upload-time = "2025-10-06T20:22:10.939Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b8/57ef1456504c43a849821920d582a738a461b76a047f352f18c0b26c6516/tiktoken-0.12.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b4e7ed1c6a7a8a60a3230965bdedba8cc58f68926b835e519341413370e0399a", size = 993712, upload-time = "2025-10-06T20:22:12.115Z" }, + { url = "https://files.pythonhosted.org/packages/72/90/13da56f664286ffbae9dbcfadcc625439142675845baa62715e49b87b68b/tiktoken-0.12.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:fc530a28591a2d74bce821d10b418b26a094bf33839e69042a6e86ddb7a7fb27", size = 1128725, upload-time = "2025-10-06T20:22:13.541Z" }, + { url = "https://files.pythonhosted.org/packages/05/df/4f80030d44682235bdaecd7346c90f67ae87ec8f3df4a3442cb53834f7e4/tiktoken-0.12.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:06a9f4f49884139013b138920a4c393aa6556b2f8f536345f11819389c703ebb", size = 1151875, upload-time = "2025-10-06T20:22:14.559Z" }, + { url = "https://files.pythonhosted.org/packages/22/1f/ae535223a8c4ef4c0c1192e3f9b82da660be9eb66b9279e95c99288e9dab/tiktoken-0.12.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:04f0e6a985d95913cabc96a741c5ffec525a2c72e9df086ff17ebe35985c800e", size = 1194451, upload-time = "2025-10-06T20:22:15.545Z" }, + { url = "https://files.pythonhosted.org/packages/78/a7/f8ead382fce0243cb625c4f266e66c27f65ae65ee9e77f59ea1653b6d730/tiktoken-0.12.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0ee8f9ae00c41770b5f9b0bb1235474768884ae157de3beb5439ca0fd70f3e25", size = 1253794, upload-time = "2025-10-06T20:22:16.624Z" }, + { url = "https://files.pythonhosted.org/packages/93/e0/6cc82a562bc6365785a3ff0af27a2a092d57c47d7a81d9e2295d8c36f011/tiktoken-0.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dc2dd125a62cb2b3d858484d6c614d136b5b848976794edfb63688d539b8b93f", size = 878777, upload-time = "2025-10-06T20:22:18.036Z" }, + { url = "https://files.pythonhosted.org/packages/72/05/3abc1db5d2c9aadc4d2c76fa5640134e475e58d9fbb82b5c535dc0de9b01/tiktoken-0.12.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a90388128df3b3abeb2bfd1895b0681412a8d7dc644142519e6f0a97c2111646", size = 1050188, upload-time = "2025-10-06T20:22:19.563Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7b/50c2f060412202d6c95f32b20755c7a6273543b125c0985d6fa9465105af/tiktoken-0.12.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:da900aa0ad52247d8794e307d6446bd3cdea8e192769b56276695d34d2c9aa88", size = 993978, upload-time = "2025-10-06T20:22:20.702Z" }, + { url = "https://files.pythonhosted.org/packages/14/27/bf795595a2b897e271771cd31cb847d479073497344c637966bdf2853da1/tiktoken-0.12.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:285ba9d73ea0d6171e7f9407039a290ca77efcdb026be7769dccc01d2c8d7fff", size = 1129271, upload-time = "2025-10-06T20:22:22.06Z" }, + { url = "https://files.pythonhosted.org/packages/f5/de/9341a6d7a8f1b448573bbf3425fa57669ac58258a667eb48a25dfe916d70/tiktoken-0.12.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:d186a5c60c6a0213f04a7a802264083dea1bbde92a2d4c7069e1a56630aef830", size = 1151216, upload-time = "2025-10-06T20:22:23.085Z" }, + { url = "https://files.pythonhosted.org/packages/75/0d/881866647b8d1be4d67cb24e50d0c26f9f807f994aa1510cb9ba2fe5f612/tiktoken-0.12.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:604831189bd05480f2b885ecd2d1986dc7686f609de48208ebbbddeea071fc0b", size = 1194860, upload-time = "2025-10-06T20:22:24.602Z" }, + { url = "https://files.pythonhosted.org/packages/b3/1e/b651ec3059474dab649b8d5b69f5c65cd8fcd8918568c1935bd4136c9392/tiktoken-0.12.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8f317e8530bb3a222547b85a58583238c8f74fd7a7408305f9f63246d1a0958b", size = 1254567, upload-time = "2025-10-06T20:22:25.671Z" }, + { url = "https://files.pythonhosted.org/packages/80/57/ce64fd16ac390fafde001268c364d559447ba09b509181b2808622420eec/tiktoken-0.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:399c3dd672a6406719d84442299a490420b458c44d3ae65516302a99675888f3", size = 921067, upload-time = "2025-10-06T20:22:26.753Z" }, + { url = "https://files.pythonhosted.org/packages/ac/a4/72eed53e8976a099539cdd5eb36f241987212c29629d0a52c305173e0a68/tiktoken-0.12.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2c714c72bc00a38ca969dae79e8266ddec999c7ceccd603cc4f0d04ccd76365", size = 1050473, upload-time = "2025-10-06T20:22:27.775Z" }, + { url = "https://files.pythonhosted.org/packages/e6/d7/0110b8f54c008466b19672c615f2168896b83706a6611ba6e47313dbc6e9/tiktoken-0.12.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cbb9a3ba275165a2cb0f9a83f5d7025afe6b9d0ab01a22b50f0e74fee2ad253e", size = 993855, upload-time = "2025-10-06T20:22:28.799Z" }, + { url = "https://files.pythonhosted.org/packages/5f/77/4f268c41a3957c418b084dd576ea2fad2e95da0d8e1ab705372892c2ca22/tiktoken-0.12.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:dfdfaa5ffff8993a3af94d1125870b1d27aed7cb97aa7eb8c1cefdbc87dbee63", size = 1129022, upload-time = "2025-10-06T20:22:29.981Z" }, + { url = "https://files.pythonhosted.org/packages/4e/2b/fc46c90fe5028bd094cd6ee25a7db321cb91d45dc87531e2bdbb26b4867a/tiktoken-0.12.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:584c3ad3d0c74f5269906eb8a659c8bfc6144a52895d9261cdaf90a0ae5f4de0", size = 1150736, upload-time = "2025-10-06T20:22:30.996Z" }, + { url = "https://files.pythonhosted.org/packages/28/c0/3c7a39ff68022ddfd7d93f3337ad90389a342f761c4d71de99a3ccc57857/tiktoken-0.12.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:54c891b416a0e36b8e2045b12b33dd66fb34a4fe7965565f1b482da50da3e86a", size = 1194908, upload-time = "2025-10-06T20:22:32.073Z" }, + { url = "https://files.pythonhosted.org/packages/ab/0d/c1ad6f4016a3968c048545f5d9b8ffebf577774b2ede3e2e352553b685fe/tiktoken-0.12.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5edb8743b88d5be814b1a8a8854494719080c28faaa1ccbef02e87354fe71ef0", size = 1253706, upload-time = "2025-10-06T20:22:33.385Z" }, + { url = "https://files.pythonhosted.org/packages/af/df/c7891ef9d2712ad774777271d39fdef63941ffba0a9d59b7ad1fd2765e57/tiktoken-0.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f61c0aea5565ac82e2ec50a05e02a6c44734e91b51c10510b084ea1b8e633a71", size = 920667, upload-time = "2025-10-06T20:22:34.444Z" }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085, upload-time = "2024-10-24T14:58:29.895Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610, upload-time = "2024-10-24T14:58:28.029Z" }, +] + +[[package]] +name = "tokenizers" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/46/fb6854cec3278fbfa4a75b50232c77622bc517ac886156e6afbfa4d8fc6e/tokenizers-0.22.1.tar.gz", hash = "sha256:61de6522785310a309b3407bac22d99c4db5dba349935e99e4d15ea2226af2d9", size = 363123, upload-time = "2025-09-19T09:49:23.424Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/33/f4b2d94ada7ab297328fc671fed209368ddb82f965ec2224eb1892674c3a/tokenizers-0.22.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:59fdb013df17455e5f950b4b834a7b3ee2e0271e6378ccb33aa74d178b513c73", size = 3069318, upload-time = "2025-09-19T09:49:11.848Z" }, + { url = "https://files.pythonhosted.org/packages/1c/58/2aa8c874d02b974990e89ff95826a4852a8b2a273c7d1b4411cdd45a4565/tokenizers-0.22.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:8d4e484f7b0827021ac5f9f71d4794aaef62b979ab7608593da22b1d2e3c4edc", size = 2926478, upload-time = "2025-09-19T09:49:09.759Z" }, + { url = "https://files.pythonhosted.org/packages/1e/3b/55e64befa1e7bfea963cf4b787b2cea1011362c4193f5477047532ce127e/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d2962dd28bc67c1f205ab180578a78eef89ac60ca7ef7cbe9635a46a56422a", size = 3256994, upload-time = "2025-09-19T09:48:56.701Z" }, + { url = "https://files.pythonhosted.org/packages/71/0b/fbfecf42f67d9b7b80fde4aabb2b3110a97fac6585c9470b5bff103a80cb/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:38201f15cdb1f8a6843e6563e6e79f4abd053394992b9bbdf5213ea3469b4ae7", size = 3153141, upload-time = "2025-09-19T09:48:59.749Z" }, + { url = "https://files.pythonhosted.org/packages/17/a9/b38f4e74e0817af8f8ef925507c63c6ae8171e3c4cb2d5d4624bf58fca69/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d1cbe5454c9a15df1b3443c726063d930c16f047a3cc724b9e6e1a91140e5a21", size = 3508049, upload-time = "2025-09-19T09:49:05.868Z" }, + { url = "https://files.pythonhosted.org/packages/d2/48/dd2b3dac46bb9134a88e35d72e1aa4869579eacc1a27238f1577270773ff/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e7d094ae6312d69cc2a872b54b91b309f4f6fbce871ef28eb27b52a98e4d0214", size = 3710730, upload-time = "2025-09-19T09:49:01.832Z" }, + { url = "https://files.pythonhosted.org/packages/93/0e/ccabc8d16ae4ba84a55d41345207c1e2ea88784651a5a487547d80851398/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afd7594a56656ace95cdd6df4cca2e4059d294c5cfb1679c57824b605556cb2f", size = 3412560, upload-time = "2025-09-19T09:49:03.867Z" }, + { url = "https://files.pythonhosted.org/packages/d0/c6/dc3a0db5a6766416c32c034286d7c2d406da1f498e4de04ab1b8959edd00/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2ef6063d7a84994129732b47e7915e8710f27f99f3a3260b8a38fc7ccd083f4", size = 3250221, upload-time = "2025-09-19T09:49:07.664Z" }, + { url = "https://files.pythonhosted.org/packages/d7/a6/2c8486eef79671601ff57b093889a345dd3d576713ef047776015dc66de7/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ba0a64f450b9ef412c98f6bcd2a50c6df6e2443b560024a09fa6a03189726879", size = 9345569, upload-time = "2025-09-19T09:49:14.214Z" }, + { url = "https://files.pythonhosted.org/packages/6b/16/32ce667f14c35537f5f605fe9bea3e415ea1b0a646389d2295ec348d5657/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:331d6d149fa9c7d632cde4490fb8bbb12337fa3a0232e77892be656464f4b446", size = 9271599, upload-time = "2025-09-19T09:49:16.639Z" }, + { url = "https://files.pythonhosted.org/packages/51/7c/a5f7898a3f6baa3fc2685c705e04c98c1094c523051c805cdd9306b8f87e/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:607989f2ea68a46cb1dfbaf3e3aabdf3f21d8748312dbeb6263d1b3b66c5010a", size = 9533862, upload-time = "2025-09-19T09:49:19.146Z" }, + { url = "https://files.pythonhosted.org/packages/36/65/7e75caea90bc73c1dd8d40438adf1a7bc26af3b8d0a6705ea190462506e1/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a0f307d490295717726598ef6fa4f24af9d484809223bbc253b201c740a06390", size = 9681250, upload-time = "2025-09-19T09:49:21.501Z" }, + { url = "https://files.pythonhosted.org/packages/30/2c/959dddef581b46e6209da82df3b78471e96260e2bc463f89d23b1bf0e52a/tokenizers-0.22.1-cp39-abi3-win32.whl", hash = "sha256:b5120eed1442765cd90b903bb6cfef781fd8fe64e34ccaecbae4c619b7b12a82", size = 2472003, upload-time = "2025-09-19T09:49:27.089Z" }, + { url = "https://files.pythonhosted.org/packages/b3/46/e33a8c93907b631a99377ef4c5f817ab453d0b34f93529421f42ff559671/tokenizers-0.22.1-cp39-abi3-win_amd64.whl", hash = "sha256:65fd6e3fb11ca1e78a6a93602490f134d1fdeb13bcef99389d5102ea318ed138", size = 2674684, upload-time = "2025-09-19T09:49:24.953Z" }, +] + +[[package]] +name = "tornado" +version = "6.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/37/1d/0a336abf618272d53f62ebe274f712e213f5a03c0b2339575430b8362ef2/tornado-6.5.4.tar.gz", hash = "sha256:a22fa9047405d03260b483980635f0b041989d8bcc9a313f8fe18b411d84b1d7", size = 513632, upload-time = "2025-12-15T19:21:03.836Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/a9/e94a9d5224107d7ce3cc1fab8d5dc97f5ea351ccc6322ee4fb661da94e35/tornado-6.5.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d6241c1a16b1c9e4cc28148b1cda97dd1c6cb4fb7068ac1bedc610768dff0ba9", size = 443909, upload-time = "2025-12-15T19:20:48.382Z" }, + { url = "https://files.pythonhosted.org/packages/db/7e/f7b8d8c4453f305a51f80dbb49014257bb7d28ccb4bbb8dd328ea995ecad/tornado-6.5.4-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2d50f63dda1d2cac3ae1fa23d254e16b5e38153758470e9956cbc3d813d40843", size = 442163, upload-time = "2025-12-15T19:20:49.791Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b5/206f82d51e1bfa940ba366a8d2f83904b15942c45a78dd978b599870ab44/tornado-6.5.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1cf66105dc6acb5af613c054955b8137e34a03698aa53272dbda4afe252be17", size = 445746, upload-time = "2025-12-15T19:20:51.491Z" }, + { url = "https://files.pythonhosted.org/packages/8e/9d/1a3338e0bd30ada6ad4356c13a0a6c35fbc859063fa7eddb309183364ac1/tornado-6.5.4-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50ff0a58b0dc97939d29da29cd624da010e7f804746621c78d14b80238669335", size = 445083, upload-time = "2025-12-15T19:20:52.778Z" }, + { url = "https://files.pythonhosted.org/packages/50/d4/e51d52047e7eb9a582da59f32125d17c0482d065afd5d3bc435ff2120dc5/tornado-6.5.4-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5fb5e04efa54cf0baabdd10061eb4148e0be137166146fff835745f59ab9f7f", size = 445315, upload-time = "2025-12-15T19:20:53.996Z" }, + { url = "https://files.pythonhosted.org/packages/27/07/2273972f69ca63dbc139694a3fc4684edec3ea3f9efabf77ed32483b875c/tornado-6.5.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9c86b1643b33a4cd415f8d0fe53045f913bf07b4a3ef646b735a6a86047dda84", size = 446003, upload-time = "2025-12-15T19:20:56.101Z" }, + { url = "https://files.pythonhosted.org/packages/d1/83/41c52e47502bf7260044413b6770d1a48dda2f0246f95ee1384a3cd9c44a/tornado-6.5.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:6eb82872335a53dd063a4f10917b3efd28270b56a33db69009606a0312660a6f", size = 445412, upload-time = "2025-12-15T19:20:57.398Z" }, + { url = "https://files.pythonhosted.org/packages/10/c7/bc96917f06cbee182d44735d4ecde9c432e25b84f4c2086143013e7b9e52/tornado-6.5.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6076d5dda368c9328ff41ab5d9dd3608e695e8225d1cd0fd1e006f05da3635a8", size = 445392, upload-time = "2025-12-15T19:20:58.692Z" }, + { url = "https://files.pythonhosted.org/packages/0c/1a/d7592328d037d36f2d2462f4bc1fbb383eec9278bc786c1b111cbbd44cfa/tornado-6.5.4-cp39-abi3-win32.whl", hash = "sha256:1768110f2411d5cd281bac0a090f707223ce77fd110424361092859e089b38d1", size = 446481, upload-time = "2025-12-15T19:21:00.008Z" }, + { url = "https://files.pythonhosted.org/packages/d6/6d/c69be695a0a64fd37a97db12355a035a6d90f79067a3cf936ec2b1dc38cd/tornado-6.5.4-cp39-abi3-win_amd64.whl", hash = "sha256:fa07d31e0cd85c60713f2b995da613588aa03e1303d75705dca6af8babc18ddc", size = 446886, upload-time = "2025-12-15T19:21:01.287Z" }, + { url = "https://files.pythonhosted.org/packages/50/49/8dc3fd90902f70084bd2cd059d576ddb4f8bb44c2c7c0e33a11422acb17e/tornado-6.5.4-cp39-abi3-win_arm64.whl", hash = "sha256:053e6e16701eb6cbe641f308f4c1a9541f91b6261991160391bfc342e8a551a1", size = 445910, upload-time = "2025-12-15T19:21:02.571Z" }, +] + +[[package]] +name = "tqdm" +version = "4.67.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, +] + +[[package]] +name = "typer" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "click" }, + { name = "rich" }, + { name = "shellingham" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7b/27/ede8cec7596e0041ba7e7b80b47d132562f56ff454313a16f6084e555c9f/typer-0.25.0.tar.gz", hash = "sha256:123eaf9f19bb40fd268310e12a542c0c6b4fab9c98d9d23342a01ff95e3ce930", size = 120150, upload-time = "2026-04-26T08:46:14.767Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/72/193d4e586ec5a4db834a36bbeb47641a62f951f114ffd0fe5b1b46e8d56f/typer-0.25.0-py3-none-any.whl", hash = "sha256:ac01b48823d3db9a83c9e164338057eadbb1c9957a2a6b4eeb486669c560b5dc", size = 55993, upload-time = "2026-04-26T08:46:15.889Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, +] + +[[package]] +name = "tzdata" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" }, +] + +[[package]] +name = "tzlocal" +version = "5.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "tzdata", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761, upload-time = "2025-03-05T21:17:41.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026, upload-time = "2025-03-05T21:17:39.857Z" }, +] + +[[package]] +name = "uc-micro-py" +version = "1.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" }, +] + +[[package]] +name = "uncalled-for" +version = "0.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/68/35c1d87e608940badbcfeb630347aa0509897284684f61fab6423d02b253/uncalled_for-0.3.1.tar.gz", hash = "sha256:5e412ac6708f04b56bef5867b5dcf6690ebce4eb7316058d9c50787492bb4bca", size = 49693, upload-time = "2026-04-07T13:05:06.462Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/e1/7ec67882ad8fc9f86384bef6421fa252c9cbe5744f8df6ce77afc9eca1f5/uncalled_for-0.3.1-py3-none-any.whl", hash = "sha256:074cdc92da8356278f93d0ded6f2a66dd883dbecaf9bc89437646ee2289cc200", size = 11361, upload-time = "2026-04-07T13:05:05.341Z" }, +] + +[[package]] +name = "universal-pathlib" +version = "0.3.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fsspec" }, + { name = "pathlib-abc" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/db/6874223d251a2e146dae57a27ca8cb1f71e7e135aa51ad394173ffe18fc0/universal_pathlib-0.3.6.tar.gz", hash = "sha256:d8640454ff08305fc639f7980e8bad4a7d38e82f6389ff993fb0e7b2a4969de9", size = 249113, upload-time = "2025-11-13T17:05:29.882Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/5d/fc1f5478eb486a59549e0dbea5827633bbba01139b549968d4936154b756/universal_pathlib-0.3.6-py3-none-any.whl", hash = "sha256:ff10a86e5340ad986b6f04847bb64ba397dff7467450234ffa2ab5ff135641d8", size = 78715, upload-time = "2025-11-13T17:05:28.101Z" }, +] + +[[package]] +name = "urllib3" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.38.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload-time = "2025-10-18T13:46:44.63Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload-time = "2025-10-18T13:46:42.958Z" }, +] + +[package.optional-dependencies] +standard = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, + { name = "watchfiles" }, + { name = "websockets" }, +] + +[[package]] +name = "uvloop" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/d5/69900f7883235562f1f50d8184bb7dd84a2fb61e9ec63f3782546fdbd057/uvloop-0.22.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c60ebcd36f7b240b30788554b6f0782454826a0ed765d8430652621b5de674b9", size = 1352420, upload-time = "2025-10-16T22:16:21.187Z" }, + { url = "https://files.pythonhosted.org/packages/a8/73/c4e271b3bce59724e291465cc936c37758886a4868787da0278b3b56b905/uvloop-0.22.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b7f102bf3cb1995cfeaee9321105e8f5da76fdb104cdad8986f85461a1b7b77", size = 748677, upload-time = "2025-10-16T22:16:22.558Z" }, + { url = "https://files.pythonhosted.org/packages/86/94/9fb7fad2f824d25f8ecac0d70b94d0d48107ad5ece03769a9c543444f78a/uvloop-0.22.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53c85520781d84a4b8b230e24a5af5b0778efdb39142b424990ff1ef7c48ba21", size = 3753819, upload-time = "2025-10-16T22:16:23.903Z" }, + { url = "https://files.pythonhosted.org/packages/74/4f/256aca690709e9b008b7108bc85fba619a2bc37c6d80743d18abad16ee09/uvloop-0.22.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56a2d1fae65fd82197cb8c53c367310b3eabe1bbb9fb5a04d28e3e3520e4f702", size = 3804529, upload-time = "2025-10-16T22:16:25.246Z" }, + { url = "https://files.pythonhosted.org/packages/7f/74/03c05ae4737e871923d21a76fe28b6aad57f5c03b6e6bfcfa5ad616013e4/uvloop-0.22.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40631b049d5972c6755b06d0bfe8233b1bd9a8a6392d9d1c45c10b6f9e9b2733", size = 3621267, upload-time = "2025-10-16T22:16:26.819Z" }, + { url = "https://files.pythonhosted.org/packages/75/be/f8e590fe61d18b4a92070905497aec4c0e64ae1761498cad09023f3f4b3e/uvloop-0.22.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:535cc37b3a04f6cd2c1ef65fa1d370c9a35b6695df735fcff5427323f2cd5473", size = 3723105, upload-time = "2025-10-16T22:16:28.252Z" }, + { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" }, + { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" }, + { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" }, + { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" }, + { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" }, + { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" }, + { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" }, + { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" }, + { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" }, + { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" }, + { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" }, + { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" }, + { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" }, + { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" }, + { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" }, + { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" }, + { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" }, + { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" }, + { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" }, +] + +[[package]] +name = "watchfiles" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/f8/2c5f479fb531ce2f0564eda479faecf253d886b1ab3630a39b7bf7362d46/watchfiles-1.1.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f57b396167a2565a4e8b5e56a5a1c537571733992b226f4f1197d79e94cf0ae5", size = 406529, upload-time = "2025-10-14T15:04:32.899Z" }, + { url = "https://files.pythonhosted.org/packages/fe/cd/f515660b1f32f65df671ddf6f85bfaca621aee177712874dc30a97397977/watchfiles-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:421e29339983e1bebc281fab40d812742268ad057db4aee8c4d2bce0af43b741", size = 394384, upload-time = "2025-10-14T15:04:33.761Z" }, + { url = "https://files.pythonhosted.org/packages/7b/c3/28b7dc99733eab43fca2d10f55c86e03bd6ab11ca31b802abac26b23d161/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e43d39a741e972bab5d8100b5cdacf69db64e34eb19b6e9af162bccf63c5cc6", size = 448789, upload-time = "2025-10-14T15:04:34.679Z" }, + { url = "https://files.pythonhosted.org/packages/4a/24/33e71113b320030011c8e4316ccca04194bf0cbbaeee207f00cbc7d6b9f5/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f537afb3276d12814082a2e9b242bdcf416c2e8fd9f799a737990a1dbe906e5b", size = 460521, upload-time = "2025-10-14T15:04:35.963Z" }, + { url = "https://files.pythonhosted.org/packages/f4/c3/3c9a55f255aa57b91579ae9e98c88704955fa9dac3e5614fb378291155df/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2cd9e04277e756a2e2d2543d65d1e2166d6fd4c9b183f8808634fda23f17b14", size = 488722, upload-time = "2025-10-14T15:04:37.091Z" }, + { url = "https://files.pythonhosted.org/packages/49/36/506447b73eb46c120169dc1717fe2eff07c234bb3232a7200b5f5bd816e9/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3f58818dc0b07f7d9aa7fe9eb1037aecb9700e63e1f6acfed13e9fef648f5d", size = 596088, upload-time = "2025-10-14T15:04:38.39Z" }, + { url = "https://files.pythonhosted.org/packages/82/ab/5f39e752a9838ec4d52e9b87c1e80f1ee3ccdbe92e183c15b6577ab9de16/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bb9f66367023ae783551042d31b1d7fd422e8289eedd91f26754a66f44d5cff", size = 472923, upload-time = "2025-10-14T15:04:39.666Z" }, + { url = "https://files.pythonhosted.org/packages/af/b9/a419292f05e302dea372fa7e6fda5178a92998411f8581b9830d28fb9edb/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aebfd0861a83e6c3d1110b78ad54704486555246e542be3e2bb94195eabb2606", size = 456080, upload-time = "2025-10-14T15:04:40.643Z" }, + { url = "https://files.pythonhosted.org/packages/b0/c3/d5932fd62bde1a30c36e10c409dc5d54506726f08cb3e1d8d0ba5e2bc8db/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5fac835b4ab3c6487b5dbad78c4b3724e26bcc468e886f8ba8cc4306f68f6701", size = 629432, upload-time = "2025-10-14T15:04:41.789Z" }, + { url = "https://files.pythonhosted.org/packages/f7/77/16bddd9779fafb795f1a94319dc965209c5641db5bf1edbbccace6d1b3c0/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:399600947b170270e80134ac854e21b3ccdefa11a9529a3decc1327088180f10", size = 623046, upload-time = "2025-10-14T15:04:42.718Z" }, + { url = "https://files.pythonhosted.org/packages/46/ef/f2ecb9a0f342b4bfad13a2787155c6ee7ce792140eac63a34676a2feeef2/watchfiles-1.1.1-cp311-cp311-win32.whl", hash = "sha256:de6da501c883f58ad50db3a32ad397b09ad29865b5f26f64c24d3e3281685849", size = 271473, upload-time = "2025-10-14T15:04:43.624Z" }, + { url = "https://files.pythonhosted.org/packages/94/bc/f42d71125f19731ea435c3948cad148d31a64fccde3867e5ba4edee901f9/watchfiles-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:35c53bd62a0b885bf653ebf6b700d1bf05debb78ad9292cf2a942b23513dc4c4", size = 287598, upload-time = "2025-10-14T15:04:44.516Z" }, + { url = "https://files.pythonhosted.org/packages/57/c9/a30f897351f95bbbfb6abcadafbaca711ce1162f4db95fc908c98a9165f3/watchfiles-1.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:57ca5281a8b5e27593cb7d82c2ac927ad88a96ed406aa446f6344e4328208e9e", size = 277210, upload-time = "2025-10-14T15:04:45.883Z" }, + { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" }, + { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" }, + { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" }, + { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" }, + { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" }, + { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" }, + { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" }, + { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" }, + { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" }, + { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" }, + { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" }, + { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" }, + { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" }, + { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" }, + { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" }, + { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" }, + { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" }, + { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" }, + { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" }, + { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" }, + { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" }, + { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" }, + { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" }, + { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" }, + { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" }, + { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" }, + { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" }, + { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" }, + { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" }, + { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" }, + { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" }, + { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" }, + { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" }, + { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" }, + { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" }, + { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" }, + { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" }, + { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" }, + { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" }, + { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" }, + { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" }, + { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" }, + { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" }, + { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" }, + { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" }, + { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" }, + { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" }, + { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" }, + { url = "https://files.pythonhosted.org/packages/d3/8e/e500f8b0b77be4ff753ac94dc06b33d8f0d839377fee1b78e8c8d8f031bf/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:db476ab59b6765134de1d4fe96a1a9c96ddf091683599be0f26147ea1b2e4b88", size = 408250, upload-time = "2025-10-14T15:06:10.264Z" }, + { url = "https://files.pythonhosted.org/packages/bd/95/615e72cd27b85b61eec764a5ca51bd94d40b5adea5ff47567d9ebc4d275a/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:89eef07eee5e9d1fda06e38822ad167a044153457e6fd997f8a858ab7564a336", size = 396117, upload-time = "2025-10-14T15:06:11.28Z" }, + { url = "https://files.pythonhosted.org/packages/c9/81/e7fe958ce8a7fb5c73cc9fb07f5aeaf755e6aa72498c57d760af760c91f8/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce19e06cbda693e9e7686358af9cd6f5d61312ab8b00488bc36f5aabbaf77e24", size = 450493, upload-time = "2025-10-14T15:06:12.321Z" }, + { url = "https://files.pythonhosted.org/packages/6e/d4/ed38dd3b1767193de971e694aa544356e63353c33a85d948166b5ff58b9e/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6f39af2eab0118338902798b5aa6664f46ff66bc0280de76fca67a7f262a49", size = 457546, upload-time = "2025-10-14T15:06:13.372Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.2.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" }, +] + +[[package]] +name = "websockets" +version = "15.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" }, + { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" }, + { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" }, + { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" }, + { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" }, + { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" }, + { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" }, + { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" }, + { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" }, + { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" }, + { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" }, + { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" }, + { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" }, + { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" }, + { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" }, + { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" }, + { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" }, + { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" }, + { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" }, + { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" }, + { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" }, + { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" }, + { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" }, + { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" }, + { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" }, + { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" }, + { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" }, + { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" }, + { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" }, +] + +[[package]] +name = "whoosh" +version = "2.7.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/25/2b/6beed2107b148edc1321da0d489afc4617b9ed317ef7b72d4993cad9b684/Whoosh-2.7.4.tar.gz", hash = "sha256:7ca5633dbfa9e0e0fa400d3151a8a0c4bec53bd2ecedc0a67705b17565c31a83", size = 968741, upload-time = "2016-04-04T01:19:32.327Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/19/24d0f1f454a2c1eb689ca28d2f178db81e5024f42d82729a4ff6771155cf/Whoosh-2.7.4-py2.py3-none-any.whl", hash = "sha256:aa39c3c3426e3fd107dcb4bde64ca1e276a65a889d9085a6e4b54ba82420a852", size = 468790, upload-time = "2016-04-04T01:19:40.379Z" }, +] + +[[package]] +name = "wrapt" +version = "1.17.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" }, + { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" }, + { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" }, + { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" }, + { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" }, + { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" }, + { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" }, + { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" }, + { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" }, + { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" }, + { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" }, + { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" }, + { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" }, + { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" }, + { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" }, + { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" }, + { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" }, + { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" }, + { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" }, + { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" }, + { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" }, + { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" }, + { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" }, + { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" }, + { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" }, + { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" }, + { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" }, + { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" }, + { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" }, + { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" }, + { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" }, + { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" }, + { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" }, + { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" }, + { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" }, + { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" }, + { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" }, + { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" }, + { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" }, + { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" }, + { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" }, + { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" }, + { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" }, + { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" }, + { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" }, +] + +[[package]] +name = "xxhash" +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/d4/cc2f0400e9154df4b9964249da78ebd72f318e35ccc425e9f403c392f22a/xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a", size = 32844, upload-time = "2025-10-02T14:34:14.037Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ec/1cc11cd13e26ea8bc3cb4af4eaadd8d46d5014aebb67be3f71fb0b68802a/xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa", size = 30809, upload-time = "2025-10-02T14:34:15.484Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/19fe357ea348d98ca22f456f75a30ac0916b51c753e1f8b2e0e6fb884cce/xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248", size = 194665, upload-time = "2025-10-02T14:34:16.541Z" }, + { url = "https://files.pythonhosted.org/packages/90/3b/d1f1a8f5442a5fd8beedae110c5af7604dc37349a8e16519c13c19a9a2de/xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62", size = 213550, upload-time = "2025-10-02T14:34:17.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ef/3a9b05eb527457d5db13a135a2ae1a26c80fecd624d20f3e8dcc4cb170f3/xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f", size = 212384, upload-time = "2025-10-02T14:34:19.182Z" }, + { url = "https://files.pythonhosted.org/packages/0f/18/ccc194ee698c6c623acbf0f8c2969811a8a4b6185af5e824cd27b9e4fd3e/xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e", size = 445749, upload-time = "2025-10-02T14:34:20.659Z" }, + { url = "https://files.pythonhosted.org/packages/a5/86/cf2c0321dc3940a7aa73076f4fd677a0fb3e405cb297ead7d864fd90847e/xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8", size = 193880, upload-time = "2025-10-02T14:34:22.431Z" }, + { url = "https://files.pythonhosted.org/packages/82/fb/96213c8560e6f948a1ecc9a7613f8032b19ee45f747f4fca4eb31bb6d6ed/xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0", size = 210912, upload-time = "2025-10-02T14:34:23.937Z" }, + { url = "https://files.pythonhosted.org/packages/40/aa/4395e669b0606a096d6788f40dbdf2b819d6773aa290c19e6e83cbfc312f/xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77", size = 198654, upload-time = "2025-10-02T14:34:25.644Z" }, + { url = "https://files.pythonhosted.org/packages/67/74/b044fcd6b3d89e9b1b665924d85d3f400636c23590226feb1eb09e1176ce/xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c", size = 210867, upload-time = "2025-10-02T14:34:27.203Z" }, + { url = "https://files.pythonhosted.org/packages/bc/fd/3ce73bf753b08cb19daee1eb14aa0d7fe331f8da9c02dd95316ddfe5275e/xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b", size = 414012, upload-time = "2025-10-02T14:34:28.409Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b3/5a4241309217c5c876f156b10778f3ab3af7ba7e3259e6d5f5c7d0129eb2/xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3", size = 191409, upload-time = "2025-10-02T14:34:29.696Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/99bfbc15fb9abb9a72b088c1d95219fc4782b7d01fc835bd5744d66dd0b8/xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd", size = 30574, upload-time = "2025-10-02T14:34:31.028Z" }, + { url = "https://files.pythonhosted.org/packages/65/79/9d24d7f53819fe301b231044ea362ce64e86c74f6e8c8e51320de248b3e5/xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef", size = 31481, upload-time = "2025-10-02T14:34:32.062Z" }, + { url = "https://files.pythonhosted.org/packages/30/4e/15cd0e3e8772071344eab2961ce83f6e485111fed8beb491a3f1ce100270/xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7", size = 27861, upload-time = "2025-10-02T14:34:33.555Z" }, + { url = "https://files.pythonhosted.org/packages/9a/07/d9412f3d7d462347e4511181dea65e47e0d0e16e26fbee2ea86a2aefb657/xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c", size = 32744, upload-time = "2025-10-02T14:34:34.622Z" }, + { url = "https://files.pythonhosted.org/packages/79/35/0429ee11d035fc33abe32dca1b2b69e8c18d236547b9a9b72c1929189b9a/xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204", size = 30816, upload-time = "2025-10-02T14:34:36.043Z" }, + { url = "https://files.pythonhosted.org/packages/b7/f2/57eb99aa0f7d98624c0932c5b9a170e1806406cdbcdb510546634a1359e0/xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490", size = 194035, upload-time = "2025-10-02T14:34:37.354Z" }, + { url = "https://files.pythonhosted.org/packages/4c/ed/6224ba353690d73af7a3f1c7cdb1fc1b002e38f783cb991ae338e1eb3d79/xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2", size = 212914, upload-time = "2025-10-02T14:34:38.6Z" }, + { url = "https://files.pythonhosted.org/packages/38/86/fb6b6130d8dd6b8942cc17ab4d90e223653a89aa32ad2776f8af7064ed13/xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa", size = 212163, upload-time = "2025-10-02T14:34:39.872Z" }, + { url = "https://files.pythonhosted.org/packages/ee/dc/e84875682b0593e884ad73b2d40767b5790d417bde603cceb6878901d647/xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0", size = 445411, upload-time = "2025-10-02T14:34:41.569Z" }, + { url = "https://files.pythonhosted.org/packages/11/4f/426f91b96701ec2f37bb2b8cec664eff4f658a11f3fa9d94f0a887ea6d2b/xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2", size = 193883, upload-time = "2025-10-02T14:34:43.249Z" }, + { url = "https://files.pythonhosted.org/packages/53/5a/ddbb83eee8e28b778eacfc5a85c969673e4023cdeedcfcef61f36731610b/xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9", size = 210392, upload-time = "2025-10-02T14:34:45.042Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c2/ff69efd07c8c074ccdf0a4f36fcdd3d27363665bcdf4ba399abebe643465/xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e", size = 197898, upload-time = "2025-10-02T14:34:46.302Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/faa05ac19b3b622c7c9317ac3e23954187516298a091eb02c976d0d3dd45/xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374", size = 210655, upload-time = "2025-10-02T14:34:47.571Z" }, + { url = "https://files.pythonhosted.org/packages/d4/7a/06aa7482345480cc0cb597f5c875b11a82c3953f534394f620b0be2f700c/xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d", size = 414001, upload-time = "2025-10-02T14:34:49.273Z" }, + { url = "https://files.pythonhosted.org/packages/23/07/63ffb386cd47029aa2916b3d2f454e6cc5b9f5c5ada3790377d5430084e7/xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae", size = 191431, upload-time = "2025-10-02T14:34:50.798Z" }, + { url = "https://files.pythonhosted.org/packages/0f/93/14fde614cadb4ddf5e7cebf8918b7e8fac5ae7861c1875964f17e678205c/xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb", size = 30617, upload-time = "2025-10-02T14:34:51.954Z" }, + { url = "https://files.pythonhosted.org/packages/13/5d/0d125536cbe7565a83d06e43783389ecae0c0f2ed037b48ede185de477c0/xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c", size = 31534, upload-time = "2025-10-02T14:34:53.276Z" }, + { url = "https://files.pythonhosted.org/packages/54/85/6ec269b0952ec7e36ba019125982cf11d91256a778c7c3f98a4c5043d283/xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829", size = 27876, upload-time = "2025-10-02T14:34:54.371Z" }, + { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" }, + { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" }, + { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" }, + { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" }, + { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" }, + { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" }, + { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" }, + { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" }, + { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" }, + { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" }, + { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3a/6797e0114c21d1725e2577508e24006fd7ff1d8c0c502d3b52e45c1771d8/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799", size = 30620, upload-time = "2025-10-02T14:35:14.129Z" }, + { url = "https://files.pythonhosted.org/packages/86/15/9bc32671e9a38b413a76d24722a2bf8784a132c043063a8f5152d390b0f9/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392", size = 31542, upload-time = "2025-10-02T14:35:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/39/c5/cc01e4f6188656e56112d6a8e0dfe298a16934b8c47a247236549a3f7695/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6", size = 27880, upload-time = "2025-10-02T14:35:16.315Z" }, + { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" }, + { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" }, + { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" }, + { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" }, + { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" }, + { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" }, + { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" }, + { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" }, + { url = "https://files.pythonhosted.org/packages/19/fa/0172e350361d61febcea941b0cc541d6e6c8d65d153e85f850a7b256ff8a/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec", size = 30916, upload-time = "2025-10-02T14:35:35.107Z" }, + { url = "https://files.pythonhosted.org/packages/ad/e6/e8cf858a2b19d6d45820f072eff1bea413910592ff17157cabc5f1227a16/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8", size = 31799, upload-time = "2025-10-02T14:35:36.165Z" }, + { url = "https://files.pythonhosted.org/packages/56/15/064b197e855bfb7b343210e82490ae672f8bc7cdf3ddb02e92f64304ee8a/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746", size = 28044, upload-time = "2025-10-02T14:35:37.195Z" }, + { url = "https://files.pythonhosted.org/packages/7e/5e/0138bc4484ea9b897864d59fce9be9086030825bc778b76cb5a33a906d37/xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e", size = 32754, upload-time = "2025-10-02T14:35:38.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/d7/5dac2eb2ec75fd771957a13e5dda560efb2176d5203f39502a5fc571f899/xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405", size = 30846, upload-time = "2025-10-02T14:35:39.6Z" }, + { url = "https://files.pythonhosted.org/packages/fe/71/8bc5be2bb00deb5682e92e8da955ebe5fa982da13a69da5a40a4c8db12fb/xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3", size = 194343, upload-time = "2025-10-02T14:35:40.69Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3b/52badfb2aecec2c377ddf1ae75f55db3ba2d321c5e164f14461c90837ef3/xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6", size = 213074, upload-time = "2025-10-02T14:35:42.29Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2b/ae46b4e9b92e537fa30d03dbc19cdae57ed407e9c26d163895e968e3de85/xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063", size = 212388, upload-time = "2025-10-02T14:35:43.929Z" }, + { url = "https://files.pythonhosted.org/packages/f5/80/49f88d3afc724b4ac7fbd664c8452d6db51b49915be48c6982659e0e7942/xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7", size = 445614, upload-time = "2025-10-02T14:35:45.216Z" }, + { url = "https://files.pythonhosted.org/packages/ed/ba/603ce3961e339413543d8cd44f21f2c80e2a7c5cfe692a7b1f2cccf58f3c/xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b", size = 194024, upload-time = "2025-10-02T14:35:46.959Z" }, + { url = "https://files.pythonhosted.org/packages/78/d1/8e225ff7113bf81545cfdcd79eef124a7b7064a0bba53605ff39590b95c2/xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd", size = 210541, upload-time = "2025-10-02T14:35:48.301Z" }, + { url = "https://files.pythonhosted.org/packages/6f/58/0f89d149f0bad89def1a8dd38feb50ccdeb643d9797ec84707091d4cb494/xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0", size = 198305, upload-time = "2025-10-02T14:35:49.584Z" }, + { url = "https://files.pythonhosted.org/packages/11/38/5eab81580703c4df93feb5f32ff8fa7fe1e2c51c1f183ee4e48d4bb9d3d7/xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152", size = 210848, upload-time = "2025-10-02T14:35:50.877Z" }, + { url = "https://files.pythonhosted.org/packages/5e/6b/953dc4b05c3ce678abca756416e4c130d2382f877a9c30a20d08ee6a77c0/xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11", size = 414142, upload-time = "2025-10-02T14:35:52.15Z" }, + { url = "https://files.pythonhosted.org/packages/08/a9/238ec0d4e81a10eb5026d4a6972677cbc898ba6c8b9dbaec12ae001b1b35/xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5", size = 191547, upload-time = "2025-10-02T14:35:53.547Z" }, + { url = "https://files.pythonhosted.org/packages/f1/ee/3cf8589e06c2164ac77c3bf0aa127012801128f1feebf2a079272da5737c/xxhash-3.6.0-cp314-cp314-win32.whl", hash = "sha256:a756fe893389483ee8c394d06b5ab765d96e68fbbfe6fde7aa17e11f5720559f", size = 31214, upload-time = "2025-10-02T14:35:54.746Z" }, + { url = "https://files.pythonhosted.org/packages/02/5d/a19552fbc6ad4cb54ff953c3908bbc095f4a921bc569433d791f755186f1/xxhash-3.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:39be8e4e142550ef69629c9cd71b88c90e9a5db703fecbcf265546d9536ca4ad", size = 32290, upload-time = "2025-10-02T14:35:55.791Z" }, + { url = "https://files.pythonhosted.org/packages/b1/11/dafa0643bc30442c887b55baf8e73353a344ee89c1901b5a5c54a6c17d39/xxhash-3.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:25915e6000338999236f1eb68a02a32c3275ac338628a7eaa5a269c401995679", size = 28795, upload-time = "2025-10-02T14:35:57.162Z" }, + { url = "https://files.pythonhosted.org/packages/2c/db/0e99732ed7f64182aef4a6fb145e1a295558deec2a746265dcdec12d191e/xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4", size = 32955, upload-time = "2025-10-02T14:35:58.267Z" }, + { url = "https://files.pythonhosted.org/packages/55/f4/2a7c3c68e564a099becfa44bb3d398810cc0ff6749b0d3cb8ccb93f23c14/xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67", size = 31072, upload-time = "2025-10-02T14:35:59.382Z" }, + { url = "https://files.pythonhosted.org/packages/c6/d9/72a29cddc7250e8a5819dad5d466facb5dc4c802ce120645630149127e73/xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad", size = 196579, upload-time = "2025-10-02T14:36:00.838Z" }, + { url = "https://files.pythonhosted.org/packages/63/93/b21590e1e381040e2ca305a884d89e1c345b347404f7780f07f2cdd47ef4/xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b", size = 215854, upload-time = "2025-10-02T14:36:02.207Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b8/edab8a7d4fa14e924b29be877d54155dcbd8b80be85ea00d2be3413a9ed4/xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b", size = 214965, upload-time = "2025-10-02T14:36:03.507Z" }, + { url = "https://files.pythonhosted.org/packages/27/67/dfa980ac7f0d509d54ea0d5a486d2bb4b80c3f1bb22b66e6a05d3efaf6c0/xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca", size = 448484, upload-time = "2025-10-02T14:36:04.828Z" }, + { url = "https://files.pythonhosted.org/packages/8c/63/8ffc2cc97e811c0ca5d00ab36604b3ea6f4254f20b7bc658ca825ce6c954/xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a", size = 196162, upload-time = "2025-10-02T14:36:06.182Z" }, + { url = "https://files.pythonhosted.org/packages/4b/77/07f0e7a3edd11a6097e990f6e5b815b6592459cb16dae990d967693e6ea9/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99", size = 213007, upload-time = "2025-10-02T14:36:07.733Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d8/bc5fa0d152837117eb0bef6f83f956c509332ce133c91c63ce07ee7c4873/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3", size = 200956, upload-time = "2025-10-02T14:36:09.106Z" }, + { url = "https://files.pythonhosted.org/packages/26/a5/d749334130de9411783873e9b98ecc46688dad5db64ca6e04b02acc8b473/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6", size = 213401, upload-time = "2025-10-02T14:36:10.585Z" }, + { url = "https://files.pythonhosted.org/packages/89/72/abed959c956a4bfc72b58c0384bb7940663c678127538634d896b1195c10/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93", size = 417083, upload-time = "2025-10-02T14:36:12.276Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b3/62fd2b586283b7d7d665fb98e266decadf31f058f1cf6c478741f68af0cb/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518", size = 193913, upload-time = "2025-10-02T14:36:14.025Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/c19c42c5b3f5a4aad748a6d5b4f23df3bed7ee5445accc65a0fb3ff03953/xxhash-3.6.0-cp314-cp314t-win32.whl", hash = "sha256:5851f033c3030dd95c086b4a36a2683c2ff4a799b23af60977188b057e467119", size = 31586, upload-time = "2025-10-02T14:36:15.603Z" }, + { url = "https://files.pythonhosted.org/packages/03/d6/4cc450345be9924fd5dc8c590ceda1db5b43a0a889587b0ae81a95511360/xxhash-3.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0444e7967dac37569052d2409b00a8860c2135cff05502df4da80267d384849f", size = 32526, upload-time = "2025-10-02T14:36:16.708Z" }, + { url = "https://files.pythonhosted.org/packages/0f/c9/7243eb3f9eaabd1a88a5a5acadf06df2d83b100c62684b7425c6a11bcaa8/xxhash-3.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bb79b1e63f6fd84ec778a4b1916dfe0a7c3fdb986c06addd5db3a0d413819d95", size = 28898, upload-time = "2025-10-02T14:36:17.843Z" }, + { url = "https://files.pythonhosted.org/packages/93/1e/8aec23647a34a249f62e2398c42955acd9b4c6ed5cf08cbea94dc46f78d2/xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0", size = 30662, upload-time = "2025-10-02T14:37:01.743Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0b/b14510b38ba91caf43006209db846a696ceea6a847a0c9ba0a5b1adc53d6/xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296", size = 41056, upload-time = "2025-10-02T14:37:02.879Z" }, + { url = "https://files.pythonhosted.org/packages/50/55/15a7b8a56590e66ccd374bbfa3f9ffc45b810886c8c3b614e3f90bd2367c/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13", size = 36251, upload-time = "2025-10-02T14:37:04.44Z" }, + { url = "https://files.pythonhosted.org/packages/62/b2/5ac99a041a29e58e95f907876b04f7067a0242cb85b5f39e726153981503/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd", size = 32481, upload-time = "2025-10-02T14:37:05.869Z" }, + { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" }, +] + +[[package]] +name = "yarl" +version = "1.22.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/57/63/0c6ebca57330cd313f6102b16dd57ffaf3ec4c83403dcb45dbd15c6f3ea1/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71", size = 187169, upload-time = "2025-10-06T14:12:55.963Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/27/5ab13fc84c76a0250afd3d26d5936349a35be56ce5785447d6c423b26d92/yarl-1.22.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ab72135b1f2db3fed3997d7e7dc1b80573c67138023852b6efb336a5eae6511", size = 141607, upload-time = "2025-10-06T14:09:16.298Z" }, + { url = "https://files.pythonhosted.org/packages/6a/a1/d065d51d02dc02ce81501d476b9ed2229d9a990818332242a882d5d60340/yarl-1.22.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:669930400e375570189492dc8d8341301578e8493aec04aebc20d4717f899dd6", size = 94027, upload-time = "2025-10-06T14:09:17.786Z" }, + { url = "https://files.pythonhosted.org/packages/c1/da/8da9f6a53f67b5106ffe902c6fa0164e10398d4e150d85838b82f424072a/yarl-1.22.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:792a2af6d58177ef7c19cbf0097aba92ca1b9cb3ffdd9c7470e156c8f9b5e028", size = 94963, upload-time = "2025-10-06T14:09:19.662Z" }, + { url = "https://files.pythonhosted.org/packages/68/fe/2c1f674960c376e29cb0bec1249b117d11738db92a6ccc4a530b972648db/yarl-1.22.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ea66b1c11c9150f1372f69afb6b8116f2dd7286f38e14ea71a44eee9ec51b9d", size = 368406, upload-time = "2025-10-06T14:09:21.402Z" }, + { url = "https://files.pythonhosted.org/packages/95/26/812a540e1c3c6418fec60e9bbd38e871eaba9545e94fa5eff8f4a8e28e1e/yarl-1.22.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3e2daa88dc91870215961e96a039ec73e4937da13cf77ce17f9cad0c18df3503", size = 336581, upload-time = "2025-10-06T14:09:22.98Z" }, + { url = "https://files.pythonhosted.org/packages/0b/f5/5777b19e26fdf98563985e481f8be3d8a39f8734147a6ebf459d0dab5a6b/yarl-1.22.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba440ae430c00eee41509353628600212112cd5018d5def7e9b05ea7ac34eb65", size = 388924, upload-time = "2025-10-06T14:09:24.655Z" }, + { url = "https://files.pythonhosted.org/packages/86/08/24bd2477bd59c0bbd994fe1d93b126e0472e4e3df5a96a277b0a55309e89/yarl-1.22.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e6438cc8f23a9c1478633d216b16104a586b9761db62bfacb6425bac0a36679e", size = 392890, upload-time = "2025-10-06T14:09:26.617Z" }, + { url = "https://files.pythonhosted.org/packages/46/00/71b90ed48e895667ecfb1eaab27c1523ee2fa217433ed77a73b13205ca4b/yarl-1.22.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c52a6e78aef5cf47a98ef8e934755abf53953379b7d53e68b15ff4420e6683d", size = 365819, upload-time = "2025-10-06T14:09:28.544Z" }, + { url = "https://files.pythonhosted.org/packages/30/2d/f715501cae832651d3282387c6a9236cd26bd00d0ff1e404b3dc52447884/yarl-1.22.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3b06bcadaac49c70f4c88af4ffcfbe3dc155aab3163e75777818092478bcbbe7", size = 363601, upload-time = "2025-10-06T14:09:30.568Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f9/a678c992d78e394e7126ee0b0e4e71bd2775e4334d00a9278c06a6cce96a/yarl-1.22.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6944b2dc72c4d7f7052683487e3677456050ff77fcf5e6204e98caf785ad1967", size = 358072, upload-time = "2025-10-06T14:09:32.528Z" }, + { url = "https://files.pythonhosted.org/packages/2c/d1/b49454411a60edb6fefdcad4f8e6dbba7d8019e3a508a1c5836cba6d0781/yarl-1.22.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d5372ca1df0f91a86b047d1277c2aaf1edb32d78bbcefffc81b40ffd18f027ed", size = 385311, upload-time = "2025-10-06T14:09:34.634Z" }, + { url = "https://files.pythonhosted.org/packages/87/e5/40d7a94debb8448c7771a916d1861d6609dddf7958dc381117e7ba36d9e8/yarl-1.22.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:51af598701f5299012b8416486b40fceef8c26fc87dc6d7d1f6fc30609ea0aa6", size = 381094, upload-time = "2025-10-06T14:09:36.268Z" }, + { url = "https://files.pythonhosted.org/packages/35/d8/611cc282502381ad855448643e1ad0538957fc82ae83dfe7762c14069e14/yarl-1.22.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b266bd01fedeffeeac01a79ae181719ff848a5a13ce10075adbefc8f1daee70e", size = 370944, upload-time = "2025-10-06T14:09:37.872Z" }, + { url = "https://files.pythonhosted.org/packages/2d/df/fadd00fb1c90e1a5a8bd731fa3d3de2e165e5a3666a095b04e31b04d9cb6/yarl-1.22.0-cp311-cp311-win32.whl", hash = "sha256:a9b1ba5610a4e20f655258d5a1fdc7ebe3d837bb0e45b581398b99eb98b1f5ca", size = 81804, upload-time = "2025-10-06T14:09:39.359Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f7/149bb6f45f267cb5c074ac40c01c6b3ea6d8a620d34b337f6321928a1b4d/yarl-1.22.0-cp311-cp311-win_amd64.whl", hash = "sha256:078278b9b0b11568937d9509b589ee83ef98ed6d561dfe2020e24a9fd08eaa2b", size = 86858, upload-time = "2025-10-06T14:09:41.068Z" }, + { url = "https://files.pythonhosted.org/packages/2b/13/88b78b93ad3f2f0b78e13bfaaa24d11cbc746e93fe76d8c06bf139615646/yarl-1.22.0-cp311-cp311-win_arm64.whl", hash = "sha256:b6a6f620cfe13ccec221fa312139135166e47ae169f8253f72a0abc0dae94376", size = 81637, upload-time = "2025-10-06T14:09:42.712Z" }, + { url = "https://files.pythonhosted.org/packages/75/ff/46736024fee3429b80a165a732e38e5d5a238721e634ab41b040d49f8738/yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f", size = 142000, upload-time = "2025-10-06T14:09:44.631Z" }, + { url = "https://files.pythonhosted.org/packages/5a/9a/b312ed670df903145598914770eb12de1bac44599549b3360acc96878df8/yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2", size = 94338, upload-time = "2025-10-06T14:09:46.372Z" }, + { url = "https://files.pythonhosted.org/packages/ba/f5/0601483296f09c3c65e303d60c070a5c19fcdbc72daa061e96170785bc7d/yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74", size = 94909, upload-time = "2025-10-06T14:09:48.648Z" }, + { url = "https://files.pythonhosted.org/packages/60/41/9a1fe0b73dbcefce72e46cf149b0e0a67612d60bfc90fb59c2b2efdfbd86/yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df", size = 372940, upload-time = "2025-10-06T14:09:50.089Z" }, + { url = "https://files.pythonhosted.org/packages/17/7a/795cb6dfee561961c30b800f0ed616b923a2ec6258b5def2a00bf8231334/yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb", size = 345825, upload-time = "2025-10-06T14:09:52.142Z" }, + { url = "https://files.pythonhosted.org/packages/d7/93/a58f4d596d2be2ae7bab1a5846c4d270b894958845753b2c606d666744d3/yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2", size = 386705, upload-time = "2025-10-06T14:09:54.128Z" }, + { url = "https://files.pythonhosted.org/packages/61/92/682279d0e099d0e14d7fd2e176bd04f48de1484f56546a3e1313cd6c8e7c/yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82", size = 396518, upload-time = "2025-10-06T14:09:55.762Z" }, + { url = "https://files.pythonhosted.org/packages/db/0f/0d52c98b8a885aeda831224b78f3be7ec2e1aa4a62091f9f9188c3c65b56/yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a", size = 377267, upload-time = "2025-10-06T14:09:57.958Z" }, + { url = "https://files.pythonhosted.org/packages/22/42/d2685e35908cbeaa6532c1fc73e89e7f2efb5d8a7df3959ea8e37177c5a3/yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124", size = 365797, upload-time = "2025-10-06T14:09:59.527Z" }, + { url = "https://files.pythonhosted.org/packages/a2/83/cf8c7bcc6355631762f7d8bdab920ad09b82efa6b722999dfb05afa6cfac/yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa", size = 365535, upload-time = "2025-10-06T14:10:01.139Z" }, + { url = "https://files.pythonhosted.org/packages/25/e1/5302ff9b28f0c59cac913b91fe3f16c59a033887e57ce9ca5d41a3a94737/yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7", size = 382324, upload-time = "2025-10-06T14:10:02.756Z" }, + { url = "https://files.pythonhosted.org/packages/bf/cd/4617eb60f032f19ae3a688dc990d8f0d89ee0ea378b61cac81ede3e52fae/yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d", size = 383803, upload-time = "2025-10-06T14:10:04.552Z" }, + { url = "https://files.pythonhosted.org/packages/59/65/afc6e62bb506a319ea67b694551dab4a7e6fb7bf604e9bd9f3e11d575fec/yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520", size = 374220, upload-time = "2025-10-06T14:10:06.489Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3d/68bf18d50dc674b942daec86a9ba922d3113d8399b0e52b9897530442da2/yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8", size = 81589, upload-time = "2025-10-06T14:10:09.254Z" }, + { url = "https://files.pythonhosted.org/packages/c8/9a/6ad1a9b37c2f72874f93e691b2e7ecb6137fb2b899983125db4204e47575/yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c", size = 87213, upload-time = "2025-10-06T14:10:11.369Z" }, + { url = "https://files.pythonhosted.org/packages/44/c5/c21b562d1680a77634d748e30c653c3ca918beb35555cff24986fff54598/yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74", size = 81330, upload-time = "2025-10-06T14:10:13.112Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f3/d67de7260456ee105dc1d162d43a019ecad6b91e2f51809d6cddaa56690e/yarl-1.22.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8dee9c25c74997f6a750cd317b8ca63545169c098faee42c84aa5e506c819b53", size = 139980, upload-time = "2025-10-06T14:10:14.601Z" }, + { url = "https://files.pythonhosted.org/packages/01/88/04d98af0b47e0ef42597b9b28863b9060bb515524da0a65d5f4db160b2d5/yarl-1.22.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01e73b85a5434f89fc4fe27dcda2aff08ddf35e4d47bbbea3bdcd25321af538a", size = 93424, upload-time = "2025-10-06T14:10:16.115Z" }, + { url = "https://files.pythonhosted.org/packages/18/91/3274b215fd8442a03975ce6bee5fe6aa57a8326b29b9d3d56234a1dca244/yarl-1.22.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:22965c2af250d20c873cdbee8ff958fb809940aeb2e74ba5f20aaf6b7ac8c70c", size = 93821, upload-time = "2025-10-06T14:10:17.993Z" }, + { url = "https://files.pythonhosted.org/packages/61/3a/caf4e25036db0f2da4ca22a353dfeb3c9d3c95d2761ebe9b14df8fc16eb0/yarl-1.22.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4f15793aa49793ec8d1c708ab7f9eded1aa72edc5174cae703651555ed1b601", size = 373243, upload-time = "2025-10-06T14:10:19.44Z" }, + { url = "https://files.pythonhosted.org/packages/6e/9e/51a77ac7516e8e7803b06e01f74e78649c24ee1021eca3d6a739cb6ea49c/yarl-1.22.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5542339dcf2747135c5c85f68680353d5cb9ffd741c0f2e8d832d054d41f35a", size = 342361, upload-time = "2025-10-06T14:10:21.124Z" }, + { url = "https://files.pythonhosted.org/packages/d4/f8/33b92454789dde8407f156c00303e9a891f1f51a0330b0fad7c909f87692/yarl-1.22.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c401e05ad47a75869c3ab3e35137f8468b846770587e70d71e11de797d113df", size = 387036, upload-time = "2025-10-06T14:10:22.902Z" }, + { url = "https://files.pythonhosted.org/packages/d9/9a/c5db84ea024f76838220280f732970aa4ee154015d7f5c1bfb60a267af6f/yarl-1.22.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:243dda95d901c733f5b59214d28b0120893d91777cb8aa043e6ef059d3cddfe2", size = 397671, upload-time = "2025-10-06T14:10:24.523Z" }, + { url = "https://files.pythonhosted.org/packages/11/c9/cd8538dc2e7727095e0c1d867bad1e40c98f37763e6d995c1939f5fdc7b1/yarl-1.22.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bec03d0d388060058f5d291a813f21c011041938a441c593374da6077fe21b1b", size = 377059, upload-time = "2025-10-06T14:10:26.406Z" }, + { url = "https://files.pythonhosted.org/packages/a1/b9/ab437b261702ced75122ed78a876a6dec0a1b0f5e17a4ac7a9a2482d8abe/yarl-1.22.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0748275abb8c1e1e09301ee3cf90c8a99678a4e92e4373705f2a2570d581273", size = 365356, upload-time = "2025-10-06T14:10:28.461Z" }, + { url = "https://files.pythonhosted.org/packages/b2/9d/8e1ae6d1d008a9567877b08f0ce4077a29974c04c062dabdb923ed98e6fe/yarl-1.22.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:47fdb18187e2a4e18fda2c25c05d8251a9e4a521edaed757fef033e7d8498d9a", size = 361331, upload-time = "2025-10-06T14:10:30.541Z" }, + { url = "https://files.pythonhosted.org/packages/ca/5a/09b7be3905962f145b73beb468cdd53db8aa171cf18c80400a54c5b82846/yarl-1.22.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c7044802eec4524fde550afc28edda0dd5784c4c45f0be151a2d3ba017daca7d", size = 382590, upload-time = "2025-10-06T14:10:33.352Z" }, + { url = "https://files.pythonhosted.org/packages/aa/7f/59ec509abf90eda5048b0bc3e2d7b5099dffdb3e6b127019895ab9d5ef44/yarl-1.22.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:139718f35149ff544caba20fce6e8a2f71f1e39b92c700d8438a0b1d2a631a02", size = 385316, upload-time = "2025-10-06T14:10:35.034Z" }, + { url = "https://files.pythonhosted.org/packages/e5/84/891158426bc8036bfdfd862fabd0e0fa25df4176ec793e447f4b85cf1be4/yarl-1.22.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e1b51bebd221006d3d2f95fbe124b22b247136647ae5dcc8c7acafba66e5ee67", size = 374431, upload-time = "2025-10-06T14:10:37.76Z" }, + { url = "https://files.pythonhosted.org/packages/bb/49/03da1580665baa8bef5e8ed34c6df2c2aca0a2f28bf397ed238cc1bbc6f2/yarl-1.22.0-cp313-cp313-win32.whl", hash = "sha256:d3e32536234a95f513bd374e93d717cf6b2231a791758de6c509e3653f234c95", size = 81555, upload-time = "2025-10-06T14:10:39.649Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ee/450914ae11b419eadd067c6183ae08381cfdfcb9798b90b2b713bbebddda/yarl-1.22.0-cp313-cp313-win_amd64.whl", hash = "sha256:47743b82b76d89a1d20b83e60d5c20314cbd5ba2befc9cda8f28300c4a08ed4d", size = 86965, upload-time = "2025-10-06T14:10:41.313Z" }, + { url = "https://files.pythonhosted.org/packages/98/4d/264a01eae03b6cf629ad69bae94e3b0e5344741e929073678e84bf7a3e3b/yarl-1.22.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d0fcda9608875f7d052eff120c7a5da474a6796fe4d83e152e0e4d42f6d1a9b", size = 81205, upload-time = "2025-10-06T14:10:43.167Z" }, + { url = "https://files.pythonhosted.org/packages/88/fc/6908f062a2f77b5f9f6d69cecb1747260831ff206adcbc5b510aff88df91/yarl-1.22.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:719ae08b6972befcba4310e49edb1161a88cdd331e3a694b84466bd938a6ab10", size = 146209, upload-time = "2025-10-06T14:10:44.643Z" }, + { url = "https://files.pythonhosted.org/packages/65/47/76594ae8eab26210b4867be6f49129861ad33da1f1ebdf7051e98492bf62/yarl-1.22.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:47d8a5c446df1c4db9d21b49619ffdba90e77c89ec6e283f453856c74b50b9e3", size = 95966, upload-time = "2025-10-06T14:10:46.554Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ce/05e9828a49271ba6b5b038b15b3934e996980dd78abdfeb52a04cfb9467e/yarl-1.22.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cfebc0ac8333520d2d0423cbbe43ae43c8838862ddb898f5ca68565e395516e9", size = 97312, upload-time = "2025-10-06T14:10:48.007Z" }, + { url = "https://files.pythonhosted.org/packages/d1/c5/7dffad5e4f2265b29c9d7ec869c369e4223166e4f9206fc2243ee9eea727/yarl-1.22.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4398557cbf484207df000309235979c79c4356518fd5c99158c7d38203c4da4f", size = 361967, upload-time = "2025-10-06T14:10:49.997Z" }, + { url = "https://files.pythonhosted.org/packages/50/b2/375b933c93a54bff7fc041e1a6ad2c0f6f733ffb0c6e642ce56ee3b39970/yarl-1.22.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2ca6fd72a8cd803be290d42f2dec5cdcd5299eeb93c2d929bf060ad9efaf5de0", size = 323949, upload-time = "2025-10-06T14:10:52.004Z" }, + { url = "https://files.pythonhosted.org/packages/66/50/bfc2a29a1d78644c5a7220ce2f304f38248dc94124a326794e677634b6cf/yarl-1.22.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca1f59c4e1ab6e72f0a23c13fca5430f889634166be85dbf1013683e49e3278e", size = 361818, upload-time = "2025-10-06T14:10:54.078Z" }, + { url = "https://files.pythonhosted.org/packages/46/96/f3941a46af7d5d0f0498f86d71275696800ddcdd20426298e572b19b91ff/yarl-1.22.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c5010a52015e7c70f86eb967db0f37f3c8bd503a695a49f8d45700144667708", size = 372626, upload-time = "2025-10-06T14:10:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/c1/42/8b27c83bb875cd89448e42cd627e0fb971fa1675c9ec546393d18826cb50/yarl-1.22.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d7672ecf7557476642c88497c2f8d8542f8e36596e928e9bcba0e42e1e7d71f", size = 341129, upload-time = "2025-10-06T14:10:57.985Z" }, + { url = "https://files.pythonhosted.org/packages/49/36/99ca3122201b382a3cf7cc937b95235b0ac944f7e9f2d5331d50821ed352/yarl-1.22.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3b7c88eeef021579d600e50363e0b6ee4f7f6f728cd3486b9d0f3ee7b946398d", size = 346776, upload-time = "2025-10-06T14:10:59.633Z" }, + { url = "https://files.pythonhosted.org/packages/85/b4/47328bf996acd01a4c16ef9dcd2f59c969f495073616586f78cd5f2efb99/yarl-1.22.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f4afb5c34f2c6fecdcc182dfcfc6af6cccf1aa923eed4d6a12e9d96904e1a0d8", size = 334879, upload-time = "2025-10-06T14:11:01.454Z" }, + { url = "https://files.pythonhosted.org/packages/c2/ad/b77d7b3f14a4283bffb8e92c6026496f6de49751c2f97d4352242bba3990/yarl-1.22.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:59c189e3e99a59cf8d83cbb31d4db02d66cda5a1a4374e8a012b51255341abf5", size = 350996, upload-time = "2025-10-06T14:11:03.452Z" }, + { url = "https://files.pythonhosted.org/packages/81/c8/06e1d69295792ba54d556f06686cbd6a7ce39c22307100e3fb4a2c0b0a1d/yarl-1.22.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:5a3bf7f62a289fa90f1990422dc8dff5a458469ea71d1624585ec3a4c8d6960f", size = 356047, upload-time = "2025-10-06T14:11:05.115Z" }, + { url = "https://files.pythonhosted.org/packages/4b/b8/4c0e9e9f597074b208d18cef227d83aac36184bfbc6eab204ea55783dbc5/yarl-1.22.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:de6b9a04c606978fdfe72666fa216ffcf2d1a9f6a381058d4378f8d7b1e5de62", size = 342947, upload-time = "2025-10-06T14:11:08.137Z" }, + { url = "https://files.pythonhosted.org/packages/e0/e5/11f140a58bf4c6ad7aca69a892bff0ee638c31bea4206748fc0df4ebcb3a/yarl-1.22.0-cp313-cp313t-win32.whl", hash = "sha256:1834bb90991cc2999f10f97f5f01317f99b143284766d197e43cd5b45eb18d03", size = 86943, upload-time = "2025-10-06T14:11:10.284Z" }, + { url = "https://files.pythonhosted.org/packages/31/74/8b74bae38ed7fe6793d0c15a0c8207bbb819cf287788459e5ed230996cdd/yarl-1.22.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff86011bd159a9d2dfc89c34cfd8aff12875980e3bd6a39ff097887520e60249", size = 93715, upload-time = "2025-10-06T14:11:11.739Z" }, + { url = "https://files.pythonhosted.org/packages/69/66/991858aa4b5892d57aef7ee1ba6b4d01ec3b7eb3060795d34090a3ca3278/yarl-1.22.0-cp313-cp313t-win_arm64.whl", hash = "sha256:7861058d0582b847bc4e3a4a4c46828a410bca738673f35a29ba3ca5db0b473b", size = 83857, upload-time = "2025-10-06T14:11:13.586Z" }, + { url = "https://files.pythonhosted.org/packages/46/b3/e20ef504049f1a1c54a814b4b9bed96d1ac0e0610c3b4da178f87209db05/yarl-1.22.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4", size = 140520, upload-time = "2025-10-06T14:11:15.465Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/3532d990fdbab02e5ede063676b5c4260e7f3abea2151099c2aa745acc4c/yarl-1.22.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683", size = 93504, upload-time = "2025-10-06T14:11:17.106Z" }, + { url = "https://files.pythonhosted.org/packages/11/63/ff458113c5c2dac9a9719ac68ee7c947cb621432bcf28c9972b1c0e83938/yarl-1.22.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b", size = 94282, upload-time = "2025-10-06T14:11:19.064Z" }, + { url = "https://files.pythonhosted.org/packages/a7/bc/315a56aca762d44a6aaaf7ad253f04d996cb6b27bad34410f82d76ea8038/yarl-1.22.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e", size = 372080, upload-time = "2025-10-06T14:11:20.996Z" }, + { url = "https://files.pythonhosted.org/packages/3f/3f/08e9b826ec2e099ea6e7c69a61272f4f6da62cb5b1b63590bb80ca2e4a40/yarl-1.22.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590", size = 338696, upload-time = "2025-10-06T14:11:22.847Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9f/90360108e3b32bd76789088e99538febfea24a102380ae73827f62073543/yarl-1.22.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2", size = 387121, upload-time = "2025-10-06T14:11:24.889Z" }, + { url = "https://files.pythonhosted.org/packages/98/92/ab8d4657bd5b46a38094cfaea498f18bb70ce6b63508fd7e909bd1f93066/yarl-1.22.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da", size = 394080, upload-time = "2025-10-06T14:11:27.307Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e7/d8c5a7752fef68205296201f8ec2bf718f5c805a7a7e9880576c67600658/yarl-1.22.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784", size = 372661, upload-time = "2025-10-06T14:11:29.387Z" }, + { url = "https://files.pythonhosted.org/packages/b6/2e/f4d26183c8db0bb82d491b072f3127fb8c381a6206a3a56332714b79b751/yarl-1.22.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b", size = 364645, upload-time = "2025-10-06T14:11:31.423Z" }, + { url = "https://files.pythonhosted.org/packages/80/7c/428e5812e6b87cd00ee8e898328a62c95825bf37c7fa87f0b6bb2ad31304/yarl-1.22.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694", size = 355361, upload-time = "2025-10-06T14:11:33.055Z" }, + { url = "https://files.pythonhosted.org/packages/ec/2a/249405fd26776f8b13c067378ef4d7dd49c9098d1b6457cdd152a99e96a9/yarl-1.22.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d", size = 381451, upload-time = "2025-10-06T14:11:35.136Z" }, + { url = "https://files.pythonhosted.org/packages/67/a8/fb6b1adbe98cf1e2dd9fad71003d3a63a1bc22459c6e15f5714eb9323b93/yarl-1.22.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd", size = 383814, upload-time = "2025-10-06T14:11:37.094Z" }, + { url = "https://files.pythonhosted.org/packages/d9/f9/3aa2c0e480fb73e872ae2814c43bc1e734740bb0d54e8cb2a95925f98131/yarl-1.22.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da", size = 370799, upload-time = "2025-10-06T14:11:38.83Z" }, + { url = "https://files.pythonhosted.org/packages/50/3c/af9dba3b8b5eeb302f36f16f92791f3ea62e3f47763406abf6d5a4a3333b/yarl-1.22.0-cp314-cp314-win32.whl", hash = "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2", size = 82990, upload-time = "2025-10-06T14:11:40.624Z" }, + { url = "https://files.pythonhosted.org/packages/ac/30/ac3a0c5bdc1d6efd1b41fa24d4897a4329b3b1e98de9449679dd327af4f0/yarl-1.22.0-cp314-cp314-win_amd64.whl", hash = "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79", size = 88292, upload-time = "2025-10-06T14:11:42.578Z" }, + { url = "https://files.pythonhosted.org/packages/df/0a/227ab4ff5b998a1b7410abc7b46c9b7a26b0ca9e86c34ba4b8d8bc7c63d5/yarl-1.22.0-cp314-cp314-win_arm64.whl", hash = "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33", size = 82888, upload-time = "2025-10-06T14:11:44.863Z" }, + { url = "https://files.pythonhosted.org/packages/06/5e/a15eb13db90abd87dfbefb9760c0f3f257ac42a5cac7e75dbc23bed97a9f/yarl-1.22.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1", size = 146223, upload-time = "2025-10-06T14:11:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/18/82/9665c61910d4d84f41a5bf6837597c89e665fa88aa4941080704645932a9/yarl-1.22.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca", size = 95981, upload-time = "2025-10-06T14:11:48.845Z" }, + { url = "https://files.pythonhosted.org/packages/5d/9a/2f65743589809af4d0a6d3aa749343c4b5f4c380cc24a8e94a3c6625a808/yarl-1.22.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53", size = 97303, upload-time = "2025-10-06T14:11:50.897Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ab/5b13d3e157505c43c3b43b5a776cbf7b24a02bc4cccc40314771197e3508/yarl-1.22.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c", size = 361820, upload-time = "2025-10-06T14:11:52.549Z" }, + { url = "https://files.pythonhosted.org/packages/fb/76/242a5ef4677615cf95330cfc1b4610e78184400699bdda0acb897ef5e49a/yarl-1.22.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf", size = 323203, upload-time = "2025-10-06T14:11:54.225Z" }, + { url = "https://files.pythonhosted.org/packages/8c/96/475509110d3f0153b43d06164cf4195c64d16999e0c7e2d8a099adcd6907/yarl-1.22.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face", size = 363173, upload-time = "2025-10-06T14:11:56.069Z" }, + { url = "https://files.pythonhosted.org/packages/c9/66/59db471aecfbd559a1fd48aedd954435558cd98c7d0da8b03cc6c140a32c/yarl-1.22.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b", size = 373562, upload-time = "2025-10-06T14:11:58.783Z" }, + { url = "https://files.pythonhosted.org/packages/03/1f/c5d94abc91557384719da10ff166b916107c1b45e4d0423a88457071dd88/yarl-1.22.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486", size = 339828, upload-time = "2025-10-06T14:12:00.686Z" }, + { url = "https://files.pythonhosted.org/packages/5f/97/aa6a143d3afba17b6465733681c70cf175af89f76ec8d9286e08437a7454/yarl-1.22.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138", size = 347551, upload-time = "2025-10-06T14:12:02.628Z" }, + { url = "https://files.pythonhosted.org/packages/43/3c/45a2b6d80195959239a7b2a8810506d4eea5487dce61c2a3393e7fc3c52e/yarl-1.22.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a", size = 334512, upload-time = "2025-10-06T14:12:04.871Z" }, + { url = "https://files.pythonhosted.org/packages/86/a0/c2ab48d74599c7c84cb104ebd799c5813de252bea0f360ffc29d270c2caa/yarl-1.22.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529", size = 352400, upload-time = "2025-10-06T14:12:06.624Z" }, + { url = "https://files.pythonhosted.org/packages/32/75/f8919b2eafc929567d3d8411f72bdb1a2109c01caaab4ebfa5f8ffadc15b/yarl-1.22.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093", size = 357140, upload-time = "2025-10-06T14:12:08.362Z" }, + { url = "https://files.pythonhosted.org/packages/cf/72/6a85bba382f22cf78add705d8c3731748397d986e197e53ecc7835e76de7/yarl-1.22.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c", size = 341473, upload-time = "2025-10-06T14:12:10.994Z" }, + { url = "https://files.pythonhosted.org/packages/35/18/55e6011f7c044dc80b98893060773cefcfdbf60dfefb8cb2f58b9bacbd83/yarl-1.22.0-cp314-cp314t-win32.whl", hash = "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e", size = 89056, upload-time = "2025-10-06T14:12:13.317Z" }, + { url = "https://files.pythonhosted.org/packages/f9/86/0f0dccb6e59a9e7f122c5afd43568b1d31b8ab7dda5f1b01fb5c7025c9a9/yarl-1.22.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27", size = 96292, upload-time = "2025-10-06T14:12:15.398Z" }, + { url = "https://files.pythonhosted.org/packages/48/b7/503c98092fb3b344a179579f55814b613c1fbb1c23b3ec14a7b008a66a6e/yarl-1.22.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1", size = 85171, upload-time = "2025-10-06T14:12:16.935Z" }, + { url = "https://files.pythonhosted.org/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload-time = "2025-10-06T14:12:53.872Z" }, +] + +[[package]] +name = "zipp" +version = "3.23.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" }, +]