Add files using upload-large-folder tool

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/_hot_reload/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# 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.

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/_hot_reload/client.py

@@ -0,0 +1,104 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# 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.
+
+
+import json
+from collections import deque
+from collections.abc import Iterator
+from typing import Literal, TypedDict
+
+import httpx
+
+from ..utils._headers import build_hf_headers
+from ..utils._http import hf_raise_for_status
+from .sse_client import SSEClient
+from .types import ApiGetReloadEventSourceData, ApiGetReloadRequest
+
+
+HOT_RELOADING_PORT = 7887
+
+
+class MultiReplicaStreamEvent(TypedDict):
+    kind: Literal["event"]
+    event: ApiGetReloadEventSourceData
+
+
+class MultiReplicaStreamReplicaHash(TypedDict):
+    kind: Literal["replicaHash"]
+    hash: str
+
+
+class MultiReplicaStreamFullMatch(TypedDict):
+    kind: Literal["fullMatch"]
+
+
+class ReloadClient:
+    def __init__(
+        self,
+        *,
+        host: str,
+        subdomain: str,
+        replica_hash: str,
+        token: str | None,
+    ):
+        base_host = host.replace(subdomain, f"{subdomain}--{HOT_RELOADING_PORT}")
+        self.replica_hash = replica_hash
+        self.client = httpx.Client(
+            base_url=f"{base_host}/--replicas/+{replica_hash}",
+            headers=build_hf_headers(token=token),
+        )
+
+    def get_reload(self, reload_id: str) -> Iterator[ApiGetReloadEventSourceData]:
+        req = ApiGetReloadRequest(reloadId=reload_id)
+        with self.client.stream("POST", "/get-reload", json=req) as res:
+            hf_raise_for_status(res)
+            for event in SSEClient(res.iter_bytes()).events():
+                if event.event == "message":
+                    yield json.loads(event.data)
+
+
+def multi_replica_reload_events(
+    commit_sha: str,
+    host: str,
+    subdomain: str,
+    replica_hashes: list[str],
+    token: str | None,
+) -> Iterator[MultiReplicaStreamEvent | MultiReplicaStreamReplicaHash | MultiReplicaStreamFullMatch]:
+    clients = [
+        ReloadClient(
+            host=host,
+            subdomain=subdomain,
+            replica_hash=hash,
+            token=token,
+        )
+        for hash in replica_hashes
+    ]
+
+    first_client_events: dict[int, ApiGetReloadEventSourceData] = {}
+    for client_index, client in enumerate(clients):
+        if len(clients) > 1:
+            yield {"kind": "replicaHash", "hash": client.replica_hash}
+        full_match = True
+        replay: deque[ApiGetReloadEventSourceData] = deque()
+        for event_index, event in enumerate(client.get_reload(commit_sha)):
+            if client_index == 0:
+                first_client_events[event_index] = event
+            elif full_match := full_match and first_client_events.get(event_index) == event:
+                replay.append(event)
+                continue
+            while replay:
+                yield {"kind": "event", "event": replay.popleft()}
+            yield {"kind": "event", "event": event}
+        if client_index > 0 and full_match:
+            yield {"kind": "fullMatch"}

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/_hot_reload/sse_client.py

@@ -0,0 +1,144 @@
+"""
+Vendored file: Server Side Events (SSE) client for Python.
+
+Source:
+- Author: Maxime Petazzoni <maxime.petazzoni@bulix.org>
+- Repository: https://github.com/mpetazzoni/sseclient
+- File: https://github.com/mpetazzoni/sseclient/blob/main/sseclient/__init__.py
+
+License:
+- Apache-2.0 (from upstream project)
+
+Provides a generator of SSE received through an existing HTTP response.
+"""
+
+import logging
+
+__author__ = 'Maxime Petazzoni <maxime.petazzoni@bulix.org>'
+__email__ = 'maxime.petazzoni@bulix.org'
+__all__ = ['SSEClient']
+
+_FIELD_SEPARATOR = ':'
+
+
+class SSEClient:
+    """Implementation of a SSE client.
+
+    See http://www.w3.org/TR/2009/WD-eventsource-20091029/ for the
+    specification.
+    """
+
+    def __init__(self, event_source, char_enc='utf-8'):
+        """Initialize the SSE client over an existing, ready to consume
+        event source.
+
+        The event source is expected to be a binary stream and have a close()
+        method. That would usually be something that implements
+        io.BinaryIOBase, like an httplib or urllib3 HTTPResponse object.
+        """
+        self._logger = logging.getLogger(self.__class__.__module__)
+        self._logger.debug('Initialized SSE client from event source %s',
+                           event_source)
+        self._event_source = event_source
+        self._char_enc = char_enc
+
+    def _read(self):
+        """Read the incoming event source stream and yield event chunks.
+
+        Unfortunately it is possible for some servers to decide to break an
+        event into multiple HTTP chunks in the response. It is thus necessary
+        to correctly stitch together consecutive response chunks and find the
+        SSE delimiter (empty new line) to yield full, correct event chunks."""
+        data = b''
+        for chunk in self._event_source:
+            for line in chunk.splitlines(True):
+                data += line
+                if data.endswith((b'\r\r', b'\n\n', b'\r\n\r\n')):
+                    yield data
+                    data = b''
+        if data:
+            yield data
+
+    def events(self):
+        for chunk in self._read():
+            event = Event()
+            # Split before decoding so splitlines() only uses \r and \n
+            for line in chunk.splitlines():
+                # Decode the line.
+                line = line.decode(self._char_enc)
+
+                # Lines starting with a separator are comments and are to be
+                # ignored.
+                if not line.strip() or line.startswith(_FIELD_SEPARATOR):
+                    continue
+
+                data = line.split(_FIELD_SEPARATOR, 1)
+                field = data[0]
+
+                # Ignore unknown fields.
+                if field not in event.__dict__:
+                    self._logger.debug('Saw invalid field %s while parsing '
+                                       'Server Side Event', field)
+                    continue
+
+                if len(data) > 1:
+                    # From the spec:
+                    # "If value starts with a single U+0020 SPACE character,
+                    # remove it from value."
+                    if data[1].startswith(' '):
+                        value = data[1][1:]
+                    else:
+                        value = data[1]
+                else:
+                    # If no value is present after the separator,
+                    # assume an empty value.
+                    value = ''
+
+                # The data field may come over multiple lines and their values
+                # are concatenated with each other.
+                if field == 'data':
+                    event.__dict__[field] += value + '\n'
+                else:
+                    event.__dict__[field] = value
+
+            # Events with no data are not dispatched.
+            if not event.data:
+                continue
+
+            # If the data field ends with a newline, remove it.
+            if event.data.endswith('\n'):
+                event.data = event.data[0:-1]
+
+            # Empty event names default to 'message'
+            event.event = event.event or 'message'
+
+            # Dispatch the event
+            self._logger.debug('Dispatching %s...', event)
+            yield event
+
+    def close(self):
+        """Manually close the event source stream."""
+        self._event_source.close()
+
+
+class Event:
+    """Representation of an event from the event stream."""
+
+    def __init__(self, id=None, event='message', data='', retry=None):
+        self.id = id
+        self.event = event
+        self.data = data
+        self.retry = retry
+
+    def __str__(self):
+        s = f'{self.event} event'
+        if self.id:
+            s += f' #{self.id}'
+        if self.data:
+            s += ', {} byte{}'.format(len(self.data),
+                                        's' if len(self.data) else '')
+        else:
+            s += ', no data'
+        if self.retry:
+            s += f', retry in {self.retry}ms'
+        return s

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/_hot_reload/types.py

@@ -0,0 +1,115 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# 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.
+
+
+from typing import Literal, TypedDict
+
+from typing_extensions import NotRequired
+
+
+class ReloadRegion(TypedDict):
+    startLine: int
+    startCol: int
+    endLine: int
+    endCol: int
+
+
+class ReloadOperationObject(TypedDict):
+    kind: Literal["add", "update", "delete"]
+    region: ReloadRegion
+    objectType: str
+    objectName: str
+
+
+class ReloadOperationRun(TypedDict):
+    kind: Literal["run"]
+    region: ReloadRegion
+    codeLines: str
+    stdout: NotRequired[str]
+    stderr: NotRequired[str]
+
+
+class ReloadOperationException(TypedDict):
+    kind: Literal["exception"]
+    region: ReloadRegion
+    traceback: str
+
+
+class ReloadOperationError(TypedDict):
+    kind: Literal["error"]
+    traceback: str
+
+
+class ReloadOperationUI(TypedDict):
+    kind: Literal["ui"]
+    updated: bool
+
+
+class ApiCreateReloadRequest(TypedDict):
+    filepath: str
+    contents: str
+    reloadId: NotRequired[str]
+
+
+class ApiCreateReloadResponseSuccess(TypedDict):
+    status: Literal["created"]
+    reloadId: str
+
+
+class ApiCreateReloadResponseError(TypedDict):
+    status: Literal["alreadyReloading", "fileNotFound"]
+
+
+class ApiCreateReloadResponse(TypedDict):
+    res: ApiCreateReloadResponseError | ApiCreateReloadResponseSuccess
+
+
+class ApiGetReloadRequest(TypedDict):
+    reloadId: str
+
+
+class ApiGetReloadEventSourceData(TypedDict):
+    data: (
+        ReloadOperationError
+        | ReloadOperationException
+        | ReloadOperationObject
+        | ReloadOperationRun
+        | ReloadOperationUI
+    )
+
+
+class ApiGetStatusRequest(TypedDict):
+    revision: str
+
+
+class ApiGetStatusResponse(TypedDict):
+    reloading: bool
+    uncommited: list[str]
+
+
+class ApiFetchContentsRequest(TypedDict):
+    filepath: str
+
+
+class ApiFetchContentsResponseError(TypedDict):
+    status: Literal["fileNotFound"]
+
+
+class ApiFetchContentsResponseSuccess(TypedDict):
+    status: Literal["ok"]
+    contents: str
+
+
+class ApiFetchContentsResponse(TypedDict):
+    res: ApiFetchContentsResponseError | ApiFetchContentsResponseSuccess

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/cli/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2025 The HuggingFace Team. All rights reserved.
+#
+# 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.

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/cli/_cli_utils.py

@@ -0,0 +1,1102 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# 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.
+"""Contains CLI utilities (styling, helpers)."""
+
+import dataclasses
+import datetime
+import difflib
+import importlib.metadata
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from collections.abc import Callable, Sequence
+from enum import Enum
+from pathlib import Path
+from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeVar, Union, cast
+
+import click
+import typer
+from typer.core import TyperCommand, TyperGroup
+
+from huggingface_hub import Volume, __version__, constants
+from huggingface_hub.errors import CLIError
+from huggingface_hub.utils import ANSI, get_session, hf_raise_for_status, installation_method, logging, tabulate
+from huggingface_hub.utils._dotenv import load_dotenv
+
+from ._output import OutputFormatWithAuto, out
+
+
+logger = logging.get_logger()
+
+# Arbitrary maximum length of a cell in a table output
+_MAX_CELL_LENGTH = 35
+
+if TYPE_CHECKING:
+    from huggingface_hub.hf_api import HfApi
+
+
+def get_hf_api(token: str | None = None) -> "HfApi":
+    # Import here to avoid circular import
+    from huggingface_hub.hf_api import HfApi
+
+    return HfApi(token=token, library_name="huggingface-cli", library_version=__version__)
+
+
+#### TYPER UTILS
+
+CLI_REFERENCE_URL = "https://huggingface.co/docs/huggingface_hub/en/guides/cli"
+
+
+def generate_epilog(examples: list[str], docs_anchor: str | None = None) -> str:
+    """Generate an epilog with examples and a Learn More section.
+
+    Args:
+        examples: List of example commands (without the `$ ` prefix).
+        docs_anchor: Optional anchor for the docs URL (e.g., "#hf-download").
+
+    Returns:
+        Formatted epilog string.
+    """
+    docs_url = f"{CLI_REFERENCE_URL}{docs_anchor}" if docs_anchor else CLI_REFERENCE_URL
+    examples_str = "\n".join(f"  $ {ex}" for ex in examples)
+    return f"""\
+Examples
+{examples_str}
+
+Learn more
+  Use `hf <command> --help` for more information about a command.
+  Read the documentation at {docs_url}
+"""
+
+
+TOPIC_T = Literal["main", "help"] | str
+FallbackHandlerT = Callable[[list[str], set[str]], int | None]
+ExpandPropertyT = TypeVar("ExpandPropertyT", bound=str)
+
+
+def _format_epilog_no_indent(epilog: str | None, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+    """Write the epilog without indentation."""
+    if epilog:
+        formatter.write_paragraph()
+        for line in epilog.split("\n"):
+            formatter.write_text(line)
+
+
+_ALIAS_SPLIT = re.compile(r"\s*\|\s*")
+
+
+class HFCliTyperGroup(TyperGroup):
+    """
+    Typer Group that:
+    - lists commands alphabetically within sections.
+    - separates commands by topic (main, help, etc.).
+    - formats epilog without extra indentation.
+    - supports aliases via pipe-separated names (e.g. ``name="list | ls"``).
+    - rewrites ``--json`` to ``--format json`` for commands that accept ``--format``.
+    - rewrites ``spaces/user/repo`` to ``user/repo --type space`` for commands that accept ``--type``.
+    - enriches "No such option" / "No such command" errors with available options or commands.
+    """
+
+    def invoke(self, ctx: click.Context) -> None:
+        """Enrich unknown-option errors with available options or subcommands.
+
+        Catches `NoSuchOption` raised during subcommand `make_context()`
+        (option parsing).  For leaf commands (e.g. `hf repos create --test`)
+        we list the command's options; for groups (e.g. `hf cache --test`)
+        we list subcommands since groups have no user-facing options.
+        """
+        try:
+            return super().invoke(ctx)
+        except click.NoSuchOption as e:
+            if e.ctx is not None and e.ctx.command is not None:
+                cmd = e.ctx.command
+                if isinstance(cmd, click.Group):
+                    # Group has no user-facing options -> show subcommands instead
+                    items = [
+                        (name, sub.get_short_help_str(limit=80))
+                        for name in cmd.list_commands(e.ctx)
+                        if (sub := cmd.get_command(e.ctx, name)) is not None and not sub.hidden
+                    ]
+                    _enrich_usage_error(e, "commands", items)
+                else:
+                    # Leaf command -> show its options using Click's rich formatting
+                    items = [
+                        record
+                        for p in cmd.get_params(e.ctx)
+                        if isinstance(p, click.Option) and not p.hidden and (record := p.get_help_record(e.ctx))
+                    ]
+                    _enrich_usage_error(e, "options", items)
+            raise
+
+    def resolve_command(self, ctx: click.Context, args: list[str]) -> tuple:
+        cmd_name = args[0] if args and not args[0].startswith("-") else None
+        cmd = self.get_command(ctx, cmd_name) if cmd_name else None
+
+        if cmd is not None:
+            self._rewrite_json_shorthand(cmd, args)
+            self._rewrite_quiet_shorthand(cmd, args)
+            self._rewrite_repo_type_prefix(cmd, args)
+
+        try:
+            return super().resolve_command(ctx, args)
+        except click.UsageError as e:
+            # Unknown subcommand -> add fuzzy suggestions and list available commands.
+            if cmd is None and cmd_name is not None:
+                # Expand aliases ("list | ls" → ["list", "ls"]) for accurate fuzzy matching.
+                visible_names = [
+                    alias
+                    for key, registered in self.commands.items()
+                    if not registered.hidden
+                    for alias in _ALIAS_SPLIT.split(key)
+                ]
+                matches = difflib.get_close_matches(cmd_name, visible_names)
+                if matches:
+                    suggestions = ", ".join(f"'{m}'" for m in matches)
+                    e.message = f"{e.message.rstrip('.')}. Did you mean {suggestions}?"
+                items = [
+                    (name, sub.get_short_help_str(limit=80))
+                    for name in self.list_commands(ctx)
+                    if (sub := self.get_command(ctx, name)) is not None and not sub.hidden
+                ]
+                _enrich_usage_error(e, "commands", items)
+            raise
+
+    @staticmethod
+    def _rewrite_json_shorthand(cmd: click.Command, args: list[str]) -> None:
+        """Rewrite hidden ``--json`` shorthand to ``--format json``.
+
+        Only applies to commands that accept ``--format``.  This avoids rewriting
+        ``--json`` for commands that pass args through to external binaries
+        (e.g. ``hf extensions exec``) or that simply don't support ``--format``.
+        """
+        if "--json" not in args:
+            return
+        has_format_option = any(isinstance(param, click.Option) and "--format" in param.opts for param in cmd.params)
+        if has_format_option:
+            if any(arg == "--format" or arg.startswith("--format=") for arg in args):
+                raise click.UsageError("'--json' and '--format' are mutually exclusive.")
+            idx = args.index("--json")
+            args[idx : idx + 1] = ["--format", "json"]
+
+    @staticmethod
+    def _rewrite_quiet_shorthand(cmd: click.Command, args: list[str]) -> None:
+        """Rewrite ``-q`` / ``--quiet`` shorthand to ``--format quiet``.
+
+        Only applies to commands that accept ``--format`` but do NOT already
+        have their own ``--quiet`` / ``-q`` option.
+        """
+        has_quiet = "-q" in args or "--quiet" in args
+        if not has_quiet:
+            return
+        has_format_option = any(isinstance(param, click.Option) and "--format" in param.opts for param in cmd.params)
+        has_quiet_option = any(
+            isinstance(param, click.Option) and ("--quiet" in param.opts or "-q" in param.opts) for param in cmd.params
+        )
+        if has_format_option and not has_quiet_option:
+            if any(arg == "--format" or arg.startswith("--format=") for arg in args):
+                raise click.UsageError("'--quiet' and '--format' are mutually exclusive.")
+            flag = "-q" if "-q" in args else "--quiet"
+            idx = args.index(flag)
+            args[idx : idx + 1] = ["--format", "quiet"]
+
+    @staticmethod
+    def _rewrite_repo_type_prefix(cmd: click.Command, args: list[str]) -> None:
+        """Rewrite prefixed repo IDs (e.g. ``spaces/user/repo``) to ``user/repo --type space``.
+
+        Only applies to commands that have a ``--type`` / ``--repo-type`` option and
+        at least one repo-ID positional argument (any ``click.Argument`` whose name
+        ends with ``_id``, e.g. ``repo_id``, ``from_id``, ``to_id``).  When the
+        token that maps to such an argument matches ``{prefix}/org/repo`` (where
+        *prefix* is one of ``spaces``, ``datasets``, or ``models``), the prefix is
+        stripped and an implicit ``--type {type}`` is appended.  An error is raised
+        if ``--type`` is also provided explicitly or if multiple prefixed arguments
+        disagree on the repo type.
+
+        Only repo-ID positional slots are inspected so that other positional
+        arguments (filenames, local paths, patterns …) are never misinterpreted as
+        prefixed repo IDs.
+        """
+        has_type_option = any(isinstance(param, click.Option) and "--type" in param.opts for param in cmd.params)
+        if not has_type_option:
+            return
+
+        # Locate all repo-ID positional arguments and their indices among Arguments.
+        repo_id_positions: set[int] = set()
+        arg_idx = 0
+        for param in cmd.params:
+            if isinstance(param, click.Argument):
+                if param.name in ("repo_id", "from_id", "to_id"):
+                    repo_id_positions.add(arg_idx)
+                arg_idx += 1
+
+        if not repo_id_positions:
+            return
+
+        # Build a set of option names that consume a following value token.
+        value_options: set[str] = set()
+        for param in cmd.params:
+            if isinstance(param, click.Option) and not param.is_flag:
+                for opt in (*param.opts, *param.secondary_opts):
+                    value_options.add(opt)
+
+        # Walk through args (skipping args[0] = command name) to map positional
+        # slots to their indices in `args`.
+        positional_count = 0
+        repo_id_arg_indices: list[int] = []
+        i = 1
+        while i < len(args):
+            arg = args[i]
+            if arg == "--":
+                break  # everything after -- is positional literal; stop rewriting
+            if arg.startswith("-"):
+                if "=" in arg or arg not in value_options:
+                    i += 1  # flag or --opt=val — single token
+                else:
+                    i += 2  # value-taking option — skip the value too
+            else:
+                if positional_count in repo_id_positions:
+                    repo_id_arg_indices.append(i)
+                positional_count += 1
+                i += 1
+
+        if not repo_id_arg_indices:
+            return
+
+        # Check each repo-ID arg for a type prefix and collect rewrites.
+        inferred_type: str | None = None
+        first_prefix: str | None = None
+        rewrites: list[tuple[int, str]] = []  # (args index, new value without prefix)
+
+        for arg_index in repo_id_arg_indices:
+            parts = args[arg_index].split("/", 2)
+            if len(parts) != 3 or parts[0] not in constants.REPO_TYPES_MAPPING:
+                continue
+            prefix = parts[0]
+            mapped_type = constants.REPO_TYPES_MAPPING[prefix]
+            if inferred_type is not None and mapped_type != inferred_type:
+                raise click.UsageError(f"Conflicting repo type prefixes: '{first_prefix}/' and '{prefix}/'.")
+            inferred_type = mapped_type
+            first_prefix = prefix
+            rewrites.append((arg_index, f"{parts[1]}/{parts[2]}"))
+
+        if not rewrites:
+            return
+
+        # Error if --type / --repo-type was also provided explicitly.
+        if any(
+            arg == "--type" or arg.startswith("--type=") or arg == "--repo-type" or arg.startswith("--repo-type=")
+            for arg in args
+        ):
+            raise click.UsageError(
+                f"Ambiguous repo type: got prefix '{first_prefix}/' in repo ID and explicit --type. Use one or the other."
+            )
+
+        # Apply all rewrites and append --type once.
+        for arg_index, new_value in rewrites:
+            args[arg_index] = new_value
+        args.extend(["--type", inferred_type])  # type: ignore
+
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        # Try exact match first
+        cmd = super().get_command(ctx, cmd_name)
+        if cmd is not None:
+            return cmd
+        # Fall back to alias lookup: check if cmd_name matches any alias
+        # taken from https://github.com/fastapi/typer/issues/132#issuecomment-2417492805
+        for registered_name, registered_cmd in self.commands.items():
+            aliases = _ALIAS_SPLIT.split(registered_name)
+            if cmd_name in aliases:
+                return registered_cmd
+        return None
+
+    def _alias_map(self) -> dict[str, list[str]]:
+        """Build a mapping from primary command name to its aliases (if any)."""
+        result: dict[str, list[str]] = {}
+        for registered_name in self.commands:
+            parts = _ALIAS_SPLIT.split(registered_name)
+            primary = parts[0]
+            result[primary] = parts[1:]
+        return result
+
+    def format_commands(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        topics: dict[str, list] = {}
+        alias_map = self._alias_map()
+
+        for name in self.list_commands(ctx):
+            cmd = self.get_command(ctx, name)
+            if cmd is None or cmd.hidden:
+                continue
+            help_text = cmd.get_short_help_str(limit=formatter.width)
+            aliases = alias_map.get(name, [])
+            if aliases:
+                help_text = f"{help_text} [alias: {', '.join(aliases)}]"
+            topic = getattr(cmd, "topic", "main")
+            topics.setdefault(topic, []).append((name, help_text))
+
+        with formatter.section("Main commands"):
+            formatter.write_dl(topics["main"])
+        for topic in sorted(topics.keys()):
+            if topic == "main":
+                continue
+            with formatter.section(f"{topic.capitalize()} commands"):
+                formatter.write_dl(topics[topic])
+
+    def format_epilog(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        # Collect only the first example from each command (to keep group help concise)
+        # Full examples are shown in individual subcommand help (e.g. `hf buckets sync --help`)
+        all_examples: list[str] = []
+        for name in self.list_commands(ctx):
+            cmd = self.get_command(ctx, name)
+            if cmd is None or cmd.hidden:
+                continue
+            cmd_examples = getattr(cmd, "examples", [])
+            if cmd_examples:
+                all_examples.append(cmd_examples[0])
+
+        if all_examples:
+            epilog = generate_epilog(all_examples)
+            _format_epilog_no_indent(epilog, ctx, formatter)
+        elif self.epilog:
+            _format_epilog_no_indent(self.epilog, ctx, formatter)
+
+    def list_commands(self, ctx: click.Context) -> list[str]:  # type: ignore[name-defined]
+        # For aliased commands ("list | ls"), use the primary name (first entry).
+        primary_names: list[str] = []
+        for name in self.commands:
+            primary = _ALIAS_SPLIT.split(name)[0]
+            primary_names.append(primary)
+        return sorted(primary_names)
+
+
+def _enrich_usage_error(error: click.UsageError, label: str, items: list[tuple[str, str]]) -> None:
+    """Append a list of available options or commands to a usage error message."""
+    if not items or error.ctx is None or f"Available {label} for" in error.message:
+        return
+    cmd_path = error.ctx.command_path
+    lines = [f"\n\nAvailable {label} for '{cmd_path}':"]
+    for name, help_text in items:
+        lines.append(f"  {name:30s} {help_text}")
+    lines.append(f"\nRun '{cmd_path} --help' for full details.")
+    if isinstance(error, click.NoSuchOption) and error.possibilities:
+        lines.append(f"\nDid you mean: {', '.join(sorted(error.possibilities))}?")
+        error.possibilities = []
+    error.message += "\n".join(lines)
+
+
+def fallback_typer_group_factory(
+    fallback_handler: FallbackHandlerT,
+    extra_commands_provider: Callable[[], list[tuple[str, str]]] | None = None,
+) -> type[HFCliTyperGroup]:
+    """Return a Typer group class that runs a fallback handler before command resolution."""
+
+    class FallbackTyperGroup(HFCliTyperGroup):
+        def resolve_command(self, ctx: click.Context, args: list[str]) -> tuple:
+            fallback_exit_code = fallback_handler(args, set(self.commands.keys()))
+            if fallback_exit_code is not None:
+                raise SystemExit(fallback_exit_code)
+            return super().resolve_command(ctx, args)
+
+        def format_commands(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+            super().format_commands(ctx, formatter)
+            if extra_commands_provider is not None:
+                entries = extra_commands_provider()
+                if entries:
+                    with formatter.section("Extension commands"):
+                        formatter.write_dl(entries)
+
+    return FallbackTyperGroup
+
+
+def HFCliCommand(topic: TOPIC_T, examples: list[str] | None = None) -> type[TyperCommand]:
+    def format_epilog(self: click.Command, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        _format_epilog_no_indent(self.epilog, ctx, formatter)
+
+    return type(
+        f"TyperCommand{topic.capitalize()}",
+        (TyperCommand,),
+        {"topic": topic, "examples": examples or [], "format_epilog": format_epilog},
+    )
+
+
+class HFCliApp(typer.Typer):
+    """Custom Typer app for Hugging Face CLI."""
+
+    def command(  # type: ignore
+        self,
+        name: str | None = None,
+        *,
+        topic: TOPIC_T = "main",
+        examples: list[str] | None = None,
+        context_settings: dict[str, Any] | None = None,
+        help: str | None = None,
+        epilog: str | None = None,
+        short_help: str | None = None,
+        options_metavar: str = "[OPTIONS]",
+        add_help_option: bool = True,
+        no_args_is_help: bool = False,
+        hidden: bool = False,
+        deprecated: bool = False,
+        rich_help_panel: str | None = None,
+    ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        # Generate epilog from examples if not explicitly provided
+        if epilog is None and examples:
+            epilog = generate_epilog(examples)
+
+        def _inner(func: Callable[..., Any]) -> Callable[..., Any]:
+            return super(HFCliApp, self).command(
+                name,
+                cls=HFCliCommand(topic, examples),
+                context_settings=context_settings,
+                help=help,
+                epilog=epilog,
+                short_help=short_help,
+                options_metavar=options_metavar,
+                add_help_option=add_help_option,
+                no_args_is_help=no_args_is_help,
+                hidden=hidden,
+                deprecated=deprecated,
+                rich_help_panel=rich_help_panel,
+            )(func)
+
+        return _inner
+
+
+def typer_factory(help: str, epilog: str | None = None, cls: type[TyperGroup] | None = None) -> "HFCliApp":
+    """Create a Typer app with consistent settings.
+
+    Args:
+        help: Help text for the app.
+        epilog: Optional epilog text (use `generate_epilog` to create one).
+        cls: Optional Click group class to use (defaults to `HFCliTyperGroup`).
+
+    Returns:
+        A configured Typer app.
+    """
+    if cls is None:
+        cls = HFCliTyperGroup
+    return HFCliApp(
+        help=help,
+        epilog=epilog,
+        add_completion=True,
+        no_args_is_help=True,
+        cls=cls,
+        # Disable rich completely for consistent experience
+        rich_markup_mode=None,
+        rich_help_panel=None,
+        pretty_exceptions_enable=False,
+        # Disable TyperGroup's suggest_commands, it matches against raw aliased
+        # keys ("list | ls") leaking pipe syntax into user-facing messages.
+        # HFCliTyperGroup.resolve_command() handles suggestions with expanded names.
+        suggest_commands=False,
+        # Increase max content width for better readability
+        context_settings={
+            "max_content_width": 120,
+            "help_option_names": ["-h", "--help"],
+        },
+    )
+
+
+class RepoType(str, Enum):
+    model = "model"
+    dataset = "dataset"
+    space = "space"
+
+
+RepoIdArg = Annotated[
+    str,
+    typer.Argument(
+        help="The ID of the repo (e.g. `username/repo-name` or `spaces/username/repo-name`).",
+    ),
+]
+
+
+RepoTypeOpt = Annotated[
+    RepoType,
+    typer.Option(
+        "--type",
+        "--repo-type",
+        help="The type of repository (model, dataset, or space).",
+    ),
+]
+
+TokenOpt = Annotated[
+    str | None,
+    typer.Option(
+        help="A User Access Token generated from https://huggingface.co/settings/tokens.",
+    ),
+]
+
+PrivateOpt = Annotated[
+    bool | None,
+    typer.Option(
+        help="Whether to create a private repo if repo doesn't exist on the Hub. Ignored if the repo already exists.",
+    ),
+]
+
+RevisionOpt = Annotated[
+    str | None,
+    typer.Option(
+        help="Git revision id which can be a branch name, a tag, or a commit hash.",
+    ),
+]
+
+
+LimitOpt = Annotated[
+    int,
+    typer.Option(help="Limit the number of results."),
+]
+
+AuthorOpt = Annotated[
+    str | None,
+    typer.Option(help="Filter by author or organization."),
+]
+
+FilterOpt = Annotated[
+    list[str] | None,
+    typer.Option(help="Filter by tags (e.g. 'text-classification'). Can be used multiple times."),
+]
+
+SearchOpt = Annotated[
+    str | None,
+    typer.Option(help="Search query."),
+]
+
+
+# --- Env / Secrets shared options and parsing helpers (used by jobs, repos, etc.) ---
+
+EnvOpt = Annotated[
+    list[str] | None,
+    typer.Option(
+        "-e",
+        "--env",
+        help="Set environment variables. E.g. --env ENV=value",
+    ),
+]
+
+SecretsOpt = Annotated[
+    list[str] | None,
+    typer.Option(
+        "-s",
+        "--secrets",
+        help=(
+            "Set secret environment variables. E.g. --secrets SECRET=value"
+            " or `--secrets HF_TOKEN` to pass your Hugging Face token."
+        ),
+    ),
+]
+
+EnvFileOpt = Annotated[
+    str | None,
+    typer.Option(
+        "--env-file",
+        help="Read in a file of environment variables.",
+    ),
+]
+
+SecretsFileOpt = Annotated[
+    str | None,
+    typer.Option(
+        help="Read in a file of secret environment variables.",
+    ),
+]
+
+
+def _get_extended_environ() -> dict[str, str]:
+    """Return a copy of ``os.environ`` with the user's HF token injected (if available)."""
+    from huggingface_hub import get_token
+
+    extended_environ = os.environ.copy()
+    if (token := get_token()) is not None:
+        extended_environ["HF_TOKEN"] = token
+    return extended_environ
+
+
+def parse_env_map(
+    env: list[str] | None = None,
+    env_file: str | None = None,
+) -> dict[str, str | None]:
+    """Parse ``-e``/``--env``/``-s``/``--secrets`` and ``--env-file``/``--secrets-file`` CLI args into a dict.
+
+    Uses an extended environment that includes the user's HF token so that
+    bare ``--secrets HF_TOKEN`` resolves correctly.
+    """
+    extended_environ = _get_extended_environ()
+    env_map: dict[str, str | None] = {}
+    if env_file:
+        env_map.update(load_dotenv(Path(env_file).read_text(), environ=extended_environ))
+    for env_value in env or []:
+        env_map.update(load_dotenv(env_value, environ=extended_environ))
+    return env_map
+
+
+def env_map_to_key_value_list(env_map: dict[str, str | None]) -> list[dict[str, str]] | None:
+    """Convert an env/secrets dict to the ``[{"key": ..., "value": ...}]`` format used by the Hub API."""
+    if not env_map:
+        return None
+    return [{"key": k, "value": v or ""} for k, v in env_map.items()]
+
+
+VolumesOpt = Annotated[
+    list[str] | None,
+    typer.Option(
+        "-v",
+        "--volume",
+        help="Mount a volume. Format: hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro]. "
+        "TYPE is one of: models, datasets, spaces, buckets. "
+        "TYPE defaults to models if omitted. "
+        "models, datasets and spaces are always mounted read-only. buckets are read+write by default."
+        "E.g. -v hf://gpt2:/data or -v hf://datasets/org/ds:/data or -v hf://buckets/org/b:/mnt:ro",
+    ),
+]
+
+_HF_PREFIX = "hf://"
+_HF_VOLUME_TYPES = {
+    "models": constants.REPO_TYPE_MODEL,
+    "datasets": constants.REPO_TYPE_DATASET,
+    "spaces": constants.REPO_TYPE_SPACE,
+    "buckets": "bucket",
+}
+
+
+def parse_volumes(volumes: list[str] | None) -> "list[Volume] | None":
+    """Parse volume specs from CLI arguments.
+
+    Format: hf://[TYPE/]SOURCE[/PATH]:/MOUNT_PATH[:ro|:rw]
+    Where TYPE is one of: models, datasets, spaces, buckets (defaults to models if omitted).
+    SOURCE is the repo/bucket identifier (e.g. 'username/my-model').
+    PATH is an optional subfolder inside the repo/bucket.
+    MOUNT_PATH starts with '/'.
+    Optional ':ro' or ':rw' suffix for read-only or read-write.
+
+    Examples:
+        hf://gpt2:/data                          (model, implicit type)
+        hf://my-org/my-model:/data                (model, implicit type)
+        hf://models/my-org/my-model:/data         (model, explicit type)
+        hf://datasets/my-org/my-dataset:/data:ro
+        hf://buckets/my-org/my-bucket:/mnt
+        hf://spaces/my-org/my-space:/app
+        hf://datasets/org/ds/train:/data          (with path inside repo)
+        hf://buckets/org/b/sub/dir:/mnt           (with path inside bucket)
+    """
+
+    if not volumes:
+        return None
+
+    result: list[Volume] = []
+    for raw_spec in volumes:
+        # Strip :ro/:rw suffix
+        spec = raw_spec
+        read_only = None
+        if spec.endswith(":ro"):
+            read_only = True
+            spec = spec[:-3]
+        elif spec.endswith(":rw"):
+            read_only = False
+            spec = spec[:-3]
+
+        # Validate hf:// prefix
+        if not spec.startswith(_HF_PREFIX):
+            raise CLIError(
+                f"Invalid volume format: '{raw_spec}'. Source must start with 'hf://'. "
+                f"Expected hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro]. E.g. hf://gpt2:/data"
+            )
+        spec = spec[len(_HF_PREFIX) :]
+
+        # Find the mount path: look for :/ pattern
+        colon_slash_idx = spec.find(":/")
+        if colon_slash_idx == -1:
+            raise CLIError(
+                f"Invalid volume format: '{raw_spec}'. Expected hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro]. E.g. hf://gpt2:/data"
+            )
+        source_part = spec[:colon_slash_idx]
+        mount_path = spec[colon_slash_idx + 1 :]
+
+        # Parse type from source_part (first segment before /)
+        # Then split remaining into source (namespace/name or name) and optional path.
+        slash_idx = source_part.find("/")
+        if slash_idx == -1:
+            # No slash: bare source like "gpt2" -> model type
+            vol_type_str = constants.REPO_TYPE_MODEL
+            source = source_part
+            path = None
+        else:
+            first_segment = source_part[:slash_idx]
+            if first_segment in _HF_VOLUME_TYPES:
+                vol_type_str = _HF_VOLUME_TYPES[first_segment]
+                remaining = source_part[slash_idx + 1 :]
+            else:
+                # First segment isn't a known type -> model type
+                vol_type_str = constants.REPO_TYPE_MODEL
+                remaining = source_part
+
+            # Split remaining into source (namespace/name) and optional path.
+            # Repo/bucket IDs are "namespace/name" (2 segments) or "name" (1 segment).
+            # Any extra segments are the path inside the repo/bucket.
+            parts = remaining.split("/", 2)
+            if len(parts) >= 3:
+                source = parts[0] + "/" + parts[1]
+                path = parts[2]
+            else:
+                source = remaining
+                path = None
+
+        result.append(
+            Volume(
+                type=vol_type_str,
+                source=source,
+                mount_path=mount_path,
+                read_only=read_only,
+                path=path,
+            )
+        )
+    return result
+
+
+class OutputFormat(str, Enum):
+    """Output format for CLI list commands."""
+
+    table = "table"
+    json = "json"
+
+
+FormatOpt = Annotated[
+    OutputFormat,
+    typer.Option(
+        help="Output format (table or json).",
+    ),
+]
+
+
+def _set_output_mode(value: OutputFormatWithAuto) -> OutputFormatWithAuto:
+    out.set_mode(value)
+    return value
+
+
+FormatWithAutoOpt = Annotated[
+    OutputFormatWithAuto,
+    typer.Option(
+        help="Output format.",
+        callback=_set_output_mode,
+    ),
+]
+
+QuietOpt = Annotated[
+    bool,
+    typer.Option(
+        "-q",
+        "--quiet",
+        help="Print only IDs (one per line).",
+    ),
+]
+
+
+def _to_header(name: str) -> str:
+    """Convert a camelCase or PascalCase string to SCREAMING_SNAKE_CASE to be used as table header."""
+    s = re.sub(r"([a-z])([A-Z])", r"\1_\2", name)
+    return s.upper()
+
+
+def _format_value(value: Any) -> str:
+    """Convert a value to string for terminal display."""
+    if not value:
+        return ""
+    if isinstance(value, bool):
+        return "✔" if value else ""
+    if isinstance(value, datetime.datetime):
+        return value.strftime("%Y-%m-%d")
+    if isinstance(value, str) and re.match(r"^\d{4}-\d{2}-\d{2}T", value):
+        return value[:10]
+    if isinstance(value, list):
+        return ", ".join(_format_value(v) for v in value)
+    elif isinstance(value, dict):
+        if "name" in value:  # Likely to be a user or org => print name
+            return str(value["name"])
+        # TODO: extend if needed
+        return json.dumps(value)
+    return str(value)
+
+
+def _format_cell(value: Any, max_len: int = _MAX_CELL_LENGTH) -> str:
+    """Format a value + truncate it for table display."""
+    cell = _format_value(value)
+    if len(cell) > max_len:
+        cell = cell[: max_len - 3] + "..."
+    return cell
+
+
+def print_as_table(
+    items: Sequence[dict[str, Any]],
+    headers: list[str],
+    row_fn: Callable[[dict[str, Any]], list[str]],
+    alignments: dict[str, str] | None = None,
+) -> None:
+    """Print items as a formatted table.
+
+    Args:
+        items: Sequence of dictionaries representing the items to display.
+        headers: List of column headers.
+        row_fn: Function that takes an item dict and returns a list of string values for each column.
+        alignments: Optional mapping of header name to "left" or "right". Defaults to "left".
+    """
+    if not items:
+        print("No results found.")
+        return
+    rows = cast(list[list[Union[str, int]]], [row_fn(item) for item in items])
+    screaming_headers = [_to_header(h) for h in headers]
+    # Remap alignments keys to screaming case to match tabulate headers
+    screaming_alignments = {_to_header(k): v for k, v in (alignments or {}).items()}
+    print(tabulate(rows, headers=screaming_headers, alignments=screaming_alignments))
+
+
+def print_list_output(
+    items: Sequence[dict[str, Any]],
+    format: OutputFormat,
+    quiet: bool,
+    id_key: str = "id",
+    headers: list[str] | None = None,
+    row_fn: Callable[[dict[str, Any]], list[str]] | None = None,
+    alignments: dict[str, str] | None = None,
+) -> None:
+    """Print list command output in the specified format.
+
+    Args:
+        items: Sequence of dictionaries representing the items to display.
+        format: Output format.
+        quiet: If True, print only IDs (one per line).
+        id_key: Key to use for extracting IDs in quiet mode.
+        headers: Optional list of column names for headers. If not provided, auto-detected from keys.
+        row_fn: Optional function to extract row values. If not provided, uses _format_cell on each column.
+        alignments: Optional mapping of header name to "left" or "right". Defaults to "left".
+    """
+    if quiet:
+        for item in items:
+            print(item[id_key])
+        return
+
+    if format == OutputFormat.json:
+        print(json.dumps(list(items), indent=2, default=str))
+        return
+
+    if headers is None:
+        all_columns = list(items[0].keys()) if items else [id_key]
+        headers = [col for col in all_columns if any(_format_cell(item.get(col)) for item in items)]
+
+    if row_fn is None:
+
+        def row_fn(item: dict[str, Any]) -> list[str]:
+            return [_format_cell(item.get(col)) for col in headers]  # type: ignore[union-attr]
+
+    print_as_table(items, headers=headers, row_fn=row_fn, alignments=alignments)
+
+
+def _serialize_value(v: object) -> object:
+    """Recursively serialize a value to be JSON-compatible."""
+    if isinstance(v, datetime.datetime):
+        return v.isoformat()
+    elif isinstance(v, dict):
+        return {key: _serialize_value(val) for key, val in v.items() if val is not None}
+    elif isinstance(v, list):
+        return [_serialize_value(item) for item in v]
+    return v
+
+
+def api_object_to_dict(info: Any) -> dict[str, Any]:
+    """Convert repo info dataclasses to json-serializable dicts."""
+    return {k: _serialize_value(v) for k, v in dataclasses.asdict(info).items() if v is not None}
+
+
+def make_expand_properties_parser(valid_properties: Sequence[ExpandPropertyT]):
+    """Create a callback to parse and validate comma-separated expand properties."""
+
+    def _parse_expand_properties(value: str | None) -> list[ExpandPropertyT] | None:
+        if value is None:
+            return None
+        properties = [p.strip() for p in value.split(",")]
+        for prop in properties:
+            if prop not in valid_properties:
+                raise typer.BadParameter(
+                    f"Invalid expand property: '{prop}'. Valid values are: {', '.join(valid_properties)}"
+                )
+        return [cast(ExpandPropertyT, prop) for prop in properties]
+
+    return _parse_expand_properties
+
+
+### PyPI VERSION CHECKER
+
+
+def check_cli_update(library: Literal["huggingface_hub", "transformers"]) -> None:
+    """
+    Check whether a newer version of a library is available on PyPI.
+
+    If a newer version is found and stdin/stderr are attached to a TTY, prompt the user to update interactively.
+    Otherwise (non-TTY or update command cannot be determined), print a warning to stderr.
+
+    If current version is a pre-release (e.g. `1.0.0.rc1`), or a dev version (e.g. `1.0.0.dev1`), no check is performed.
+
+    This function is called at the entry point of the CLI. It only performs the check once every 24 hours, and any error
+    during the check is caught and logged, to avoid breaking the CLI.
+
+    Args:
+        library: The library to check for updates. Currently supports "huggingface_hub" and "transformers".
+    """
+    try:
+        _check_cli_update(library)
+    except Exception:
+        # We don't want the CLI to fail on version checks, no matter the reason.
+        logger.debug("Error while checking for CLI update.", exc_info=True)
+
+
+def _check_cli_update(library: Literal["huggingface_hub", "transformers"]) -> None:
+    current_version = importlib.metadata.version(library)
+
+    # Skip if current version is a pre-release or dev version
+    if any(tag in current_version for tag in ["rc", "dev"]):
+        return
+
+    # Skip if already checked in the last 24 hours
+    if os.path.exists(constants.CHECK_FOR_UPDATE_DONE_PATH):
+        mtime = os.path.getmtime(constants.CHECK_FOR_UPDATE_DONE_PATH)
+        if (time.time() - mtime) < 24 * 3600:
+            return
+
+    # Touch the file to mark that we did the check now
+    Path(constants.CHECK_FOR_UPDATE_DONE_PATH).parent.mkdir(parents=True, exist_ok=True)
+    Path(constants.CHECK_FOR_UPDATE_DONE_PATH).touch()
+
+    # Check latest version from PyPI
+    response = get_session().get(f"https://pypi.org/pypi/{library}/json", timeout=2)
+    hf_raise_for_status(response)
+    data = response.json()
+    latest_version = data["info"]["version"]
+
+    if current_version == latest_version:
+        return
+
+    if library == "huggingface_hub":
+        update_command = _get_huggingface_hub_update_command()
+    else:
+        update_command = _get_transformers_update_command()
+
+    if sys.stdin.isatty() and sys.stderr.isatty() and update_command is not None:
+        _prompt_autoupdate(library, current_version, latest_version, update_command)
+    else:
+        display_cmd = " ".join(update_command) if update_command else None
+        update_hint = f"To update, run: {ANSI.bold(display_cmd)}" if display_cmd else ""
+        click.echo(
+            ANSI.yellow(
+                f"A new version of {library} ({latest_version}) is available! "
+                f"You are using version {current_version}." + (f"\n{update_hint}" if update_hint else "") + "\n"
+            ),
+            file=sys.stderr,
+        )
+
+
+def _prompt_autoupdate(
+    library: str,
+    current_version: str,
+    latest_version: str,
+    update_command: list[str],
+) -> None:
+    """Interactively ask the user if they want to update, and run the update command if accepted.
+
+    After a successful update the CLI exits so the user can re-run their command with the new version.
+    All output goes to stderr to keep stdout clean for command output.
+    """
+    display_cmd = " ".join(update_command)
+
+    click.echo("", file=sys.stderr)
+    click.echo(
+        ANSI.yellow(f"  A new version of {library} is available: {current_version} → {latest_version}"),
+        file=sys.stderr,
+    )
+    click.echo("", file=sys.stderr)
+
+    click.echo(
+        ANSI.yellow("  Do you want to update now? [Y/n] ") + ANSI.gray(f"({display_cmd})") + " ",
+        file=sys.stderr,
+        nl=False,
+    )
+    try:
+        raw_answer = sys.stdin.readline()
+    except (EOFError, KeyboardInterrupt):
+        click.echo("", file=sys.stderr)
+        return
+
+    if raw_answer == "":
+        # EOF (e.g. Ctrl+D) — treat as cancellation, not acceptance
+        click.echo("", file=sys.stderr)
+        return
+
+    answer = raw_answer.strip().lower()  # Note: if user press 'Enter', raw_answer is `\n`
+    if answer in ("", "y", "yes"):
+        click.echo("", file=sys.stderr)
+        click.echo(ANSI.gray(f"  Running: {display_cmd}"), file=sys.stderr)
+        click.echo("", file=sys.stderr)
+        returncode = subprocess.call(update_command)
+        if returncode == 0:
+            click.echo("", file=sys.stderr)
+            click.echo(
+                ANSI.green(f"  ✓ Successfully updated {library} to {latest_version}. Please re-run your command."),
+                file=sys.stderr,
+            )
+            raise SystemExit(0)
+        else:
+            click.echo("", file=sys.stderr)
+            click.echo(
+                ANSI.red(f"  ✗ Update failed (exit code {returncode}). Please update manually."),
+                file=sys.stderr,
+            )
+    else:
+        click.echo(
+            ANSI.gray(f"  Skipped. You can update later with: {display_cmd}"),
+            file=sys.stderr,
+        )
+    click.echo("", file=sys.stderr)
+
+
+def _get_huggingface_hub_update_command() -> list[str] | None:
+    """Return the command to update huggingface_hub as an argv list, or None if the installation method is unknown."""
+    match installation_method():
+        case "brew":
+            return ["brew", "upgrade", "hf"]
+        case "hf_installer" if os.name == "nt":
+            return ["powershell", "-NoProfile", "-Command", "iwr -useb https://hf.co/cli/install.ps1 | iex"]
+        case "hf_installer":
+            return ["bash", "-c", "curl -LsSf https://hf.co/cli/install.sh | bash -"]
+        case "pip":
+            return [sys.executable, "-m", "pip", "install", "-U", "huggingface_hub"]
+        case _:
+            return None
+
+
+def _get_transformers_update_command() -> list[str] | None:
+    """Return the command to update transformers as an argv list, or None if the installation method is unknown."""
+    match installation_method():
+        case "hf_installer" if os.name == "nt":
+            return [
+                "powershell",
+                "-NoProfile",
+                "-Command",
+                "iwr -useb https://hf.co/cli/install.ps1 | iex -WithTransformers",
+            ]
+        case "hf_installer":
+            return ["bash", "-c", "curl -LsSf https://hf.co/cli/install.sh | bash -s -- --with-transformers"]
+        case "pip":
+            return [sys.executable, "-m", "pip", "install", "-U", "transformers"]
+        case _:
+            return None

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/cli/_errors.py

@@ -0,0 +1,113 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# 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.
+"""CLI error handling utilities."""
+
+import traceback
+from collections.abc import Callable
+
+from huggingface_hub.errors import (
+    BucketNotFoundError,
+    CLIError,
+    CLIExtensionInstallError,
+    GatedRepoError,
+    HfHubHTTPError,
+    LocalTokenNotFoundError,
+    RemoteEntryNotFoundError,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+)
+
+
+def _format_repo_not_found(error: RepositoryNotFoundError) -> str:
+    label = error.repo_type.capitalize() if error.repo_type else "Repository"
+    if error.repo_id:
+        msg = f"{label} '{error.repo_id}' not found."
+    else:
+        msg = f"{label} not found."
+    msg += " If the repo is private, make sure you are authenticated and your token has the required permissions."
+    return msg
+
+
+def _format_gated_repo(error: GatedRepoError) -> str:
+    label = error.repo_type if error.repo_type else "repository"
+    if error.repo_id:
+        return f"Access denied. {label.capitalize()} '{error.repo_id}' requires approval."
+    return f"Access denied. This {label} requires approval."
+
+
+def _format_bucket_not_found(error: BucketNotFoundError) -> str:
+    if error.bucket_id:
+        return f"Bucket '{error.bucket_id}' not found. If the bucket is private, make sure you are authenticated and your token has the required permissions."
+    return "Bucket not found. Check the bucket id (namespace/name). If the bucket is private, make sure you are authenticated and your token has the required permissions."
+
+
+def _format_entry_not_found(error: RemoteEntryNotFoundError) -> str:
+    label = error.repo_type if error.repo_type else "repository"
+    url = str(error.response.url) if error.response else None
+    if error.repo_id:
+        msg = f"File not found in {label} '{error.repo_id}'."
+    else:
+        msg = f"File not found in {label}."
+    if url:
+        msg += f"\nURL: {url}"
+    return msg
+
+
+def _format_revision_not_found(error: RevisionNotFoundError) -> str:
+    label = error.repo_type if error.repo_type else "repository"
+    if error.repo_id:
+        return f"Revision not found in {label} '{error.repo_id}'."
+    return f"Revision not found in {label}. Check the revision parameter."
+
+
+def _format_cli_error(error: CLIError) -> str:
+    """No traceback, just the error message."""
+    return str(error)
+
+
+def _format_cli_extension_install_error(error: CLIExtensionInstallError) -> str:
+    """Format a CLI extension installation error.
+
+    The error is likely to be a tricky subprocess error to investigate. In this specific case we want to format the
+    traceback of the root cause while keeping the "nicely formatted" error message of the CLIExtensionInstallError
+    as a 1-line message.
+    """
+    cause_tb = (
+        "".join(traceback.format_exception(type(error.__cause__), error.__cause__, error.__cause__.__traceback__))
+        if error.__cause__ is not None
+        else ""
+    )
+    return f"{cause_tb}\n{error}"
+
+
+CLI_ERROR_MAPPINGS: dict[type[Exception], Callable[..., str]] = {
+    # GatedRepoError must come before RepositoryNotFoundError (it's a subclass).
+    GatedRepoError: _format_gated_repo,
+    BucketNotFoundError: _format_bucket_not_found,
+    RepositoryNotFoundError: _format_repo_not_found,
+    RevisionNotFoundError: _format_revision_not_found,
+    LocalTokenNotFoundError: lambda _: "Not logged in. Run 'hf auth login' first.",
+    RemoteEntryNotFoundError: _format_entry_not_found,
+    HfHubHTTPError: lambda error: str(error),
+    ValueError: lambda error: f"Invalid value. {error}",
+    CLIExtensionInstallError: _format_cli_extension_install_error,
+    CLIError: _format_cli_error,
+}
+
+
+def format_known_exception(error: Exception) -> str | None:
+    for exc_type, formatter in CLI_ERROR_MAPPINGS.items():
+        if isinstance(error, exc_type):
+            return formatter(error)
+    return None

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/cli/_output.py

@@ -0,0 +1,238 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# 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.
+"""Output framework for the `hf` CLI."""
+
+import dataclasses
+import datetime
+import json
+import re
+import sys
+from collections.abc import Sequence
+from enum import Enum
+from typing import Any
+
+from huggingface_hub.utils import ANSI, is_agent, tabulate
+
+
+# TODO: remove OutputFormat in _cli_utils.py once all commands are migrated to OutputFormatWithAuto.
+class OutputFormatWithAuto(str, Enum):
+    """Output format for CLI commands with auto detection of agent/human mode."""
+
+    agent = "agent"
+    auto = "auto"
+    human = "human"
+    json = "json"
+    quiet = "quiet"
+
+
+class Output:
+    """Output sink for the `hf` CLI.
+
+    Mode is resolved once at init time based on `is_agent()` auto-detection
+    and can be overridden per-command via `set_mode()`.
+    """
+
+    mode: OutputFormatWithAuto
+
+    def __init__(self) -> None:
+        self.set_mode()
+
+    def set_mode(self, mode: OutputFormatWithAuto = OutputFormatWithAuto.auto) -> None:
+        """Override the output mode (called by commands that receive ``--format``)."""
+        if mode == OutputFormatWithAuto.auto:
+            mode = OutputFormatWithAuto.agent if is_agent() else OutputFormatWithAuto.human
+        self.mode = mode
+
+    def text(self, msg: str | None = None, *, human: str | None = None, agent: str | None = None) -> None:
+        """Print a free-form text message to stdout."""
+        if msg is not None:
+            if human is not None or agent is not None:
+                raise ValueError("Cannot mix 'msg' with 'human'/'agent'.")
+            human = msg
+            agent = _strip_ansi(msg)
+
+        match self.mode:
+            case OutputFormatWithAuto.human:
+                if human is not None:
+                    print(human)
+            case OutputFormatWithAuto.agent:
+                if agent is not None:
+                    print(agent)
+            # json/quiet: no-op
+
+    def table(
+        self,
+        items: Sequence[dict[str, Any]],
+        *,
+        headers: list[str] | None = None,
+        id_key: str | None = None,
+        alignments: dict[str, str] | None = None,
+    ) -> None:
+        """Print tabular data to stdout.
+
+        Args:
+            items: List of dicts. Headers are auto-detected from keys if not provided.
+            headers: Explicit column names. If None, derived from dict keys (all-None columns filtered).
+            id_key: Key to print in quiet mode. If None, uses the first header.
+            alignments: Optional mapping of header name to "left" or "right". Defaults to "left".
+        """
+        if not items:
+            match self.mode:
+                case OutputFormatWithAuto.agent | OutputFormatWithAuto.human:
+                    print("No results found.")
+                case OutputFormatWithAuto.json:
+                    print("[]")
+            return
+
+        if headers is None:
+            all_columns = list(items[0].keys())
+            headers = [col for col in all_columns if any(item.get(col) is not None for item in items)]
+        rows = [[item.get(h) for h in headers] for item in items]
+
+        match self.mode:
+            case OutputFormatWithAuto.human:  # padded table, truncated cells, SCREAMING_SNAKE headers
+                formatted_rows: list[list[str | int]] = [[_format_table_cell_human(v) for v in row] for row in rows]
+                screaming_headers = [_to_header(h) for h in headers]
+                screaming_alignments = {_to_header(k): v for k, v in (alignments or {}).items()}
+                print(tabulate(formatted_rows, headers=screaming_headers, alignments=screaming_alignments))
+            case OutputFormatWithAuto.agent:  # TSV, no truncation, full timestamps
+                print("\t".join(headers))
+                for row in rows:
+                    print("\t".join(_format_table_cell_agent(v) for v in row))
+            case OutputFormatWithAuto.json:  # compact JSON array
+                print(json.dumps(list(items), default=str))
+            case OutputFormatWithAuto.quiet:  # id_key column (or first column), one per line
+                quiet_key = id_key or headers[0]
+                for item in items:
+                    print(item.get(quiet_key, ""))
+
+    def dict(self, data: Any) -> None:
+        """Print structured data as JSON in all modes (indented for human, compact otherwise).
+
+        Accepts a dict or a dataclass.
+        """
+        if dataclasses.is_dataclass(data) and not isinstance(data, type):
+            data = _dataclass_to_dict(data)
+        indent = 2 if self.mode == OutputFormatWithAuto.human else None
+        print(json.dumps(data, indent=indent, default=str))
+
+    def result(self, message: str, **data: Any) -> None:
+        """Print a success summary to stdout."""
+        match self.mode:
+            case OutputFormatWithAuto.human:  # ✓ message + key: value lines
+                parts = [ANSI.green(f"✓ {message}")]
+                for k, v in data.items():
+                    if v is not None:
+                        parts.append(f"  {k}: {v}")
+                print("\n".join(parts))
+            case OutputFormatWithAuto.agent:  # key=val pairs, space-separated
+                parts = [f"{k}={v}" for k, v in data.items() if v is not None]
+                print(" ".join(parts) if parts else message)
+            case OutputFormatWithAuto.json:  # json.dumps(data), message ignored
+                print(json.dumps(data, default=str) if data else "")
+            case OutputFormatWithAuto.quiet:  # first value only
+                values = list(data.values())
+                if values:
+                    print(values[0])
+
+    def warning(self, message: str) -> None:
+        """Print a non-fatal warning to stderr (all modes)."""
+        if self.mode == OutputFormatWithAuto.human:
+            print(ANSI.yellow(f"Warning: {message}"), file=sys.stderr)
+        else:
+            print(f"Warning: {message}", file=sys.stderr)
+
+    def error(self, message: str) -> None:
+        """Print an error to stderr (all modes)."""
+        if self.mode == OutputFormatWithAuto.human:
+            print(ANSI.red(f"Error: {message}"), file=sys.stderr)
+        else:
+            print(f"Error: {message}", file=sys.stderr)
+
+    def hint(self, message: str) -> None:
+        """Print a helpful hint to stderr (human: gray, agent/json: plain text)."""
+        if self.mode == OutputFormatWithAuto.human:
+            print(ANSI.gray(f"Hint: {message}"), file=sys.stderr)
+        else:
+            print(f"Hint: {message}", file=sys.stderr)
+
+
+# HELPERS
+
+
+def _serialize_value(v: object) -> object:
+    """Recursively serialize a value to be JSON-compatible."""
+    if isinstance(v, datetime.datetime):
+        return v.isoformat()
+    elif isinstance(v, dict):
+        return {key: _serialize_value(val) for key, val in v.items() if val is not None}
+    elif isinstance(v, list):
+        return [_serialize_value(item) for item in v]
+    return v
+
+
+def _dataclass_to_dict(info: Any) -> dict[str, Any]:
+    """Convert a dataclass to a json-serializable dict."""
+    return {k: _serialize_value(v) for k, v in dataclasses.asdict(info).items() if v is not None}
+
+
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+_MAX_CELL_LENGTH = 35
+
+
+def _strip_ansi(text: str) -> str:
+    return _ANSI_RE.sub("", text)
+
+
+def _to_header(name: str) -> str:
+    """Convert a camelCase or PascalCase string to SCREAMING_SNAKE_CASE."""
+    s = re.sub(r"([a-z])([A-Z])", r"\1_\2", name)
+    return s.upper()
+
+
+def _format_table_value_human(value: Any) -> str:
+    """Convert a value to string for terminal display."""
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "✔" if value else ""
+    if isinstance(value, datetime.datetime):
+        return value.strftime("%Y-%m-%d")
+    if isinstance(value, str) and re.match(r"^\d{4}-\d{2}-\d{2}T", value):
+        return value[:10]
+    if isinstance(value, list):
+        return ", ".join(_format_table_value_human(v) for v in value)
+    elif isinstance(value, dict):
+        if "name" in value:  # Likely to be a user or org => print name
+            return str(value["name"])
+        return json.dumps(value)
+    return str(value)
+
+
+def _format_table_cell_human(value: Any, max_len: int = _MAX_CELL_LENGTH) -> str:
+    """Format a value + truncate it for table display."""
+    cell = _format_table_value_human(value)
+    if len(cell) > max_len:
+        cell = cell[: max_len - 3] + "..."
+    return cell
+
+
+def _format_table_cell_agent(value: Any) -> str:
+    """Format a cell value for agent TSV output (ISO timestamps, tabs escaped)."""
+    if isinstance(value, datetime.datetime):
+        return value.isoformat()
+    return str(value).replace("\t", " ")
+
+
+out = Output()

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/cli/_skills.py

@@ -0,0 +1,419 @@
+"""Internal helpers for Hugging Face marketplace skill installation and upgrades."""
+
+import base64
+import io
+import json
+import shutil
+import tarfile
+import tempfile
+from dataclasses import dataclass, replace
+from pathlib import Path, PurePosixPath
+from typing import Any, Literal
+
+from huggingface_hub.errors import CLIError
+from huggingface_hub.utils import get_session
+
+
+DEFAULT_SKILLS_REPO_ID = "huggingface/skills"
+DEFAULT_SKILLS_REPO_OWNER, DEFAULT_SKILLS_REPO_NAME = DEFAULT_SKILLS_REPO_ID.split("/")
+DEFAULT_SKILLS_REF = "main"
+MARKETPLACE_PATH = ".claude-plugin/marketplace.json"
+GITHUB_API_TIMEOUT = 10
+SKILL_MANIFEST_FILENAME = ".hf-skill-manifest.json"
+SKILL_MANIFEST_SCHEMA_VERSION = 1
+
+SkillUpdateStatus = Literal[
+    "up_to_date",
+    "update_available",
+    "updated",
+    "unmanaged",
+    "invalid_metadata",
+    "source_unreachable",
+]
+
+
+@dataclass(frozen=True)
+class MarketplaceSkill:
+    name: str
+    repo_path: str
+
+
+@dataclass(frozen=True)
+class InstalledSkillManifest:
+    schema_version: int
+    installed_revision: str
+
+
+@dataclass(frozen=True)
+class SkillUpdateInfo:
+    name: str
+    skill_dir: Path
+    status: SkillUpdateStatus
+    detail: str | None = None
+    current_revision: str | None = None
+    available_revision: str | None = None
+
+
+def load_marketplace_skills() -> list[MarketplaceSkill]:
+    """Load skills from the default Hugging Face marketplace."""
+    payload = _load_marketplace_payload()
+    plugins = payload.get("plugins")
+    if not isinstance(plugins, list):
+        raise CLIError("Invalid marketplace payload: expected a top-level 'plugins' list.")
+
+    skills: list[MarketplaceSkill] = []
+    for plugin in plugins:
+        if not isinstance(plugin, dict):
+            continue
+        name = plugin.get("name")
+        source = plugin.get("source")
+        if not isinstance(name, str) or not isinstance(source, str):
+            continue
+        skills.append(MarketplaceSkill(name=name, repo_path=_normalize_repo_path(source)))
+    return skills
+
+
+def get_marketplace_skill(selector: str) -> MarketplaceSkill:
+    """Resolve a marketplace skill by name."""
+    selected = _select_marketplace_skill(load_marketplace_skills(), selector)
+    if selected is None:
+        raise CLIError(
+            f"Skill '{selector}' not found in {DEFAULT_SKILLS_REPO_ID}. "
+            "Try `hf skills add` to install `hf-cli` or use a known skill name."
+        )
+    return selected
+
+
+def install_marketplace_skill(skill: MarketplaceSkill, destination_root: Path, force: bool = False) -> Path:
+    """Install a marketplace skill into a local skills directory."""
+    destination_root = destination_root.expanduser().resolve()
+    destination_root.mkdir(parents=True, exist_ok=True)
+    install_dir = destination_root / skill.name
+
+    if install_dir.exists() and not force:
+        raise FileExistsError(f"Skill already exists: {install_dir}")
+
+    if install_dir.exists():
+        with tempfile.TemporaryDirectory(dir=destination_root, prefix=f".{install_dir.name}.install-") as tmp_dir_str:
+            tmp_dir = Path(tmp_dir_str)
+            staged_dir = tmp_dir / install_dir.name
+            _populate_install_dir(skill=skill, install_dir=staged_dir)
+            _atomic_replace_directory(existing_dir=install_dir, staged_dir=staged_dir)
+        return install_dir
+
+    try:
+        _populate_install_dir(skill=skill, install_dir=install_dir)
+    except Exception:
+        if install_dir.exists():
+            shutil.rmtree(install_dir)
+        raise
+    return install_dir
+
+
+def check_for_updates(
+    roots: list[Path],
+    selector: str | None = None,
+) -> list[SkillUpdateInfo]:
+    """Check managed skill installs for newer upstream revisions."""
+    marketplace_skills = {skill.name.lower(): skill for skill in load_marketplace_skills()}
+    updates = [_evaluate_update(skill_dir, marketplace_skills) for skill_dir in _iter_unique_skill_dirs(roots)]
+    filtered = _filter_updates(updates, selector)
+    if selector is not None and not filtered:
+        raise CLIError(f"No installed skills match '{selector}'.")
+    return filtered
+
+
+def apply_updates(
+    roots: list[Path],
+    selector: str | None = None,
+) -> list[SkillUpdateInfo]:
+    """Upgrade managed skills in place when the upstream revision changes."""
+    updates = check_for_updates(roots, selector)
+    results: list[SkillUpdateInfo] = []
+    for update in updates:
+        results.append(_apply_single_update(update))
+    return results
+
+
+def read_installed_skill_manifest(skill_dir: Path) -> tuple[InstalledSkillManifest | None, str | None]:
+    """Read local skill metadata written by `hf skills add`."""
+    manifest_path = skill_dir / SKILL_MANIFEST_FILENAME
+    if not manifest_path.exists():
+        return None, None
+    try:
+        payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except Exception as exc:  # noqa: BLE001
+        return None, f"invalid json: {exc}"
+    if not isinstance(payload, dict):
+        return None, "metadata root must be an object"
+    try:
+        return _parse_installed_skill_manifest(payload), None
+    except ValueError as exc:
+        return None, str(exc)
+
+
+def write_installed_skill_manifest(skill_dir: Path, manifest: InstalledSkillManifest) -> None:
+    payload = {
+        "schema_version": manifest.schema_version,
+        "installed_revision": manifest.installed_revision,
+    }
+    (skill_dir / SKILL_MANIFEST_FILENAME).write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _load_marketplace_payload() -> dict[str, Any]:
+    response = _fetch_from_skills_repo(
+        f"contents/{MARKETPLACE_PATH}",
+        params={"ref": DEFAULT_SKILLS_REF},
+    )
+    try:
+        payload = response.json()
+    except Exception as exc:  # noqa: BLE001
+        raise CLIError(f"Failed to decode GitHub API response for 'contents/{MARKETPLACE_PATH}': {exc}") from exc
+    if not isinstance(payload, dict):
+        raise CLIError("Invalid marketplace response: expected a JSON object.")
+
+    content = payload.get("content")
+    encoding = payload.get("encoding")
+    if not isinstance(content, str) or encoding != "base64":
+        raise CLIError("Invalid marketplace payload: expected base64-encoded content.")
+
+    try:
+        decoded = base64.b64decode(content).decode("utf-8")
+        parsed = json.loads(decoded)
+    except Exception as exc:  # noqa: BLE001
+        raise CLIError(f"Failed to decode marketplace payload: {exc}") from exc
+
+    if not isinstance(parsed, dict):
+        raise CLIError("Invalid marketplace payload: expected a JSON object.")
+    return parsed
+
+
+def _select_marketplace_skill(skills: list[MarketplaceSkill], selector: str) -> MarketplaceSkill | None:
+    selector_lower = selector.strip().lower()
+    for skill in skills:
+        if skill.name.lower() == selector_lower:
+            return skill
+    return None
+
+
+def _normalize_repo_path(path: str) -> str:
+    normalized = path.strip()
+    while normalized.startswith("./"):
+        normalized = normalized[2:]
+    normalized = normalized.strip("/")
+    if not normalized:
+        raise CLIError("Invalid marketplace entry: empty source path.")
+    return normalized
+
+
+def _populate_install_dir(skill: MarketplaceSkill, install_dir: Path) -> None:
+    installed_revision = _resolve_available_revision(skill)
+    install_dir.mkdir(parents=True, exist_ok=True)
+    _extract_remote_github_path(
+        revision=installed_revision,
+        source_path=skill.repo_path,
+        install_dir=install_dir,
+    )
+    _validate_installed_skill_dir(install_dir)
+    write_installed_skill_manifest(
+        install_dir,
+        InstalledSkillManifest(
+            schema_version=SKILL_MANIFEST_SCHEMA_VERSION,
+            installed_revision=installed_revision,
+        ),
+    )
+
+
+def _validate_installed_skill_dir(skill_dir: Path) -> None:
+    skill_file = skill_dir / "SKILL.md"
+    if not skill_file.is_file():
+        raise RuntimeError(f"Installed skill is missing SKILL.md: {skill_file}")
+
+
+def _extract_remote_github_path(revision: str, source_path: str, install_dir: Path) -> None:
+    tar_bytes = _fetch_from_skills_repo(f"tarball/{revision}").content
+    _extract_tar_subpath(tar_bytes, source_path=source_path, install_dir=install_dir)
+
+
+def _extract_tar_subpath(tar_bytes: bytes, source_path: str, install_dir: Path) -> None:
+    """Extract a skill subdirectory from a tar archive.
+
+    GitHub tarballs include a leading `<repo>-<revision>/` directory. The helper also
+    accepts archives that start directly at `skills/<name>/...` to keep tests simple.
+    """
+    source_parts = PurePosixPath(source_path).parts
+    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:*") as archive:
+        members = archive.getmembers()
+        matched = False
+        for member in members:
+            relative_parts = _member_relative_parts(member_name=member.name, source_parts=source_parts)
+            if relative_parts is None:
+                continue
+            if not relative_parts:
+                matched = True
+                continue
+            matched = True
+            relative_path = Path(*relative_parts)
+            if ".." in relative_path.parts:
+                raise RuntimeError(f"Invalid path found in archive for {source_path}.")
+            destination_path = install_dir / relative_path
+            if member.isdir():
+                destination_path.mkdir(parents=True, exist_ok=True)
+                continue
+            if not member.isfile():
+                continue
+            destination_path.parent.mkdir(parents=True, exist_ok=True)
+            extracted = archive.extractfile(member)
+            if extracted is None:
+                raise RuntimeError(f"Failed to extract {member.name}.")
+            destination_path.write_bytes(extracted.read())
+    if not matched:
+        raise FileNotFoundError(f"Path '{source_path}' not found in source archive.")
+
+
+def _member_relative_parts(member_name: str, source_parts: tuple[str, ...]) -> tuple[str, ...] | None:
+    path_parts = PurePosixPath(member_name).parts
+    if tuple(path_parts[: len(source_parts)]) == source_parts:
+        return path_parts[len(source_parts) :]
+    if len(path_parts) > len(source_parts) and tuple(path_parts[1 : 1 + len(source_parts)]) == source_parts:
+        return path_parts[1 + len(source_parts) :]
+    return None
+
+
+def _atomic_replace_directory(existing_dir: Path, staged_dir: Path) -> None:
+    backup_dir = staged_dir.parent / f"{existing_dir.name}.backup"
+    try:
+        existing_dir.rename(backup_dir)
+        staged_dir.rename(existing_dir)
+        shutil.rmtree(backup_dir)
+    except Exception:
+        if backup_dir.exists() and not existing_dir.exists():
+            backup_dir.rename(existing_dir)
+        raise
+
+
+def _iter_unique_skill_dirs(roots: list[Path]) -> list[Path]:
+    seen: set[Path] = set()
+    discovered: list[Path] = []
+    for root in roots:
+        root = root.expanduser().resolve()
+        if not root.is_dir():
+            continue
+        for child in sorted(root.iterdir()):
+            if child.name.startswith("."):
+                continue
+            if not child.is_dir() and not child.is_symlink():
+                continue
+            resolved = child.resolve()
+            if resolved in seen or not resolved.is_dir():
+                continue
+            seen.add(resolved)
+            discovered.append(resolved)
+    return discovered
+
+
+def _evaluate_update(skill_dir: Path, marketplace_skills: dict[str, MarketplaceSkill]) -> SkillUpdateInfo:
+    base = SkillUpdateInfo(name=skill_dir.name, skill_dir=skill_dir, status="unmanaged")
+
+    manifest, error = read_installed_skill_manifest(skill_dir)
+    if manifest is None:
+        return replace(base, status="invalid_metadata" if error else "unmanaged", detail=error)
+
+    skill = marketplace_skills.get(skill_dir.name.lower())
+    if skill is None:
+        return replace(
+            base,
+            status="source_unreachable",
+            detail=f"Skill '{skill_dir.name}' is no longer available in {DEFAULT_SKILLS_REPO_ID}.",
+            current_revision=manifest.installed_revision,
+        )
+
+    current_revision = manifest.installed_revision
+    try:
+        available_revision = _resolve_available_revision(skill)
+    except Exception as exc:
+        return replace(base, status="source_unreachable", detail=str(exc), current_revision=current_revision)
+
+    status: SkillUpdateStatus = "up_to_date" if available_revision == current_revision else "update_available"
+    return replace(
+        base,
+        status=status,
+        detail="update available" if status == "update_available" else None,
+        current_revision=current_revision,
+        available_revision=available_revision,
+    )
+
+
+def _apply_single_update(update: SkillUpdateInfo) -> SkillUpdateInfo:
+    if update.status != "update_available":
+        return update
+
+    try:
+        skill = get_marketplace_skill(update.skill_dir.name)
+        install_marketplace_skill(skill, update.skill_dir.parent, force=True)
+    except Exception as exc:
+        return replace(update, status="source_unreachable", detail=str(exc))
+
+    return replace(update, status="updated", detail="updated")
+
+
+def _filter_updates(updates: list[SkillUpdateInfo], selector: str | None) -> list[SkillUpdateInfo]:
+    if selector is None:
+        return updates
+    selector_lower = selector.strip().lower()
+    return [update for update in updates if update.name.lower() == selector_lower]
+
+
+def _resolve_available_revision(skill: MarketplaceSkill) -> str:
+    response = _fetch_from_skills_repo(
+        "commits",
+        params={"sha": DEFAULT_SKILLS_REF, "path": skill.repo_path, "per_page": 1},
+    )
+    try:
+        payload = response.json()
+    except Exception as exc:  # noqa: BLE001
+        raise CLIError(f"Failed to decode GitHub API response for 'commits': {exc}") from exc
+    if not isinstance(payload, list) or not payload:
+        raise CLIError(f"Unable to resolve the current revision for skill '{skill.name}'.")
+
+    latest = payload[0]
+    if not isinstance(latest, dict):
+        raise CLIError(f"Invalid commit response while resolving skill '{skill.name}'.")
+
+    revision = latest.get("sha")
+    if not isinstance(revision, str) or not revision:
+        raise CLIError(f"Invalid commit response while resolving skill '{skill.name}'.")
+    return revision
+
+
+def _parse_installed_skill_manifest(payload: dict[str, Any]) -> InstalledSkillManifest:
+    if payload.get("schema_version") != SKILL_MANIFEST_SCHEMA_VERSION:
+        raise ValueError(f"unsupported schema_version: {payload.get('schema_version')}")
+
+    installed_revision = payload.get("installed_revision")
+    if not isinstance(installed_revision, str) or not installed_revision:
+        raise ValueError("missing installed_revision")
+
+    return InstalledSkillManifest(
+        schema_version=SKILL_MANIFEST_SCHEMA_VERSION,
+        installed_revision=installed_revision,
+    )
+
+
+def _fetch_from_skills_repo(endpoint: str, params: dict[str, Any] | None = None) -> Any:
+    url = f"https://api.github.com/repos/{DEFAULT_SKILLS_REPO_OWNER}/{DEFAULT_SKILLS_REPO_NAME}/{endpoint.lstrip('/')}"
+    try:
+        response = get_session().get(
+            url,
+            params=params,
+            headers={"Accept": "application/vnd.github+json"},
+            follow_redirects=True,
+            timeout=GITHUB_API_TIMEOUT,
+        )
+        response.raise_for_status()
+    except Exception as exc:  # noqa: BLE001
+        raise CLIError(f"Failed to fetch '{endpoint}' from {DEFAULT_SKILLS_REPO_ID}: {exc}") from exc
+    return response

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/__init__.py

@@ -0,0 +1,204 @@
+# This file is auto-generated by `utils/generate_inference_types.py`.
+# Do not modify it manually.
+#
+# ruff: noqa: F401
+
+from .audio_classification import (
+    AudioClassificationInput,
+    AudioClassificationOutputElement,
+    AudioClassificationOutputTransform,
+    AudioClassificationParameters,
+)
+from .audio_to_audio import AudioToAudioInput, AudioToAudioOutputElement
+from .automatic_speech_recognition import (
+    AutomaticSpeechRecognitionEarlyStoppingEnum,
+    AutomaticSpeechRecognitionGenerationParameters,
+    AutomaticSpeechRecognitionInput,
+    AutomaticSpeechRecognitionOutput,
+    AutomaticSpeechRecognitionOutputChunk,
+    AutomaticSpeechRecognitionParameters,
+)
+from .base import BaseInferenceType
+from .chat_completion import (
+    ChatCompletionInput,
+    ChatCompletionInputFunctionDefinition,
+    ChatCompletionInputFunctionName,
+    ChatCompletionInputGrammarType,
+    ChatCompletionInputJSONSchema,
+    ChatCompletionInputMessage,
+    ChatCompletionInputMessageChunk,
+    ChatCompletionInputMessageChunkType,
+    ChatCompletionInputResponseFormatJSONObject,
+    ChatCompletionInputResponseFormatJSONSchema,
+    ChatCompletionInputResponseFormatText,
+    ChatCompletionInputStreamOptions,
+    ChatCompletionInputTool,
+    ChatCompletionInputToolCall,
+    ChatCompletionInputToolChoiceClass,
+    ChatCompletionInputToolChoiceEnum,
+    ChatCompletionInputURL,
+    ChatCompletionOutput,
+    ChatCompletionOutputComplete,
+    ChatCompletionOutputFunctionDefinition,
+    ChatCompletionOutputLogprob,
+    ChatCompletionOutputLogprobs,
+    ChatCompletionOutputMessage,
+    ChatCompletionOutputToolCall,
+    ChatCompletionOutputTopLogprob,
+    ChatCompletionOutputUsage,
+    ChatCompletionStreamOutput,
+    ChatCompletionStreamOutputChoice,
+    ChatCompletionStreamOutputDelta,
+    ChatCompletionStreamOutputDeltaToolCall,
+    ChatCompletionStreamOutputFunction,
+    ChatCompletionStreamOutputLogprob,
+    ChatCompletionStreamOutputLogprobs,
+    ChatCompletionStreamOutputTopLogprob,
+    ChatCompletionStreamOutputUsage,
+)
+from .depth_estimation import DepthEstimationInput, DepthEstimationOutput
+from .document_question_answering import (
+    DocumentQuestionAnsweringInput,
+    DocumentQuestionAnsweringInputData,
+    DocumentQuestionAnsweringOutputElement,
+    DocumentQuestionAnsweringParameters,
+)
+from .feature_extraction import FeatureExtractionInput, FeatureExtractionInputTruncationDirection
+from .fill_mask import FillMaskInput, FillMaskOutputElement, FillMaskParameters
+from .image_classification import (
+    ImageClassificationInput,
+    ImageClassificationOutputElement,
+    ImageClassificationOutputTransform,
+    ImageClassificationParameters,
+)
+from .image_segmentation import (
+    ImageSegmentationInput,
+    ImageSegmentationOutputElement,
+    ImageSegmentationParameters,
+    ImageSegmentationSubtask,
+)
+from .image_text_to_image import (
+    ImageTextToImageInput,
+    ImageTextToImageOutput,
+    ImageTextToImageParameters,
+    ImageTextToImageTargetSize,
+)
+from .image_text_to_video import (
+    ImageTextToVideoInput,
+    ImageTextToVideoOutput,
+    ImageTextToVideoParameters,
+    ImageTextToVideoTargetSize,
+)
+from .image_to_image import ImageToImageInput, ImageToImageOutput, ImageToImageParameters, ImageToImageTargetSize
+from .image_to_text import (
+    ImageToTextEarlyStoppingEnum,
+    ImageToTextGenerationParameters,
+    ImageToTextInput,
+    ImageToTextOutput,
+    ImageToTextParameters,
+)
+from .image_to_video import ImageToVideoInput, ImageToVideoOutput, ImageToVideoParameters, ImageToVideoTargetSize
+from .object_detection import (
+    ObjectDetectionBoundingBox,
+    ObjectDetectionInput,
+    ObjectDetectionOutputElement,
+    ObjectDetectionParameters,
+)
+from .question_answering import (
+    QuestionAnsweringInput,
+    QuestionAnsweringInputData,
+    QuestionAnsweringOutputElement,
+    QuestionAnsweringParameters,
+)
+from .sentence_similarity import SentenceSimilarityInput, SentenceSimilarityInputData
+from .summarization import (
+    SummarizationInput,
+    SummarizationOutput,
+    SummarizationParameters,
+    SummarizationTruncationStrategy,
+)
+from .table_question_answering import (
+    Padding,
+    TableQuestionAnsweringInput,
+    TableQuestionAnsweringInputData,
+    TableQuestionAnsweringOutputElement,
+    TableQuestionAnsweringParameters,
+)
+from .text2text_generation import (
+    Text2TextGenerationInput,
+    Text2TextGenerationOutput,
+    Text2TextGenerationParameters,
+    Text2TextGenerationTruncationStrategy,
+)
+from .text_classification import (
+    TextClassificationInput,
+    TextClassificationOutputElement,
+    TextClassificationOutputTransform,
+    TextClassificationParameters,
+)
+from .text_generation import (
+    TextGenerationInput,
+    TextGenerationInputGenerateParameters,
+    TextGenerationInputGrammarType,
+    TextGenerationOutput,
+    TextGenerationOutputBestOfSequence,
+    TextGenerationOutputDetails,
+    TextGenerationOutputFinishReason,
+    TextGenerationOutputPrefillToken,
+    TextGenerationOutputToken,
+    TextGenerationStreamOutput,
+    TextGenerationStreamOutputStreamDetails,
+    TextGenerationStreamOutputToken,
+    TypeEnum,
+)
+from .text_to_audio import (
+    TextToAudioEarlyStoppingEnum,
+    TextToAudioGenerationParameters,
+    TextToAudioInput,
+    TextToAudioOutput,
+    TextToAudioParameters,
+)
+from .text_to_image import TextToImageInput, TextToImageOutput, TextToImageParameters
+from .text_to_speech import (
+    TextToSpeechEarlyStoppingEnum,
+    TextToSpeechGenerationParameters,
+    TextToSpeechInput,
+    TextToSpeechOutput,
+    TextToSpeechParameters,
+)
+from .text_to_video import TextToVideoInput, TextToVideoOutput, TextToVideoParameters
+from .token_classification import (
+    TokenClassificationAggregationStrategy,
+    TokenClassificationInput,
+    TokenClassificationOutputElement,
+    TokenClassificationParameters,
+)
+from .translation import TranslationInput, TranslationOutput, TranslationParameters, TranslationTruncationStrategy
+from .video_classification import (
+    VideoClassificationInput,
+    VideoClassificationOutputElement,
+    VideoClassificationOutputTransform,
+    VideoClassificationParameters,
+)
+from .visual_question_answering import (
+    VisualQuestionAnsweringInput,
+    VisualQuestionAnsweringInputData,
+    VisualQuestionAnsweringOutputElement,
+    VisualQuestionAnsweringParameters,
+)
+from .zero_shot_classification import (
+    ZeroShotClassificationInput,
+    ZeroShotClassificationOutputElement,
+    ZeroShotClassificationParameters,
+)
+from .zero_shot_image_classification import (
+    ZeroShotImageClassificationInput,
+    ZeroShotImageClassificationOutputElement,
+    ZeroShotImageClassificationParameters,
+)
+from .zero_shot_object_detection import (
+    ZeroShotObjectDetectionBoundingBox,
+    ZeroShotObjectDetectionInput,
+    ZeroShotObjectDetectionOutputElement,
+    ZeroShotObjectDetectionParameters,
+)

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/audio_classification.py

@@ -0,0 +1,43 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+AudioClassificationOutputTransform = Literal["sigmoid", "softmax", "none"]
+
+
+@dataclass_with_extra
+class AudioClassificationParameters(BaseInferenceType):
+    """Additional inference parameters for Audio Classification"""
+
+    function_to_apply: Optional["AudioClassificationOutputTransform"] = None
+    """The function to apply to the model outputs in order to retrieve the scores."""
+    top_k: int | None = None
+    """When specified, limits the output to the top K most probable classes."""
+
+
+@dataclass_with_extra
+class AudioClassificationInput(BaseInferenceType):
+    """Inputs for Audio Classification inference"""
+
+    inputs: str
+    """The input audio data as a base64-encoded string. If no `parameters` are provided, you can
+    also provide the audio data as a raw bytes payload.
+    """
+    parameters: AudioClassificationParameters | None = None
+    """Additional inference parameters for Audio Classification"""
+
+
+@dataclass_with_extra
+class AudioClassificationOutputElement(BaseInferenceType):
+    """Outputs for Audio Classification inference"""
+
+    label: str
+    """The predicted class label."""
+    score: float
+    """The corresponding probability."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/audio_to_audio.py

@@ -0,0 +1,30 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class AudioToAudioInput(BaseInferenceType):
+    """Inputs for Audio to Audio inference"""
+
+    inputs: Any
+    """The input audio data"""
+
+
+@dataclass_with_extra
+class AudioToAudioOutputElement(BaseInferenceType):
+    """Outputs of inference for the Audio To Audio task
+    A generated audio file with its label.
+    """
+
+    blob: Any
+    """The generated audio file."""
+    content_type: str
+    """The content type of audio file."""
+    label: str
+    """The label of the audio file."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/automatic_speech_recognition.py

@@ -0,0 +1,113 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Literal, Union
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+AutomaticSpeechRecognitionEarlyStoppingEnum = Literal["never"]
+
+
+@dataclass_with_extra
+class AutomaticSpeechRecognitionGenerationParameters(BaseInferenceType):
+    """Parametrization of the text generation process"""
+
+    do_sample: bool | None = None
+    """Whether to use sampling instead of greedy decoding when generating new tokens."""
+    early_stopping: Union[bool, "AutomaticSpeechRecognitionEarlyStoppingEnum"] | None = None
+    """Controls the stopping condition for beam-based methods."""
+    epsilon_cutoff: float | None = None
+    """If set to float strictly between 0 and 1, only tokens with a conditional probability
+    greater than epsilon_cutoff will be sampled. In the paper, suggested values range from
+    3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language
+    Model Desmoothing](https://hf.co/papers/2210.15191) for more details.
+    """
+    eta_cutoff: float | None = None
+    """Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to
+    float strictly between 0 and 1, a token is only considered if it is greater than either
+    eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter
+    term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In
+    the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model.
+    See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191)
+    for more details.
+    """
+    max_length: int | None = None
+    """The maximum length (in tokens) of the generated text, including the input."""
+    max_new_tokens: int | None = None
+    """The maximum number of tokens to generate. Takes precedence over max_length."""
+    min_length: int | None = None
+    """The minimum length (in tokens) of the generated text, including the input."""
+    min_new_tokens: int | None = None
+    """The minimum number of tokens to generate. Takes precedence over min_length."""
+    num_beam_groups: int | None = None
+    """Number of groups to divide num_beams into in order to ensure diversity among different
+    groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details.
+    """
+    num_beams: int | None = None
+    """Number of beams to use for beam search."""
+    penalty_alpha: float | None = None
+    """The value balances the model confidence and the degeneration penalty in contrastive
+    search decoding.
+    """
+    temperature: float | None = None
+    """The value used to modulate the next token probabilities."""
+    top_k: int | None = None
+    """The number of highest probability vocabulary tokens to keep for top-k-filtering."""
+    top_p: float | None = None
+    """If set to float < 1, only the smallest set of most probable tokens with probabilities
+    that add up to top_p or higher are kept for generation.
+    """
+    typical_p: float | None = None
+    """Local typicality measures how similar the conditional probability of predicting a target
+    token next is to the expected conditional probability of predicting a random token next,
+    given the partial text already generated. If set to float < 1, the smallest set of the
+    most locally typical tokens with probabilities that add up to typical_p or higher are
+    kept for generation. See [this paper](https://hf.co/papers/2202.00666) for more details.
+    """
+    use_cache: bool | None = None
+    """Whether the model should use the past last key/values attentions to speed up decoding"""
+
+
+@dataclass_with_extra
+class AutomaticSpeechRecognitionParameters(BaseInferenceType):
+    """Additional inference parameters for Automatic Speech Recognition"""
+
+    generation_parameters: AutomaticSpeechRecognitionGenerationParameters | None = None
+    """Parametrization of the text generation process"""
+    return_timestamps: bool | None = None
+    """Whether to output corresponding timestamps with the generated text"""
+
+
+@dataclass_with_extra
+class AutomaticSpeechRecognitionInput(BaseInferenceType):
+    """Inputs for Automatic Speech Recognition inference"""
+
+    inputs: str
+    """The input audio data as a base64-encoded string. If no `parameters` are provided, you can
+    also provide the audio data as a raw bytes payload.
+    """
+    parameters: AutomaticSpeechRecognitionParameters | None = None
+    """Additional inference parameters for Automatic Speech Recognition"""
+
+
+@dataclass_with_extra
+class AutomaticSpeechRecognitionOutputChunk(BaseInferenceType):
+    text: str
+    """A chunk of text identified by the model"""
+    timestamp: list[float]
+    """The start and end timestamps corresponding with the text"""
+
+
+@dataclass_with_extra
+class AutomaticSpeechRecognitionOutput(BaseInferenceType):
+    """Outputs of inference for the Automatic Speech Recognition task"""
+
+    text: str
+    """The recognized text."""
+    chunks: list[AutomaticSpeechRecognitionOutputChunk] | None = None
+    """When returnTimestamps is enabled, chunks contains a list of audio chunks identified by
+    the model.
+    """

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/base.py

@@ -0,0 +1,167 @@
+# Copyright 2024 The HuggingFace Team. All rights reserved.
+#
+# 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.
+"""Contains a base class for all inference types."""
+
+import inspect
+import json
+import types
+from dataclasses import asdict, dataclass
+from typing import Any, TypeVar, get_args
+
+from typing_extensions import dataclass_transform
+
+
+T = TypeVar("T", bound="BaseInferenceType")
+
+
+def _repr_with_extra(self):
+    fields = list(self.__dataclass_fields__.keys())
+    other_fields = list(k for k in self.__dict__ if k not in fields)
+    return f"{self.__class__.__name__}({', '.join(f'{k}={self.__dict__[k]!r}' for k in fields + other_fields)})"
+
+
+@dataclass_transform()
+def dataclass_with_extra(cls: type[T]) -> type[T]:
+    """Decorator to add a custom __repr__ method to a dataclass, showing all fields, including extra ones.
+
+    This decorator only works with dataclasses that inherit from `BaseInferenceType`.
+    """
+    cls = dataclass(cls)
+    cls.__repr__ = _repr_with_extra  # type: ignore[method-assign]
+    return cls
+
+
+@dataclass
+class BaseInferenceType(dict):
+    """Base class for all inference types.
+
+    Object is a dataclass and a dict for backward compatibility but plan is to remove the dict part in the future.
+
+    Handle parsing from dict, list and json strings in a permissive way to ensure future-compatibility (e.g. all fields
+    are made optional, and non-expected fields are added as dict attributes).
+    """
+
+    @classmethod
+    def parse_obj_as_list(cls: type[T], data: bytes | str | list | dict) -> list[T]:
+        """Alias to parse server response and return a single instance.
+
+        See `parse_obj` for more details.
+        """
+        output = cls.parse_obj(data)
+        if not isinstance(output, list):
+            raise ValueError(f"Invalid input data for {cls}. Expected a list, but got {type(output)}.")
+        return output
+
+    @classmethod
+    def parse_obj_as_instance(cls: type[T], data: bytes | str | list | dict) -> T:
+        """Alias to parse server response and return a single instance.
+
+        See `parse_obj` for more details.
+        """
+        output = cls.parse_obj(data)
+        if isinstance(output, list):
+            raise ValueError(f"Invalid input data for {cls}. Expected a single instance, but got a list.")
+        return output
+
+    @classmethod
+    def parse_obj(cls: type[T], data: bytes | str | list | dict) -> list[T] | T:
+        """Parse server response as a dataclass or list of dataclasses.
+
+        To enable future-compatibility, we want to handle cases where the server return more fields than expected.
+        In such cases, we don't want to raise an error but still create the dataclass object. Remaining fields are
+        added as dict attributes.
+        """
+        # Parse server response (from bytes)
+        if isinstance(data, bytes):
+            data = data.decode()
+        if isinstance(data, str):
+            data = json.loads(data)
+
+        # If a list, parse each item individually
+        if isinstance(data, list):
+            return [cls.parse_obj(d) for d in data]  # type: ignore
+
+        # At this point, we expect a dict
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data type: {type(data)}")
+
+        init_values = {}
+        other_values = {}
+        for key, value in data.items():
+            key = normalize_key(key)
+            if key in cls.__dataclass_fields__ and cls.__dataclass_fields__[key].init:
+                if isinstance(value, dict) or isinstance(value, list):
+                    field_type = cls.__dataclass_fields__[key].type
+
+                    # if `field_type` is a `BaseInferenceType`, parse it
+                    if inspect.isclass(field_type) and issubclass(field_type, BaseInferenceType):
+                        value = field_type.parse_obj(value)
+
+                    # otherwise, recursively parse nested dataclasses (if possible)
+                    # `get_args` returns handle Union and Optional for us
+                    else:
+                        expected_types = get_args(field_type)
+                        for expected_type in expected_types:
+                            if (
+                                isinstance(expected_type, types.GenericAlias) and expected_type.__origin__ is list
+                            ) or getattr(expected_type, "_name", None) == "List":
+                                expected_type = get_args(expected_type)[
+                                    0
+                                ]  # assume same type for all items in the list
+                            if inspect.isclass(expected_type) and issubclass(expected_type, BaseInferenceType):
+                                value = expected_type.parse_obj(value)
+                                break
+                init_values[key] = value
+            else:
+                other_values[key] = value
+
+        # Make all missing fields default to None
+        # => ensure that dataclass initialization will never fail even if the server does not return all fields.
+        for key in cls.__dataclass_fields__:
+            if key not in init_values:
+                init_values[key] = None
+
+        # Initialize dataclass with expected values
+        item = cls(**init_values)
+
+        # Add remaining fields as dict attributes
+        item.update(other_values)
+
+        # Add remaining fields as extra dataclass fields.
+        # They won't be part of the dataclass fields but will be accessible as attributes.
+        # Use @dataclass_with_extra to show them in __repr__.
+        item.__dict__.update(other_values)
+        return item
+
+    def __post_init__(self):
+        self.update(asdict(self))
+
+    def __setitem__(self, __key: Any, __value: Any) -> None:
+        # Hacky way to keep dataclass values in sync when dict is updated
+        super().__setitem__(__key, __value)
+        if __key in self.__dataclass_fields__ and getattr(self, __key, None) != __value:
+            self.__setattr__(__key, __value)
+        return
+
+    def __setattr__(self, __name: str, __value: Any) -> None:
+        # Hacky way to keep dict values is sync when dataclass is updated
+        super().__setattr__(__name, __value)
+        if self.get(__name) != __value:
+            self[__name] = __value
+        return
+
+
+def normalize_key(key: str) -> str:
+    # e.g "content-type" -> "content_type", "Accept" -> "accept"
+    return key.replace("-", "_").replace(" ", "_").lower()

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/chat_completion.py

@@ -0,0 +1,347 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any, Literal, Union
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class ChatCompletionInputURL(BaseInferenceType):
+    url: str
+
+
+ChatCompletionInputMessageChunkType = Literal["text", "image_url"]
+
+
+@dataclass_with_extra
+class ChatCompletionInputMessageChunk(BaseInferenceType):
+    type: "ChatCompletionInputMessageChunkType"
+    image_url: ChatCompletionInputURL | None = None
+    text: str | None = None
+
+
+@dataclass_with_extra
+class ChatCompletionInputFunctionDefinition(BaseInferenceType):
+    name: str
+    parameters: Any
+    description: str | None = None
+
+
+@dataclass_with_extra
+class ChatCompletionInputToolCall(BaseInferenceType):
+    function: ChatCompletionInputFunctionDefinition
+    id: str
+    type: str
+
+
+@dataclass_with_extra
+class ChatCompletionInputMessage(BaseInferenceType):
+    role: str
+    content: list[ChatCompletionInputMessageChunk] | str | None = None
+    name: str | None = None
+    tool_calls: list[ChatCompletionInputToolCall] | None = None
+
+
+@dataclass_with_extra
+class ChatCompletionInputJSONSchema(BaseInferenceType):
+    name: str
+    """
+    The name of the response format.
+    """
+    description: str | None = None
+    """
+    A description of what the response format is for, used by the model to determine
+    how to respond in the format.
+    """
+    schema: dict[str, object] | None = None
+    """
+    The schema for the response format, described as a JSON Schema object. Learn how
+    to build JSON schemas [here](https://json-schema.org/).
+    """
+    strict: bool | None = None
+    """
+    Whether to enable strict schema adherence when generating the output. If set to
+    true, the model will always follow the exact schema defined in the `schema`
+    field.
+    """
+
+
+@dataclass_with_extra
+class ChatCompletionInputResponseFormatText(BaseInferenceType):
+    type: Literal["text"]
+
+
+@dataclass_with_extra
+class ChatCompletionInputResponseFormatJSONSchema(BaseInferenceType):
+    type: Literal["json_schema"]
+    json_schema: ChatCompletionInputJSONSchema
+
+
+@dataclass_with_extra
+class ChatCompletionInputResponseFormatJSONObject(BaseInferenceType):
+    type: Literal["json_object"]
+
+
+ChatCompletionInputGrammarType = Union[
+    ChatCompletionInputResponseFormatText,
+    ChatCompletionInputResponseFormatJSONSchema,
+    ChatCompletionInputResponseFormatJSONObject,
+]
+
+
+@dataclass_with_extra
+class ChatCompletionInputStreamOptions(BaseInferenceType):
+    include_usage: bool | None = None
+    """If set, an additional chunk will be streamed before the data: [DONE] message. The usage
+    field on this chunk shows the token usage statistics for the entire request, and the
+    choices field will always be an empty array. All other chunks will also include a usage
+    field, but with a null value.
+    """
+
+
+@dataclass_with_extra
+class ChatCompletionInputFunctionName(BaseInferenceType):
+    name: str
+
+
+@dataclass_with_extra
+class ChatCompletionInputToolChoiceClass(BaseInferenceType):
+    function: ChatCompletionInputFunctionName
+
+
+ChatCompletionInputToolChoiceEnum = Literal["auto", "none", "required"]
+
+
+@dataclass_with_extra
+class ChatCompletionInputTool(BaseInferenceType):
+    function: ChatCompletionInputFunctionDefinition
+    type: str
+
+
+@dataclass_with_extra
+class ChatCompletionInput(BaseInferenceType):
+    """Chat Completion Input.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
+
+    messages: list[ChatCompletionInputMessage]
+    """A list of messages comprising the conversation so far."""
+    frequency_penalty: float | None = None
+    """Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing
+    frequency in the text so far,
+    decreasing the model's likelihood to repeat the same line verbatim.
+    """
+    logit_bias: list[float] | None = None
+    """UNUSED
+    Modify the likelihood of specified tokens appearing in the completion. Accepts a JSON
+    object that maps tokens
+    (specified by their token ID in the tokenizer) to an associated bias value from -100 to
+    100. Mathematically,
+    the bias is added to the logits generated by the model prior to sampling. The exact
+    effect will vary per model,
+    but values between -1 and 1 should decrease or increase likelihood of selection; values
+    like -100 or 100 should
+    result in a ban or exclusive selection of the relevant token.
+    """
+    logprobs: bool | None = None
+    """Whether to return log probabilities of the output tokens or not. If true, returns the log
+    probabilities of each
+    output token returned in the content of message.
+    """
+    max_tokens: int | None = None
+    """The maximum number of tokens that can be generated in the chat completion."""
+    model: str | None = None
+    """[UNUSED] ID of the model to use. See the model endpoint compatibility table for details
+    on which models work with the Chat API.
+    """
+    n: int | None = None
+    """UNUSED
+    How many chat completion choices to generate for each input message. Note that you will
+    be charged based on the
+    number of generated tokens across all of the choices. Keep n as 1 to minimize costs.
+    """
+    presence_penalty: float | None = None
+    """Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they
+    appear in the text so far,
+    increasing the model's likelihood to talk about new topics
+    """
+    response_format: ChatCompletionInputGrammarType | None = None
+    seed: int | None = None
+    stop: list[str] | None = None
+    """Up to 4 sequences where the API will stop generating further tokens."""
+    stream: bool | None = None
+    stream_options: ChatCompletionInputStreamOptions | None = None
+    temperature: float | None = None
+    """What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the
+    output more random, while
+    lower values like 0.2 will make it more focused and deterministic.
+    We generally recommend altering this or `top_p` but not both.
+    """
+    tool_choice: Union[ChatCompletionInputToolChoiceClass, "ChatCompletionInputToolChoiceEnum"] | None = None
+    tool_prompt: str | None = None
+    """A prompt to be appended before the tools"""
+    tools: list[ChatCompletionInputTool] | None = None
+    """A list of tools the model may call. Currently, only functions are supported as a tool.
+    Use this to provide a list of
+    functions the model may generate JSON inputs for.
+    """
+    top_logprobs: int | None = None
+    """An integer between 0 and 5 specifying the number of most likely tokens to return at each
+    token position, each with
+    an associated log probability. logprobs must be set to true if this parameter is used.
+    """
+    top_p: float | None = None
+    """An alternative to sampling with temperature, called nucleus sampling, where the model
+    considers the results of the
+    tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10%
+    probability mass are considered.
+    """
+
+
+@dataclass_with_extra
+class ChatCompletionOutputTopLogprob(BaseInferenceType):
+    logprob: float
+    token: str
+
+
+@dataclass_with_extra
+class ChatCompletionOutputLogprob(BaseInferenceType):
+    logprob: float
+    token: str
+    top_logprobs: list[ChatCompletionOutputTopLogprob]
+
+
+@dataclass_with_extra
+class ChatCompletionOutputLogprobs(BaseInferenceType):
+    content: list[ChatCompletionOutputLogprob]
+
+
+@dataclass_with_extra
+class ChatCompletionOutputFunctionDefinition(BaseInferenceType):
+    arguments: str
+    name: str
+    description: str | None = None
+
+
+@dataclass_with_extra
+class ChatCompletionOutputToolCall(BaseInferenceType):
+    function: ChatCompletionOutputFunctionDefinition
+    id: str
+    type: str
+
+
+@dataclass_with_extra
+class ChatCompletionOutputMessage(BaseInferenceType):
+    role: str
+    content: str | None = None
+    reasoning: str | None = None
+    tool_call_id: str | None = None
+    tool_calls: list[ChatCompletionOutputToolCall] | None = None
+
+
+@dataclass_with_extra
+class ChatCompletionOutputComplete(BaseInferenceType):
+    finish_reason: str
+    index: int
+    message: ChatCompletionOutputMessage
+    logprobs: ChatCompletionOutputLogprobs | None = None
+
+
+@dataclass_with_extra
+class ChatCompletionOutputUsage(BaseInferenceType):
+    completion_tokens: int
+    prompt_tokens: int
+    total_tokens: int
+
+
+@dataclass_with_extra
+class ChatCompletionOutput(BaseInferenceType):
+    """Chat Completion Output.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
+
+    choices: list[ChatCompletionOutputComplete]
+    created: int
+    id: str
+    model: str
+    system_fingerprint: str
+    usage: ChatCompletionOutputUsage
+
+
+@dataclass_with_extra
+class ChatCompletionStreamOutputFunction(BaseInferenceType):
+    arguments: str
+    name: str | None = None
+
+
+@dataclass_with_extra
+class ChatCompletionStreamOutputDeltaToolCall(BaseInferenceType):
+    function: ChatCompletionStreamOutputFunction
+    id: str
+    index: int
+    type: str
+
+
+@dataclass_with_extra
+class ChatCompletionStreamOutputDelta(BaseInferenceType):
+    role: str
+    content: str | None = None
+    reasoning: str | None = None
+    tool_call_id: str | None = None
+    tool_calls: list[ChatCompletionStreamOutputDeltaToolCall] | None = None
+
+
+@dataclass_with_extra
+class ChatCompletionStreamOutputTopLogprob(BaseInferenceType):
+    logprob: float
+    token: str
+
+
+@dataclass_with_extra
+class ChatCompletionStreamOutputLogprob(BaseInferenceType):
+    logprob: float
+    token: str
+    top_logprobs: list[ChatCompletionStreamOutputTopLogprob]
+
+
+@dataclass_with_extra
+class ChatCompletionStreamOutputLogprobs(BaseInferenceType):
+    content: list[ChatCompletionStreamOutputLogprob]
+
+
+@dataclass_with_extra
+class ChatCompletionStreamOutputChoice(BaseInferenceType):
+    delta: ChatCompletionStreamOutputDelta
+    index: int
+    finish_reason: str | None = None
+    logprobs: ChatCompletionStreamOutputLogprobs | None = None
+
+
+@dataclass_with_extra
+class ChatCompletionStreamOutputUsage(BaseInferenceType):
+    completion_tokens: int
+    prompt_tokens: int
+    total_tokens: int
+
+
+@dataclass_with_extra
+class ChatCompletionStreamOutput(BaseInferenceType):
+    """Chat Completion Stream Output.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
+
+    choices: list[ChatCompletionStreamOutputChoice]
+    created: int
+    id: str
+    model: str
+    system_fingerprint: str
+    usage: ChatCompletionStreamOutputUsage | None = None

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/depth_estimation.py

@@ -0,0 +1,28 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class DepthEstimationInput(BaseInferenceType):
+    """Inputs for Depth Estimation inference"""
+
+    inputs: Any
+    """The input image data"""
+    parameters: dict[str, Any] | None = None
+    """Additional inference parameters for Depth Estimation"""
+
+
+@dataclass_with_extra
+class DepthEstimationOutput(BaseInferenceType):
+    """Outputs of inference for the Depth Estimation task"""
+
+    depth: Any
+    """The predicted depth as an image"""
+    predicted_depth: Any
+    """The predicted depth as a tensor"""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/document_question_answering.py

@@ -0,0 +1,80 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class DocumentQuestionAnsweringInputData(BaseInferenceType):
+    """One (document, question) pair to answer"""
+
+    image: Any
+    """The image on which the question is asked"""
+    question: str
+    """A question to ask of the document"""
+
+
+@dataclass_with_extra
+class DocumentQuestionAnsweringParameters(BaseInferenceType):
+    """Additional inference parameters for Document Question Answering"""
+
+    doc_stride: int | None = None
+    """If the words in the document are too long to fit with the question for the model, it will
+    be split in several chunks with some overlap. This argument controls the size of that
+    overlap.
+    """
+    handle_impossible_answer: bool | None = None
+    """Whether to accept impossible as an answer"""
+    lang: str | None = None
+    """Language to use while running OCR. Defaults to english."""
+    max_answer_len: int | None = None
+    """The maximum length of predicted answers (e.g., only answers with a shorter length are
+    considered).
+    """
+    max_question_len: int | None = None
+    """The maximum length of the question after tokenization. It will be truncated if needed."""
+    max_seq_len: int | None = None
+    """The maximum length of the total sentence (context + question) in tokens of each chunk
+    passed to the model. The context will be split in several chunks (using doc_stride as
+    overlap) if needed.
+    """
+    top_k: int | None = None
+    """The number of answers to return (will be chosen by order of likelihood). Can return less
+    than top_k answers if there are not enough options available within the context.
+    """
+    word_boxes: list[list[float] | str] | None = None
+    """A list of words and bounding boxes (normalized 0->1000). If provided, the inference will
+    skip the OCR step and use the provided bounding boxes instead.
+    """
+
+
+@dataclass_with_extra
+class DocumentQuestionAnsweringInput(BaseInferenceType):
+    """Inputs for Document Question Answering inference"""
+
+    inputs: DocumentQuestionAnsweringInputData
+    """One (document, question) pair to answer"""
+    parameters: DocumentQuestionAnsweringParameters | None = None
+    """Additional inference parameters for Document Question Answering"""
+
+
+@dataclass_with_extra
+class DocumentQuestionAnsweringOutputElement(BaseInferenceType):
+    """Outputs of inference for the Document Question Answering task"""
+
+    answer: str
+    """The answer to the question."""
+    end: int
+    """The end word index of the answer (in the OCR’d version of the input or provided word
+    boxes).
+    """
+    score: float
+    """The probability associated to the answer."""
+    start: int
+    """The start word index of the answer (in the OCR’d version of the input or provided word
+    boxes).
+    """

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/feature_extraction.py

@@ -0,0 +1,36 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+FeatureExtractionInputTruncationDirection = Literal["left", "right"]
+
+
+@dataclass_with_extra
+class FeatureExtractionInput(BaseInferenceType):
+    """Feature Extraction Input.
+    Auto-generated from TEI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tei-import.ts.
+    """
+
+    inputs: list[str] | str
+    """The text or list of texts to embed."""
+    normalize: bool | None = None
+    prompt_name: str | None = None
+    """The name of the prompt that should be used by for encoding. If not set, no prompt
+    will be applied.
+    Must be a key in the `sentence-transformers` configuration `prompts` dictionary.
+    For example if ``prompt_name`` is "query" and the ``prompts`` is {"query": "query: ",
+    ...},
+    then the sentence "What is the capital of France?" will be encoded as
+    "query: What is the capital of France?" because the prompt text will be prepended before
+    any text to encode.
+    """
+    truncate: bool | None = None
+    truncation_direction: Optional["FeatureExtractionInputTruncationDirection"] = None

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/fill_mask.py

@@ -0,0 +1,47 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class FillMaskParameters(BaseInferenceType):
+    """Additional inference parameters for Fill Mask"""
+
+    targets: list[str] | None = None
+    """When passed, the model will limit the scores to the passed targets instead of looking up
+    in the whole vocabulary. If the provided targets are not in the model vocab, they will be
+    tokenized and the first resulting token will be used (with a warning, and that might be
+    slower).
+    """
+    top_k: int | None = None
+    """When passed, overrides the number of predictions to return."""
+
+
+@dataclass_with_extra
+class FillMaskInput(BaseInferenceType):
+    """Inputs for Fill Mask inference"""
+
+    inputs: str
+    """The text with masked tokens"""
+    parameters: FillMaskParameters | None = None
+    """Additional inference parameters for Fill Mask"""
+
+
+@dataclass_with_extra
+class FillMaskOutputElement(BaseInferenceType):
+    """Outputs of inference for the Fill Mask task"""
+
+    score: float
+    """The corresponding probability"""
+    sequence: str
+    """The corresponding input with the mask token prediction."""
+    token: int
+    """The predicted token id (to replace the masked one)."""
+    token_str: Any
+    fill_mask_output_token_str: str | None = None
+    """The predicted token (to replace the masked one)."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/image_classification.py

@@ -0,0 +1,43 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+ImageClassificationOutputTransform = Literal["sigmoid", "softmax", "none"]
+
+
+@dataclass_with_extra
+class ImageClassificationParameters(BaseInferenceType):
+    """Additional inference parameters for Image Classification"""
+
+    function_to_apply: Optional["ImageClassificationOutputTransform"] = None
+    """The function to apply to the model outputs in order to retrieve the scores."""
+    top_k: int | None = None
+    """When specified, limits the output to the top K most probable classes."""
+
+
+@dataclass_with_extra
+class ImageClassificationInput(BaseInferenceType):
+    """Inputs for Image Classification inference"""
+
+    inputs: str
+    """The input image data as a base64-encoded string. If no `parameters` are provided, you can
+    also provide the image data as a raw bytes payload.
+    """
+    parameters: ImageClassificationParameters | None = None
+    """Additional inference parameters for Image Classification"""
+
+
+@dataclass_with_extra
+class ImageClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Image Classification task"""
+
+    label: str
+    """The predicted class label."""
+    score: float
+    """The corresponding probability."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/image_segmentation.py

@@ -0,0 +1,51 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+ImageSegmentationSubtask = Literal["instance", "panoptic", "semantic"]
+
+
+@dataclass_with_extra
+class ImageSegmentationParameters(BaseInferenceType):
+    """Additional inference parameters for Image Segmentation"""
+
+    mask_threshold: float | None = None
+    """Threshold to use when turning the predicted masks into binary values."""
+    overlap_mask_area_threshold: float | None = None
+    """Mask overlap threshold to eliminate small, disconnected segments."""
+    subtask: Optional["ImageSegmentationSubtask"] = None
+    """Segmentation task to be performed, depending on model capabilities."""
+    threshold: float | None = None
+    """Probability threshold to filter out predicted masks."""
+
+
+@dataclass_with_extra
+class ImageSegmentationInput(BaseInferenceType):
+    """Inputs for Image Segmentation inference"""
+
+    inputs: str
+    """The input image data as a base64-encoded string. If no `parameters` are provided, you can
+    also provide the image data as a raw bytes payload.
+    """
+    parameters: ImageSegmentationParameters | None = None
+    """Additional inference parameters for Image Segmentation"""
+
+
+@dataclass_with_extra
+class ImageSegmentationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Image Segmentation task
+    A predicted mask / segment
+    """
+
+    label: str
+    """The label of the predicted segment."""
+    mask: str
+    """The corresponding mask as a black-and-white image (base64-encoded)."""
+    score: float | None = None
+    """The score or confidence degree the model has."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/image_text_to_image.py

@@ -0,0 +1,67 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class ImageTextToImageTargetSize(BaseInferenceType):
+    """The size in pixels of the output image. This parameter is only supported by some
+    providers and for specific models. It will be ignored when unsupported.
+    """
+
+    height: int
+    width: int
+
+
+@dataclass_with_extra
+class ImageTextToImageParameters(BaseInferenceType):
+    """Additional inference parameters for Image Text To Image"""
+
+    guidance_scale: float | None = None
+    """For diffusion models. A higher guidance scale value encourages the model to generate
+    images closely linked to the text prompt at the expense of lower image quality.
+    """
+    negative_prompt: str | None = None
+    """One prompt to guide what NOT to include in image generation."""
+    num_inference_steps: int | None = None
+    """For diffusion models. The number of denoising steps. More denoising steps usually lead to
+    a higher quality image at the expense of slower inference.
+    """
+    prompt: str | None = None
+    """The text prompt to guide the image generation. Either this or inputs (image) must be
+    provided.
+    """
+    seed: int | None = None
+    """Seed for the random number generator."""
+    target_size: ImageTextToImageTargetSize | None = None
+    """The size in pixels of the output image. This parameter is only supported by some
+    providers and for specific models. It will be ignored when unsupported.
+    """
+
+
+@dataclass_with_extra
+class ImageTextToImageInput(BaseInferenceType):
+    """Inputs for Image Text To Image inference. Either inputs (image) or prompt (in parameters)
+    must be provided, or both.
+    """
+
+    inputs: str | None = None
+    """The input image data as a base64-encoded string. If no `parameters` are provided, you can
+    also provide the image data as a raw bytes payload. Either this or prompt must be
+    provided.
+    """
+    parameters: ImageTextToImageParameters | None = None
+    """Additional inference parameters for Image Text To Image"""
+
+
+@dataclass_with_extra
+class ImageTextToImageOutput(BaseInferenceType):
+    """Outputs of inference for the Image Text To Image task"""
+
+    image: Any
+    """The generated image returned as raw bytes in the payload."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/image_text_to_video.py

@@ -0,0 +1,65 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class ImageTextToVideoTargetSize(BaseInferenceType):
+    """The size in pixel of the output video frames."""
+
+    height: int
+    width: int
+
+
+@dataclass_with_extra
+class ImageTextToVideoParameters(BaseInferenceType):
+    """Additional inference parameters for Image Text To Video"""
+
+    guidance_scale: float | None = None
+    """For diffusion models. A higher guidance scale value encourages the model to generate
+    videos closely linked to the text prompt at the expense of lower image quality.
+    """
+    negative_prompt: str | None = None
+    """One prompt to guide what NOT to include in video generation."""
+    num_frames: float | None = None
+    """The num_frames parameter determines how many video frames are generated."""
+    num_inference_steps: int | None = None
+    """The number of denoising steps. More denoising steps usually lead to a higher quality
+    video at the expense of slower inference.
+    """
+    prompt: str | None = None
+    """The text prompt to guide the video generation. Either this or inputs (image) must be
+    provided.
+    """
+    seed: int | None = None
+    """Seed for the random number generator."""
+    target_size: ImageTextToVideoTargetSize | None = None
+    """The size in pixel of the output video frames."""
+
+
+@dataclass_with_extra
+class ImageTextToVideoInput(BaseInferenceType):
+    """Inputs for Image Text To Video inference. Either inputs (image) or prompt (in parameters)
+    must be provided, or both.
+    """
+
+    inputs: str | None = None
+    """The input image data as a base64-encoded string. If no `parameters` are provided, you can
+    also provide the image data as a raw bytes payload. Either this or prompt must be
+    provided.
+    """
+    parameters: ImageTextToVideoParameters | None = None
+    """Additional inference parameters for Image Text To Video"""
+
+
+@dataclass_with_extra
+class ImageTextToVideoOutput(BaseInferenceType):
+    """Outputs of inference for the Image Text To Video task"""
+
+    video: Any
+    """The generated video returned as raw bytes in the payload."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/image_to_image.py

@@ -0,0 +1,60 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class ImageToImageTargetSize(BaseInferenceType):
+    """The size in pixels of the output image. This parameter is only supported by some
+    providers and for specific models. It will be ignored when unsupported.
+    """
+
+    height: int
+    width: int
+
+
+@dataclass_with_extra
+class ImageToImageParameters(BaseInferenceType):
+    """Additional inference parameters for Image To Image"""
+
+    guidance_scale: float | None = None
+    """For diffusion models. A higher guidance scale value encourages the model to generate
+    images closely linked to the text prompt at the expense of lower image quality.
+    """
+    negative_prompt: str | None = None
+    """One prompt to guide what NOT to include in image generation."""
+    num_inference_steps: int | None = None
+    """For diffusion models. The number of denoising steps. More denoising steps usually lead to
+    a higher quality image at the expense of slower inference.
+    """
+    prompt: str | None = None
+    """The text prompt to guide the image generation."""
+    target_size: ImageToImageTargetSize | None = None
+    """The size in pixels of the output image. This parameter is only supported by some
+    providers and for specific models. It will be ignored when unsupported.
+    """
+
+
+@dataclass_with_extra
+class ImageToImageInput(BaseInferenceType):
+    """Inputs for Image To Image inference"""
+
+    inputs: str
+    """The input image data as a base64-encoded string. If no `parameters` are provided, you can
+    also provide the image data as a raw bytes payload.
+    """
+    parameters: ImageToImageParameters | None = None
+    """Additional inference parameters for Image To Image"""
+
+
+@dataclass_with_extra
+class ImageToImageOutput(BaseInferenceType):
+    """Outputs of inference for the Image To Image task"""
+
+    image: Any
+    """The output image returned as raw bytes in the payload."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/image_to_text.py

@@ -0,0 +1,100 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any, Literal, Union
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+ImageToTextEarlyStoppingEnum = Literal["never"]
+
+
+@dataclass_with_extra
+class ImageToTextGenerationParameters(BaseInferenceType):
+    """Parametrization of the text generation process"""
+
+    do_sample: bool | None = None
+    """Whether to use sampling instead of greedy decoding when generating new tokens."""
+    early_stopping: Union[bool, "ImageToTextEarlyStoppingEnum"] | None = None
+    """Controls the stopping condition for beam-based methods."""
+    epsilon_cutoff: float | None = None
+    """If set to float strictly between 0 and 1, only tokens with a conditional probability
+    greater than epsilon_cutoff will be sampled. In the paper, suggested values range from
+    3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language
+    Model Desmoothing](https://hf.co/papers/2210.15191) for more details.
+    """
+    eta_cutoff: float | None = None
+    """Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to
+    float strictly between 0 and 1, a token is only considered if it is greater than either
+    eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter
+    term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In
+    the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model.
+    See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191)
+    for more details.
+    """
+    max_length: int | None = None
+    """The maximum length (in tokens) of the generated text, including the input."""
+    max_new_tokens: int | None = None
+    """The maximum number of tokens to generate. Takes precedence over max_length."""
+    min_length: int | None = None
+    """The minimum length (in tokens) of the generated text, including the input."""
+    min_new_tokens: int | None = None
+    """The minimum number of tokens to generate. Takes precedence over min_length."""
+    num_beam_groups: int | None = None
+    """Number of groups to divide num_beams into in order to ensure diversity among different
+    groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details.
+    """
+    num_beams: int | None = None
+    """Number of beams to use for beam search."""
+    penalty_alpha: float | None = None
+    """The value balances the model confidence and the degeneration penalty in contrastive
+    search decoding.
+    """
+    temperature: float | None = None
+    """The value used to modulate the next token probabilities."""
+    top_k: int | None = None
+    """The number of highest probability vocabulary tokens to keep for top-k-filtering."""
+    top_p: float | None = None
+    """If set to float < 1, only the smallest set of most probable tokens with probabilities
+    that add up to top_p or higher are kept for generation.
+    """
+    typical_p: float | None = None
+    """Local typicality measures how similar the conditional probability of predicting a target
+    token next is to the expected conditional probability of predicting a random token next,
+    given the partial text already generated. If set to float < 1, the smallest set of the
+    most locally typical tokens with probabilities that add up to typical_p or higher are
+    kept for generation. See [this paper](https://hf.co/papers/2202.00666) for more details.
+    """
+    use_cache: bool | None = None
+    """Whether the model should use the past last key/values attentions to speed up decoding"""
+
+
+@dataclass_with_extra
+class ImageToTextParameters(BaseInferenceType):
+    """Additional inference parameters for Image To Text"""
+
+    generation_parameters: ImageToTextGenerationParameters | None = None
+    """Parametrization of the text generation process"""
+    max_new_tokens: int | None = None
+    """The amount of maximum tokens to generate."""
+
+
+@dataclass_with_extra
+class ImageToTextInput(BaseInferenceType):
+    """Inputs for Image To Text inference"""
+
+    inputs: Any
+    """The input image data"""
+    parameters: ImageToTextParameters | None = None
+    """Additional inference parameters for Image To Text"""
+
+
+@dataclass_with_extra
+class ImageToTextOutput(BaseInferenceType):
+    """Outputs of inference for the Image To Text task"""
+
+    generated_text: Any
+    image_to_text_output_generated_text: str | None = None
+    """The generated text."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/image_to_video.py

@@ -0,0 +1,60 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class ImageToVideoTargetSize(BaseInferenceType):
+    """The size in pixel of the output video frames."""
+
+    height: int
+    width: int
+
+
+@dataclass_with_extra
+class ImageToVideoParameters(BaseInferenceType):
+    """Additional inference parameters for Image To Video"""
+
+    guidance_scale: float | None = None
+    """For diffusion models. A higher guidance scale value encourages the model to generate
+    videos closely linked to the text prompt at the expense of lower image quality.
+    """
+    negative_prompt: str | None = None
+    """One prompt to guide what NOT to include in video generation."""
+    num_frames: float | None = None
+    """The num_frames parameter determines how many video frames are generated."""
+    num_inference_steps: int | None = None
+    """The number of denoising steps. More denoising steps usually lead to a higher quality
+    video at the expense of slower inference.
+    """
+    prompt: str | None = None
+    """The text prompt to guide the video generation."""
+    seed: int | None = None
+    """Seed for the random number generator."""
+    target_size: ImageToVideoTargetSize | None = None
+    """The size in pixel of the output video frames."""
+
+
+@dataclass_with_extra
+class ImageToVideoInput(BaseInferenceType):
+    """Inputs for Image To Video inference"""
+
+    inputs: str
+    """The input image data as a base64-encoded string. If no `parameters` are provided, you can
+    also provide the image data as a raw bytes payload.
+    """
+    parameters: ImageToVideoParameters | None = None
+    """Additional inference parameters for Image To Video"""
+
+
+@dataclass_with_extra
+class ImageToVideoOutput(BaseInferenceType):
+    """Outputs of inference for the Image To Video task"""
+
+    video: Any
+    """The generated video returned as raw bytes in the payload."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/object_detection.py

@@ -0,0 +1,56 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class ObjectDetectionParameters(BaseInferenceType):
+    """Additional inference parameters for Object Detection"""
+
+    threshold: float | None = None
+    """The probability necessary to make a prediction."""
+
+
+@dataclass_with_extra
+class ObjectDetectionInput(BaseInferenceType):
+    """Inputs for Object Detection inference"""
+
+    inputs: str
+    """The input image data as a base64-encoded string. If no `parameters` are provided, you can
+    also provide the image data as a raw bytes payload.
+    """
+    parameters: ObjectDetectionParameters | None = None
+    """Additional inference parameters for Object Detection"""
+
+
+@dataclass_with_extra
+class ObjectDetectionBoundingBox(BaseInferenceType):
+    """The predicted bounding box. Coordinates are relative to the top left corner of the input
+    image.
+    """
+
+    xmax: int
+    """The x-coordinate of the bottom-right corner of the bounding box."""
+    xmin: int
+    """The x-coordinate of the top-left corner of the bounding box."""
+    ymax: int
+    """The y-coordinate of the bottom-right corner of the bounding box."""
+    ymin: int
+    """The y-coordinate of the top-left corner of the bounding box."""
+
+
+@dataclass_with_extra
+class ObjectDetectionOutputElement(BaseInferenceType):
+    """Outputs of inference for the Object Detection task"""
+
+    box: ObjectDetectionBoundingBox
+    """The predicted bounding box. Coordinates are relative to the top left corner of the input
+    image.
+    """
+    label: str
+    """The predicted label for the bounding box."""
+    score: float
+    """The associated score / probability."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/question_answering.py

@@ -0,0 +1,72 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class QuestionAnsweringInputData(BaseInferenceType):
+    """One (context, question) pair to answer"""
+
+    context: str
+    """The context to be used for answering the question"""
+    question: str
+    """The question to be answered"""
+
+
+@dataclass_with_extra
+class QuestionAnsweringParameters(BaseInferenceType):
+    """Additional inference parameters for Question Answering"""
+
+    align_to_words: bool | None = None
+    """Attempts to align the answer to real words. Improves quality on space separated
+    languages. Might hurt on non-space-separated languages (like Japanese or Chinese)
+    """
+    doc_stride: int | None = None
+    """If the context is too long to fit with the question for the model, it will be split in
+    several chunks with some overlap. This argument controls the size of that overlap.
+    """
+    handle_impossible_answer: bool | None = None
+    """Whether to accept impossible as an answer."""
+    max_answer_len: int | None = None
+    """The maximum length of predicted answers (e.g., only answers with a shorter length are
+    considered).
+    """
+    max_question_len: int | None = None
+    """The maximum length of the question after tokenization. It will be truncated if needed."""
+    max_seq_len: int | None = None
+    """The maximum length of the total sentence (context + question) in tokens of each chunk
+    passed to the model. The context will be split in several chunks (using docStride as
+    overlap) if needed.
+    """
+    top_k: int | None = None
+    """The number of answers to return (will be chosen by order of likelihood). Note that we
+    return less than topk answers if there are not enough options available within the
+    context.
+    """
+
+
+@dataclass_with_extra
+class QuestionAnsweringInput(BaseInferenceType):
+    """Inputs for Question Answering inference"""
+
+    inputs: QuestionAnsweringInputData
+    """One (context, question) pair to answer"""
+    parameters: QuestionAnsweringParameters | None = None
+    """Additional inference parameters for Question Answering"""
+
+
+@dataclass_with_extra
+class QuestionAnsweringOutputElement(BaseInferenceType):
+    """Outputs of inference for the Question Answering task"""
+
+    answer: str
+    """The answer to the question."""
+    end: int
+    """The character position in the input where the answer ends."""
+    score: float
+    """The probability associated to the answer."""
+    start: int
+    """The character position in the input where the answer begins."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/sentence_similarity.py

@@ -0,0 +1,27 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class SentenceSimilarityInputData(BaseInferenceType):
+    sentences: list[str]
+    """A list of strings which will be compared against the source_sentence."""
+    source_sentence: str
+    """The string that you wish to compare the other strings with. This can be a phrase,
+    sentence, or longer passage, depending on the model being used.
+    """
+
+
+@dataclass_with_extra
+class SentenceSimilarityInput(BaseInferenceType):
+    """Inputs for Sentence similarity inference"""
+
+    inputs: SentenceSimilarityInputData
+    parameters: dict[str, Any] | None = None
+    """Additional inference parameters for Sentence Similarity"""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/summarization.py

@@ -0,0 +1,41 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any, Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+SummarizationTruncationStrategy = Literal["do_not_truncate", "longest_first", "only_first", "only_second"]
+
+
+@dataclass_with_extra
+class SummarizationParameters(BaseInferenceType):
+    """Additional inference parameters for summarization."""
+
+    clean_up_tokenization_spaces: bool | None = None
+    """Whether to clean up the potential extra spaces in the text output."""
+    generate_parameters: dict[str, Any] | None = None
+    """Additional parametrization of the text generation algorithm."""
+    truncation: Optional["SummarizationTruncationStrategy"] = None
+    """The truncation strategy to use."""
+
+
+@dataclass_with_extra
+class SummarizationInput(BaseInferenceType):
+    """Inputs for Summarization inference"""
+
+    inputs: str
+    """The input text to summarize."""
+    parameters: SummarizationParameters | None = None
+    """Additional inference parameters for summarization."""
+
+
+@dataclass_with_extra
+class SummarizationOutput(BaseInferenceType):
+    """Outputs of inference for the Summarization task"""
+
+    summary_text: str
+    """The summarized text."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/table_question_answering.py

@@ -0,0 +1,62 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class TableQuestionAnsweringInputData(BaseInferenceType):
+    """One (table, question) pair to answer"""
+
+    question: str
+    """The question to be answered about the table"""
+    table: dict[str, list[str]]
+    """The table to serve as context for the questions"""
+
+
+Padding = Literal["do_not_pad", "longest", "max_length"]
+
+
+@dataclass_with_extra
+class TableQuestionAnsweringParameters(BaseInferenceType):
+    """Additional inference parameters for Table Question Answering"""
+
+    padding: Optional["Padding"] = None
+    """Activates and controls padding."""
+    sequential: bool | None = None
+    """Whether to do inference sequentially or as a batch. Batching is faster, but models like
+    SQA require the inference to be done sequentially to extract relations within sequences,
+    given their conversational nature.
+    """
+    truncation: bool | None = None
+    """Activates and controls truncation."""
+
+
+@dataclass_with_extra
+class TableQuestionAnsweringInput(BaseInferenceType):
+    """Inputs for Table Question Answering inference"""
+
+    inputs: TableQuestionAnsweringInputData
+    """One (table, question) pair to answer"""
+    parameters: TableQuestionAnsweringParameters | None = None
+    """Additional inference parameters for Table Question Answering"""
+
+
+@dataclass_with_extra
+class TableQuestionAnsweringOutputElement(BaseInferenceType):
+    """Outputs of inference for the Table Question Answering task"""
+
+    answer: str
+    """The answer of the question given the table. If there is an aggregator, the answer will be
+    preceded by `AGGREGATOR >`.
+    """
+    cells: list[str]
+    """list of strings made up of the answer cell values."""
+    coordinates: list[list[int]]
+    """Coordinates of the cells of the answers."""
+    aggregator: str | None = None
+    """If the model has an aggregator, this returns the aggregator."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/text2text_generation.py

@@ -0,0 +1,42 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any, Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+Text2TextGenerationTruncationStrategy = Literal["do_not_truncate", "longest_first", "only_first", "only_second"]
+
+
+@dataclass_with_extra
+class Text2TextGenerationParameters(BaseInferenceType):
+    """Additional inference parameters for Text2text Generation"""
+
+    clean_up_tokenization_spaces: bool | None = None
+    """Whether to clean up the potential extra spaces in the text output."""
+    generate_parameters: dict[str, Any] | None = None
+    """Additional parametrization of the text generation algorithm"""
+    truncation: Optional["Text2TextGenerationTruncationStrategy"] = None
+    """The truncation strategy to use"""
+
+
+@dataclass_with_extra
+class Text2TextGenerationInput(BaseInferenceType):
+    """Inputs for Text2text Generation inference"""
+
+    inputs: str
+    """The input text data"""
+    parameters: Text2TextGenerationParameters | None = None
+    """Additional inference parameters for Text2text Generation"""
+
+
+@dataclass_with_extra
+class Text2TextGenerationOutput(BaseInferenceType):
+    """Outputs of inference for the Text2text Generation task"""
+
+    generated_text: Any
+    text2_text_generation_output_generated_text: str | None = None
+    """The generated text."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/text_classification.py

@@ -0,0 +1,41 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+TextClassificationOutputTransform = Literal["sigmoid", "softmax", "none"]
+
+
+@dataclass_with_extra
+class TextClassificationParameters(BaseInferenceType):
+    """Additional inference parameters for Text Classification"""
+
+    function_to_apply: Optional["TextClassificationOutputTransform"] = None
+    """The function to apply to the model outputs in order to retrieve the scores."""
+    top_k: int | None = None
+    """When specified, limits the output to the top K most probable classes."""
+
+
+@dataclass_with_extra
+class TextClassificationInput(BaseInferenceType):
+    """Inputs for Text Classification inference"""
+
+    inputs: str
+    """The text to classify"""
+    parameters: TextClassificationParameters | None = None
+    """Additional inference parameters for Text Classification"""
+
+
+@dataclass_with_extra
+class TextClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Text Classification task"""
+
+    label: str
+    """The predicted class label."""
+    score: float
+    """The corresponding probability."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/text_generation.py

@@ -0,0 +1,168 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any, Literal
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+TypeEnum = Literal["json", "regex", "json_schema"]
+
+
+@dataclass_with_extra
+class TextGenerationInputGrammarType(BaseInferenceType):
+    type: "TypeEnum"
+    value: Any
+    """A string that represents a [JSON Schema](https://json-schema.org/).
+    JSON Schema is a declarative language that allows to annotate JSON documents
+    with types and descriptions.
+    """
+
+
+@dataclass_with_extra
+class TextGenerationInputGenerateParameters(BaseInferenceType):
+    adapter_id: str | None = None
+    """Lora adapter id"""
+    best_of: int | None = None
+    """Generate best_of sequences and return the one if the highest token logprobs."""
+    decoder_input_details: bool | None = None
+    """Whether to return decoder input token logprobs and ids."""
+    details: bool | None = None
+    """Whether to return generation details."""
+    do_sample: bool | None = None
+    """Activate logits sampling."""
+    frequency_penalty: float | None = None
+    """The parameter for frequency penalty. 1.0 means no penalty
+    Penalize new tokens based on their existing frequency in the text so far,
+    decreasing the model's likelihood to repeat the same line verbatim.
+    """
+    grammar: TextGenerationInputGrammarType | None = None
+    max_new_tokens: int | None = None
+    """Maximum number of tokens to generate."""
+    repetition_penalty: float | None = None
+    """The parameter for repetition penalty. 1.0 means no penalty.
+    See [this paper](https://arxiv.org/pdf/1909.05858.pdf) for more details.
+    """
+    return_full_text: bool | None = None
+    """Whether to prepend the prompt to the generated text"""
+    seed: int | None = None
+    """Random sampling seed."""
+    stop: list[str] | None = None
+    """Stop generating tokens if a member of `stop` is generated."""
+    temperature: float | None = None
+    """The value used to module the logits distribution."""
+    top_k: int | None = None
+    """The number of highest probability vocabulary tokens to keep for top-k-filtering."""
+    top_n_tokens: int | None = None
+    """The number of highest probability vocabulary tokens to keep for top-n-filtering."""
+    top_p: float | None = None
+    """Top-p value for nucleus sampling."""
+    truncate: int | None = None
+    """Truncate inputs tokens to the given size."""
+    typical_p: float | None = None
+    """Typical Decoding mass
+    See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666)
+    for more information.
+    """
+    watermark: bool | None = None
+    """Watermarking with [A Watermark for Large Language
+    Models](https://arxiv.org/abs/2301.10226).
+    """
+
+
+@dataclass_with_extra
+class TextGenerationInput(BaseInferenceType):
+    """Text Generation Input.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
+
+    inputs: str
+    parameters: TextGenerationInputGenerateParameters | None = None
+    stream: bool | None = None
+
+
+TextGenerationOutputFinishReason = Literal["length", "eos_token", "stop_sequence"]
+
+
+@dataclass_with_extra
+class TextGenerationOutputPrefillToken(BaseInferenceType):
+    id: int
+    logprob: float
+    text: str
+
+
+@dataclass_with_extra
+class TextGenerationOutputToken(BaseInferenceType):
+    id: int
+    logprob: float
+    special: bool
+    text: str
+
+
+@dataclass_with_extra
+class TextGenerationOutputBestOfSequence(BaseInferenceType):
+    finish_reason: "TextGenerationOutputFinishReason"
+    generated_text: str
+    generated_tokens: int
+    prefill: list[TextGenerationOutputPrefillToken]
+    tokens: list[TextGenerationOutputToken]
+    seed: int | None = None
+    top_tokens: list[list[TextGenerationOutputToken]] | None = None
+
+
+@dataclass_with_extra
+class TextGenerationOutputDetails(BaseInferenceType):
+    finish_reason: "TextGenerationOutputFinishReason"
+    generated_tokens: int
+    prefill: list[TextGenerationOutputPrefillToken]
+    tokens: list[TextGenerationOutputToken]
+    best_of_sequences: list[TextGenerationOutputBestOfSequence] | None = None
+    seed: int | None = None
+    top_tokens: list[list[TextGenerationOutputToken]] | None = None
+
+
+@dataclass_with_extra
+class TextGenerationOutput(BaseInferenceType):
+    """Text Generation Output.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
+
+    generated_text: str
+    details: TextGenerationOutputDetails | None = None
+
+
+@dataclass_with_extra
+class TextGenerationStreamOutputStreamDetails(BaseInferenceType):
+    finish_reason: "TextGenerationOutputFinishReason"
+    generated_tokens: int
+    input_length: int
+    seed: int | None = None
+
+
+@dataclass_with_extra
+class TextGenerationStreamOutputToken(BaseInferenceType):
+    id: int
+    logprob: float
+    special: bool
+    text: str
+
+
+@dataclass_with_extra
+class TextGenerationStreamOutput(BaseInferenceType):
+    """Text Generation Stream Output.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
+
+    index: int
+    token: TextGenerationStreamOutputToken
+    details: TextGenerationStreamOutputStreamDetails | None = None
+    generated_text: str | None = None
+    top_tokens: list[TextGenerationStreamOutputToken] | None = None

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/text_to_audio.py

@@ -0,0 +1,99 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any, Literal, Union
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+TextToAudioEarlyStoppingEnum = Literal["never"]
+
+
+@dataclass_with_extra
+class TextToAudioGenerationParameters(BaseInferenceType):
+    """Parametrization of the text generation process"""
+
+    do_sample: bool | None = None
+    """Whether to use sampling instead of greedy decoding when generating new tokens."""
+    early_stopping: Union[bool, "TextToAudioEarlyStoppingEnum"] | None = None
+    """Controls the stopping condition for beam-based methods."""
+    epsilon_cutoff: float | None = None
+    """If set to float strictly between 0 and 1, only tokens with a conditional probability
+    greater than epsilon_cutoff will be sampled. In the paper, suggested values range from
+    3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language
+    Model Desmoothing](https://hf.co/papers/2210.15191) for more details.
+    """
+    eta_cutoff: float | None = None
+    """Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to
+    float strictly between 0 and 1, a token is only considered if it is greater than either
+    eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter
+    term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In
+    the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model.
+    See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191)
+    for more details.
+    """
+    max_length: int | None = None
+    """The maximum length (in tokens) of the generated text, including the input."""
+    max_new_tokens: int | None = None
+    """The maximum number of tokens to generate. Takes precedence over max_length."""
+    min_length: int | None = None
+    """The minimum length (in tokens) of the generated text, including the input."""
+    min_new_tokens: int | None = None
+    """The minimum number of tokens to generate. Takes precedence over min_length."""
+    num_beam_groups: int | None = None
+    """Number of groups to divide num_beams into in order to ensure diversity among different
+    groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details.
+    """
+    num_beams: int | None = None
+    """Number of beams to use for beam search."""
+    penalty_alpha: float | None = None
+    """The value balances the model confidence and the degeneration penalty in contrastive
+    search decoding.
+    """
+    temperature: float | None = None
+    """The value used to modulate the next token probabilities."""
+    top_k: int | None = None
+    """The number of highest probability vocabulary tokens to keep for top-k-filtering."""
+    top_p: float | None = None
+    """If set to float < 1, only the smallest set of most probable tokens with probabilities
+    that add up to top_p or higher are kept for generation.
+    """
+    typical_p: float | None = None
+    """Local typicality measures how similar the conditional probability of predicting a target
+    token next is to the expected conditional probability of predicting a random token next,
+    given the partial text already generated. If set to float < 1, the smallest set of the
+    most locally typical tokens with probabilities that add up to typical_p or higher are
+    kept for generation. See [this paper](https://hf.co/papers/2202.00666) for more details.
+    """
+    use_cache: bool | None = None
+    """Whether the model should use the past last key/values attentions to speed up decoding"""
+
+
+@dataclass_with_extra
+class TextToAudioParameters(BaseInferenceType):
+    """Additional inference parameters for Text To Audio"""
+
+    generation_parameters: TextToAudioGenerationParameters | None = None
+    """Parametrization of the text generation process"""
+
+
+@dataclass_with_extra
+class TextToAudioInput(BaseInferenceType):
+    """Inputs for Text To Audio inference"""
+
+    inputs: str
+    """The input text data"""
+    parameters: TextToAudioParameters | None = None
+    """Additional inference parameters for Text To Audio"""
+
+
+@dataclass_with_extra
+class TextToAudioOutput(BaseInferenceType):
+    """Outputs of inference for the Text To Audio task"""
+
+    audio: Any
+    """The generated audio waveform."""
+    sampling_rate: float
+    """The sampling rate of the generated audio waveform."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/text_to_image.py

@@ -0,0 +1,50 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class TextToImageParameters(BaseInferenceType):
+    """Additional inference parameters for Text To Image"""
+
+    guidance_scale: float | None = None
+    """A higher guidance scale value encourages the model to generate images closely linked to
+    the text prompt, but values too high may cause saturation and other artifacts.
+    """
+    height: int | None = None
+    """The height in pixels of the output image"""
+    negative_prompt: str | None = None
+    """One prompt to guide what NOT to include in image generation."""
+    num_inference_steps: int | None = None
+    """The number of denoising steps. More denoising steps usually lead to a higher quality
+    image at the expense of slower inference.
+    """
+    scheduler: str | None = None
+    """Override the scheduler with a compatible one."""
+    seed: int | None = None
+    """Seed for the random number generator."""
+    width: int | None = None
+    """The width in pixels of the output image"""
+
+
+@dataclass_with_extra
+class TextToImageInput(BaseInferenceType):
+    """Inputs for Text To Image inference"""
+
+    inputs: str
+    """The input text data (sometimes called "prompt")"""
+    parameters: TextToImageParameters | None = None
+    """Additional inference parameters for Text To Image"""
+
+
+@dataclass_with_extra
+class TextToImageOutput(BaseInferenceType):
+    """Outputs of inference for the Text To Image task"""
+
+    image: Any
+    """The generated image returned as raw bytes in the payload."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/text_to_speech.py

@@ -0,0 +1,99 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any, Literal, Union
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+TextToSpeechEarlyStoppingEnum = Literal["never"]
+
+
+@dataclass_with_extra
+class TextToSpeechGenerationParameters(BaseInferenceType):
+    """Parametrization of the text generation process"""
+
+    do_sample: bool | None = None
+    """Whether to use sampling instead of greedy decoding when generating new tokens."""
+    early_stopping: Union[bool, "TextToSpeechEarlyStoppingEnum"] | None = None
+    """Controls the stopping condition for beam-based methods."""
+    epsilon_cutoff: float | None = None
+    """If set to float strictly between 0 and 1, only tokens with a conditional probability
+    greater than epsilon_cutoff will be sampled. In the paper, suggested values range from
+    3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language
+    Model Desmoothing](https://hf.co/papers/2210.15191) for more details.
+    """
+    eta_cutoff: float | None = None
+    """Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to
+    float strictly between 0 and 1, a token is only considered if it is greater than either
+    eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter
+    term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In
+    the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model.
+    See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191)
+    for more details.
+    """
+    max_length: int | None = None
+    """The maximum length (in tokens) of the generated text, including the input."""
+    max_new_tokens: int | None = None
+    """The maximum number of tokens to generate. Takes precedence over max_length."""
+    min_length: int | None = None
+    """The minimum length (in tokens) of the generated text, including the input."""
+    min_new_tokens: int | None = None
+    """The minimum number of tokens to generate. Takes precedence over min_length."""
+    num_beam_groups: int | None = None
+    """Number of groups to divide num_beams into in order to ensure diversity among different
+    groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details.
+    """
+    num_beams: int | None = None
+    """Number of beams to use for beam search."""
+    penalty_alpha: float | None = None
+    """The value balances the model confidence and the degeneration penalty in contrastive
+    search decoding.
+    """
+    temperature: float | None = None
+    """The value used to modulate the next token probabilities."""
+    top_k: int | None = None
+    """The number of highest probability vocabulary tokens to keep for top-k-filtering."""
+    top_p: float | None = None
+    """If set to float < 1, only the smallest set of most probable tokens with probabilities
+    that add up to top_p or higher are kept for generation.
+    """
+    typical_p: float | None = None
+    """Local typicality measures how similar the conditional probability of predicting a target
+    token next is to the expected conditional probability of predicting a random token next,
+    given the partial text already generated. If set to float < 1, the smallest set of the
+    most locally typical tokens with probabilities that add up to typical_p or higher are
+    kept for generation. See [this paper](https://hf.co/papers/2202.00666) for more details.
+    """
+    use_cache: bool | None = None
+    """Whether the model should use the past last key/values attentions to speed up decoding"""
+
+
+@dataclass_with_extra
+class TextToSpeechParameters(BaseInferenceType):
+    """Additional inference parameters for Text To Speech"""
+
+    generation_parameters: TextToSpeechGenerationParameters | None = None
+    """Parametrization of the text generation process"""
+
+
+@dataclass_with_extra
+class TextToSpeechInput(BaseInferenceType):
+    """Inputs for Text To Speech inference"""
+
+    inputs: str
+    """The input text data"""
+    parameters: TextToSpeechParameters | None = None
+    """Additional inference parameters for Text To Speech"""
+
+
+@dataclass_with_extra
+class TextToSpeechOutput(BaseInferenceType):
+    """Outputs of inference for the Text To Speech task"""
+
+    audio: Any
+    """The generated audio"""
+    sampling_rate: float | None = None
+    """The sampling rate of the generated audio waveform."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/text_to_video.py

@@ -0,0 +1,46 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class TextToVideoParameters(BaseInferenceType):
+    """Additional inference parameters for Text To Video"""
+
+    guidance_scale: float | None = None
+    """A higher guidance scale value encourages the model to generate videos closely linked to
+    the text prompt, but values too high may cause saturation and other artifacts.
+    """
+    negative_prompt: list[str] | None = None
+    """One or several prompt to guide what NOT to include in video generation."""
+    num_frames: float | None = None
+    """The num_frames parameter determines how many video frames are generated."""
+    num_inference_steps: int | None = None
+    """The number of denoising steps. More denoising steps usually lead to a higher quality
+    video at the expense of slower inference.
+    """
+    seed: int | None = None
+    """Seed for the random number generator."""
+
+
+@dataclass_with_extra
+class TextToVideoInput(BaseInferenceType):
+    """Inputs for Text To Video inference"""
+
+    inputs: str
+    """The input text data (sometimes called "prompt")"""
+    parameters: TextToVideoParameters | None = None
+    """Additional inference parameters for Text To Video"""
+
+
+@dataclass_with_extra
+class TextToVideoOutput(BaseInferenceType):
+    """Outputs of inference for the Text To Video task"""
+
+    video: Any
+    """The generated video returned as raw bytes in the payload."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/token_classification.py

@@ -0,0 +1,51 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+TokenClassificationAggregationStrategy = Literal["none", "simple", "first", "average", "max"]
+
+
+@dataclass_with_extra
+class TokenClassificationParameters(BaseInferenceType):
+    """Additional inference parameters for Token Classification"""
+
+    aggregation_strategy: Optional["TokenClassificationAggregationStrategy"] = None
+    """The strategy used to fuse tokens based on model predictions"""
+    ignore_labels: list[str] | None = None
+    """A list of labels to ignore"""
+    stride: int | None = None
+    """The number of overlapping tokens between chunks when splitting the input text."""
+
+
+@dataclass_with_extra
+class TokenClassificationInput(BaseInferenceType):
+    """Inputs for Token Classification inference"""
+
+    inputs: str
+    """The input text data"""
+    parameters: TokenClassificationParameters | None = None
+    """Additional inference parameters for Token Classification"""
+
+
+@dataclass_with_extra
+class TokenClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Token Classification task"""
+
+    end: int
+    """The character position in the input where this group ends."""
+    score: float
+    """The associated score / probability"""
+    start: int
+    """The character position in the input where this group begins."""
+    word: str
+    """The corresponding text"""
+    entity: str | None = None
+    """The predicted label for a single token"""
+    entity_group: str | None = None
+    """The predicted label for a group of one or more tokens"""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/translation.py

@@ -0,0 +1,49 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any, Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+TranslationTruncationStrategy = Literal["do_not_truncate", "longest_first", "only_first", "only_second"]
+
+
+@dataclass_with_extra
+class TranslationParameters(BaseInferenceType):
+    """Additional inference parameters for Translation"""
+
+    clean_up_tokenization_spaces: bool | None = None
+    """Whether to clean up the potential extra spaces in the text output."""
+    generate_parameters: dict[str, Any] | None = None
+    """Additional parametrization of the text generation algorithm."""
+    src_lang: str | None = None
+    """The source language of the text. Required for models that can translate from multiple
+    languages.
+    """
+    tgt_lang: str | None = None
+    """Target language to translate to. Required for models that can translate to multiple
+    languages.
+    """
+    truncation: Optional["TranslationTruncationStrategy"] = None
+    """The truncation strategy to use."""
+
+
+@dataclass_with_extra
+class TranslationInput(BaseInferenceType):
+    """Inputs for Translation inference"""
+
+    inputs: str
+    """The text to translate."""
+    parameters: TranslationParameters | None = None
+    """Additional inference parameters for Translation"""
+
+
+@dataclass_with_extra
+class TranslationOutput(BaseInferenceType):
+    """Outputs of inference for the Translation task"""
+
+    translation_text: str
+    """The translated text."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/video_classification.py

@@ -0,0 +1,45 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any, Literal, Optional
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+VideoClassificationOutputTransform = Literal["sigmoid", "softmax", "none"]
+
+
+@dataclass_with_extra
+class VideoClassificationParameters(BaseInferenceType):
+    """Additional inference parameters for Video Classification"""
+
+    frame_sampling_rate: int | None = None
+    """The sampling rate used to select frames from the video."""
+    function_to_apply: Optional["VideoClassificationOutputTransform"] = None
+    """The function to apply to the model outputs in order to retrieve the scores."""
+    num_frames: int | None = None
+    """The number of sampled frames to consider for classification."""
+    top_k: int | None = None
+    """When specified, limits the output to the top K most probable classes."""
+
+
+@dataclass_with_extra
+class VideoClassificationInput(BaseInferenceType):
+    """Inputs for Video Classification inference"""
+
+    inputs: Any
+    """The input video data"""
+    parameters: VideoClassificationParameters | None = None
+    """Additional inference parameters for Video Classification"""
+
+
+@dataclass_with_extra
+class VideoClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Video Classification task"""
+
+    label: str
+    """The predicted class label."""
+    score: float
+    """The corresponding probability."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/visual_question_answering.py

@@ -0,0 +1,49 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from typing import Any
+
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class VisualQuestionAnsweringInputData(BaseInferenceType):
+    """One (image, question) pair to answer"""
+
+    image: Any
+    """The image."""
+    question: str
+    """The question to answer based on the image."""
+
+
+@dataclass_with_extra
+class VisualQuestionAnsweringParameters(BaseInferenceType):
+    """Additional inference parameters for Visual Question Answering"""
+
+    top_k: int | None = None
+    """The number of answers to return (will be chosen by order of likelihood). Note that we
+    return less than topk answers if there are not enough options available within the
+    context.
+    """
+
+
+@dataclass_with_extra
+class VisualQuestionAnsweringInput(BaseInferenceType):
+    """Inputs for Visual Question Answering inference"""
+
+    inputs: VisualQuestionAnsweringInputData
+    """One (image, question) pair to answer"""
+    parameters: VisualQuestionAnsweringParameters | None = None
+    """Additional inference parameters for Visual Question Answering"""
+
+
+@dataclass_with_extra
+class VisualQuestionAnsweringOutputElement(BaseInferenceType):
+    """Outputs of inference for the Visual Question Answering task"""
+
+    score: float
+    """The associated score / probability"""
+    answer: str | None = None
+    """The answer to the question"""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/zero_shot_classification.py

@@ -0,0 +1,43 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class ZeroShotClassificationParameters(BaseInferenceType):
+    """Additional inference parameters for Zero Shot Classification"""
+
+    candidate_labels: list[str]
+    """The set of possible class labels to classify the text into."""
+    hypothesis_template: str | None = None
+    """The sentence used in conjunction with `candidate_labels` to attempt the text
+    classification by replacing the placeholder with the candidate labels.
+    """
+    multi_label: bool | None = None
+    """Whether multiple candidate labels can be true. If false, the scores are normalized such
+    that the sum of the label likelihoods for each sequence is 1. If true, the labels are
+    considered independent and probabilities are normalized for each candidate.
+    """
+
+
+@dataclass_with_extra
+class ZeroShotClassificationInput(BaseInferenceType):
+    """Inputs for Zero Shot Classification inference"""
+
+    inputs: str
+    """The text to classify"""
+    parameters: ZeroShotClassificationParameters
+    """Additional inference parameters for Zero Shot Classification"""
+
+
+@dataclass_with_extra
+class ZeroShotClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Zero Shot Classification task"""
+
+    label: str
+    """The predicted class label."""
+    score: float
+    """The corresponding probability."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/zero_shot_image_classification.py

@@ -0,0 +1,38 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class ZeroShotImageClassificationParameters(BaseInferenceType):
+    """Additional inference parameters for Zero Shot Image Classification"""
+
+    candidate_labels: list[str]
+    """The candidate labels for this image"""
+    hypothesis_template: str | None = None
+    """The sentence used in conjunction with `candidate_labels` to attempt the image
+    classification by replacing the placeholder with the candidate labels.
+    """
+
+
+@dataclass_with_extra
+class ZeroShotImageClassificationInput(BaseInferenceType):
+    """Inputs for Zero Shot Image Classification inference"""
+
+    inputs: str
+    """The input image data to classify as a base64-encoded string."""
+    parameters: ZeroShotImageClassificationParameters
+    """Additional inference parameters for Zero Shot Image Classification"""
+
+
+@dataclass_with_extra
+class ZeroShotImageClassificationOutputElement(BaseInferenceType):
+    """Outputs of inference for the Zero Shot Image Classification task"""
+
+    label: str
+    """The predicted class label."""
+    score: float
+    """The corresponding probability."""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_generated/types/zero_shot_object_detection.py

@@ -0,0 +1,50 @@
+# Inference code generated from the JSON schema spec in @huggingface/tasks.
+#
+# See:
+#   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
+#   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
+from .base import BaseInferenceType, dataclass_with_extra
+
+
+@dataclass_with_extra
+class ZeroShotObjectDetectionParameters(BaseInferenceType):
+    """Additional inference parameters for Zero Shot Object Detection"""
+
+    candidate_labels: list[str]
+    """The candidate labels for this image"""
+
+
+@dataclass_with_extra
+class ZeroShotObjectDetectionInput(BaseInferenceType):
+    """Inputs for Zero Shot Object Detection inference"""
+
+    inputs: str
+    """The input image data as a base64-encoded string."""
+    parameters: ZeroShotObjectDetectionParameters
+    """Additional inference parameters for Zero Shot Object Detection"""
+
+
+@dataclass_with_extra
+class ZeroShotObjectDetectionBoundingBox(BaseInferenceType):
+    """The predicted bounding box. Coordinates are relative to the top left corner of the input
+    image.
+    """
+
+    xmax: int
+    xmin: int
+    ymax: int
+    ymin: int
+
+
+@dataclass_with_extra
+class ZeroShotObjectDetectionOutputElement(BaseInferenceType):
+    """Outputs of inference for the Zero Shot Object Detection task"""
+
+    box: ZeroShotObjectDetectionBoundingBox
+    """The predicted bounding box. Coordinates are relative to the top left corner of the input
+    image.
+    """
+    label: str
+    """A candidate label"""
+    score: float
+    """The associated score / probability"""

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_mcp/_cli_hacks.py

@@ -0,0 +1,88 @@
+import asyncio
+import sys
+from functools import partial
+
+import typer
+
+
+def _patch_anyio_open_process():
+    """
+    Patch anyio.open_process to allow detached processes on Windows and Unix-like systems.
+
+    This is necessary to prevent the MCP client from being interrupted by Ctrl+C when running in the CLI.
+    """
+    import subprocess
+
+    import anyio
+
+    if getattr(anyio, "_tiny_agents_patched", False):
+        return
+    anyio._tiny_agents_patched = True  # ty: ignore[invalid-assignment]
+
+    original_open_process = anyio.open_process
+
+    if sys.platform == "win32":
+        # On Windows, we need to set the creation flags to create a new process group
+
+        async def open_process_in_new_group(*args, **kwargs):
+            """
+            Wrapper for open_process to handle Windows-specific process creation flags.
+            """
+            # Ensure we pass the creation flags for Windows
+            kwargs.setdefault("creationflags", subprocess.CREATE_NEW_PROCESS_GROUP)
+            return await original_open_process(*args, **kwargs)
+
+        anyio.open_process = open_process_in_new_group  # ty: ignore[invalid-assignment]
+    else:
+        # For Unix-like systems, we can use setsid to create a new session
+        async def open_process_in_new_group(*args, **kwargs):
+            """
+            Wrapper for open_process to handle Unix-like systems with start_new_session=True.
+            """
+            kwargs.setdefault("start_new_session", True)
+            return await original_open_process(*args, **kwargs)
+
+        anyio.open_process = open_process_in_new_group  # ty: ignore[invalid-assignment]
+
+
+async def _async_prompt(exit_event: asyncio.Event, prompt: str = "» ") -> str:
+    """
+    Asynchronous prompt function that reads input from stdin without blocking.
+
+    This function is designed to work in an asynchronous context, allowing the event loop to gracefully stop it (e.g. on Ctrl+C).
+
+    Alternatively, we could use https://github.com/vxgmichel/aioconsole but that would be an additional dependency.
+    """
+    loop = asyncio.get_event_loop()
+
+    if sys.platform == "win32":
+        # Windows: Use run_in_executor to avoid blocking the event loop
+        # Degraded solution: this is not ideal as user will have to CTRL+C once more to stop the prompt (and it'll not be graceful)
+        return await loop.run_in_executor(None, partial(typer.prompt, prompt, prompt_suffix=" "))
+    else:
+        # UNIX-like: Use loop.add_reader for non-blocking stdin read
+        future = loop.create_future()
+
+        def on_input():
+            line = sys.stdin.readline()
+            loop.remove_reader(sys.stdin)
+            future.set_result(line)
+
+        print(prompt, end=" ", flush=True)
+        loop.add_reader(sys.stdin, on_input)  # not supported on Windows
+
+        # Wait for user input or exit event
+        # Wait until either the user hits enter or exit_event is set
+        exit_task = asyncio.create_task(exit_event.wait())
+        await asyncio.wait(
+            [future, exit_task],
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+
+        # Check which one has been triggered
+        if exit_event.is_set():
+            future.cancel()
+            return ""
+
+        line = await future
+        return line.strip()

.cache/uv/archive-v0/FEnMHFy3LOtQOffttELVc/huggingface_hub/inference/_mcp/agent.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import asyncio
+from typing import AsyncGenerator, Iterable, Optional, Union
+
+from huggingface_hub import ChatCompletionInputMessage, ChatCompletionStreamOutput, MCPClient
+
+from .._providers import PROVIDER_OR_POLICY_T
+from .constants import DEFAULT_SYSTEM_PROMPT, EXIT_LOOP_TOOLS, MAX_NUM_TURNS
+from .types import ServerConfig
+
+
+class Agent(MCPClient):
+    """
+    Implementation of a Simple Agent, which is a simple while loop built right on top of an [`MCPClient`].
+
+    > [!WARNING]
+    > This class is experimental and might be subject to breaking changes in the future without prior notice.
+
+    Args:
+        model (`str`, *optional*):
+            The model to run inference with. Can be a model id hosted on the Hugging Face Hub, e.g. `meta-llama/Meta-Llama-3-8B-Instruct`
+            or a URL to a deployed Inference Endpoint or other local or remote endpoint.
+        servers (`Iterable[dict]`):
+            MCP servers to connect to. Each server is a dictionary containing a `type` key and a `config` key. The `type` key can be `"stdio"` or `"sse"`, and the `config` key is a dictionary of arguments for the server.
+        provider (`str`, *optional*):
+            Name of the provider to use for inference. Defaults to "auto" i.e. the first of the providers available for the model, sorted by the user's order in https://hf.co/settings/inference-providers.
+            If model is a URL or `base_url` is passed, then `provider` is not used.
+        base_url (`str`, *optional*):
+            The base URL to run inference. Defaults to None.
+        api_key (`str`, *optional*):
+            Token to use for authentication. Will default to the locally Hugging Face saved token if not provided. You can also use your own provider API key to interact directly with the provider's service.
+        prompt (`str`, *optional*):
+            The system prompt to use for the agent. Defaults to the default system prompt in `constants.py`.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: Optional[str] = None,
+        servers: Iterable[ServerConfig],
+        provider: Optional[PROVIDER_OR_POLICY_T] = None,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        prompt: Optional[str] = None,
+    ):
+        super().__init__(model=model, provider=provider, base_url=base_url, api_key=api_key)
+        self._servers_cfg = list(servers)
+        self.messages: list[Union[dict, ChatCompletionInputMessage]] = [
+            {"role": "system", "content": prompt or DEFAULT_SYSTEM_PROMPT}
+        ]
+
+    async def load_tools(self) -> None:
+        for cfg in self._servers_cfg:
+            await self.add_mcp_server(**cfg)
+
+    async def run(
+        self,
+        user_input: str,
+        *,
+        abort_event: Optional[asyncio.Event] = None,
+    ) -> AsyncGenerator[Union[ChatCompletionStreamOutput, ChatCompletionInputMessage], None]:
+        """
+        Run the agent with the given user input.
+
+        Args:
+            user_input (`str`):
+                The user input to run the agent with.
+            abort_event (`asyncio.Event`, *optional*):
+                An event that can be used to abort the agent. If the event is set, the agent will stop running.
+        """
+        self.messages.append({"role": "user", "content": user_input})
+
+        num_turns: int = 0
+        next_turn_should_call_tools = True
+
+        while True:
+            if abort_event and abort_event.is_set():
+                return
+
+            async for item in self.process_single_turn_with_tools(
+                self.messages,
+                exit_loop_tools=EXIT_LOOP_TOOLS,
+                exit_if_first_chunk_no_tool=(num_turns > 0 and next_turn_should_call_tools),
+            ):
+                yield item
+
+            num_turns += 1
+            last = self.messages[-1]
+
+            if last.get("role") == "tool" and last.get("name") in {t.function.name for t in EXIT_LOOP_TOOLS}:
+                return
+
+            if last.get("role") != "tool" and num_turns > MAX_NUM_TURNS:
+                return
+
+            if last.get("role") != "tool" and next_turn_should_call_tools:
+                return
+
+            next_turn_should_call_tools = last.get("role") != "tool"