diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000..2e78ac2
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,33 @@
+# Copilot Instructions For This Repository
+
+## Design Principles
+
+- Prefer explicit data models over loosely structured dictionaries when representing domain concepts.
+- Favor Domain-Driven Design (DDD) thinking for new features and refactors when it fits the change:
+  - Keep domain concepts, language, and invariants clear.
+  - Organize code around domain behavior and boundaries, not only technical layers.
+  - Avoid leaking infrastructure details into core domain logic.
+- Keep business rules close to domain models and domain services.
+- Use modern python syntax for python 3.10 and higher, such as pattern matching, type hints, dataclasses, enums, f-strings, and more.
+- Favor pathlib for file system paths and operations
+- Follow pep8 and use type hints (avoid dynamically typed Any when possible, prefer more specific types)
+## Command Execution
+
+- Use `uv run` when project Python dependencies or the project environment are needed.
+- This applies to tests, linting, type-checking, scripts, and local tooling commands that rely on the repository environment.
+- It is acceptable to run commands without `uv run` when the `.venv` or project dependencies are not needed.
+- Prefer forms like:
+  - `uv run pytest`
+  - `uv run ruff check .`
+  - `uv run mypy .`
+  - `uv run python <script>.py`
+
+## Change Discipline
+
+- Preserve existing behavior unless a change request explicitly asks for behavior changes.
+- Keep changes minimal and focused on the requested outcome.
+- Add or update tests when behavior is added or changed.
+
+## Test driven development (TDD)
+- If the change is a bug fix, first write a test that reproduces the bug. The test should fail before the fix is implemented.
+- For new features, and changes this is optional but encouraged. Do it when it makes sense.
\ No newline at end of file
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
new file mode 100644
index 0000000..3b0961f
--- /dev/null
+++ b/.vscode/tasks.json
@@ -0,0 +1,135 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Create New Release",
+            "type": "shell",
+            "command": "uv run --no-sync toolit create-new-release",
+            "problemMatcher": [],
+            "detail": "Create a new release for the project, by reading the version from the pyproject.toml file, and adding and pushing a new tag to the repository."
+        },
+        {
+            "label": "Create New Task In Devops",
+            "type": "shell",
+            "command": "uv run --no-sync toolit create-new-task-in-devops \"${input:create_new_task_in_devops_title}\" \"${input:create_new_task_in_devops_description}\" \"${input:create_new_task_in_devops_work_item_id}\" \"${input:create_new_task_in_devops_target_branch}\" --draft \"${input:create_new_task_in_devops_draft}\"",
+            "problemMatcher": [],
+            "detail": "Create a new task in Azure DevOps."
+        },
+        {
+            "label": "Get Change Log",
+            "type": "shell",
+            "command": "uv run --no-sync toolit get-change-log",
+            "problemMatcher": [],
+            "detail": "Mocked for now."
+        },
+        {
+            "label": "Task String Input With Default",
+            "type": "shell",
+            "command": "uv run --no-sync toolit task-string-input-with-default --string-input \"${input:task_string_input_with_default_string_input}\"",
+            "problemMatcher": [],
+            "detail": "A task that uses a string input with a default value."
+        },
+        {
+            "label": "Task Use Bool Input",
+            "type": "shell",
+            "command": "uv run --no-sync toolit task-use-bool-input \"${input:task_use_bool_input_bool_input}\"",
+            "problemMatcher": [],
+            "detail": "A task that uses a boolean input."
+        },
+        {
+            "label": "Task Use Enum Input",
+            "type": "shell",
+            "command": "uv run --no-sync toolit task-use-enum-input \"${input:task_use_enum_input_enum_input}\"",
+            "problemMatcher": [],
+            "detail": "A task that uses an enum input."
+        },
+        {
+            "label": "Dummy Clitool",
+            "type": "shell",
+            "command": "uv run --no-sync toolit dummy-clitool",
+            "problemMatcher": [],
+            "detail": "A dummy CLI tool that returns a shell command string."
+        },
+        {
+            "label": "Group: Task Run Both Tools",
+            "dependsOn": [
+                "Task Use Bool Input",
+                "Task Use Enum Input"
+            ],
+            "problemMatcher": [],
+            "dependsOrder": "sequence",
+            "detail": "Run both tools in a sequential group."
+        },
+        {
+            "label": "Group: Task Run Both Tools Parallel",
+            "dependsOn": [
+                "Task Use Bool Input",
+                "Task Use Enum Input"
+            ],
+            "problemMatcher": [],
+            "detail": "Run both tools in a parallel group."
+        }
+    ],
+    "inputs": [
+        {
+            "id": "create_new_task_in_devops_title",
+            "type": "promptString",
+            "description": "Enter value for title (str)",
+            "default": ""
+        },
+        {
+            "id": "create_new_task_in_devops_description",
+            "type": "promptString",
+            "description": "Enter value for description (str)",
+            "default": ""
+        },
+        {
+            "id": "create_new_task_in_devops_work_item_id",
+            "type": "promptString",
+            "description": "Enter value for work_item_id (str)",
+            "default": ""
+        },
+        {
+            "id": "create_new_task_in_devops_target_branch",
+            "type": "promptString",
+            "description": "Enter value for target_branch (str)",
+            "default": ""
+        },
+        {
+            "id": "create_new_task_in_devops_draft",
+            "type": "pickString",
+            "description": "Enter value for draft (bool)",
+            "default": "False",
+            "options": [
+                "True",
+                "False"
+            ]
+        },
+        {
+            "id": "task_string_input_with_default_string_input",
+            "type": "promptString",
+            "description": "Enter value for string_input (str)",
+            "default": "default value"
+        },
+        {
+            "id": "task_use_bool_input_bool_input",
+            "type": "pickString",
+            "description": "Enter value for bool_input (bool)",
+            "default": "False",
+            "options": [
+                "True",
+                "False"
+            ]
+        },
+        {
+            "id": "task_use_enum_input_enum_input",
+            "type": "pickString",
+            "description": "Enter value for enum_input (DummyEnum)",
+            "default": "Option a",
+            "options": [
+                "Option a",
+                "Option b"
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 38700b0..0e11fd3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,11 +3,13 @@ All notable changes to this project will be documented in this file.
 
 *NOTE:* Version 0.X.X might have breaking changes in bumps of the minor version number. This is because the project is still in early development and the API is not yet stable. It will still be marked clearly in the release notes.
 
-## [0.7.0] - Unreleased
+## [0.7.0] - 03-05-2026
 - Added support for the Optional and Union type hints in the CLI arguments. This allows for more flexible command definitions and better type checking.
 - Improved support for list parameters in the CLI, and handled the vscode tasks generation for list parameters appropriately.
 - Raise an error if a proper type hint is not provided for a parameter in a tool function.
 - Make it possible to invoke the CLI using `python -m toolit` in addition to the `toolit` command, which is useful for environments where the command might not be available (or when there is a specific venv or python version you want to use).
+- Add the @clitool decorator for ability to easily run CLI commands
+- Better support for environment activation by using `uv run --no-sync` to fix problem of python interpreter not being correctly detected in vscode when using uv as the environment manager.
 
 ## [0.6.0] - 20-12-2025
 - Abandon python 3.9 which is deprecated. Now only support python 3.10 and higher.
diff --git a/README.md b/README.md
index 99093f4..98c6bf0 100644
--- a/README.md
+++ b/README.md
@@ -36,6 +36,20 @@ toolit --help  # To see available commands
 toolit my-command --to_print "Hello, Toolit!"  # To run your command
 ```
 
+You add a command line command with parameter as a devtool, and it will be available as a command in the CLI and in the generated `tasks.json` file for Visual Studio Code. You do this by:
+
+```python
+# devtools/my_cli_commands.py
+from toolit import clitool
+@clitool
+def execute_cli_command(to_print: str = "Hello, World!") -> str:
+    """This is a command that can be run from the CLI."""
+    return "python -c 'print(\"" + to_print + "\")'"
+```
+
+When this command runs from CLI or a generated VS Code task, Toolit executes the returned string in your shell.
+
+
 ### Customizing the DevTools Folder
 By default, Toolit looks for a folder named `devtools` in the project root. You can customize this by creating a `toolit.ini` or use your `pyproject.toml` file in your project root with the following content:
 
diff --git a/tests/cli_command_builder_test.py b/tests/cli_command_builder_test.py
new file mode 100644
index 0000000..f44a11b
--- /dev/null
+++ b/tests/cli_command_builder_test.py
@@ -0,0 +1,528 @@
+"""Tests for CLI command builder with full parameter analysis and metadata generation."""
+
+import enum
+import inspect
+from types import FunctionType
+from typing import Any, Optional, cast
+
+import pytest
+
+from toolit.cli_command_builder import CliCommandBuilder
+from toolit.constants import OPTIONAL_STR_SENTINEL
+
+
+def _as_function(func: Any) -> FunctionType:
+    """Cast a Python function to FunctionType for strict type checks."""
+    return cast(FunctionType, func)
+
+
+class Color(enum.Enum):
+    """Test enum for colors."""
+
+    RED = "red"
+    GREEN = "green"
+    BLUE = "blue"
+
+
+class Environment(str, enum.Enum):
+    """Test enum for environments."""
+
+    DEV = "development"
+    STAGING = "staging"
+    PROD = "production"
+
+
+def _tool_with_pep604_optional(input_dataset_name: str | None = None) -> None:
+    """Tool with a PEP 604 optional argument."""
+
+
+def _tool_with_typing_optional(input_dataset_name: str | None = None) -> None:
+    """Tool with a typing.Optional argument."""
+
+
+def _tool_without_type_hint(to_print) -> None:  # type: ignore[no-untyped-def]  # noqa: ANN001
+    """Tool without a type hint on a parameter."""
+
+
+def _tool_with_multiple_params_missing_hint(name, value: str) -> None:  # type: ignore[no-untyped-def]  # noqa: ANN001
+    """Tool where only the first parameter is missing a type hint."""
+
+
+def _tool_with_enum_param(color: Color) -> None:  # noqa: ARG001
+    """Tool with an enum parameter."""
+
+
+def _tool_with_enum_param_with_default(color: Color = Color.RED) -> None:  # noqa: ARG001
+    """Tool with an enum parameter that has a default value."""
+
+
+def _tool_with_multiple_enum_params(
+    color: Color = Color.RED,  # noqa: ARG001
+    environment: Environment | None = None,  # noqa: ARG001
+) -> None:
+    """Tool with multiple enum parameters."""
+
+
+def _tool_with_list_str_param(items: list[str]) -> None:  # noqa: ARG001
+    """Tool with a list[str] parameter."""
+
+
+def _tool_with_list_int_param(numbers: list[int] = [1, 2, 3]) -> None:  # noqa: B006, ARG001
+    """Tool with a list[int] parameter and list default."""
+
+
+def _tool_with_list_enum_param(colors: list[Color] = [Color.RED, Color.GREEN]) -> None:  # noqa: B006, ARG001
+    """Tool with a list[Enum] parameter and list default."""
+
+
+def _tool_with_optional_list_param(values: list[str] | None = None) -> None:  # noqa: ARG001
+    """Tool with an optional list parameter."""
+
+
+def _tool_with_bool_param(is_enabled: bool = False) -> None:  # noqa: ARG001
+    """Tool with a bool parameter."""
+
+
+def _tool_with_multiple_bool_params(
+    verbose: bool = False,  # noqa: ARG001
+    dry_run: bool = True,  # noqa: ARG001
+) -> None:
+    """Tool with multiple bool parameters."""
+
+
+def _tool_with_mixed_params(
+    name: str,
+    count: int = 5,  # noqa: ARG001
+    color: Color = Color.RED,  # noqa: ARG001
+    is_active: bool = False,  # noqa: ARG001
+) -> None:
+    """Tool with mixed parameter types."""
+
+
+def _tool_with_single_param(name: str) -> None:  # noqa: ARG001
+    """Tool with a single required parameter."""
+
+
+def _tool_with_no_params() -> None:
+    """Tool with no parameters."""
+
+
+# ============ Tests for annotation string conversion ============
+
+
+@pytest.mark.parametrize(
+    ("annotation", "expected"),
+    [
+        (inspect.Parameter.empty, "str"),
+        (Any, "Any"),
+        (list[str], "list[str]"),
+        (dict[str, int], "dict[str, int]"),
+        (str | None, "str | None"),
+        (Optional[int], "int | None"),
+    ],
+)
+def test_annotation_to_string_formats_common_and_complex_types(annotation: Any, expected: str) -> None:
+    """Ensure annotation string conversion supports unions, optionals, and generics."""
+    builder = CliCommandBuilder()
+    assert builder._annotation_to_string(annotation) == expected
+
+
+# ============ Tests for optional parameters ============
+
+
+def test_create_args_for_tool_handles_pep604_optional() -> None:
+    """Ensure str | None annotations do not crash and are rendered in descriptions."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_pep604_optional))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == [
+        '--input-dataset-name "'
+        f'{OPTIONAL_STR_SENTINEL}'
+        '${input:_tool_with_pep604_optional_input_dataset_name}'
+        '"'
+    ]
+    assert inputs[0]["description"] == "Enter value for input_dataset_name (str | None)"
+    assert inputs[0]["default"] is None
+
+
+def test_create_args_for_tool_handles_typing_optional() -> None:
+    """Ensure typing.Optional[str] annotations do not crash and are rendered in descriptions."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_typing_optional))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == [
+        '--input-dataset-name "'
+        f'{OPTIONAL_STR_SENTINEL}'
+        '${input:_tool_with_typing_optional_input_dataset_name}'
+        '"'
+    ]
+    assert inputs[0]["description"] == "Enter value for input_dataset_name (str | None)"
+    assert inputs[0]["default"] is None
+
+
+# ============ Tests for error handling ============
+
+
+def test_create_args_for_tool_raises_on_missing_type_hint() -> None:
+    """Ensure a missing type hint raises ValueError with an instructive message."""
+    cmd_builder = CliCommandBuilder()
+
+    with pytest.raises(
+        ValueError, match="Parameter 'to_print' in function '_tool_without_type_hint' is missing a type annotation"
+    ):
+        cmd_builder.analyze_tool(_as_function(_tool_without_type_hint))
+
+
+def test_create_args_for_tool_error_message_includes_fix_hint() -> None:
+    """Ensure the error message tells the user how to fix the missing annotation."""
+    cmd_builder = CliCommandBuilder()
+
+    with pytest.raises(ValueError, match=r"def _tool_without_type_hint\(to_print: str\) -> None"):
+        cmd_builder.analyze_tool(_as_function(_tool_without_type_hint))
+
+
+def test_create_args_for_tool_raises_on_first_missing_hint_in_mixed_params() -> None:
+    """Ensure the error reports the specific parameter that is missing the annotation."""
+    cmd_builder = CliCommandBuilder()
+
+    with pytest.raises(ValueError, match="Parameter 'name' in function '_tool_with_multiple_params_missing_hint'"):
+        cmd_builder.analyze_tool(_as_function(_tool_with_multiple_params_missing_hint))
+
+
+# ============ Tests for enum parameters ============
+
+
+def test_create_args_for_tool_enum_creates_picklist_input() -> None:
+    """Ensure enum parameters create pickString input type in tasks.json."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_enum_param))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == ['"${input:_tool_with_enum_param_color}"']
+    assert inputs[0]["type"] == "pickString"
+    assert inputs[0]["options"] == ["red", "green", "blue"]
+
+
+def test_create_args_for_tool_enum_sets_default_to_first_choice() -> None:
+    """Ensure enum parameters default to the first enum value when no default provided."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_enum_param))
+
+    inputs = spec.get_input_entries()
+
+    assert inputs[0]["default"] == "red"
+
+
+def test_create_args_for_tool_enum_respects_provided_default() -> None:
+    """Ensure enum parameters use the provided default value if specified."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_enum_param_with_default))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == ['--color "${input:_tool_with_enum_param_with_default_color}"']
+    assert inputs[0]["default"] == Color.RED.value
+
+
+def test_create_args_for_tool_multiple_enum_params() -> None:
+    """Ensure multiple enum parameters are all correctly handled in tasks.json."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_multiple_enum_params))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == [
+        '--color "${input:_tool_with_multiple_enum_params_color}"',
+        '--environment "${input:_tool_with_multiple_enum_params_environment}"',
+    ]
+    assert len(inputs) == 2
+    # First input (color)
+    assert inputs[0]["type"] == "pickString"
+    assert inputs[0]["options"] == ["red", "green", "blue"]
+    assert inputs[0]["default"] == "red"
+    # Second input (environment)
+    assert inputs[1]["type"] == "pickString"
+    assert inputs[1]["options"] == ["development", "staging", "production"]
+    assert inputs[1]["default"] == "development"
+
+
+# ============ Tests for list parameters ============
+
+
+def test_create_args_for_tool_list_str_uses_promptstring_and_guidance() -> None:
+    """Ensure list[str] parameters use promptString with comma-separated guidance."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_list_str_param))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == ['"${input:_tool_with_list_str_param_items}"']
+    assert inputs[0]["type"] == "promptString"
+    assert inputs[0]["description"] == "Enter comma-separated text values for items (e.g. alpha, beta, gamma)"
+    assert inputs[0]["default"] == ""
+
+
+def test_create_args_for_tool_list_int_serializes_default_values() -> None:
+    """Ensure list[int] defaults are serialized to comma-separated text."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_list_int_param))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == ['--numbers "${input:_tool_with_list_int_param_numbers}"']
+    assert inputs[0]["description"] == "Enter comma-separated integer values for numbers (e.g. 1, 2, 3)"
+    assert inputs[0]["default"] == "1, 2, 3"
+
+
+def test_create_args_for_tool_list_enum_serializes_default_values() -> None:
+    """Ensure list[Enum] defaults are serialized using enum values."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_list_enum_param))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == ['--colors "${input:_tool_with_list_enum_param_colors}"']
+    assert (
+        inputs[0]["description"]
+        == "Enter comma-separated enum values for colors. Accepted values: [red, green, blue]. You can also use enum member names."
+    )
+    assert inputs[0]["default"] == "red, green"
+
+
+def test_create_args_for_tool_optional_list_keeps_none_default() -> None:
+    """Ensure optional list parameters preserve None as default."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_optional_list_param))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == ['--values "${input:_tool_with_optional_list_param_values}"']
+    assert inputs[0]["default"] is None
+
+
+# ============ Tests for bool parameters ============
+
+
+def test_create_args_for_tool_bool_creates_picklist_input() -> None:
+    """Ensure bool parameters create pickString input type with True/False options."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_bool_param))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert args == ['--is-enabled "${input:_tool_with_bool_param_is_enabled}"']
+    assert inputs[0]["type"] == "pickString"
+    assert inputs[0]["options"] == ["True", "False"]
+    assert inputs[0]["default"] == "False"
+
+
+def test_create_args_for_tool_bool_respects_true_default() -> None:
+    """Ensure bool parameters with True default preserve that value."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_multiple_bool_params))
+
+    inputs = spec.get_input_entries()
+
+    # dry_run has True default
+    assert inputs[1]["default"] == "True"
+
+
+def test_create_args_for_tool_multiple_bool_params() -> None:
+    """Ensure multiple bool parameters are all correctly handled."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_multiple_bool_params))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    assert len(inputs) == 2
+    assert all(inp["type"] == "pickString" for inp in inputs)
+    assert all(inp["options"] == ["True", "False"] for inp in inputs)
+
+
+# ============ Tests for mixed parameter types ============
+
+
+def test_create_args_for_tool_mixed_params_preserves_order() -> None:
+    """Ensure mixed parameter types are processed in definition order."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_mixed_params))
+
+    args = spec.get_argument_strings()
+    inputs = spec.get_input_entries()
+
+    # Verify parameter order
+    assert len(args) == 4
+    assert "name" in args[0]
+    assert "count" in args[1]
+    assert "color" in args[2]
+    assert "is-active" in args[3]
+
+
+# ============ Tests for CLI option names ============
+
+
+def test_cli_command_builder_create_typer_option_name_replaces_underscores() -> None:
+    """Ensure option names follow Typer's kebab-case convention."""
+    assert CliCommandBuilder.create_typer_option_name("string_input") == "--string-input"
+
+
+def test_cli_command_builder_create_typer_option_name_handles_multiple_underscores() -> None:
+    """Ensure multiple underscores are all replaced with dashes."""
+    assert CliCommandBuilder.create_typer_option_name("this_is_a_long_name") == "--this-is-a-long-name"
+
+
+# ============ Tests for command name formatting ============
+
+
+def test_cli_command_builder_create_typer_command_name_converts_underscores() -> None:
+    """Ensure command names use kebab-case."""
+    assert CliCommandBuilder.create_typer_command_name(lambda: None) is not None  # Just verify the method exists
+
+
+def test_cli_command_builder_create_display_name_formats_function_name() -> None:
+    """Ensure display names are title-cased with spaces."""
+    cmd_builder = CliCommandBuilder()
+    # Note: Leading underscores in function names create leading spaces in display names
+    assert cmd_builder.create_display_name(_tool_with_single_param) == " Tool With Single Param"
+
+
+def test_cli_command_builder_create_group_name_adds_group_prefix() -> None:
+    """Ensure group names are prefixed with 'Group: '."""
+    cmd_builder = CliCommandBuilder()
+    group_name = cmd_builder.create_group_name(_tool_with_single_param)
+    assert group_name.startswith("Group: ")
+
+
+# ============ Tests for command building ============
+
+
+def test_cli_command_builder_build_command_with_no_params() -> None:
+    """Ensure command building works for functions with no parameters."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_no_params))
+
+    command = spec.build_command()
+
+    assert "no-params" in command
+    assert command.endswith("no-params")
+
+
+def test_cli_command_builder_build_command_with_single_param() -> None:
+    """Ensure command building includes parameter placeholders."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_single_param))
+
+    command = spec.build_command()
+
+    assert "single-param" in command
+    assert "${input:" in command
+
+
+def test_cli_command_builder_build_command_respects_custom_program_name() -> None:
+    """Ensure custom program name is used when provided."""
+    cmd_builder = CliCommandBuilder(program_name="custom-tool")
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_single_param))
+
+    command = spec.build_command(program_name="custom-tool")
+
+    assert "custom-tool" in command
+
+
+def test_cli_command_builder_build_command_respects_custom_prefix() -> None:
+    """Ensure custom command prefix is used when provided."""
+    cmd_builder = CliCommandBuilder(command_prefix="python -m ")
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_single_param))
+
+    command = spec.build_command(command_prefix="python -m ")
+
+    assert command.startswith("python -m ")
+
+
+def test_cli_command_builder_build_command_detects_uv_when_available() -> None:
+    """Ensure uv prefix is detected and used automatically when available."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_single_param))
+
+    command = spec.build_command()
+
+    # The command should have some prefix (either 'uv run --no-sync' or empty)
+    # We just verify it constructs properly
+    assert "single-param" in command
+
+
+# ============ Tests for tool specification analysis ============
+
+
+def test_cli_command_builder_analyze_tool_returns_complete_spec() -> None:
+    """Ensure analyze_tool returns a ToolCommandSpec with all required fields."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_mixed_params))
+
+    assert spec.tool == _tool_with_mixed_params
+    assert spec.tool_name == "_tool_with_mixed_params"
+    assert spec.display_name == " Tool With Mixed Params"  # Leading underscore creates leading space
+    assert spec.docstring == "Tool with mixed parameter types."
+    assert len(spec.parameters) == 4
+    assert spec.command_name == "-tool-with-mixed-params"  # Note: first underscore creates leading dash
+
+
+def test_cli_command_builder_parameter_spec_contains_metadata() -> None:
+    """Ensure ParameterSpec contains all required metadata."""
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_single_param))
+
+    param_spec = spec.parameters["name"]
+
+    assert param_spec.name == "name"
+    assert param_spec.annotation == str
+    assert param_spec.input_id == "_tool_with_single_param_name"
+    assert param_spec.option_name == "--name"
+    assert param_spec.uses_option is False  # Required parameter
+    assert param_spec.input_type == "promptString"
+
+
+# ============ Tests for edge cases ============
+
+
+def test_cli_command_builder_handles_empty_string_default() -> None:
+    """Ensure empty string defaults are preserved in parameter specs."""
+
+    def _tool_with_empty_default(text: str = "") -> None:  # noqa: ARG001
+        """Tool with empty string default."""
+
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_empty_default))
+
+    inputs = spec.get_input_entries()
+
+    assert inputs[0]["default"] == ""
+
+
+def test_cli_command_builder_handles_zero_as_default() -> None:
+    """Ensure zero integer defaults are preserved and not treated as falsy."""
+
+    def _tool_with_zero_default(count: int = 0) -> None:  # noqa: ARG001
+        """Tool with zero default."""
+
+    cmd_builder = CliCommandBuilder()
+    spec = cmd_builder.analyze_tool(_as_function(_tool_with_zero_default))
+
+    inputs = spec.get_input_entries()
+
+    assert inputs[0]["default"] == 0
diff --git a/tests/cli_integration_test.py b/tests/cli_integration_test.py
new file mode 100644
index 0000000..9a3012e
--- /dev/null
+++ b/tests/cli_integration_test.py
@@ -0,0 +1,579 @@
+"""Integration tests for CLI command builder with actual typer command execution.
+
+This module tests that commands built by CliCommandBuilder can actually be
+executed through a real Typer CLI application. It validates parameter parsing,
+type conversions, and handling of edge cases like empty strings and multiple values.
+"""
+
+import enum
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+import pytest
+import typer
+
+from toolit.cli_command_builder import CliCommandBuilder
+
+
+# ============ Test enums and types ============
+
+
+class Priority(str, enum.Enum):
+    """Test priority enum."""
+
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class Mode(enum.Enum):
+    """Test mode enum."""
+
+    DEVELOPMENT = "dev"
+    PRODUCTION = "prod"
+
+
+# ============ Test CLI app setup ============
+
+
+def _create_test_cli_app() -> tuple[typer.Typer, dict[str, Any]]:
+    """Create a test CLI app with various tool functions.
+
+    Returns:
+        Tuple of (app, results_dict) where results_dict stores command outputs
+        for assertion in tests.
+    """
+    app = typer.Typer()
+    results: dict[str, Any] = {}
+
+    @app.command()
+    def simple_string(text: str) -> None:
+        """Simple string parameter."""
+        results["simple_string"] = text
+
+    @app.command()
+    def with_default(name: str = "default") -> None:
+        """Parameter with default value."""
+        results["with_default"] = name
+
+    @app.command()
+    def with_integer(count: int) -> None:
+        """Integer parameter."""
+        results["with_integer"] = count
+
+    @app.command()
+    def with_bool(enabled: bool = False) -> None:
+        """Boolean parameter."""
+        results["with_bool"] = enabled
+
+    @app.command()
+    def with_priority(priority: Priority = Priority.MEDIUM) -> None:
+        """Enum parameter."""
+        results["with_priority"] = priority.value
+
+    @app.command()
+    def with_list_str(items: list[str]) -> None:
+        """List of strings parameter."""
+        results["with_list_str"] = items
+
+    @app.command()
+    def with_list_int(numbers: list[int]) -> None:
+        """List of integers parameter."""
+        results["with_list_int"] = numbers
+
+    @app.command()
+    def multiple_params(name: str, count: int = 1, verbose: bool = False) -> None:
+        """Multiple parameters of different types."""
+        results["multiple_params"] = {"name": name, "count": count, "verbose": verbose}
+
+    return app, results
+
+
+# ============ Tests for basic parameter types ============
+
+
+class TestBasicParameterExecution:
+    """Tests for basic parameter types through CLI execution."""
+
+    def test_simple_string_parameter_passes_correctly(self) -> None:
+        """Ensure simple string parameters are passed and received correctly."""
+        cmd_builder = CliCommandBuilder()
+
+        def simple_string(text: str) -> None:  # noqa: ARG001
+            """Simple string parameter."""
+
+        spec = cmd_builder.analyze_tool(simple_string)
+        
+        # Verify the spec is correctly generated for a simple string parameter
+        assert "text" in spec.parameters
+        assert spec.parameters["text"].annotation == str
+        assert spec.parameters["text"].uses_option is False  # Required parameter
+
+    def test_parameter_with_default_value(self) -> None:
+        """Ensure parameters with defaults work correctly."""
+
+        def with_default(name: str = "default") -> None:  # noqa: ARG001
+            """Parameter with default."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_default)
+
+        param = spec.parameters["name"]
+        assert param.uses_option is True
+        assert param.option_name == "--name"
+        inputs = spec.get_input_entries()
+        assert inputs[0]["default"] == "default"
+
+    def test_integer_parameter_conversion(self) -> None:
+        """Ensure integer parameters are handled correctly."""
+
+        def with_integer(count: int) -> None:  # noqa: ARG001
+            """Integer parameter."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_integer)
+
+        param = spec.parameters["count"]
+        assert param.annotation == int
+        assert param.uses_option is False
+
+
+# ============ Tests for boolean parameters ============
+
+
+class TestBooleanParameterExecution:
+    """Tests for boolean parameter handling through CLI."""
+
+    def test_bool_parameter_defaults_to_false(self) -> None:
+        """Ensure bool parameters default to False when not specified."""
+
+        def with_bool(enabled: bool = False) -> None:  # noqa: ARG001
+            """Boolean parameter."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_bool)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["type"] == "pickString"
+        assert inputs[0]["options"] == ["True", "False"]
+        assert inputs[0]["default"] == "False"
+
+    def test_bool_parameter_with_true_default(self) -> None:
+        """Ensure bool parameters with True default preserve it."""
+
+        def with_bool_true(enabled: bool = True) -> None:  # noqa: ARG001
+            """Boolean parameter with True default."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_bool_true)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["default"] == "True"
+
+    def test_bool_command_with_true_string(self) -> None:
+        """Ensure 'True' string is correctly converted to bool True."""
+        cmd = CliCommandBuilder().create_typer_option_name("enabled")
+        assert cmd == "--enabled"
+
+
+# ============ Tests for enum parameters ============
+
+
+class TestEnumParameterExecution:
+    """Tests for enum parameter handling through CLI."""
+
+    def test_enum_parameter_creates_picklist(self) -> None:
+        """Ensure enum parameters create pickString input."""
+
+        def with_priority(priority: Priority = Priority.MEDIUM) -> None:  # noqa: ARG001
+            """Enum parameter."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_priority)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["type"] == "pickString"
+        assert "low" in inputs[0]["options"]
+        assert "medium" in inputs[0]["options"]
+        assert "high" in inputs[0]["options"]
+        assert inputs[0]["default"] == "medium"
+
+    def test_enum_with_no_default_uses_first_value(self) -> None:
+        """Ensure enum parameters without default use first enum value."""
+
+        def with_mode(mode: Mode) -> None:  # noqa: ARG001
+            """Mode parameter without default."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_mode)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["default"] == "dev"  # First enum value
+
+
+# ============ Tests for list parameters ============
+
+
+class TestListParameterExecution:
+    """Tests for list parameter handling through CLI."""
+
+    def test_list_string_parameter_description(self) -> None:
+        """Ensure list[str] parameters provide comma-separated guidance."""
+
+        def with_list_str(items: list[str]) -> None:  # noqa: ARG001
+            """List of strings."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_list_str)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["type"] == "promptString"
+        assert "comma-separated" in inputs[0]["description"].lower()
+        assert "alpha, beta, gamma" in inputs[0]["description"]
+
+    def test_list_int_parameter_description(self) -> None:
+        """Ensure list[int] parameters provide integer-specific guidance."""
+
+        def with_list_int(numbers: list[int]) -> None:  # noqa: ARG001
+            """List of integers."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_list_int)
+
+        inputs = spec.get_input_entries()
+        assert "integer" in inputs[0]["description"].lower()
+        assert "1, 2, 3" in inputs[0]["description"]
+
+    def test_list_with_defaults_serializes_correctly(self) -> None:
+        """Ensure list defaults are serialized to comma-separated strings."""
+
+        def with_list_default(values: list[int] = [10, 20, 30]) -> None:  # noqa: ARG001, B006
+            """List with default."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_list_default)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["default"] == "10, 20, 30"
+
+
+# ============ Tests for edge cases ============
+
+
+class TestEdgeCases:
+    """Tests for edge cases in parameter handling."""
+
+    def test_empty_string_default_is_preserved(self) -> None:
+        """Ensure empty string defaults are preserved."""
+
+        def with_empty_default(text: str = "") -> None:  # noqa: ARG001
+            """Tool with empty string default."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_empty_default)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["default"] == ""
+        assert inputs[0]["type"] == "promptString"
+
+    def test_zero_integer_default_is_not_falsy(self) -> None:
+        """Ensure zero integer defaults are preserved and not treated as falsy."""
+
+        def with_zero(count: int = 0) -> None:  # noqa: ARG001
+            """Tool with zero default."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_zero)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["default"] == 0
+
+    def test_none_default_for_optional_string(self) -> None:
+        """Ensure None defaults for optional strings are preserved."""
+
+        def with_optional(text: str | None = None) -> None:  # noqa: ARG001
+            """Tool with optional parameter."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_optional)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["default"] is None
+
+    def test_empty_list_default(self) -> None:
+        """Ensure empty list defaults are handled correctly."""
+
+        def with_empty_list(items: list[str] = []) -> None:  # noqa: ARG001, B006
+            """Tool with empty list default."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_empty_list)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["default"] == ""
+
+    def test_parameter_with_special_characters_in_default(self) -> None:
+        """Ensure defaults with special characters are preserved."""
+
+        def with_special_chars(text: str = "hello,world!") -> None:  # noqa: ARG001
+            """Tool with special characters in default."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(with_special_chars)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["default"] == "hello,world!"
+
+
+# ============ Tests for command building ============
+
+
+class TestCommandBuilding:
+    """Tests for building complete commands from tool specs."""
+
+    def test_command_includes_all_parameters_in_order(self) -> None:
+        """Ensure command includes all parameters in the correct order."""
+
+        def multi_param(name: str, count: int = 1, verbose: bool = False) -> None:  # noqa: ARG001
+            """Multiple parameters."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(multi_param)
+
+        command = spec.build_command()
+        
+        # Verify all parameters are in the command
+        assert "--count" in command or "count" in command
+        assert "--verbose" in command or "verbose" in command
+        assert "${input:multi_param_name}" in command
+
+    def test_command_with_no_parameters(self) -> None:
+        """Ensure commands with no parameters are built correctly."""
+
+        def no_params() -> None:
+            """Tool with no parameters."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(no_params)
+
+        command = spec.build_command()
+        assert "no-params" in command
+        assert "${input:" not in command  # No input placeholders
+
+    def test_command_with_custom_program_name(self) -> None:
+        """Ensure custom program names are used in commands."""
+
+        def example(name: str) -> None:  # noqa: ARG001
+            """Example tool."""
+
+        cmd_builder = CliCommandBuilder(program_name="mytool")
+        spec = cmd_builder.analyze_tool(example)
+
+        command = spec.build_command(program_name="mytool")
+        assert "mytool" in command
+
+    def test_command_with_custom_prefix(self) -> None:
+        """Ensure custom command prefixes are used."""
+
+        def example(name: str) -> None:  # noqa: ARG001
+            """Example tool."""
+
+        cmd_builder = CliCommandBuilder(command_prefix="python -m ")
+        spec = cmd_builder.analyze_tool(example)
+
+        command = spec.build_command(command_prefix="python -m ")
+        assert command.startswith("python -m ")
+
+
+# ============ Tests for potential issues ============
+
+
+class TestPotentialIssues:
+    """Tests highlighting potential issues with current implementation.
+
+    These tests identify areas where the generated commands might not work
+    correctly when executed through the actual CLI.
+    """
+
+    @pytest.mark.xfail(reason="Empty string from tasks.json might not parse correctly in Typer")
+    def test_empty_string_input_execution(self) -> None:
+        """
+        Test whether empty strings from task inputs are correctly passed to the CLI.
+
+        POTENTIAL ISSUE: When a user provides an empty string in a tasks.json input,
+        it's unclear if Typer will correctly receive and parse an empty string versus
+        treating it as a missing argument. This needs verification.
+        """
+
+        def process_text(text: str) -> None:  # noqa: ARG001
+            """Process text input."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(process_text)
+
+        # The generated command would look like:
+        # toolit process-text ""
+        # Question: Does Typer handle the empty string correctly?
+        args = spec.get_argument_strings()
+        assert args[0] == '"${input:process_text_text}"'
+
+    @pytest.mark.xfail(reason="Comma-separated list parsing needs Typer configuration")
+    def test_comma_separated_list_input_execution(self) -> None:
+        """
+        Test whether comma-separated list inputs are correctly parsed by Typer.
+
+        POTENTIAL ISSUE: The tasks.json input provides "item1, item2, item3",
+        but Typer expects list[str] to be specified multiple times as:
+        --items item1 --items item2 --items item3
+
+        The current implementation doesn't handle the conversion from comma-separated
+        strings to repeated option flags. This needs a custom Typer callback or parser.
+        """
+
+        def process_items(items: list[str]) -> None:  # noqa: ARG001
+            """Process list of items."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(process_items)
+
+        inputs = spec.get_input_entries()
+        description = inputs[0]["description"]
+        assert "comma-separated" in description.lower()
+
+        # The generated command would be:
+        # toolit process-items "item1, item2, item3"
+        # But Typer might not correctly parse this as a list without custom handling.
+
+    @pytest.mark.xfail(reason="Boolean string conversion needs Typer configuration")
+    def test_bool_string_conversion_in_typer(self) -> None:
+        """
+        Test whether string "True"/"False" from tasks.json are converted to bool by Typer.
+
+        POTENTIAL ISSUE: The tasks.json input provides "True" or "False" as strings,
+        but Typer needs to convert these to actual boolean values. Typer's default
+        behavior might not handle this conversion without custom configuration.
+        """
+
+        def set_flag(enabled: bool = False) -> None:  # noqa: ARG001
+            """Set a boolean flag."""
+
+        cmd_builder = CliCommandBuilder()
+        spec = cmd_builder.analyze_tool(set_flag)
+
+        inputs = spec.get_input_entries()
+        assert inputs[0]["options"] == ["True", "False"]
+
+        # The generated command would be:
+        # toolit set-flag --enabled True
+        # Question: Does Typer correctly convert the string "True" to bool True?
+
+
+# ============ Question for design discussion ============
+
+
+class TestDesignQuestions:
+    """Tests and questions about the overall design.
+
+    These highlight areas where design decisions need to be made.
+    """
+
+    def test_how_should_list_parameters_be_handled_in_tasks_json(self) -> None:
+        """
+        Question: How should list parameters be input through tasks.json?
+
+        Current approach:
+        - Input: "item1, item2, item3" (user types comma-separated values)
+        - Command: toolit process-items "item1, item2, item3"
+        - Typer expectation: --items item1 --items item2 --items item3
+
+        Alternative approaches:
+        1. Use a custom separator character (e.g., semicolon or pipe)
+        2. Use a Typer callback to parse comma-separated strings
+        3. Require quoted JSON format: '["item1", "item2"]'
+        4. Use a different input mechanism entirely
+        """
+        pass
+
+    def test_how_should_empty_strings_be_handled(self) -> None:
+        """
+        Question: How should empty string values be handled in tasks.json inputs?
+
+        Current approach:
+        - User leaves input blank or types nothing
+        - Input default is empty string ""
+        - Generated command: toolit command-name ""
+
+        Issues:
+        - Unclear if shell will pass empty string to Typer
+        - Unclear if Typer will treat it as None vs empty string
+        - Might conflict with required string parameters
+
+        Should empty strings be:
+        1. Not allowed for required parameters?
+        2. Converted to None for optional parameters?
+        3. Treated as a special marker?
+        """
+        pass
+
+
+@pytest.mark.skipif(sys.platform != "win32", reason="PowerShell empty argument behavior is Windows-specific")
+def test_toolit_cli_handles_empty_optional_string_from_generated_task_command(tmp_path: Path) -> None:
+    """Ensure generated task commands can pass empty optional string values through PowerShell."""
+    workspace: Path = tmp_path / "workspace"
+    workspace.mkdir()
+
+    (workspace / "pyproject.toml").write_text('[toolit]\ntools_folder = "devtools"\n', encoding="utf-8")
+
+    devtools_dir: Path = workspace / "devtools"
+    devtools_dir.mkdir()
+    (devtools_dir / "chat_tools.py").write_text(
+        "from toolit.decorators import tool\n"
+        "import typer\n\n"
+        "@tool\n"
+        "def run_chatflow(question: str, chat_history: str | None = None) -> None:\n"
+        "    typer.echo(f\"question={question}\")\n"
+        "    typer.echo(f\"chat_history={chat_history!r}\")\n",
+        encoding="utf-8",
+    )
+
+    generate_tasks_result = subprocess.run(
+        [sys.executable, "-m", "toolit", "create-vscode-tasks-json"],
+        cwd=workspace,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert generate_tasks_result.returncode == 0, (
+        "Failed to generate tasks.json.\n"
+        f"stdout:\n{generate_tasks_result.stdout}\n"
+        f"stderr:\n{generate_tasks_result.stderr}"
+    )
+
+    tasks_path: Path = workspace / ".vscode" / "tasks.json"
+    tasks_payload = json.loads(tasks_path.read_text(encoding="utf-8"))
+    task_entry = next(task for task in tasks_payload["tasks"] if task["label"] == "Run Chatflow")
+
+    command: str = task_entry["command"]
+    command = command.replace('${input:run_chatflow_question}', "What is an e-pump?")
+    command = command.replace('${input:run_chatflow_chat_history}', "")
+    # Emulate task/native command paths where explicit empty-string arguments are dropped.
+    command = command.replace('""', "")
+
+    execute_result = subprocess.run(
+        ["pwsh", "-NoProfile", "-Command", command],
+        cwd=workspace,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert execute_result.returncode == 0, (
+        "Executing generated command failed.\n"
+        f"Command: {command}\n"
+        f"stdout:\n{execute_result.stdout}\n"
+        f"stderr:\n{execute_result.stderr}"
+    )
+    assert "chat_history=None" in execute_result.stdout
diff --git a/tests/cli_test.py b/tests/cli_test.py
index a1c6200..67e8803 100644
--- a/tests/cli_test.py
+++ b/tests/cli_test.py
@@ -4,6 +4,7 @@
 import enum
 import pytest
 from typer.testing import CliRunner
+from toolit import clitool
 
 
 def test_cli_run_with_no_tools() -> None:
@@ -132,3 +133,184 @@ def optional_list_tool(values: list[str] | None = None) -> None:
 
     assert result.exit_code == 0, f"CLI invocation failed with output: {result.output}, captured: {captured}"
     assert captured["values"] is None
+
+
+def test_clitool_runtime_executes_returned_shell_command(monkeypatch: pytest.MonkeyPatch) -> None:
+    captured: dict[str, str] = {}
+
+    class DummyCompletedProcess:
+        """Completed-process stand-in with return code for subprocess mocks."""
+
+        def __init__(self, returncode: int) -> None:
+            self.returncode = returncode
+
+    def fake_run(command: object, *args: object, **kwargs: object) -> DummyCompletedProcess:
+        captured["command"] = str(command)
+        captured["shell"] = str(kwargs.get("shell"))
+        captured["check"] = str(kwargs.get("check"))
+        return DummyCompletedProcess(returncode=0)
+
+    monkeypatch.setattr(create_apps_and_register.subprocess, "run", fake_run)
+
+    @clitool
+    def run_echo(target: str) -> str:
+        return f"echo {target}"
+
+    create_apps_and_register.register_command(run_echo, name="test-clitool-runtime-executes-returned-shell-command")
+    runner = CliRunner()
+    result = runner.invoke(
+        create_apps_and_register.app,
+        ["test-clitool-runtime-executes-returned-shell-command", "hello"],
+    )
+
+    assert result.exit_code == 0, result.output
+    # Runtime may execute as a shell string or split argv list depending on platform/safety path.
+    assert "echo" in captured["command"]
+    assert "hello" in captured["command"]
+    assert captured["check"] == "False"
+
+
+def test_clitool_runtime_requires_string_return_type() -> None:
+    @clitool
+    def returns_wrong_type() -> int:  # type: ignore[return-value]
+        return 42
+
+    create_apps_and_register.register_command(returns_wrong_type, name="test-clitool-runtime-requires-string-return-type")
+    runner = CliRunner()
+    result = runner.invoke(create_apps_and_register.app, ["test-clitool-runtime-requires-string-return-type"])
+
+    assert result.exit_code == 1
+    assert "must return a string command" in result.output
+
+
+def test_cli_bool_option_true_string_is_received_as_true() -> None:
+    """Ensure passing 'True' string for a bool option results in Python True."""
+    captured: dict[str, bool] = {}
+
+    def bool_tool(is_enabled: bool = False) -> None:
+        captured["is_enabled"] = is_enabled
+
+    create_apps_and_register.register_command(bool_tool, name="test-bool-true-string")
+    runner = CliRunner()
+    result = runner.invoke(create_apps_and_register.app, ["test-bool-true-string", "--is-enabled", "True"])
+
+    assert result.exit_code == 0, f"CLI failed: {result.output}"
+    assert captured["is_enabled"] is True
+
+
+def test_cli_bool_option_false_string_is_received_as_false() -> None:
+    """Ensure passing 'False' string for a bool option results in Python False."""
+    captured: dict[str, bool] = {}
+
+    def bool_tool(is_enabled: bool = True) -> None:
+        captured["is_enabled"] = is_enabled
+
+    create_apps_and_register.register_command(bool_tool, name="test-bool-false-string")
+    runner = CliRunner()
+    result = runner.invoke(create_apps_and_register.app, ["test-bool-false-string", "--is-enabled", "False"])
+
+    assert result.exit_code == 0, f"CLI failed: {result.output}"
+    assert captured["is_enabled"] is False
+
+
+def test_cli_list_str_comma_separated_single_arg_is_split() -> None:
+    """Ensure a single comma-separated string is split into a list[str]."""
+    captured: dict[str, list[str]] = {}
+
+    def list_str_tool(items: list[str]) -> None:
+        captured["items"] = items
+
+    create_apps_and_register.register_command(list_str_tool, name="test-list-str-comma")
+    runner = CliRunner()
+    result = runner.invoke(create_apps_and_register.app, ["test-list-str-comma", "alpha, beta, gamma"])
+
+    assert result.exit_code == 0, f"CLI failed: {result.output}"
+    assert captured["items"] == ["alpha", "beta", "gamma"]
+
+
+def test_cli_list_int_comma_separated_single_arg_is_split_and_converted() -> None:
+    """Ensure a single comma-separated string is split and converted to list[int]."""
+    captured: dict[str, list[int]] = {}
+
+    def list_int_tool(numbers: list[int]) -> None:
+        captured["numbers"] = numbers
+
+    create_apps_and_register.register_command(list_int_tool, name="test-list-int-comma")
+    runner = CliRunner()
+    result = runner.invoke(create_apps_and_register.app, ["test-list-int-comma", "1, 2, 3"])
+
+    assert result.exit_code == 0, f"CLI failed: {result.output}"
+    assert captured["numbers"] == [1, 2, 3]
+
+
+def test_cli_list_enum_comma_separated_single_arg_is_split_and_converted() -> None:
+    """Ensure a single comma-separated string is split and converted to list[Enum]."""
+    captured: dict[str, list[object]] = {}
+
+    class Severity(enum.Enum):
+        LOW = "low"
+        HIGH = "high"
+
+    def list_enum_tool(levels: list[Severity]) -> None:
+        captured["levels"] = levels
+
+    create_apps_and_register.register_command(list_enum_tool, name="test-list-enum-comma")
+    runner = CliRunner()
+    result = runner.invoke(create_apps_and_register.app, ["test-list-enum-comma", "low, high"])
+
+    assert result.exit_code == 0, f"CLI failed: {result.output}"
+    assert captured["levels"] == [Severity.LOW, Severity.HIGH]
+
+
+def test_cli_optional_str_empty_string_becomes_none() -> None:
+    """Ensure an empty string for str | None parameter is converted to None."""
+    captured: dict[str, str | None] = {}
+
+    def optional_str_tool(text: str | None = None) -> None:
+        captured["text"] = text
+
+    create_apps_and_register.register_command(optional_str_tool, name="test-optional-str-empty")
+    runner = CliRunner()
+    result = runner.invoke(create_apps_and_register.app, ["test-optional-str-empty", "--text", ""])
+
+    assert result.exit_code == 0, f"CLI failed: {result.output}"
+    assert captured["text"] is None
+
+
+def test_cli_required_str_empty_string_is_rejected() -> None:
+    """Ensure an empty string for a required str parameter is rejected with an error."""
+
+    def required_str_tool(text: str) -> None:  # noqa: ARG001
+        pass
+
+    create_apps_and_register.register_command(required_str_tool, name="test-required-str-empty")
+    runner = CliRunner()
+    result = runner.invoke(create_apps_and_register.app, ["test-required-str-empty", ""])
+
+    assert result.exit_code != 0, "Expected non-zero exit code for empty required string"
+
+
+def test_clitool_runtime_propagates_subprocess_exit_code(monkeypatch: pytest.MonkeyPatch) -> None:
+    class DummyCompletedProcess:
+        """Completed-process stand-in with return code for subprocess mocks."""
+
+        def __init__(self, returncode: int) -> None:
+            self.returncode = returncode
+
+    def fake_run(command: object, *args: object, **kwargs: object) -> DummyCompletedProcess:  # noqa: ARG001
+        return DummyCompletedProcess(returncode=9)
+
+    monkeypatch.setattr(create_apps_and_register.subprocess, "run", fake_run)
+
+    @clitool
+    def returns_failing_command() -> str:
+        return "exit 9"
+
+    create_apps_and_register.register_command(
+        returns_failing_command,
+        name="test-clitool-runtime-propagates-subprocess-exit-code",
+    )
+    runner = CliRunner()
+    result = runner.invoke(create_apps_and_register.app, ["test-clitool-runtime-propagates-subprocess-exit-code"])
+
+    assert result.exit_code == 9
diff --git a/tests/create_tasks_json_test.py b/tests/create_tasks_json_test.py
index cd67ab0..6bf8fad 100644
--- a/tests/create_tasks_json_test.py
+++ b/tests/create_tasks_json_test.py
@@ -1,226 +1,128 @@
-"""Tests for create_tasks_json type annotation handling."""
+"""Tests for tasks.json generation and structure.
 
-import enum
-import inspect
-from typing import Any, Optional
-
-import pytest
-
-from toolit.create_tasks_json import TaskJsonBuilder, _annotation_to_string  # noqa: PLC2701
-
-
-class Color(enum.Enum):
-    """Test enum for colors."""
-
-    RED = "red"
-    GREEN = "green"
-    BLUE = "blue"
-
-
-class Environment(str, enum.Enum):
-    """Test enum for environments."""
-
-    DEV = "development"
-    STAGING = "staging"
-    PROD = "production"
-
-
-def _tool_with_pep604_optional(input_dataset_name: str | None = None) -> None:
-    """Tool with a PEP 604 optional argument."""
-
-
-def _tool_with_typing_optional(input_dataset_name: str | None = None) -> None:
-    """Tool with a typing.Optional argument."""
-
-
-def _tool_without_type_hint(to_print) -> None:  # type: ignore[no-untyped-def]  # noqa: ANN001
-    """Tool without a type hint on a parameter."""
-
-
-def _tool_with_multiple_params_missing_hint(name, value: str) -> None:  # type: ignore[no-untyped-def]  # noqa: ANN001
-    """Tool where only the first parameter is missing a type hint."""
-
-
-def _tool_with_enum_param(color: Color) -> None:  # noqa: ARG001
-    """Tool with an enum parameter."""
-
-
-def _tool_with_enum_param_with_default(color: Color = Color.RED) -> None:  # noqa: ARG001
-    """Tool with an enum parameter that has a default value."""
-
-
-def _tool_with_multiple_enum_params(
-    color: Color = Color.RED,  # noqa: ARG001
-    environment: Environment | None = None,  # noqa: ARG001
-) -> None:
-    """Tool with multiple enum parameters."""
+This module tests the _TaskJsonBuilder class and ensures that tasks.json
+is properly structured with correct task entries and input metadata.
+"""
 
+from types import FunctionType
+from typing import Any, cast
 
-def _tool_with_list_str_param(items: list[str]) -> None:  # noqa: ARG001
-    """Tool with a list[str] parameter."""
-
-
-def _tool_with_list_int_param(numbers: list[int] = [1, 2, 3]) -> None:  # noqa: B006, ARG001
-    """Tool with a list[int] parameter and list default."""
-
-
-def _tool_with_list_enum_param(colors: list[Color] = [Color.RED, Color.GREEN]) -> None:  # noqa: B006, ARG001
-    """Tool with a list[Enum] parameter and list default."""
-
-
-def _tool_with_optional_list_param(values: list[str] | None = None) -> None:  # noqa: ARG001
-    """Tool with an optional list parameter."""
-
-
-def test_create_args_for_tool_handles_pep604_optional() -> None:
-    """Ensure str | None annotations do not crash and are rendered in descriptions."""
-    builder = TaskJsonBuilder()
-
-    args = builder._create_args_for_tool(_tool_with_pep604_optional)  # noqa: SLF001
-
-    assert args == ['"${input:_tool_with_pep604_optional_input_dataset_name}"']
-    assert builder.inputs[0]["description"] == "Enter value for input_dataset_name (str | None)"
-    assert builder.inputs[0]["default"] is None
-
-
-def test_create_args_for_tool_handles_typing_optional() -> None:
-    """Ensure typing.Optional[str] annotations do not crash and are rendered in descriptions."""
-    builder = TaskJsonBuilder()
-
-    args = builder._create_args_for_tool(_tool_with_typing_optional)  # noqa: SLF001
-
-    assert args == ['"${input:_tool_with_typing_optional_input_dataset_name}"']
-    assert builder.inputs[0]["description"] == "Enter value for input_dataset_name (str | None)"
-    assert builder.inputs[0]["default"] is None
-
-
-@pytest.mark.parametrize(
-    ("annotation", "expected"),
-    [
-        (inspect.Parameter.empty, "str"),
-        (Any, "Any"),
-        (list[str], "list[str]"),
-        (dict[str, int], "dict[str, int]"),
-        (str | None, "str | None"),
-        (Optional[int], "int | None"),
-    ],
-)
-def test_annotation_to_string_formats_common_and_complex_types(annotation: Any, expected: str) -> None:
-    """Ensure annotation string conversion supports unions, optionals, and generics."""
-    assert _annotation_to_string(annotation) == expected
-
+import pytest
 
-def test_create_args_for_tool_raises_on_missing_type_hint() -> None:
-    """Ensure a missing type hint raises ValueError with an instructive message."""
-    builder = TaskJsonBuilder()
+from toolit import clitool
+from toolit.cli_command_builder import CliCommandBuilder
+from toolit.create_tasks_json import _TaskJsonBuilder
 
-    with pytest.raises(
-        ValueError, match="Parameter 'to_print' in function '_tool_without_type_hint' is missing a type annotation"
-    ):
-        builder._create_args_for_tool(_tool_without_type_hint)
 
+def _as_function(func: Any) -> FunctionType:
+    """Cast a Python function to FunctionType for strict type checks."""
+    return cast(FunctionType, func)
 
-def test_create_args_for_tool_error_message_includes_fix_hint() -> None:
-    """Ensure the error message tells the user how to fix the missing annotation."""
-    builder = TaskJsonBuilder()
 
-    with pytest.raises(ValueError, match=r"def _tool_without_type_hint\(to_print: str\) -> None"):
-        builder._create_args_for_tool(_tool_without_type_hint)
+# ============ Tests for task entry creation ============
 
 
-def test_create_args_for_tool_raises_on_first_missing_hint_in_mixed_params() -> None:
-    """Ensure the error reports the specific parameter that is missing the annotation."""
-    builder = TaskJsonBuilder()
+def test_task_json_builder_creates_task_entry_from_spec() -> None:
+    """Ensure _TaskJsonBuilder creates properly formatted task entries."""
 
-    with pytest.raises(ValueError, match="Parameter 'name' in function '_tool_with_multiple_params_missing_hint'"):
-        builder._create_args_for_tool(_tool_with_multiple_params_missing_hint)
+    @clitool
+    def run_script(name: str) -> str:
+        """Run a shell script."""
+        return f"echo {name}"
 
+    cmd_builder = CliCommandBuilder()
+    builder = _TaskJsonBuilder(cmd_builder)
+    spec = cmd_builder.analyze_tool(_as_function(run_script))
 
-def test_create_args_for_tool_enum_creates_picklist_input() -> None:
-    """Ensure enum parameters create pickString input type in tasks.json."""
-    builder = TaskJsonBuilder()
+    builder._create_task_entry(spec)
 
-    args = builder._create_args_for_tool(_tool_with_enum_param)  # noqa: SLF001
+    assert len(builder.tasks) == 1
+    task = builder.tasks[0]
 
-    assert args == ['"${input:_tool_with_enum_param_color}"']
-    assert builder.inputs[0]["type"] == "pickString"
-    assert builder.inputs[0]["options"] == ["red", "green", "blue"]
+    assert task["label"] == "Run Script"
+    assert task["type"] == "shell"
+    assert task["command"].endswith('toolit run-script "${input:run_script_name}"')
+    assert task["detail"] == "Run a shell script."
+    assert task["problemMatcher"] == []
 
 
-def test_create_args_for_tool_enum_sets_default_to_first_choice() -> None:
-    """Ensure enum parameters default to the first enum value when no default provided."""
-    builder = TaskJsonBuilder()
+def test_task_json_builder_omits_detail_when_no_docstring() -> None:
+    """Ensure detail field is omitted when tool has no docstring."""
 
-    args = builder._create_args_for_tool(_tool_with_enum_param)  # noqa: SLF001
+    @clitool
+    def run_without_docstring(name: str) -> str:  # type: ignore[no-untyped-def]
+        pass
 
-    assert builder.inputs[0]["default"] == "red"
+    cmd_builder = CliCommandBuilder()
+    builder = _TaskJsonBuilder(cmd_builder)
+    spec = cmd_builder.analyze_tool(_as_function(run_without_docstring))
 
+    # Docstring is None, so we'll set it explicitly to test
+    spec.docstring = None
+    builder._create_task_entry(spec)
 
-def test_create_args_for_tool_enum_respects_provided_default() -> None:
-    """Ensure enum parameters use the provided default value if specified."""
-    builder = TaskJsonBuilder()
+    task = builder.tasks[0]
+    assert "detail" not in task
 
-    args = builder._create_args_for_tool(_tool_with_enum_param_with_default)  # noqa: SLF001
 
-    assert builder.inputs[0]["default"] == Color.RED.value
+def test_task_json_builder_collects_input_entries() -> None:
+    """Ensure all input entries are collected during processing."""
 
+    @clitool
+    def multi_param(name: str, count: int = 5) -> None:  # noqa: ARG001
+        """Tool with multiple parameters."""
 
-def test_create_args_for_tool_multiple_enum_params() -> None:
-    """Ensure multiple enum parameters are all correctly handled in tasks.json."""
-    builder = TaskJsonBuilder()
+    cmd_builder = CliCommandBuilder()
+    builder = _TaskJsonBuilder(cmd_builder)
+    spec = cmd_builder.analyze_tool(_as_function(multi_param))
 
-    args = builder._create_args_for_tool(_tool_with_multiple_enum_params)  # noqa: SLF001
+    builder._create_task_entry(spec)
+    builder.inputs.extend(spec.get_input_entries())
 
     assert len(builder.inputs) == 2
-    # First input (color)
-    assert builder.inputs[0]["type"] == "pickString"
-    assert builder.inputs[0]["options"] == ["red", "green", "blue"]
-    assert builder.inputs[0]["default"] == "red"
-    # Second input (environment)
-    assert builder.inputs[1]["type"] == "pickString"
-    assert builder.inputs[1]["options"] == ["development", "staging", "production"]
-    assert builder.inputs[1]["default"] == "development"
-
-
-def test_create_args_for_tool_list_str_uses_promptstring_and_guidance() -> None:
-    """Ensure list[str] parameters use promptString with comma-separated guidance."""
-    builder = TaskJsonBuilder()
-
-    args = builder._create_args_for_tool(_tool_with_list_str_param)  # noqa: SLF001
-
-    assert args == ['"${input:_tool_with_list_str_param_items}"']
-    assert builder.inputs[0]["type"] == "promptString"
-    assert builder.inputs[0]["description"] == "Enter comma-separated text values for items (e.g. alpha, beta, gamma)"
-    assert builder.inputs[0]["default"] == ""
+    assert builder.inputs[0]["id"] == "multi_param_name"
+    assert builder.inputs[1]["id"] == "multi_param_count"
 
 
-def test_create_args_for_tool_list_int_serializes_default_values() -> None:
-    """Ensure list[int] defaults are serialized to comma-separated text."""
-    builder = TaskJsonBuilder()
+def test_task_json_builder_create_tasks_json_returns_proper_structure() -> None:
+    """Ensure create_tasks_json returns properly formatted output."""
 
-    builder._create_args_for_tool(_tool_with_list_int_param)  # noqa: SLF001
+    @clitool
+    def simple_tool(text: str) -> None:  # noqa: ARG001
+        """A simple tool."""
 
-    assert builder.inputs[0]["description"] == "Enter comma-separated integer values for numbers (e.g. 1, 2, 3)"
-    assert builder.inputs[0]["default"] == "1, 2, 3"
+    cmd_builder = CliCommandBuilder()
+    builder = _TaskJsonBuilder(cmd_builder)
+    spec = cmd_builder.analyze_tool(_as_function(simple_tool))
+    builder.process_tool(simple_tool)
 
+    tasks_json = builder.create_tasks_json()
 
-def test_create_args_for_tool_list_enum_serializes_default_values() -> None:
-    """Ensure list[Enum] defaults are serialized using enum values."""
-    builder = TaskJsonBuilder()
+    assert "version" in tasks_json
+    assert tasks_json["version"] == "2.0.0"
+    assert "tasks" in tasks_json
+    assert "inputs" in tasks_json
+    assert isinstance(tasks_json["tasks"], list)
+    assert isinstance(tasks_json["inputs"], list)
 
-    builder._create_args_for_tool(_tool_with_list_enum_param)  # noqa: SLF001
 
-    assert (
-        builder.inputs[0]["description"]
-        == "Enter comma-separated enum values for colors. Accepted values: [red, green, blue]. You can also use enum member names."
-    )
-    assert builder.inputs[0]["default"] == "red, green"
+def test_task_json_builder_final_json_structure() -> None:
+    """Ensure the final tasks.json has correct structure with tasks and inputs."""
 
+    @clitool
+    def example_tool(name: str, enabled: bool = False) -> None:  # noqa: ARG001
+        """Example tool."""
 
-def test_create_args_for_tool_optional_list_keeps_none_default() -> None:
-    """Ensure optional list parameters preserve None as default."""
-    builder = TaskJsonBuilder()
+    cmd_builder = CliCommandBuilder()
+    builder = _TaskJsonBuilder(cmd_builder)
+    spec = cmd_builder.analyze_tool(_as_function(example_tool))
+    builder.process_tool(example_tool)
 
-    builder._create_args_for_tool(_tool_with_optional_list_param)  # noqa: SLF001
+    tasks_json = builder.create_tasks_json()
 
-    assert builder.inputs[0]["default"] is None
+    assert len(tasks_json["tasks"]) == 1
+    assert len(tasks_json["inputs"]) >= 2
+    
+    task = tasks_json["tasks"][0]
+    assert task["label"] == "Example Tool"
+    assert "example-tool" in task["command"]
diff --git a/tests/test_auto_loader.py b/tests/test_auto_loader.py
new file mode 100644
index 0000000..2752240
--- /dev/null
+++ b/tests/test_auto_loader.py
@@ -0,0 +1,107 @@
+"""Tests for load_tools_from_folder in auto_loader."""
+
+import os
+import pathlib
+import types
+
+import pytest
+
+from toolit import auto_loader
+from toolit.auto_loader import load_tools_from_folder
+
+
+class DummyToolitTypesEnum:
+    """Dummy enum for tool types."""
+
+    TOOL = "TOOL"
+    CLITOOL = "CLITOOL"
+    SEQUENTIAL_GROUP = "SEQUENTIAL_GROUP"
+    PARALLEL_GROUP = "PARALLEL_GROUP"
+
+
+@pytest.fixture
+def temp_tools_folder(tmp_path: pathlib.Path) -> pathlib.Path:
+    """Fixture to create a temporary folder with tool files."""
+    folder: pathlib.Path = tmp_path / "tools"
+    folder.mkdir()
+
+    tool_file: pathlib.Path = folder / "my_tool.py"
+    tool_file.write_text(
+        "def dummy():\n"
+        "    pass\n"
+        "dummy.toolit_type = 'TOOL'\n"
+        "\n"
+        "def group():\n"
+        "    pass\n"
+        "group.toolit_type = 'SEQUENTIAL_GROUP'\n"
+        "\n"
+        "def cli_command():\n"
+        "    pass\n"
+        "cli_command.toolit_type = 'CLITOOL'\n"
+    )
+
+    nontool_file: pathlib.Path = folder / "not_a_tool.py"
+    nontool_file.write_text(
+        "def not_a_tool():\n"
+        "    pass\n"
+    )
+    return folder
+
+
+def patch_auto_loader(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Patch auto_loader internals for isolated testing."""
+    monkeypatch.setattr(auto_loader, "ToolitTypesEnum", DummyToolitTypesEnum)
+    monkeypatch.setattr(auto_loader, "MARKER_TOOL", "toolit_type")
+    monkeypatch.setattr(auto_loader, "register_command", lambda *args, **kwargs: None)
+
+    def import_module(file: pathlib.Path) -> types.ModuleType:
+        module = types.ModuleType(file.stem)
+        code = file.read_text()
+        exec(code, module.__dict__)
+        return module
+
+    monkeypatch.setattr(auto_loader, "import_module", import_module)
+
+
+@pytest.mark.usefixtures("temp_tools_folder")
+def test_load_tools_from_folder_loads_tools_and_groups(
+    temp_tools_folder: pathlib.Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Test load_tools_from_folder loads tools and tool groups."""
+    patch_auto_loader(monkeypatch)
+    loaded = load_tools_from_folder(temp_tools_folder)
+    loaded_names: set[str] = {f.__name__ for f in loaded}
+    assert "dummy" in loaded_names
+    assert "group" in loaded_names
+    assert "cli_command" in loaded_names
+    assert "not_a_tool" not in loaded_names
+
+
+def test_load_tools_from_folder_empty_folder(tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test load_tools_from_folder returns empty list for empty folder."""
+    patch_auto_loader(monkeypatch)
+    empty_folder: pathlib.Path = tmp_path / "empty"
+    empty_folder.mkdir()
+    loaded = load_tools_from_folder(empty_folder)
+    assert loaded == []
+
+
+def test_load_tools_from_folder_relative_path(monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path) -> None:
+    """Test load_tools_from_folder works with relative paths."""
+    patch_auto_loader(monkeypatch)
+    folder: pathlib.Path = tmp_path / "reltools"
+    folder.mkdir()
+    tool_file: pathlib.Path = folder / "toolx.py"
+    tool_file.write_text(
+        "def toolx():\n"
+        "    pass\n"
+        "toolx.toolit_type = 'TOOL'\n"
+    )
+    cwd = pathlib.Path.cwd()
+    try:
+        os.chdir(tmp_path)
+        loaded = load_tools_from_folder(pathlib.Path("reltools"))
+        loaded_names: set[str] = {f.__name__ for f in loaded}
+        assert "toolx" in loaded_names
+    finally:
+        os.chdir(cwd)
\ No newline at end of file
diff --git a/toolit/__init__.py b/toolit/__init__.py
index 94ba30f..277f84a 100644
--- a/toolit/__init__.py
+++ b/toolit/__init__.py
@@ -1,9 +1,10 @@
 """Public API for the package."""
 
 from toolit.config import get_config_value
-from toolit.decorators import tool
+from toolit.decorators import clitool, tool
 
 __all__ = [
+    "clitool",
     "get_config_value",
     "tool",
 ]
diff --git a/toolit/auto_loader.py b/toolit/auto_loader.py
index 75de33f..6e09a96 100644
--- a/toolit/auto_loader.py
+++ b/toolit/auto_loader.py
@@ -46,6 +46,11 @@ def tool_strategy(module: ModuleType) -> list[FunctionType]:
     return load_tools_from_file(module, ToolitTypesEnum.TOOL)
 
 
+def clitool_strategy(module: ModuleType) -> list[FunctionType]:
+    """Strategy to get CLI tools from a module."""
+    return load_tools_from_file(module, ToolitTypesEnum.CLITOOL)
+
+
 def tool_group_strategy(module: ModuleType) -> list[FunctionType]:
     """Strategy to get tool groups from a module."""
     groups: list[FunctionType] = []
@@ -82,11 +87,14 @@ def load_tools_from_folder(folder_path: pathlib.Path) -> list[FunctionType]:
         folder_path = pathlib.Path.cwd() / folder_path
 
     tools: list[FunctionType] = get_items_from_folder(folder_path, tool_strategy)
+    clitools: list[FunctionType] = get_items_from_folder(folder_path, clitool_strategy)
     tool_groups: list[FunctionType] = get_items_from_folder(folder_path, tool_group_strategy)
     # Register each tool as a command
     for tool in tools:
         register_command(tool, rich_help_panel=RichHelpPanelNames.PROJECT_COMMANDS_PANEL)
-    return tools + tool_groups
+    for clitool in clitools:
+        register_command(clitool, rich_help_panel=RichHelpPanelNames.PROJECT_COMMANDS_PANEL)
+    return tools + clitools + tool_groups
 
 
 def get_toolit_type(tool: FunctionType) -> ToolitTypesEnum | None:
diff --git a/toolit/cli.py b/toolit/cli.py
index 86ddb23..91b183f 100644
--- a/toolit/cli.py
+++ b/toolit/cli.py
@@ -1,4 +1,5 @@
 """CLI entry point for the toolit package."""
+
 from toolit.create_apps_and_register import app
 from toolit.register_all_tool_and_plugins import register_all_tools_from_folder_and_plugin
 
diff --git a/toolit/cli_command_builder.py b/toolit/cli_command_builder.py
new file mode 100644
index 0000000..81b687c
--- /dev/null
+++ b/toolit/cli_command_builder.py
@@ -0,0 +1,359 @@
+"""
+Build complete CLI commands with rich metadata for tool functions.
+
+Scope: this module handles complete tool inspection including parameter analysis,
+VS Code input metadata generation, command-line name formatting, and shell command
+assembly. The command builder is self-contained and returns rich domain objects.
+"""
+
+import enum
+import shutil
+import inspect
+from collections.abc import Callable
+from dataclasses import dataclass
+from toolit.constants import OPTIONAL_STR_SENTINEL
+from toolit.type_utils import is_union_type, unwrap_union_members
+from typing import cast, get_args, get_origin
+
+OPTIONAL_UNION_MEMBER_COUNT = 2
+
+
+@dataclass
+class ParameterSpec:
+    """
+    Complete specification for a single tool parameter.
+
+    Includes both CLI-specific information (option names, argument building)
+    and VS Code input metadata (type, description, default, options).
+    """
+
+    name: str
+    annotation: object
+    default: object
+
+    # CLI metadata
+    input_id: str
+    option_name: str  # e.g., '--param-name'
+    uses_option: bool  # whether parameter has a default (uses option flag)
+    is_optional_string: bool  # whether parameter is str | None
+
+    # VS Code input metadata
+    input_type: str  # 'promptString', 'pickString', etc.
+    input_options: dict[str, object]  # options for pickString, etc.
+    input_description: str
+    input_default: object
+
+    def get_argument_string(self) -> str:
+        """Get this parameter's argument string for command building."""
+        if self.is_optional_string:
+            input_ref = f'"{OPTIONAL_STR_SENTINEL}${{input:{self.input_id}}}"'
+        else:
+            input_ref = f'"${{input:{self.input_id}}}"'
+        if self.uses_option:
+            return f"{self.option_name} {input_ref}"
+        return input_ref
+
+    def to_input_entry(self) -> dict[str, object]:
+        """Convert to VS Code input entry for tasks.json."""
+        entry: dict[str, object] = {
+            "id": self.input_id,
+            "type": self.input_type,
+            "description": self.input_description,
+            "default": self.input_default,
+        }
+        entry.update(self.input_options)
+        return entry
+
+
+@dataclass
+class ToolCommandSpec:
+    """Rich specification for building a tool command with full metadata."""
+
+    tool: Callable[..., object]
+    tool_name: str
+    display_name: str
+    docstring: str | None
+    parameters: dict[str, ParameterSpec]  # param_name -> spec
+
+    def get_argument_strings(self) -> list[str]:
+        """Get all argument strings in parameter order."""
+        return [param.get_argument_string() for param in self.parameters.values()]
+
+    def get_input_entries(self) -> list[dict[str, object]]:
+        """Get all VS Code input entries for tasks.json."""
+        return [param.to_input_entry() for param in self.parameters.values()]
+
+    def iter_parameters(self) -> list[ParameterSpec]:
+        """Iterate parameters in order."""
+        return list(self.parameters.values())
+
+    @property
+    def command_name(self) -> str:
+        """Get the Typer command name derived from tool name."""
+        return self.tool_name.replace("_", "-").lower()
+
+    def build_command(self, program_name: str = "toolit", command_prefix: str | None = None) -> str:
+        """
+        Build the complete shell command string for this tool spec.
+
+        Args:
+            program_name: The program/command name (default: 'toolit').
+            command_prefix: Optional prefix like 'uv run --no-sync '. If None, auto-detects uv.
+
+        Returns:
+            Complete shell command string ready for execution.
+
+        """
+        if command_prefix is None:
+            command_prefix = "uv run --no-sync " if shutil.which("uv") else ""
+
+        args: list[str] = self.get_argument_strings()
+        rendered_args: str = f" {' '.join(args)}" if args else ""
+        return f"{command_prefix}{program_name} {self.command_name}{rendered_args}"
+
+
+class CliCommandBuilder:
+    """Expert analyzer for tool commands with rich metadata generation."""
+
+    def __init__(self, program_name: str = "toolit", command_prefix: str | None = None) -> None:
+        """
+        Initialize command builder settings.
+
+        When command_prefix is omitted, uv is used when available.
+        """
+        self.program_name: str = program_name
+        self.command_prefix: str = command_prefix if command_prefix is not None else self._detect_command_prefix()
+
+    @staticmethod
+    def create_typer_command_name(tool: Callable[..., object]) -> str:
+        """Create a Typer command name from a tool function name."""
+        return tool.__name__.replace("_", "-").lower()
+
+    @staticmethod
+    def create_typer_option_name(param_name: str) -> str:
+        """Create a Typer option name from a function parameter name."""
+        return f"--{param_name.replace('_', '-')}"
+
+    @staticmethod
+    def create_display_name(tool: Callable[..., object]) -> str:
+        """Create a user-facing display name from a tool function name."""
+        return tool.__name__.replace("_", " ").title()
+
+    @staticmethod
+    def create_group_name(tool: Callable[..., object]) -> str:
+        """Create a user-facing group label for grouped tools."""
+        return "Group: " + tool.__name__.replace("_", " ").title()
+
+    @staticmethod
+    def _detect_command_prefix() -> str:
+        """Detect command prefix, preferring uv when available."""
+        return "uv run --no-sync " if shutil.which("uv") else ""
+
+    @staticmethod
+    def _is_enum(annotation: object) -> bool:
+        """Check if annotation is an Enum type."""
+        return isinstance(annotation, type) and issubclass(annotation, enum.Enum)
+
+    @staticmethod
+    def _is_bool(annotation: object) -> bool:
+        """Check if annotation is a bool type."""
+        return annotation is bool
+
+    @staticmethod
+    def _unwrap_union_annotations(annotation: object) -> list[object]:
+        """Return union members for X | Y or Union[X, Y], or the annotation itself."""
+        return unwrap_union_members(annotation)
+
+    @staticmethod
+    def _extract_enum_type(annotation: object) -> type[enum.Enum] | None:
+        """Extract enum type from annotation, including optional/union wrappers."""
+        for candidate in CliCommandBuilder._unwrap_union_annotations(annotation):
+            if candidate in {None, type(None)}:
+                continue
+            if CliCommandBuilder._is_enum(candidate):
+                return cast("type[enum.Enum]", candidate)
+        return None
+
+    @staticmethod
+    def _contains_bool(annotation: object) -> bool:
+        """Check whether annotation contains bool directly or via union/optional."""
+        return any(
+            CliCommandBuilder._is_bool(candidate)
+            for candidate in CliCommandBuilder._unwrap_union_annotations(annotation)
+        )
+
+    @staticmethod
+    def _extract_list_item_type(annotation: object) -> object | None:
+        """Extract list item type from annotation, including optional/union wrappers."""
+        for candidate in CliCommandBuilder._unwrap_union_annotations(annotation):
+            if candidate in {None, type(None)}:
+                continue
+            origin = get_origin(candidate)
+            if origin is list:
+                args = get_args(candidate)
+                if args:
+                    return args[0]
+                return str
+        return None
+
+    @staticmethod
+    def _is_optional_str(annotation: object) -> bool:
+        """Check whether annotation is exactly str | None."""
+        members = CliCommandBuilder._unwrap_union_annotations(annotation)
+        return str in members and type(None) in members and len(members) == OPTIONAL_UNION_MEMBER_COUNT
+
+    @staticmethod
+    def _annotation_to_string(annotation: object) -> str:
+        """Convert Python type annotations to readable strings."""
+        result: str = ""
+
+        if annotation == inspect.Parameter.empty:
+            result = "str"
+        elif annotation is None or annotation is type(None):
+            result = "None"
+        else:
+            origin = get_origin(annotation)
+            args = get_args(annotation)
+
+            if is_union_type(annotation):
+                result = " | ".join(CliCommandBuilder._annotation_to_string(arg) for arg in args)
+            elif origin is not None:
+                origin_name = getattr(origin, "__name__", str(origin).replace("typing.", ""))
+                if args:
+                    args_repr = ", ".join(CliCommandBuilder._annotation_to_string(arg) for arg in args)
+                    result = f"{origin_name}[{args_repr}]"
+                else:
+                    result = origin_name
+            elif hasattr(annotation, "__name__"):
+                result = annotation.__name__
+            else:
+                result = str(annotation).replace("typing.", "")
+
+        return result
+
+    @staticmethod
+    def _build_list_description(param_name: str, list_item_type: object) -> str:
+        """Build type-specific description for list prompt inputs."""
+        if list_item_type is str:
+            return f"Enter comma-separated text values for {param_name} (e.g. alpha, beta, gamma)"
+        if list_item_type is int:
+            return f"Enter comma-separated integer values for {param_name} (e.g. 1, 2, 3)"
+        if CliCommandBuilder._is_enum(list_item_type):
+            enum_type = cast("type[enum.Enum]", list_item_type)
+            accepted_values = ", ".join(str(member.value) for member in enum_type)
+            return (
+                f"Enter comma-separated enum values for {param_name}. "
+                f"Accepted values: [{accepted_values}]. You can also use enum member names."
+            )
+        item_type_name = CliCommandBuilder._annotation_to_string(list_item_type)
+        return f"Enter comma-separated values for {param_name} ({item_type_name})"
+
+    def _build_input_metadata(self, param: inspect.Parameter) -> tuple[str, dict[str, object], str, object]:
+        """
+        Build VS Code input metadata for a single parameter.
+
+        Returns: (input_type, input_options, description, default_value)
+        """
+        annotation = param.annotation
+        input_type: str = "promptString"
+        input_options: dict[str, object] = {}
+        description: str = f"Enter value for {param.name} ({self._annotation_to_string(annotation)})"
+        default_value: object = "" if param.default == inspect.Parameter.empty else param.default
+
+        list_item_type = self._extract_list_item_type(annotation)
+        if list_item_type is not None:
+            description = self._build_list_description(param.name, list_item_type)
+            if param.default == inspect.Parameter.empty or param.default is None:
+                default_value = "" if param.default == inspect.Parameter.empty else None
+            else:
+                # Serialize list defaults
+                rendered_items: list[str] = []
+                default_values = cast("list[object]", param.default)
+                for item in default_values:
+                    if isinstance(item, enum.Enum):
+                        rendered_items.append(str(item.value))
+                    else:
+                        rendered_items.append(str(item))
+                default_value = ", ".join(rendered_items)
+            return input_type, input_options, description, default_value
+
+        enum_type = self._extract_enum_type(annotation)
+        if enum_type is not None:
+            input_type = "pickString"
+            choices: list[str] = [e.value for e in enum_type]
+            input_options["options"] = choices
+            if param.default == inspect.Parameter.empty or param.default is None:
+                default_value = choices[0]
+            else:
+                default_value = param.default.value
+            return input_type, input_options, description, default_value
+
+        if self._contains_bool(annotation):
+            input_type = "pickString"
+            input_options["options"] = ["True", "False"]
+            if param.default == inspect.Parameter.empty or param.default is None:
+                default_value = "False"
+            else:
+                default_value = str(param.default)
+
+        return input_type, input_options, description, default_value
+
+    def analyze_tool(self, tool: Callable[..., object]) -> ToolCommandSpec:
+        """
+        Analyze tool and return complete specification for building command and inputs.
+
+        Args:
+            tool: The tool function to analyze.
+
+        Returns:
+            ToolCommandSpec with all metadata needed for command and input generation.
+
+        Raises:
+            ValueError: If a parameter lacks a type annotation.
+
+        """
+        sig = inspect.signature(tool)
+        parameters: dict[str, ParameterSpec] = {}
+
+        for param in sig.parameters.values():
+            if param.name == "self":
+                continue
+
+            annotation = param.annotation
+            if annotation is inspect.Parameter.empty:
+                msg = (
+                    f"Parameter '{param.name}' in function '{tool.__name__}' is missing a type annotation. "
+                    f"Please add a type hint, e.g.: def {tool.__name__}({param.name}: str) -> None"
+                )
+                raise ValueError(msg)
+
+            # Build CLI metadata
+            input_id: str = f"{tool.__name__}_{param.name}"
+            option_name: str = self.create_typer_option_name(param.name)
+            uses_option: bool = param.default is not inspect.Parameter.empty
+            is_optional_string: bool = self._is_optional_str(annotation)
+
+            # Build VS Code input metadata
+            input_type, input_options, description, default_value = self._build_input_metadata(param)
+
+            parameters[param.name] = ParameterSpec(
+                name=param.name,
+                annotation=annotation,
+                default=param.default,
+                input_id=input_id,
+                option_name=option_name,
+                uses_option=uses_option,
+                is_optional_string=is_optional_string,
+                input_type=input_type,
+                input_options=input_options,
+                input_description=description,
+                input_default=default_value,
+            )
+
+        return ToolCommandSpec(
+            tool=tool,
+            tool_name=tool.__name__,
+            display_name=self.create_display_name(tool),
+            docstring=tool.__doc__,
+            parameters=parameters,
+        )
diff --git a/toolit/config.py b/toolit/config.py
index ed13087..2629bce 100644
--- a/toolit/config.py
+++ b/toolit/config.py
@@ -6,6 +6,7 @@
 - Creating a `toolit.ini` toml file in the current working directory
 - Adding to the `pyproject.toml` file in the current working directory
 """
+
 from __future__ import annotations
 
 import toml
@@ -55,6 +56,7 @@ def _load_config() -> dict[str, str]:
 @overload
 def get_config_value(key: str, default: None = None) -> str | None: ...
 
+
 @overload
 def get_config_value(key: str, default: str) -> str: ...
 
diff --git a/toolit/constants.py b/toolit/constants.py
index 6275efb..885c586 100644
--- a/toolit/constants.py
+++ b/toolit/constants.py
@@ -3,6 +3,7 @@
 import enum
 
 MARKER_TOOL = "__toolit_tool_type__"
+OPTIONAL_STR_SENTINEL = "__toolit_optional_str_prefix__"
 
 
 class RichHelpPanelNames:
@@ -23,5 +24,6 @@ class ToolitTypesEnum(enum.Enum):
     """Enum for the different types of toolit tools."""
 
     TOOL = "tool"
+    CLITOOL = "clitool"
     SEQUENTIAL_GROUP = "sequential_group"
     PARALLEL_GROUP = "parallel_group"
diff --git a/toolit/create_apps_and_register.py b/toolit/create_apps_and_register.py
index 4f4c46b..62408c9 100644
--- a/toolit/create_apps_and_register.py
+++ b/toolit/create_apps_and_register.py
@@ -2,20 +2,36 @@
 
 from __future__ import annotations
 
+import os
+import enum
+import shlex
 import typer
+import inspect
+import subprocess  # noqa: S404
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
+from functools import wraps
+from toolit.constants import (
+    MARKER_TOOL,
+    OPTIONAL_STR_SENTINEL,
+    ToolitTypesEnum,
+)
+from toolit.type_utils import unwrap_union_members
+from typing import TYPE_CHECKING, cast, get_args, get_origin
+
+OPTIONAL_UNION_MEMBER_COUNT = 2
 
 if TYPE_CHECKING:
-    from mcp.server.fastmcp import FastMCP
+    from mcp.server.fastmcp import FastMCP  # type: ignore[import-not-found]
+
     _has_mcp: bool = True
 else:
     # Make MCP optional
     try:
         from mcp.server.fastmcp import FastMCP
+
         _has_mcp = True
     except ImportError:
-        FastMCP: Any = None  # type: ignore[no-redef]
+        FastMCP: object = None  # type: ignore[no-redef]
         _has_mcp = False
 
 # Initialize the Typer app
@@ -30,7 +46,7 @@ def initialize() -> None:
 
 
 def register_command(
-    command_func: Callable[..., Any],
+    command_func: Callable[..., object],
     name: str | None = None,
     rich_help_panel: str | None = None,
 ) -> None:
@@ -38,6 +54,216 @@ def register_command(
     if not callable(command_func):
         msg = f"Command function {command_func} is not callable."
         raise TypeError(msg)
-    app.command(name=name, rich_help_panel=rich_help_panel)(command_func)
-    if mcp is not None:
+
+    command_to_register = _create_type_coercion_wrapper(command_func)
+    if getattr(command_func, MARKER_TOOL, None) == ToolitTypesEnum.CLITOOL:
+        command_to_register = _create_clitool_runtime_wrapper(command_to_register)
+
+    app.command(name=name, rich_help_panel=rich_help_panel)(command_to_register)
+
+    if mcp is not None and getattr(command_func, MARKER_TOOL, None) != ToolitTypesEnum.CLITOOL:
         mcp.tool(name)(command_func)
+
+
+def _extract_list_item_type(annotation: object) -> object | None:
+    """Return the T for list[T] (including Optional[list[T]]), or None if not a list."""
+    for candidate in unwrap_union_members(annotation):
+        if candidate is type(None):
+            continue
+        if get_origin(candidate) is list:
+            args = get_args(candidate)
+            return args[0] if args else str
+    return None
+
+
+def _is_optional_list(annotation: object) -> bool:
+    """Return True when annotation allows None alongside a list type."""
+    members = unwrap_union_members(annotation)
+    return type(None) in members and any(get_origin(m) is list for m in members)
+
+
+def _is_optional_str(annotation: object) -> bool:
+    """Return True when annotation is exactly str | None."""
+    members = unwrap_union_members(annotation)
+    return str in members and type(None) in members and len(members) == OPTIONAL_UNION_MEMBER_COUNT
+
+
+def _is_required_str(annotation: object, default: object) -> bool:
+    """Return True when annotation is plain str with no default value."""
+    return annotation is str and default is inspect.Parameter.empty
+
+
+def _contains_bool(annotation: object) -> bool:
+    """Return True when annotation is or contains bool."""
+    return any(m is bool for m in unwrap_union_members(annotation))
+
+
+def _coerce_list_value(value: list[object] | None, item_type: object) -> list[object] | None:
+    """
+    Split a single comma-separated element if needed, then convert to item_type.
+
+    Returns None unchanged (for optional list parameters with no value provided).
+    """
+    if value is None:
+        return None
+    if len(value) == 1 and isinstance(value[0], str) and "," in value[0]:
+        raw_items: list[str] = [v.strip() for v in value[0].split(",") if v.strip()]
+    else:
+        raw_items = [str(v) for v in value]
+
+    if item_type is str:
+        return cast("list[object]", raw_items)
+    if item_type is int:
+        return cast("list[object]", [int(v) for v in raw_items])
+    if isinstance(item_type, type) and issubclass(item_type, enum.Enum):
+        return cast("list[object]", [item_type(v) for v in raw_items])
+    return cast("list[object]", raw_items)
+
+
+def _parameter_coercion_spec(
+    param: inspect.Parameter,
+) -> tuple[inspect.Parameter, tuple[str, object | None] | None]:
+    """Return rewritten parameter and optional coercion metadata for runtime conversion."""
+    ann = param.annotation
+
+    list_item_type = _extract_list_item_type(ann)
+    if list_item_type is not None:
+        new_ann: object = (list[str] | None) if _is_optional_list(ann) else list[str]
+        return param.replace(annotation=new_ann), ("list", list_item_type)
+
+    if _contains_bool(ann):
+        bool_default = "False" if param.default is inspect.Parameter.empty else str(param.default)
+        return param.replace(annotation=str, default=bool_default), ("bool", None)
+
+    if _is_optional_str(ann):
+        return param, ("optional_str", None)
+
+    if _is_required_str(ann, param.default):
+        return param, ("required_str", None)
+
+    return param, None
+
+
+def _normalize_list_input(value: object) -> list[object] | None:
+    """Normalize Typer list input into a list or None before list coercion."""
+    if value is None:
+        return None
+    if isinstance(value, list):
+        return cast("list[object]", value)
+    return [value]
+
+
+def _apply_single_coercion(param_name: str, coercion_type: str, extra: object | None, value: object) -> object:
+    """Apply a single coercion strategy to one parameter value."""
+    if coercion_type == "list":
+        return _coerce_list_value(_normalize_list_input(value), extra)
+
+    if coercion_type == "bool":
+        return str(value).lower() == "true"
+
+    if coercion_type == "optional_str":
+        if isinstance(value, str) and value.startswith(OPTIONAL_STR_SENTINEL):
+            raw_value = value[len(OPTIONAL_STR_SENTINEL) :]
+            return raw_value or None
+        if isinstance(value, str) and not value:
+            return None
+        return value
+
+    if coercion_type == "required_str" and isinstance(value, str) and not value:
+        typer.secho(f"Error: '{param_name}' cannot be empty.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    return value
+
+
+def _create_type_coercion_wrapper(func: Callable[..., object]) -> Callable[..., object]:
+    """
+    Wrap a function to add CLI type coercions applied before the function is called.
+
+    Handles:
+    - list[T]: splits single comma-separated arg; preserves native multi-arg behavior.
+    - bool: changes --flag/--no-flag to --flag VALUE accepting 'True'/'False' strings.
+    - str | None: converts empty string to None.
+    - required str: rejects empty string with a non-zero exit.
+    """
+    sig = inspect.signature(func)
+    new_params: list[inspect.Parameter] = []
+    coercions: dict[str, tuple[str, object | None]] = {}
+
+    for param in sig.parameters.values():
+        rewritten_param, coercion = _parameter_coercion_spec(param)
+        new_params.append(rewritten_param)
+        if coercion is not None:
+            coercions[param.name] = coercion
+
+    if not coercions:
+        return func
+
+    new_sig = sig.replace(parameters=new_params)
+
+    @wraps(func)
+    def _wrapper(*args: object, **kwargs: object) -> object:
+        for param_name, (coercion_type, extra) in coercions.items():
+            if param_name not in kwargs:
+                continue
+            kwargs[param_name] = _apply_single_coercion(param_name, coercion_type, extra, kwargs[param_name])
+
+        return func(*args, **kwargs)
+
+    setattr(_wrapper, "__signature__", new_sig)  # noqa: B010
+    # Rebuild __annotations__ to match the new signature so Typer/get_type_hints
+    # sees the transformed types rather than the originals copied by @wraps.
+    new_annotations: dict[str, object] = {
+        p.name: p.annotation for p in new_sig.parameters.values() if p.annotation is not inspect.Parameter.empty
+    }
+    if sig.return_annotation is not inspect.Parameter.empty:
+        new_annotations["return"] = sig.return_annotation
+    _wrapper.__annotations__ = new_annotations
+    return _wrapper
+
+
+def _create_clitool_runtime_wrapper(command_func: Callable[..., object]) -> Callable[..., None]:
+    """Wrap a clitool function so its returned command string runs in a shell."""
+
+    @wraps(command_func)
+    def _wrapped(*args: object, **kwargs: object) -> None:
+        command = command_func(*args, **kwargs)
+        if not isinstance(command, str):
+            typer.secho(
+                f"Error: clitool '{command_func.__name__}' must return a string command, got {type(command).__name__}.",
+                fg=typer.colors.RED,
+            )
+            raise typer.Exit(code=1)
+
+        command_to_run: str = command.strip()
+        if not command_to_run:
+            typer.secho(
+                f"Error: clitool '{command_func.__name__}' returned an empty command.",
+                fg=typer.colors.RED,
+            )
+            raise typer.Exit(code=1)
+
+        if os.name == "nt":
+            # Use PowerShell on Windows so command quoting matches interactive pwsh usage.
+            result = subprocess.run(["pwsh", "-NoProfile", "-Command", command_to_run], check=False)  # noqa: S603, S607
+        else:
+            # For non-Windows: try to split the command safely to avoid shell injection.
+            # If the command contains shell metacharacters (pipes, redirects, etc.),
+            # fall back to shell=True which is necessary for those features.
+            shell_metacharacters = set("|&;<>()$`\\\"'")
+            if any(char in command_to_run for char in shell_metacharacters):
+                # Contains shell syntax - must use shell=True
+                result = subprocess.run(command_to_run, shell=True, check=False)  # noqa: S602
+            else:
+                # Simple command - safe to split and execute without shell
+                try:
+                    cmd_args = shlex.split(command_to_run)
+                    result = subprocess.run(cmd_args, check=False)  # noqa: S603
+                except ValueError:
+                    # If shlex.split fails, fall back to shell=True
+                    result = subprocess.run(command_to_run, shell=True, check=False)  # noqa: S602
+        if result.returncode != 0:
+            raise typer.Exit(code=result.returncode)
+
+    setattr(_wrapped, "__signature__", inspect.signature(command_func))  # noqa: B010
+    return _wrapped
diff --git a/toolit/create_tasks_json.py b/toolit/create_tasks_json.py
index c1d3368..55c42f7 100644
--- a/toolit/create_tasks_json.py
+++ b/toolit/create_tasks_json.py
@@ -1,55 +1,47 @@
-"""Create a vscode tasks.json file based on the tools discovered in the project."""
+"""
+Generate VS Code tasks.json entries from discovered tools.
+
+Scope: this module builds tasks.json structure by consuming rich metadata from
+CliCommandBuilder. It delegates all tool inspection and metadata generation to
+the command builder.
+"""
 
-import enum
 import json
 import typer
-import types
-import inspect
 import pathlib
 from toolit.auto_loader import (
+    clitool_strategy,
     get_items_from_folder,
     get_plugin_tools,
     get_toolit_type,
     tool_group_strategy,
     tool_strategy,
 )
+from toolit.cli_command_builder import CliCommandBuilder, ToolCommandSpec
 from toolit.config import load_devtools_folder
 from toolit.constants import ToolitTypesEnum
 from types import FunctionType
-from typing import Any, Union, get_args, get_origin
+from typing import Any
 
 PATH: pathlib.Path = load_devtools_folder()
 output_file_path: pathlib.Path = pathlib.Path() / ".vscode" / "tasks.json"
 
 
-def serialize_list_default(default_value: Any) -> str | None:  # noqa: ANN401
-    """Serialize list defaults to comma-separated text using enum values when needed."""
-    if default_value is None:
-        return None
-    if isinstance(default_value, list):
-        rendered_items: list[str] = []
-        for item in default_value:
-            if isinstance(item, enum.Enum):
-                rendered_items.append(str(item.value))
-            else:
-                rendered_items.append(str(item))
-        return ", ".join(rendered_items)
-    return str(default_value)
-
-
 def create_vscode_tasks_json() -> None:
     """Create a tasks.json file based on the tools discovered in the project."""
     typer.echo(f"Creating tasks.json at {output_file_path}")
     if PATH.exists() and PATH.is_dir():
         tools: list[FunctionType] = get_items_from_folder(PATH, tool_strategy)
+        clitools: list[FunctionType] = get_items_from_folder(PATH, clitool_strategy)
         tool_groups: list[FunctionType] = get_items_from_folder(PATH, tool_group_strategy)
+        tools.extend(clitools)
         tools.extend(tool_groups)
     else:
         typer.echo(f"The devtools folder does not exist or is not a directory: {PATH.absolute().as_posix()}")
         tools = []
 
     tools.extend(get_plugin_tools())
-    json_builder = TaskJsonBuilder()
+    json_builder = _TaskJsonBuilder(CliCommandBuilder())
     for tool in tools:
         json_builder.process_tool(tool)
     tasks_json: dict[str, Any] = json_builder.create_tasks_json()
@@ -59,210 +51,37 @@ def create_vscode_tasks_json() -> None:
         json.dump(tasks_json, f, indent=4)
 
 
-def _is_enum(annotation: Any) -> bool:  # noqa: ANN401
-    """Check if the annotation is an Enum type."""
-    return isinstance(annotation, type) and issubclass(annotation, enum.Enum)
-
-
-def _is_bool(annotation: Any) -> bool:  # noqa: ANN401
-    """Check if the annotation is a bool type."""
-    return annotation is bool
-
-
-def _unwrap_union_annotations(annotation: Any) -> list[Any]:  # noqa: ANN401
-    """Return union members for `X | Y` / `Union[X, Y]`, or the annotation itself."""
-    origin = get_origin(annotation)
-    args = get_args(annotation)
-    union_type = getattr(types, "UnionType", None)
-    if origin is Union or (union_type is not None and origin is union_type):
-        return list(args)
-    return [annotation]
-
-
-def _extract_enum_type(annotation: Any) -> type[enum.Enum] | None:  # noqa: ANN401
-    """Extract enum type from an annotation, including optional/union wrappers."""
-    for candidate in _unwrap_union_annotations(annotation):
-        if candidate in {None, type(None)}:
-            continue
-        if _is_enum(candidate):
-            return candidate
-    return None
-
-
-def _contains_bool(annotation: Any) -> bool:  # noqa: ANN401
-    """Check whether an annotation contains bool directly or via union/optional."""
-    return any(_is_bool(candidate) for candidate in _unwrap_union_annotations(annotation))
-
-
-def _extract_list_item_type(annotation: Any) -> Any | None:  # noqa: ANN401
-    """Extract list item type from an annotation, including optional/union wrappers."""
-    for candidate in _unwrap_union_annotations(annotation):
-        if candidate in {None, type(None)}:
-            continue
-        origin = get_origin(candidate)
-        if origin is list:
-            args = get_args(candidate)
-            if args:
-                return args[0]
-            return str
-    return None
-
-
-def _build_list_description(param_name: str, list_item_type: Any) -> str:  # noqa: ANN401
-    """Build a type-specific description for list prompt inputs."""
-    if list_item_type is str:
-        return f"Enter comma-separated text values for {param_name} (e.g. alpha, beta, gamma)"
-    if list_item_type is int:
-        return f"Enter comma-separated integer values for {param_name} (e.g. 1, 2, 3)"
-    if _is_enum(list_item_type):
-        accepted_values = ", ".join(str(member.value) for member in list_item_type)
-        return (
-            f"Enter comma-separated enum values for {param_name}. "
-            f"Accepted values: [{accepted_values}]. You can also use enum member names."
-        )
-    item_type_name = _annotation_to_string(list_item_type)
-    return f"Enter comma-separated values for {param_name} ({item_type_name})"
-
-
-def _annotation_to_string(annotation: Any) -> str:  # noqa: ANN401
-    """Convert Python type annotations to readable strings."""
-    result: str = ""
-
-    if annotation == inspect.Parameter.empty:
-        result = "str"
-    elif annotation is Any:
-        result = "Any"
-    elif annotation is None or annotation is type(None):
-        result = "None"
-    else:
-        origin = get_origin(annotation)
-        args = get_args(annotation)
+class _TaskJsonBuilder:
+    """Build tasks.json payloads from tool command specs."""
 
-        union_type = getattr(types, "UnionType", None)
-        if origin is Union or (union_type is not None and origin is union_type):
-            result = " | ".join(_annotation_to_string(arg) for arg in args)
-        elif origin is not None:
-            origin_name = getattr(origin, "__name__", str(origin).replace("typing.", ""))
-            if args:
-                args_repr = ", ".join(_annotation_to_string(arg) for arg in args)
-                result = f"{origin_name}[{args_repr}]"
-            else:
-                result = origin_name
-        elif hasattr(annotation, "__name__"):
-            result = annotation.__name__
-        else:
-            result = str(annotation).replace("typing.", "")
-
-    return result
-
-
-def _create_typer_command_name(tool: FunctionType) -> str:
-    """Create a Typer command name from a tool function name."""
-    return tool.__name__.replace("_", "-").lower()
-
-
-def _create_display_name(tool: FunctionType) -> str:
-    """Create a display name from a tool function name."""
-    return tool.__name__.replace("_", " ").title()
-
-
-class TaskJsonBuilder:
-    """Class to build tasks.json inputs and argument mappings."""
-
-    def __init__(self) -> None:
+    def __init__(self, cli_command_builder: CliCommandBuilder) -> None:
         """Initialize the object."""
+        self.cli_command_builder = cli_command_builder
         self.inputs: list[dict[str, Any]] = []
-        self.input_id_map: dict[tuple[str, str], str] = {}
         self.tasks: list[dict[str, Any]] = []
 
-    def _build_input_metadata(self, param: inspect.Parameter) -> tuple[str, dict[str, Any], str, Any]:
-        """Build VS Code input metadata for a function parameter."""
-        annotation = param.annotation
-        input_type: str = "promptString"
-        input_options: dict[str, Any] = {}
-        description: str = f"Enter value for {param.name} ({_annotation_to_string(annotation)})"
-        default_value: Any = "" if param.default == inspect.Parameter.empty else param.default
-
-        list_item_type = _extract_list_item_type(annotation)
-        if list_item_type is not None:
-            description = _build_list_description(param.name, list_item_type)
-            default_value = "" if param.default == inspect.Parameter.empty else serialize_list_default(param.default)
-            return input_type, input_options, description, default_value
-
-        enum_type = _extract_enum_type(annotation)
-        if enum_type is not None:
-            input_type = "pickString"
-            choices: list[str] = [e.value for e in enum_type]
-            input_options["options"] = choices
-            if param.default == inspect.Parameter.empty or param.default is None:
-                default_value = choices[0]
-            else:
-                default_value = param.default.value
-            return input_type, input_options, description, default_value
-
-        if _contains_bool(annotation):
-            input_type = "pickString"
-            input_options["options"] = ["True", "False"]
-            if param.default == inspect.Parameter.empty or param.default is None:
-                default_value = "False"
-            else:
-                default_value = str(param.default)
-
-        return input_type, input_options, description, default_value
-
-    def _create_args_for_tool(self, tool: FunctionType) -> list[str]:
-        """Create argument list and input entries for a given tool."""
-        sig = inspect.signature(tool)
-        args: list[str] = []
-        for param in sig.parameters.values():
-            if param.name == "self":
-                continue
-            input_id: str = f"{tool.__name__}_{param.name}"
-            self.input_id_map[tool.__name__, param.name] = input_id
-
-            annotation = param.annotation
-            if annotation is inspect.Parameter.empty:
-                msg = (
-                    f"Parameter '{param.name}' in function '{tool.__name__}' is missing a type annotation. "
-                    f"Please add a type hint, e.g.: def {tool.__name__}({param.name}: str) -> None"
-                )
-                raise ValueError(
-                    msg,
-                )
-            input_type, input_options, description, default_value = self._build_input_metadata(param)
-
-            input_entry: dict[str, Any] = {
-                "id": input_id,
-                "type": input_type,
-                "description": description,
-                "default": default_value,
-            }
-            input_entry.update(input_options)
-            self.inputs.append(input_entry)
-            args.append(f'"${{input:{input_id}}}"')
-        return args
-
-    def _create_task_entry(self, tool: FunctionType, args: list[str]) -> None:
-        """Create a task entry for a given tool."""
-        name_as_typer_command: str = _create_typer_command_name(tool)
-        display_name: str = _create_display_name(tool)
+    def _create_task_entry(self, spec: ToolCommandSpec) -> None:
+        """Create a task entry from a tool command spec."""
+        command: str = spec.build_command(
+            self.cli_command_builder.program_name, self.cli_command_builder.command_prefix,
+        )
         task: dict[str, Any] = {
-            "label": display_name,
+            "label": spec.display_name,
             "type": "shell",
-            "command": f"toolit {name_as_typer_command}" + (f" {' '.join(args)}" if args else ""),
+            "command": command,
             "problemMatcher": [],
         }
-        if tool.__doc__:
-            task["detail"] = tool.__doc__.strip()
+        if spec.docstring:
+            task["detail"] = spec.docstring.strip()
         self.tasks.append(task)
 
     def _create_task_group_entry(self, tool: FunctionType, tool_type: ToolitTypesEnum) -> None:
         """Create a task group entry for a given tool."""
-        group_name: str = "Group: " + tool.__name__.replace("_", " ").title()
+        group_name: str = self.cli_command_builder.create_group_name(tool)
         tools: list[FunctionType] = tool()  # Call the tool to get the list of tools in the group
         task: dict[str, Any] = {
             "label": group_name,
-            "dependsOn": [f"{_create_display_name(t)}" for t in tools],
+            "dependsOn": [self.cli_command_builder.create_display_name(t) for t in tools],
             "problemMatcher": [],
         }
         if tool_type == ToolitTypesEnum.SEQUENTIAL_GROUP:
@@ -274,20 +93,20 @@ def _create_task_group_entry(self, tool: FunctionType, tool_type: ToolitTypesEnu
     def process_tool(self, tool: FunctionType) -> None:
         """Process a single tool to create its task entry and inputs."""
         tool_type = get_toolit_type(tool)
-        if tool_type == ToolitTypesEnum.TOOL:
-            args = self._create_args_for_tool(tool)
-            self._create_task_entry(tool, args)
+        if tool_type in {ToolitTypesEnum.TOOL, ToolitTypesEnum.CLITOOL}:
+            spec = self.cli_command_builder.analyze_tool(tool)
+            self._create_task_entry(spec)
+            self.inputs.extend(spec.get_input_entries())
         elif tool_type in {ToolitTypesEnum.SEQUENTIAL_GROUP, ToolitTypesEnum.PARALLEL_GROUP}:
             self._create_task_group_entry(tool, tool_type)
 
     def create_tasks_json(self) -> dict[str, Any]:
         """Create the final tasks.json structure."""
-        tasks_json: dict[str, Any] = {
+        return {
             "version": "2.0.0",
             "tasks": self.tasks,
             "inputs": self.inputs,
         }
-        return tasks_json
 
 
 if __name__ == "__main__":
diff --git a/toolit/decorators.py b/toolit/decorators.py
index 38955c7..2e541fd 100644
--- a/toolit/decorators.py
+++ b/toolit/decorators.py
@@ -13,6 +13,12 @@ def tool(func: T) -> T:
     return func
 
 
+def clitool(func: T) -> T:
+    """Decorate function as a CLI tool that returns a shell command string."""
+    setattr(func, MARKER_TOOL, ToolitTypesEnum.CLITOOL)
+    return func
+
+
 def sequential_group_of_tools(func: T) -> T:
     """Decorate a function that returns a list of callable tools."""
     setattr(func, MARKER_TOOL, ToolitTypesEnum.SEQUENTIAL_GROUP)
diff --git a/toolit/register_all_tool_and_plugins.py b/toolit/register_all_tool_and_plugins.py
index 8e8bc71..23fb695 100644
--- a/toolit/register_all_tool_and_plugins.py
+++ b/toolit/register_all_tool_and_plugins.py
@@ -1,4 +1,5 @@
 """Register all tools and plugins to be used by default."""
+
 from toolit.auto_loader import load_tools_from_folder, load_tools_from_plugins
 from toolit.config import load_devtools_folder
 from toolit.constants import RichHelpPanelNames
diff --git a/toolit/type_utils.py b/toolit/type_utils.py
new file mode 100644
index 0000000..81ef981
--- /dev/null
+++ b/toolit/type_utils.py
@@ -0,0 +1,26 @@
+"""Shared utilities for type annotation handling."""
+
+from __future__ import annotations
+
+import types
+from typing import Union, get_args, get_origin
+
+
+def is_union_type(annotation: object) -> bool:
+    """
+    Check if annotation is a Union type (Union[X, Y] or X | Y).
+
+    Handles both:
+    - typing.Union[X, Y] (Python 3.9+)
+    - X | Y (PEP 604, Python 3.10+)
+    """
+    origin = get_origin(annotation)
+    union_type = getattr(types, "UnionType", None)
+    return origin is Union or (union_type is not None and origin is union_type)
+
+
+def unwrap_union_members(annotation: object) -> list[object]:
+    """Return members for X | Y / Union[X, Y], or a single-element list otherwise."""
+    if is_union_type(annotation):
+        return list(get_args(annotation))
+    return [annotation]
diff --git a/uv.lock b/uv.lock
index f016acc..9cf13dc 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,6 +1,10 @@
 version = 1
 revision = 3
 requires-python = ">=3.10"
+resolution-markers = [
+    "python_full_version >= '3.15'",
+    "python_full_version < '3.15'",
+]
 
 [[package]]
 name = "annotated-types"
@@ -19,13 +23,22 @@ dependencies = [
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
     { name = "idna" },
     { name = "sniffio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload-time = "2025-03-17T00:02:54.77Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },
 ]
 
+[[package]]
+name = "backports-asyncio-runner"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/ff/70dca7d7cb1cbc0edb2c6cc0c38b65cba36cccc491eca64cabd5fe7f8670/backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162", size = 69893, upload-time = "2025-07-02T02:27:15.685Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/59/76ab57e3fe74484f48a53f8e337171b4a2349e506eabe136d7e01d059086/backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5", size = 12313, upload-time = "2025-07-02T02:27:14.263Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2025.4.26"
@@ -122,7 +135,7 @@ name = "exceptiongroup"
 version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" }
 wheels = [
@@ -193,6 +206,91 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" },
 ]
 
+[[package]]
+name = "librt"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/6b/3d5c13fb3e3c4f43206c8f9dfed13778c2ed4f000bacaa0b7ce3c402a265/librt-0.9.0.tar.gz", hash = "sha256:a0951822531e7aee6e0dfb556b30d5ee36bbe234faf60c20a16c01be3530869d", size = 184368, upload-time = "2026-04-09T16:06:26.173Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/4a/c64265d71b84030174ff3ac2cd16d8b664072afab8c41fccd8e2ee5a6f8d/librt-0.9.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f8e12706dcb8ff6b3ed57514a19e45c49ad00bcd423e87b2b2e4b5f64578443", size = 67529, upload-time = "2026-04-09T16:04:27.373Z" },
+    { url = "https://files.pythonhosted.org/packages/23/b1/30ca0b3a8bdac209a00145c66cf42e5e7da2cc056ffc6ebc5c7b430ddd34/librt-0.9.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4e3dda8345307fd7306db0ed0cb109a63a2c85ba780eb9dc2d09b2049a931f9c", size = 70248, upload-time = "2026-04-09T16:04:28.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/fc/c6018dc181478d6ac5aa24a5846b8185101eb90894346db239eb3ea53209/librt-0.9.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:de7dac64e3eb832ffc7b840eb8f52f76420cde1b845be51b2a0f6b870890645e", size = 202184, upload-time = "2026-04-09T16:04:29.893Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/58/d69629f002203370ef41ea69ff71c49a2c618aec39b226ff49986ecd8623/librt-0.9.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22a904cbdb678f7cb348c90d543d3c52f581663d687992fee47fd566dcbf5285", size = 212926, upload-time = "2026-04-09T16:04:31.126Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/55/01d859f57824e42bd02465c77bec31fa5ef9d8c2bcee702ccf8ef1b9f508/librt-0.9.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:224b9727eb8bc188bc3bcf29d969dba0cd61b01d9bac80c41575520cc4baabb2", size = 225664, upload-time = "2026-04-09T16:04:32.352Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/02/32f63ad0ef085a94a70315291efe1151a48b9947af12261882f8445b2a30/librt-0.9.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e94cbc6ad9a6aeea46d775cbb11f361022f778a9cc8cc90af653d3a594b057ce", size = 219534, upload-time = "2026-04-09T16:04:33.667Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/5a/9d77111a183c885acf3b3b6e4c00f5b5b07b5817028226499a55f1fedc59/librt-0.9.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7bc30ad339f4e1a01d4917d645e522a0bc0030644d8973f6346397c93ba1503f", size = 227322, upload-time = "2026-04-09T16:04:34.945Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/e7/05d700c93063753e12ab230b972002a3f8f3b9c95d8a980c2f646c8b6963/librt-0.9.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:56d65b583cf43b8cf4c8fbe1e1da20fa3076cc32a1149a141507af1062718236", size = 223407, upload-time = "2026-04-09T16:04:36.22Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/26/26c3124823c67c987456977c683da9a27cc874befc194ddcead5f9988425/librt-0.9.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:0a1be03168b2691ba61927e299b352a6315189199ca18a57b733f86cb3cc8d38", size = 221302, upload-time = "2026-04-09T16:04:37.62Z" },
+    { url = "https://files.pythonhosted.org/packages/50/2b/c7cc2be5cf4ff7b017d948a789256288cb33a517687ff1995e72a7eea79f/librt-0.9.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:63c12efcd160e1d14da11af0c46c0217473e1e0d2ae1acbccc83f561ea4c2a7b", size = 243893, upload-time = "2026-04-09T16:04:38.909Z" },
+    { url = "https://files.pythonhosted.org/packages/62/d3/da553d37417a337d12660450535d5fd51373caffbedf6962173c87867246/librt-0.9.0-cp310-cp310-win32.whl", hash = "sha256:e9002e98dcb1c0a66723592520decd86238ddcef168b37ff6cfb559200b4b774", size = 55375, upload-time = "2026-04-09T16:04:40.148Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/5a/46fa357bab8311b6442a83471591f2f9e5b15ecc1d2121a43725e0c529b8/librt-0.9.0-cp310-cp310-win_amd64.whl", hash = "sha256:9fcb461fbf70654a52a7cc670e606f04449e2374c199b1825f754e16dacfedd8", size = 62581, upload-time = "2026-04-09T16:04:41.452Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/1e/2ec7afcebcf3efea593d13aee18bbcfdd3a243043d848ebf385055e9f636/librt-0.9.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:90904fac73c478f4b83f4ed96c99c8208b75e6f9a8a1910548f69a00f1eaa671", size = 67155, upload-time = "2026-04-09T16:04:42.933Z" },
+    { url = "https://files.pythonhosted.org/packages/18/77/72b85afd4435268338ad4ec6231b3da8c77363f212a0227c1ff3b45e4d35/librt-0.9.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:789fff71757facc0738e8d89e3b84e4f0251c1c975e85e81b152cdaca927cc2d", size = 69916, upload-time = "2026-04-09T16:04:44.042Z" },
+    { url = "https://files.pythonhosted.org/packages/27/fb/948ea0204fbe2e78add6d46b48330e58d39897e425560674aee302dca81c/librt-0.9.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1bf465d1e5b0a27713862441f6467b5ab76385f4ecf8f1f3a44f8aa3c695b4b6", size = 199635, upload-time = "2026-04-09T16:04:45.5Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/cd/894a29e251b296a27957856804cfd21e93c194aa131de8bb8032021be07e/librt-0.9.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f819e0c6413e259a17a7c0d49f97f405abadd3c2a316a3b46c6440b7dbbedbb1", size = 211051, upload-time = "2026-04-09T16:04:47.016Z" },
+    { url = "https://files.pythonhosted.org/packages/18/8f/dcaed0bc084a35f3721ff2d081158db569d2c57ea07d35623ddaca5cfc8e/librt-0.9.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e0785c2fb4a81e1aece366aa3e2e039f4a4d7d21aaaded5227d7f3c703427882", size = 224031, upload-time = "2026-04-09T16:04:48.207Z" },
+    { url = "https://files.pythonhosted.org/packages/03/44/88f6c1ed1132cd418601cc041fbd92fed28b3a09f39de81978e0822d13ff/librt-0.9.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80b25c7b570a86c03b5da69e665809deb39265476e8e21d96a9328f9762f9990", size = 218069, upload-time = "2026-04-09T16:04:50.025Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/90/7d02e981c2db12188d82b4410ff3e35bfdb844b26aecd02233626f46af2b/librt-0.9.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d4d16b608a1c43d7e33142099a75cd93af482dadce0bf82421e91cad077157f4", size = 224857, upload-time = "2026-04-09T16:04:51.684Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/c3/c77e706b7215ca32e928d47535cf13dbc3d25f096f84ddf8fbc06693e229/librt-0.9.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:194fc1a32e1e21fe809d38b5faea66cc65eaa00217c8901fbdb99866938adbdb", size = 219865, upload-time = "2026-04-09T16:04:52.949Z" },
+    { url = "https://files.pythonhosted.org/packages/52/d1/32b0c1a0eb8461c70c11656c46a29f760b7c7edf3c36d6f102470c17170f/librt-0.9.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:8c6bc1384d9738781cfd41d09ad7f6e8af13cfea2c75ece6bd6d2566cdea2076", size = 218451, upload-time = "2026-04-09T16:04:54.174Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d1/adfd0f9c44761b1d49b1bec66173389834c33ee2bd3c7fd2e2367f1942d4/librt-0.9.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:15cb151e52a044f06e54ac7f7b47adbfc89b5c8e2b63e1175a9d587c43e8942a", size = 241300, upload-time = "2026-04-09T16:04:55.452Z" },
+    { url = "https://files.pythonhosted.org/packages/09/b0/9074b64407712f0003c27f5b1d7655d1438979155f049720e8a1abd9b1a1/librt-0.9.0-cp311-cp311-win32.whl", hash = "sha256:f100bfe2acf8a3689af9d0cc660d89f17286c9c795f9f18f7b62dd1a6b247ae6", size = 55668, upload-time = "2026-04-09T16:04:56.689Z" },
+    { url = "https://files.pythonhosted.org/packages/24/19/40b77b77ce80b9389fb03971431b09b6b913911c38d412059e0b3e2a9ef2/librt-0.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:0b73e4266307e51c95e09c0750b7ec383c561d2e97d58e473f6f6a209952fbb8", size = 62976, upload-time = "2026-04-09T16:04:57.733Z" },
+    { url = "https://files.pythonhosted.org/packages/70/9d/9fa7a64041e29035cb8c575af5f0e3840be1b97b4c4d9061e0713f171849/librt-0.9.0-cp311-cp311-win_arm64.whl", hash = "sha256:bc5518873822d2faa8ebdd2c1a4d7c8ef47b01a058495ab7924cb65bdbf5fc9a", size = 53502, upload-time = "2026-04-09T16:04:58.806Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/90/89ddba8e1c20b0922783cd93ed8e64f34dc05ab59c38a9c7e313632e20ff/librt-0.9.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9b3e3bc363f71bda1639a4ee593cb78f7fbfeacc73411ec0d4c92f00730010a4", size = 68332, upload-time = "2026-04-09T16:05:00.09Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/40/7aa4da1fb08bdeeb540cb07bfc8207cb32c5c41642f2594dbd0098a0662d/librt-0.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0a09c2f5869649101738653a9b7ab70cf045a1105ac66cbb8f4055e61df78f2d", size = 70581, upload-time = "2026-04-09T16:05:01.213Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ac/73a2187e1031041e93b7e3a25aae37aa6f13b838c550f7e0f06f66766212/librt-0.9.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5ca8e133d799c948db2ab1afc081c333a825b5540475164726dcbf73537e5c2f", size = 203984, upload-time = "2026-04-09T16:05:02.542Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/3d/23460d571e9cbddb405b017681df04c142fb1b04cbfce77c54b08e28b108/librt-0.9.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:603138ee838ee1583f1b960b62d5d0007845c5c423feb68e44648b1359014e27", size = 215762, upload-time = "2026-04-09T16:05:04.127Z" },
+    { url = "https://files.pythonhosted.org/packages/de/1e/42dc7f8ab63e65b20640d058e63e97fd3e482c1edbda3570d813b4d0b927/librt-0.9.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4003f70c56a5addd6aa0897f200dd59afd3bf7bcd5b3cce46dd21f925743bc2", size = 230288, upload-time = "2026-04-09T16:05:05.883Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/08/ca812b6d8259ad9ece703397f8ad5c03af5b5fedfce64279693d3ce4087c/librt-0.9.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:78042f6facfd98ecb25e9829c7e37cce23363d9d7c83bc5f72702c5059eb082b", size = 224103, upload-time = "2026-04-09T16:05:07.148Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/3f/620490fb2fa66ffd44e7f900254bc110ebec8dac6c1b7514d64662570e6f/librt-0.9.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a361c9434a64d70a7dbb771d1de302c0cc9f13c0bffe1cf7e642152814b35265", size = 232122, upload-time = "2026-04-09T16:05:08.386Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/83/12864700a1b6a8be458cf5d05db209b0d8e94ae281e7ec261dbe616597b4/librt-0.9.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:dd2c7e082b0b92e1baa4da28163a808672485617bc855cc22a2fd06978fa9084", size = 225045, upload-time = "2026-04-09T16:05:09.707Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/1b/845d339c29dc7dbc87a2e992a1ba8d28d25d0e0372f9a0a2ecebde298186/librt-0.9.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7e6274fd33fc5b2a14d41c9119629d3ff395849d8bcbc80cf637d9e8d2034da8", size = 227372, upload-time = "2026-04-09T16:05:10.942Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/fe/277985610269d926a64c606f761d58d3db67b956dbbf40024921e95e7fcb/librt-0.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5093043afb226ecfa1400120d1ebd4442b4f99977783e4f4f7248879009b227f", size = 248224, upload-time = "2026-04-09T16:05:12.254Z" },
+    { url = "https://files.pythonhosted.org/packages/92/1b/ee486d244b8de6b8b5dbaefabe6bfdd4a72e08f6353edf7d16d27114da8d/librt-0.9.0-cp312-cp312-win32.whl", hash = "sha256:9edcc35d1cae9fd5320171b1a838c7da8a5c968af31e82ecc3dff30b4be0957f", size = 55986, upload-time = "2026-04-09T16:05:13.529Z" },
+    { url = "https://files.pythonhosted.org/packages/89/7a/ba1737012308c17dc6d5516143b5dce9a2c7ba3474afd54e11f44a4d1ef3/librt-0.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:3cc2917258e131ae5f958a4d872e07555b51cb7466a43433218061c74ef33745", size = 63260, upload-time = "2026-04-09T16:05:14.68Z" },
+    { url = "https://files.pythonhosted.org/packages/36/e4/01752c113da15127f18f7bf11142f5640038f062407a611c059d0036c6aa/librt-0.9.0-cp312-cp312-win_arm64.whl", hash = "sha256:90e6d5420fc8a300518d4d2288154ff45005e920425c22cbbfe8330f3f754bd9", size = 53694, upload-time = "2026-04-09T16:05:16.095Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/d7/1b3e26fffde1452d82f5666164858a81c26ebe808e7ae8c9c88628981540/librt-0.9.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f29b68cd9714531672db62cc54f6e8ff981900f824d13fa0e00749189e13778e", size = 68367, upload-time = "2026-04-09T16:05:17.243Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/5b/c61b043ad2e091fbe1f2d35d14795e545d0b56b03edaa390fa1dcee3d160/librt-0.9.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d5c8a5929ac325729f6119802070b561f4db793dffc45e9ac750992a4ed4d22", size = 70595, upload-time = "2026-04-09T16:05:18.471Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/22/2448471196d8a73370aa2f23445455dc42712c21404081fcd7a03b9e0749/librt-0.9.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:756775d25ec8345b837ab52effee3ad2f3b2dfd6bbee3e3f029c517bd5d8f05a", size = 204354, upload-time = "2026-04-09T16:05:19.593Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5e/39fc4b153c78cfd2c8a2dcb32700f2d41d2312aa1050513183be4540930d/librt-0.9.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b8f5d00b49818f4e2b1667db994488b045835e0ac16fe2f924f3871bd2b8ac5", size = 216238, upload-time = "2026-04-09T16:05:20.868Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/42/bc2d02d0fa7badfa63aa8d6dcd8793a9f7ef5a94396801684a51ed8d8287/librt-0.9.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c81aef782380f0f13ead670aae01825eb653b44b046aa0e5ebbb79f76ed4aa11", size = 230589, upload-time = "2026-04-09T16:05:22.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/7b/e2d95cc513866373692aa5edf98080d5602dd07cabfb9e5d2f70df2f25f7/librt-0.9.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66b58fed90a545328e80d575467244de3741e088c1af928f0b489ebec3ef3858", size = 224610, upload-time = "2026-04-09T16:05:23.647Z" },
+    { url = "https://files.pythonhosted.org/packages/31/d5/6cec4607e998eaba57564d06a1295c21b0a0c8de76e4e74d699e627bd98c/librt-0.9.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e78fb7419e07d98c2af4b8567b72b3eaf8cb05caad642e9963465569c8b2d87e", size = 232558, upload-time = "2026-04-09T16:05:25.025Z" },
+    { url = "https://files.pythonhosted.org/packages/95/8c/27f1d8d3aaf079d3eb26439bf0b32f1482340c3552e324f7db9dca858671/librt-0.9.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2c3786f0f4490a5cd87f1ed6cefae833ad6b1060d52044ce0434a2e85893afd0", size = 225521, upload-time = "2026-04-09T16:05:26.311Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/d8/1e0d43b1c329b416017619469b3c3801a25a6a4ef4a1c68332aeaa6f72ca/librt-0.9.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8494cfc61e03542f2d381e71804990b3931175a29b9278fdb4a5459948778dc2", size = 227789, upload-time = "2026-04-09T16:05:27.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/b4/d3d842e88610fcd4c8eec7067b0c23ef2d7d3bff31496eded6a83b0f99be/librt-0.9.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:07cf11f769831186eeac424376e6189f20ace4f7263e2134bdb9757340d84d4d", size = 248616, upload-time = "2026-04-09T16:05:29.181Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/28/527df8ad0d1eb6c8bdfa82fc190f1f7c4cca5a1b6d7b36aeabf95b52d74d/librt-0.9.0-cp313-cp313-win32.whl", hash = "sha256:850d6d03177e52700af605fd60db7f37dcb89782049a149674d1a9649c2138fd", size = 56039, upload-time = "2026-04-09T16:05:30.709Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/a7/413652ad0d92273ee5e30c000fc494b361171177c83e57c060ecd3c21538/librt-0.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:a5af136bfba820d592f86c67affcef9b3ff4d4360ac3255e341e964489b48519", size = 63264, upload-time = "2026-04-09T16:05:31.881Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/0a/92c244309b774e290ddb15e93363846ae7aa753d9586b8aad511c5e6145b/librt-0.9.0-cp313-cp313-win_arm64.whl", hash = "sha256:4c4d0440a3a8e31d962340c3e1cc3fc9ee7febd34c8d8f770d06adb947779ea5", size = 53728, upload-time = "2026-04-09T16:05:33.31Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/c1/184e539543f06ea2912f4b92a5ffaede4f9b392689e3f00acbf8134bee92/librt-0.9.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:3f05d145df35dca5056a8bc3838e940efebd893a54b3e19b2dda39ceaa299bcb", size = 67830, upload-time = "2026-04-09T16:05:34.517Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/ad/23399bdcb7afca819acacdef31b37ee59de261bd66b503a7995c03c4b0dc/librt-0.9.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1c587494461ebd42229d0f1739f3aa34237dd9980623ecf1be8d3bcba79f4499", size = 70280, upload-time = "2026-04-09T16:05:35.649Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/0b/4542dc5a2b8772dbf92cafb9194701230157e73c14b017b6961a23598b03/librt-0.9.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b0a2040f801406b93657a70b72fa12311063a319fee72ce98e1524da7200171f", size = 201925, upload-time = "2026-04-09T16:05:36.739Z" },
+    { url = "https://files.pythonhosted.org/packages/31/d4/8ee7358b08fd0cfce051ef96695380f09b3c2c11b77c9bfbc367c921cce5/librt-0.9.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f38bc489037eca88d6ebefc9c4d41a4e07c8e8b4de5188a9e6d290273ad7ebb1", size = 212381, upload-time = "2026-04-09T16:05:38.043Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/94/a2025fe442abedf8b038038dab3dba942009ad42b38ea064a1a9e6094241/librt-0.9.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3fd278f5e6bf7c75ccd6d12344eb686cc020712683363b66f46ac79d37c799f", size = 227065, upload-time = "2026-04-09T16:05:39.394Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/e9/b9fcf6afa909f957cfbbf918802f9dada1bd5d3c1da43d722fd6a310dc3f/librt-0.9.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fcbdf2a9ca24e87bbebb47f1fe34e531ef06f104f98c9ccfc953a3f3344c567a", size = 221333, upload-time = "2026-04-09T16:05:40.999Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/7c/ba54cd6aa6a3c8cd12757a6870e0c79a64b1e6327f5248dcff98423f4d43/librt-0.9.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e306d956cfa027fe041585f02a1602c32bfa6bb8ebea4899d373383295a6c62f", size = 229051, upload-time = "2026-04-09T16:05:42.605Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/4b/8cfdbad314c8677a0148bf0b70591d6d18587f9884d930276098a235461b/librt-0.9.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:465814ab157986acb9dfa5ccd7df944be5eefc0d08d31ec6e8d88bc71251d845", size = 222492, upload-time = "2026-04-09T16:05:43.842Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/d1/2eda69563a1a88706808decdce035e4b32755dbfbb0d05e1a65db9547ed1/librt-0.9.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:703f4ae36d6240bfe24f542bac784c7e4194ec49c3ba5a994d02891649e2d85b", size = 223849, upload-time = "2026-04-09T16:05:45.054Z" },
+    { url = "https://files.pythonhosted.org/packages/04/44/b2ed37df6be5b3d42cfe36318e0598e80843d5c6308dd63d0bf4e0ce5028/librt-0.9.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3be322a15ee5e70b93b7a59cfd074614f22cc8c9ff18bd27f474e79137ea8d3b", size = 245001, upload-time = "2026-04-09T16:05:46.34Z" },
+    { url = "https://files.pythonhosted.org/packages/47/e7/617e412426df89169dd2a9ed0cc8752d5763336252c65dbf945199915119/librt-0.9.0-cp314-cp314-win32.whl", hash = "sha256:b8da9f8035bb417770b1e1610526d87ad4fc58a2804dc4d79c53f6d2cf5a6eb9", size = 51799, upload-time = "2026-04-09T16:05:47.738Z" },
+    { url = "https://files.pythonhosted.org/packages/24/ed/c22ca4db0ca3cbc285e4d9206108746beda561a9792289c3c31281d7e9df/librt-0.9.0-cp314-cp314-win_amd64.whl", hash = "sha256:b8bd70d5d816566a580d193326912f4a76ec2d28a97dc4cd4cc831c0af8e330e", size = 59165, upload-time = "2026-04-09T16:05:49.198Z" },
+    { url = "https://files.pythonhosted.org/packages/24/56/875398fafa4cbc8f15b89366fc3287304ddd3314d861f182a4b87595ace0/librt-0.9.0-cp314-cp314-win_arm64.whl", hash = "sha256:fc5758e2b7a56532dc33e3c544d78cbaa9ecf0a0f2a2da2df882c1d6b99a317f", size = 49292, upload-time = "2026-04-09T16:05:50.362Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/61/bc448ecbf9b2d69c5cff88fe41496b19ab2a1cbda0065e47d4d0d51c0867/librt-0.9.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:f24b90b0e0c8cc9491fb1693ae91fe17cb7963153a1946395acdbdd5818429a4", size = 70175, upload-time = "2026-04-09T16:05:51.564Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f2/c47bb71069a73e2f04e70acbd196c1e5cc411578ac99039a224b98920fd4/librt-0.9.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3fe56e80badb66fdcde06bef81bbaa5bfcf6fbd7aefb86222d9e369c38c6b228", size = 72951, upload-time = "2026-04-09T16:05:52.699Z" },
+    { url = "https://files.pythonhosted.org/packages/29/19/0549df59060631732df758e8886d92088da5fdbedb35b80e4643664e8412/librt-0.9.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:527b5b820b47a09e09829051452bb0d1dd2122261254e2a6f674d12f1d793d54", size = 225864, upload-time = "2026-04-09T16:05:53.895Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f8/3b144396d302ac08e50f89e64452c38db84bc7b23f6c60479c5d3abd303c/librt-0.9.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d429bdd4ac0ab17c8e4a8af0ed2a7440b16eba474909ab357131018fe8c7e71", size = 241155, upload-time = "2026-04-09T16:05:55.191Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/ce/ee67ec14581de4043e61d05786d2aed6c9b5338816b7859bcf07455c6a9f/librt-0.9.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7202bdcac47d3a708271c4304a474a8605a4a9a4a709e954bf2d3241140aa938", size = 252235, upload-time = "2026-04-09T16:05:56.549Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fa/0ead15daa2b293a54101550b08d4bafe387b7d4a9fc6d2b985602bae69b6/librt-0.9.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0d620e74897f8c2613b3c4e2e9c1e422eb46d2ddd07df540784d44117836af3", size = 244963, upload-time = "2026-04-09T16:05:57.858Z" },
+    { url = "https://files.pythonhosted.org/packages/29/68/9fbf9a9aa704ba87689e40017e720aced8d9a4d2b46b82451d8142f91ec9/librt-0.9.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d69fc39e627908f4c03297d5a88d9284b73f4d90b424461e32e8c2485e21c283", size = 257364, upload-time = "2026-04-09T16:05:59.686Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/8d/9d60869f1b6716c762e45f66ed945b1e5dd649f7377684c3b176ae424648/librt-0.9.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:c2640e23d2b7c98796f123ffd95cf2022c7777aa8a4a3b98b36c570d37e85eee", size = 247661, upload-time = "2026-04-09T16:06:00.938Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ff/a5c365093962310bfdb4f6af256f191085078ffb529b3f0cbebb5b33ebe2/librt-0.9.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:451daa98463b7695b0a30aa56bf637831ea559e7b8101ac2ef6382e8eb15e29c", size = 248238, upload-time = "2026-04-09T16:06:02.537Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/3c/2d34365177f412c9e19c0a29f969d70f5343f27634b76b765a54d8b27705/librt-0.9.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:928bd06eca2c2bbf4349e5b817f837509b0604342e65a502de1d50a7570afd15", size = 269457, upload-time = "2026-04-09T16:06:03.833Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/cd/de45b239ea3bdf626f982a00c14bfcf2e12d261c510ba7db62c5969a27cd/librt-0.9.0-cp314-cp314t-win32.whl", hash = "sha256:a9c63e04d003bc0fb6a03b348018b9a3002f98268200e22cc80f146beac5dc40", size = 52453, upload-time = "2026-04-09T16:06:05.229Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/f9/bfb32ae428aa75c0c533915622176f0a17d6da7b72b5a3c6363685914f70/librt-0.9.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f162af66a2ed3f7d1d161a82ca584efd15acd9c1cff190a373458c32f7d42118", size = 60044, upload-time = "2026-04-09T16:06:06.398Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/47/7d70414bcdbb3bc1f458a8d10558f00bbfdb24e5a11740fc8197e12c3255/librt-0.9.0-cp314-cp314t-win_arm64.whl", hash = "sha256:a4b25c6c25cac5d0d9d6d6da855195b254e0021e513e0249f0e3b444dc6e0e61", size = 50009, upload-time = "2026-04-09T16:06:07.995Z" },
+]
+
 [[package]]
 name = "markdown-it-py"
 version = "3.0.0"
@@ -242,41 +340,61 @@ wheels = [
 
 [[package]]
 name = "mypy"
-version = "1.16.0"
+version = "1.20.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
     { name = "mypy-extensions" },
     { name = "pathspec" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d4/38/13c2f1abae94d5ea0354e146b95a1be9b2137a0d506728e0da037c4276f6/mypy-1.16.0.tar.gz", hash = "sha256:84b94283f817e2aa6350a14b4a8fb2a35a53c286f97c9d30f53b63620e7af8ab", size = 3323139, upload-time = "2025-05-29T13:46:12.532Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/64/5e/a0485f0608a3d67029d3d73cec209278b025e3493a3acfda3ef3a88540fd/mypy-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7909541fef256527e5ee9c0a7e2aeed78b6cda72ba44298d1334fe7881b05c5c", size = 10967416, upload-time = "2025-05-29T13:34:17.783Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/53/5837c221f74c0d53a4bfc3003296f8179c3a2a7f336d7de7bbafbe96b688/mypy-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e71d6f0090c2256c713ed3d52711d01859c82608b5d68d4fa01a3fe30df95571", size = 10087654, upload-time = "2025-05-29T13:32:37.878Z" },
-    { url = "https://files.pythonhosted.org/packages/29/59/5fd2400352c3093bed4c09017fe671d26bc5bb7e6ef2d4bf85f2a2488104/mypy-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:936ccfdd749af4766be824268bfe22d1db9eb2f34a3ea1d00ffbe5b5265f5491", size = 11875192, upload-time = "2025-05-29T13:34:54.281Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/3e/4bfec74663a64c2012f3e278dbc29ffe82b121bc551758590d1b6449ec0c/mypy-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4086883a73166631307fdd330c4a9080ce24913d4f4c5ec596c601b3a4bdd777", size = 12612939, upload-time = "2025-05-29T13:33:14.766Z" },
-    { url = "https://files.pythonhosted.org/packages/88/1f/fecbe3dcba4bf2ca34c26ca016383a9676711907f8db4da8354925cbb08f/mypy-1.16.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:feec38097f71797da0231997e0de3a58108c51845399669ebc532c815f93866b", size = 12874719, upload-time = "2025-05-29T13:21:52.09Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/51/c2d280601cd816c43dfa512a759270d5a5ef638d7ac9bea9134c8305a12f/mypy-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:09a8da6a0ee9a9770b8ff61b39c0bb07971cda90e7297f4213741b48a0cc8d93", size = 9487053, upload-time = "2025-05-29T13:33:29.797Z" },
-    { url = "https://files.pythonhosted.org/packages/24/c4/ff2f79db7075c274fe85b5fff8797d29c6b61b8854c39e3b7feb556aa377/mypy-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9f826aaa7ff8443bac6a494cf743f591488ea940dd360e7dd330e30dd772a5ab", size = 10884498, upload-time = "2025-05-29T13:18:54.066Z" },
-    { url = "https://files.pythonhosted.org/packages/02/07/12198e83006235f10f6a7808917376b5d6240a2fd5dce740fe5d2ebf3247/mypy-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82d056e6faa508501af333a6af192c700b33e15865bda49611e3d7d8358ebea2", size = 10011755, upload-time = "2025-05-29T13:34:00.851Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/9b/5fd5801a72b5d6fb6ec0105ea1d0e01ab2d4971893076e558d4b6d6b5f80/mypy-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:089bedc02307c2548eb51f426e085546db1fa7dd87fbb7c9fa561575cf6eb1ff", size = 11800138, upload-time = "2025-05-29T13:32:55.082Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/81/a117441ea5dfc3746431e51d78a4aca569c677aa225bca2cc05a7c239b61/mypy-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a2322896003ba66bbd1318c10d3afdfe24e78ef12ea10e2acd985e9d684a666", size = 12533156, upload-time = "2025-05-29T13:19:12.963Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/38/88ec57c6c86014d3f06251e00f397b5a7daa6888884d0abf187e4f5f587f/mypy-1.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:021a68568082c5b36e977d54e8f1de978baf401a33884ffcea09bd8e88a98f4c", size = 12742426, upload-time = "2025-05-29T13:20:22.72Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/53/7e9d528433d56e6f6f77ccf24af6ce570986c2d98a5839e4c2009ef47283/mypy-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:54066fed302d83bf5128632d05b4ec68412e1f03ef2c300434057d66866cea4b", size = 9478319, upload-time = "2025-05-29T13:21:17.582Z" },
-    { url = "https://files.pythonhosted.org/packages/70/cf/158e5055e60ca2be23aec54a3010f89dcffd788732634b344fc9cb1e85a0/mypy-1.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c5436d11e89a3ad16ce8afe752f0f373ae9620841c50883dc96f8b8805620b13", size = 11062927, upload-time = "2025-05-29T13:35:52.328Z" },
-    { url = "https://files.pythonhosted.org/packages/94/34/cfff7a56be1609f5d10ef386342ce3494158e4d506516890142007e6472c/mypy-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f2622af30bf01d8fc36466231bdd203d120d7a599a6d88fb22bdcb9dbff84090", size = 10083082, upload-time = "2025-05-29T13:35:33.378Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/7f/7242062ec6288c33d8ad89574df87c3903d394870e5e6ba1699317a65075/mypy-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d045d33c284e10a038f5e29faca055b90eee87da3fc63b8889085744ebabb5a1", size = 11828306, upload-time = "2025-05-29T13:21:02.164Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/5f/b392f7b4f659f5b619ce5994c5c43caab3d80df2296ae54fa888b3d17f5a/mypy-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b4968f14f44c62e2ec4a038c8797a87315be8df7740dc3ee8d3bfe1c6bf5dba8", size = 12702764, upload-time = "2025-05-29T13:20:42.826Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/c0/7646ef3a00fa39ac9bc0938626d9ff29d19d733011be929cfea59d82d136/mypy-1.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eb14a4a871bb8efb1e4a50360d4e3c8d6c601e7a31028a2c79f9bb659b63d730", size = 12896233, upload-time = "2025-05-29T13:18:37.446Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/38/52f4b808b3fef7f0ef840ee8ff6ce5b5d77381e65425758d515cdd4f5bb5/mypy-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:bd4e1ebe126152a7bbaa4daedd781c90c8f9643c79b9748caa270ad542f12bec", size = 9565547, upload-time = "2025-05-29T13:20:02.836Z" },
-    { url = "https://files.pythonhosted.org/packages/97/9c/ca03bdbefbaa03b264b9318a98950a9c683e06472226b55472f96ebbc53d/mypy-1.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a9e056237c89f1587a3be1a3a70a06a698d25e2479b9a2f57325ddaaffc3567b", size = 11059753, upload-time = "2025-05-29T13:18:18.167Z" },
-    { url = "https://files.pythonhosted.org/packages/36/92/79a969b8302cfe316027c88f7dc6fee70129490a370b3f6eb11d777749d0/mypy-1.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0b07e107affb9ee6ce1f342c07f51552d126c32cd62955f59a7db94a51ad12c0", size = 10073338, upload-time = "2025-05-29T13:19:48.079Z" },
-    { url = "https://files.pythonhosted.org/packages/14/9b/a943f09319167da0552d5cd722104096a9c99270719b1afeea60d11610aa/mypy-1.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6fb60cbd85dc65d4d63d37cb5c86f4e3a301ec605f606ae3a9173e5cf34997b", size = 11827764, upload-time = "2025-05-29T13:46:04.47Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/64/ff75e71c65a0cb6ee737287c7913ea155845a556c64144c65b811afdb9c7/mypy-1.16.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7e32297a437cc915599e0578fa6bc68ae6a8dc059c9e009c628e1c47f91495d", size = 12701356, upload-time = "2025-05-29T13:35:13.553Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/ad/0e93c18987a1182c350f7a5fab70550852f9fabe30ecb63bfbe51b602074/mypy-1.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:afe420c9380ccec31e744e8baff0d406c846683681025db3531b32db56962d52", size = 12900745, upload-time = "2025-05-29T13:17:24.409Z" },
-    { url = "https://files.pythonhosted.org/packages/28/5d/036c278d7a013e97e33f08c047fe5583ab4f1fc47c9a49f985f1cdd2a2d7/mypy-1.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:55f9076c6ce55dd3f8cd0c6fff26a008ca8e5131b89d5ba6d86bd3f47e736eeb", size = 9572200, upload-time = "2025-05-29T13:33:44.92Z" },
-    { url = "https://files.pythonhosted.org/packages/99/a3/6ed10530dec8e0fdc890d81361260c9ef1f5e5c217ad8c9b21ecb2b8366b/mypy-1.16.0-py3-none-any.whl", hash = "sha256:29e1499864a3888bca5c1542f2d7232c6e586295183320caa95758fc84034031", size = 2265773, upload-time = "2025-05-29T13:35:18.762Z" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.15'" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.15'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/af/e3d4b3e9ec91a0ff9aabfdb38692952acf49bbb899c2e4c29acb3a6da3ae/mypy-1.20.2.tar.gz", hash = "sha256:e8222c26daaafd9e8626dec58ae36029f82585890589576f769a650dd20fd665", size = 3817349, upload-time = "2026-04-21T17:12:28.473Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/97/ce2502df2cecf2ef997b6c6527c4a223b92feb9e7b790cdc8dcd683f3a8a/mypy-1.20.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cf5a4db6dca263010e2c7bff081c89383c72d187ba2cf4c44759aac970e2f0c4", size = 14457059, upload-time = "2026-04-21T17:06:14.935Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/34/417ee60b822cc80c0f3dc9f495ad7fd8dbb8d8b2cf4baf22d4046d25d01d/mypy-1.20.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7b0e817b518bff7facd7f85ea05b643ad8bdcce684cf29784987b0a7c8e1f997", size = 13346816, upload-time = "2026-04-21T17:10:41.433Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/85/e20951978702df58379d0bcc2e8f7ccdca4e78cd7dc66dd3ddbf9b29d517/mypy-1.20.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97d7b9a485b40f8ca425460e89bf1da2814625b2da627c0dcc6aa46c92631d14", size = 13772593, upload-time = "2026-04-21T17:08:11.24Z" },
+    { url = "https://files.pythonhosted.org/packages/63/a5/5441a13259ec516c56fd5de0fd96a69a9590ae6c5e5d3e5174aa84b97973/mypy-1.20.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e1c12f6d2db3d78b909b5f77513c11eb7f2dd2782b96a3ab6dffc7d44575c99", size = 14656635, upload-time = "2026-04-21T17:09:54.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/51/b89c69157c5e1f19fd125a65d991166a26906e7902f026f00feebbcfa2b9/mypy-1.20.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:89dce27e142d25ffbc154c1819383b69f2e9234dc4ed4766f42e0e8cb264ab5c", size = 14943278, upload-time = "2026-04-21T17:09:15.599Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/44/6b0eeecfe96d7cce1d71c66b8e03cb304aa70ec11f1955dc1d6b46aca3c3/mypy-1.20.2-cp310-cp310-win_amd64.whl", hash = "sha256:f376e37f9bf2a946872fc5fd1199c99310748e3c26c7a26683f13f8bdb756cbd", size = 10851915, upload-time = "2026-04-21T17:06:03.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/36/6593dc88545d75fb96416184be5392da5e2a8e8c2802a8597913e16ae25c/mypy-1.20.2-cp310-cp310-win_arm64.whl", hash = "sha256:6e2b469efd811707bc530fd1effef0f5d6eebcb7fe376affae69025da4b979a2", size = 9786676, upload-time = "2026-04-21T17:07:02.035Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/4d/9ebeae211caccbdaddde7ed5e31dfcf57faac66be9b11deb1dc6526c8078/mypy-1.20.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4077797a273e56e8843d001e9dfe4ba10e33323d6ade647ff260e5cd97d9758c", size = 14371307, upload-time = "2026-04-21T17:08:56.442Z" },
+    { url = "https://files.pythonhosted.org/packages/95/d7/93473d34b61f04fac1aecc01368485c89c5c4af7a4b9a0cab5d77d04b63f/mypy-1.20.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cdecf62abcc4292500d7858aeae87a1f8f1150f4c4dd08fb0b336ee79b2a6df3", size = 13258917, upload-time = "2026-04-21T17:05:50.978Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/30/3dd903e8bafb7b5f7bf87fcd58f8382086dea2aa19f0a7b357f21f63071b/mypy-1.20.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c566c3a88b6ece59b3d70f65bedef17304f48eb52ff040a6a18214e1917b3254", size = 13700516, upload-time = "2026-04-21T17:11:33.161Z" },
+    { url = "https://files.pythonhosted.org/packages/07/05/c61a140aba4c729ac7bc99ae26fc627c78a6e08f5b9dd319244ea71a3d7e/mypy-1.20.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0deb80d062b2479f2c87ae568f89845afc71d11bc41b04179e58165fd9f31e98", size = 14562889, upload-time = "2026-04-21T17:05:27.674Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/87/da78243742ffa8a36d98c3010f0d829f93d5da4e6786f1a1a6f2ad616502/mypy-1.20.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bba9ad231e92a3e424b3e56b65aa17704993425bba97e302c832f9466bb85bac", size = 14803844, upload-time = "2026-04-21T17:10:06.2Z" },
+    { url = "https://files.pythonhosted.org/packages/37/52/10a1ddf91b40f843943a3c6db51e2df59c9e237f29d355e95eaab427461f/mypy-1.20.2-cp311-cp311-win_amd64.whl", hash = "sha256:baf593f2765fa3a6b1ef95807dbaa3d25b594f6a52adcc506a6b9cb115e1be67", size = 10846300, upload-time = "2026-04-21T17:12:23.886Z" },
+    { url = "https://files.pythonhosted.org/packages/20/02/f9a4415b664c53bd34d6709be59da303abcae986dc4ac847b402edb6fa1e/mypy-1.20.2-cp311-cp311-win_arm64.whl", hash = "sha256:20175a1c0f49863946ec20b7f63255768058ac4f07d2b9ded6a6b46cfb5a9100", size = 9779498, upload-time = "2026-04-21T17:09:23.695Z" },
+    { url = "https://files.pythonhosted.org/packages/71/4e/7560e4528db9e9b147e4c0f22660466bf30a0a1fe3d63d1b9d3b0fd354ee/mypy-1.20.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4dbfcf869f6b0517f70cf0030ba6ea1d6645e132337a7d5204a18d8d5636c02b", size = 14539393, upload-time = "2026-04-21T17:07:12.52Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d9/34a5efed8124f5a9234f55ac6a4ced4201e2c5b81e1109c49ad23190ec8c/mypy-1.20.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4b6481b228d072315b053210b01ac320e1be243dc17f9e5887ef167f23f5fae4", size = 13361642, upload-time = "2026-04-21T17:06:53.742Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/14/eb377acf78c03c92d566a1510cda8137348215b5335085ef662ab82ecd3a/mypy-1.20.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:34397cdced6b90b836e38182076049fdb41424322e0b0728c946b0939ebdf9f6", size = 13740347, upload-time = "2026-04-21T17:12:04.73Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/94/7e4634a32b641aa1c112422eed1bbece61ee16205f674190e8b536f884de/mypy-1.20.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5da6976f20cae27059ea8d0c86e7cef3de720e04c4bb9ee18e3690fdb792066", size = 14734042, upload-time = "2026-04-21T17:07:43.16Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f3/f7e62395cb7f434541b4491a01149a4439e28ace4c0c632bbf5431e92d1f/mypy-1.20.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:56908d7e08318d39f85b1f0c6cfd47b0cac1a130da677630dac0de3e0623e102", size = 14964958, upload-time = "2026-04-21T17:11:00.665Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/0d/47e3c3a0ec2a876e35aeac365df3cac7776c36bbd4ed18cc521e1b9d255b/mypy-1.20.2-cp312-cp312-win_amd64.whl", hash = "sha256:d52ad8d78522da1d308789df651ee5379088e77c76cb1994858d40a426b343b9", size = 10911340, upload-time = "2026-04-21T17:10:49.179Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/b2/6c852d72e0ea8b01f49da817fb52539993cde327e7d010e0103dc12d0dac/mypy-1.20.2-cp312-cp312-win_arm64.whl", hash = "sha256:785b08db19c9f214dc37d65f7c165d19a30fcecb48abfa30f31b01b5acaabb58", size = 9833947, upload-time = "2026-04-21T17:09:05.267Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c4/b93812d3a192c9bcf5df405bd2f30277cd0e48106a14d1023c7f6ed6e39b/mypy-1.20.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:edfbfca868cdd6bd8d974a60f8a3682f5565d3f5c99b327640cedd24c4264026", size = 14524670, upload-time = "2026-04-21T17:10:30.737Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/47/42c122501bff18eaf1e8f457f5c017933452d8acdc52918a9f59f6812955/mypy-1.20.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e2877a02380adfcdbc69071a0f74d6e9dbbf593c0dc9d174e1f223ffd5281943", size = 13336218, upload-time = "2026-04-21T17:08:44.069Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8f/75bbc92f41725fbd585fb17b440b1119b576105df1013622983e18640a93/mypy-1.20.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7488448de6007cd5177c6cea0517ac33b4c0f5ee9b5e9f2be51ce75511a85517", size = 13724906, upload-time = "2026-04-21T17:08:01.02Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/32/4c49da27a606167391ff0c39aa955707a00edc500572e562f7c36c08a71f/mypy-1.20.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bb9c2fa06887e21d6a3a868762acb82aec34e2c6fd0174064f27c93ede68ad15", size = 14726046, upload-time = "2026-04-21T17:11:22.354Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/fc/4e354a1bd70216359deb0c9c54847ee6b32ef78dfb09f5131ff99b494078/mypy-1.20.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d56a78b646f2e3daa865bc70cd5ec5a46c50045801ca8ff17a0c43abc97e3ee", size = 14955587, upload-time = "2026-04-21T17:12:16.033Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b2/c0f2056e9eb8f08c62cafd9715e4584b89132bdc832fcf85d27d07b5f3e5/mypy-1.20.2-cp313-cp313-win_amd64.whl", hash = "sha256:2a4102b03bb7481d9a91a6da8d174740c9c8c4401024684b9ca3b7cc5e49852f", size = 10922681, upload-time = "2026-04-21T17:06:35.842Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/14/065e333721f05de8ef683d0aa804c23026bcc287446b61cac657b902ccac/mypy-1.20.2-cp313-cp313-win_arm64.whl", hash = "sha256:a95a9248b0c6fd933a442c03c3b113c3b61320086b88e2c444676d3fd1ca3330", size = 9830560, upload-time = "2026-04-21T17:07:51.023Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/d1/b4ec96b0ecc620a4443570c6e95c867903428cfcde4206518eafdd5880c3/mypy-1.20.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:419413398fe250aae057fd2fe50166b61077083c9b82754c341cf4fd73038f30", size = 14524561, upload-time = "2026-04-21T17:06:27.325Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/63/d2c2ff4fa66bc49477d32dfa26e8a167ba803ea6a69c5efb416036909d30/mypy-1.20.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e73c07f23009962885c197ccb9b41356a30cc0e5a1d0c2ea8fd8fb1362d7f924", size = 13363883, upload-time = "2026-04-21T17:11:11.239Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/56/983916806bf4eddeaaa2c9230903c3669c6718552a921154e1c5182c701f/mypy-1.20.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c64e5973df366b747646fc98da921f9d6eba9716d57d1db94a83c026a08e0fb", size = 13742945, upload-time = "2026-04-21T17:08:34.181Z" },
+    { url = "https://files.pythonhosted.org/packages/19/65/0cd9285ab010ee8214c83d67c6b49417c40d86ce46f1aa109457b5a9b8d7/mypy-1.20.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a65aa591af023864fd08a97da9974e919452cfe19cb146c8a5dc692626445dc", size = 14706163, upload-time = "2026-04-21T17:05:15.51Z" },
+    { url = "https://files.pythonhosted.org/packages/94/97/48ff3b297cafcc94d185243a9190836fb1b01c1b0918fff64e941e973cc9/mypy-1.20.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4fef51b01e638974a6e69885687e9bd40c8d1e09a6cd291cca0619625cf1f558", size = 14938677, upload-time = "2026-04-21T17:05:39.562Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/a1/1b4233d255bdd0b38a1f284feeb1c143ca508c19184964e22f8d837ec851/mypy-1.20.2-cp314-cp314-win_amd64.whl", hash = "sha256:913485a03f1bcf5d279409a9d2b9ed565c151f61c09f29991e5faa14033da4c8", size = 11089322, upload-time = "2026-04-21T17:06:44.29Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c2/ce7ee2ba36aeb954ba50f18fa25d9c1188578654b97d02a66a15b6f09531/mypy-1.20.2-cp314-cp314-win_arm64.whl", hash = "sha256:c3bae4f855d965b5453784300c12ffc63a548304ac7f99e55d4dc7c898673aa3", size = 10017775, upload-time = "2026-04-21T17:07:20.732Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/a1/9d93a7d0b5859af0ead82b4888b46df6c8797e1bc5e1e262a08518c6d48e/mypy-1.20.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2de3dcea53babc1c3237a19002bc3d228ce1833278f093b8d619e06e7cc79609", size = 15549002, upload-time = "2026-04-21T17:08:23.107Z" },
+    { url = "https://files.pythonhosted.org/packages/00/d2/09a6a10ee1bf0008f6c144d9676f2ca6a12512151b4e0ad0ff6c4fac5337/mypy-1.20.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:52b176444e2e5054dfcbcb8c75b0b719865c96247b37407184bbfca5c353f2c2", size = 14401942, upload-time = "2026-04-21T17:07:31.837Z" },
+    { url = "https://files.pythonhosted.org/packages/57/da/9594b75c3c019e805250bed3583bdf4443ff9e6ef08f97e39ae308cb06f2/mypy-1.20.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:688c3312e5dadb573a2c69c82af3a298d43ecf9e6d264e0f95df960b5f6ac19c", size = 15041649, upload-time = "2026-04-21T17:09:34.653Z" },
+    { url = "https://files.pythonhosted.org/packages/97/77/f75a65c278e6e8eba2071f7f5a90481891053ecc39878cc444634d892abe/mypy-1.20.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29752dbbf8cc53f89f6ac096d363314333045c257c9c75cbd189ca2de0455744", size = 15864588, upload-time = "2026-04-21T17:11:44.936Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/46/1a4e1c66e96c1a3246ddf5403d122ac9b0a8d2b7e65730b9d6533ba7a6d3/mypy-1.20.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:803203d2b6ea644982c644895c2f78b28d0e208bba7b27d9b921e0ec5eb207c6", size = 16093956, upload-time = "2026-04-21T17:10:17.683Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/2c/78a8851264dec38cd736ca5b8bc9380674df0dd0be7792f538916157716c/mypy-1.20.2-cp314-cp314t-win_amd64.whl", hash = "sha256:9bcb8aa397ff0093c824182fd76a935a9ba7ad097fcbef80ae89bf6c1731d8ec", size = 12568661, upload-time = "2026-04-21T17:11:54.473Z" },
+    { url = "https://files.pythonhosted.org/packages/83/01/cd7318aa03493322ce275a0e14f4f52b8896335e4e79d4fb8153a7ad2b77/mypy-1.20.2-cp314-cp314t-win_arm64.whl", hash = "sha256:e061b58443f1736f8a37c48978d7ab581636d6ab03e3d4f99e3fa90463bb9382", size = 10389240, upload-time = "2026-04-21T17:09:42.719Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9a/f23c163e25b11074188251b0b5a0342625fc1cdb6af604757174fa9acc9b/mypy-1.20.2-py3-none-any.whl", hash = "sha256:a94c5a76ab46c5e6257c7972b6c8cff0574201ca7dc05647e33e795d78680563", size = 2637314, upload-time = "2026-04-21T17:05:54.5Z" },
 ]
 
 [[package]]
@@ -299,11 +417,11 @@ wheels = [
 
 [[package]]
 name = "pathspec"
-version = "0.12.1"
+version = "1.1.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
 ]
 
 [[package]]
@@ -322,7 +440,8 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-types" },
     { name = "pydantic-core" },
-    { name = "typing-extensions" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.15'" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.15'" },
     { name = "typing-inspection" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/f0/86/8ce9040065e8f924d642c58e4a344e33163a07f6b57f836d0d734e0ad3fb/pydantic-2.11.5.tar.gz", hash = "sha256:7f853db3d0ce78ce8bbb148c401c2cdd6431b3473c0cdff2755c7690952a7b7a", size = 787102, upload-time = "2025-05-22T21:18:08.761Z" }
@@ -335,7 +454,8 @@ name = "pydantic-core"
 version = "2.33.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.15'" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.15'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" }
 wheels = [
@@ -442,7 +562,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "8.3.5"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -450,23 +570,26 @@ dependencies = [
     { name = "iniconfig" },
     { name = "packaging" },
     { name = "pluggy" },
+    { name = "pygments" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891, upload-time = "2025-03-02T12:54:54.503Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634, upload-time = "2025-03-02T12:54:52.069Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
 [[package]]
 name = "pytest-asyncio"
-version = "0.26.0"
+version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "backports-asyncio-runner", marker = "python_full_version < '3.11'" },
     { name = "pytest" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8e/c4/453c52c659521066969523e87d85d54139bbd17b78f09532fb8eb8cdb58e/pytest_asyncio-0.26.0.tar.gz", hash = "sha256:c4df2a697648241ff39e7f0e4a73050b03f123f760673956cf0d72a4990e312f", size = 54156, upload-time = "2025-03-25T06:22:28.883Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/7f/338843f449ace853647ace35870874f69a764d251872ed1b4de9f234822c/pytest_asyncio-0.26.0-py3-none-any.whl", hash = "sha256:7b51ed894f4fbea1340262bdae5135797ebbe21d8638978e35d31c6d19f72fb0", size = 19694, upload-time = "2025-03-25T06:22:27.807Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
 ]
 
 [[package]]
@@ -489,7 +612,7 @@ wheels = [
 
 [[package]]
 name = "requests"
-version = "2.32.4"
+version = "2.33.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -497,9 +620,9 @@ dependencies = [
     { name = "idna" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e1/0a/929373653770d8a0d7ea76c37de6e41f11eb07559b103b1c02cafb3f7cf8/requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422", size = 135258, upload-time = "2025-06-09T16:43:07.34Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7c/e4/56027c4a6b4ae70ca9de302488c5ca95ad4a39e190093d6c1a8ace08341b/requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c", size = 64847, upload-time = "2025-06-09T16:43:05.728Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" },
 ]
 
 [[package]]
@@ -509,7 +632,7 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown-it-py" },
     { name = "pygments" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a1/53/830aa4c3066a8ab0ae9a9955976fb770fe9c6102117c8ec4ab3ea62d89e8/rich-14.0.0.tar.gz", hash = "sha256:82f1bc23a6a21ebca4ae0c45af9bdbc492ed20231dcb63f297d6d1021a9d5725", size = 224078, upload-time = "2025-03-30T14:15:14.23Z" }
 wheels = [
@@ -518,27 +641,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.11.13"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ed/da/9c6f995903b4d9474b39da91d2d626659af3ff1eeb43e9ae7c119349dba6/ruff-0.11.13.tar.gz", hash = "sha256:26fa247dc68d1d4e72c179e08889a25ac0c7ba4d78aecfc835d49cbfd60bf514", size = 4282054, upload-time = "2025-06-05T21:00:15.721Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7d/ce/a11d381192966e0b4290842cc8d4fac7dc9214ddf627c11c1afff87da29b/ruff-0.11.13-py3-none-linux_armv6l.whl", hash = "sha256:4bdfbf1240533f40042ec00c9e09a3aade6f8c10b6414cf11b519488d2635d46", size = 10292516, upload-time = "2025-06-05T20:59:32.944Z" },
-    { url = "https://files.pythonhosted.org/packages/78/db/87c3b59b0d4e753e40b6a3b4a2642dfd1dcaefbff121ddc64d6c8b47ba00/ruff-0.11.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:aef9c9ed1b5ca28bb15c7eac83b8670cf3b20b478195bd49c8d756ba0a36cf48", size = 11106083, upload-time = "2025-06-05T20:59:37.03Z" },
-    { url = "https://files.pythonhosted.org/packages/77/79/d8cec175856ff810a19825d09ce700265f905c643c69f45d2b737e4a470a/ruff-0.11.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:53b15a9dfdce029c842e9a5aebc3855e9ab7771395979ff85b7c1dedb53ddc2b", size = 10436024, upload-time = "2025-06-05T20:59:39.741Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/5b/f6d94f2980fa1ee854b41568368a2e1252681b9238ab2895e133d303538f/ruff-0.11.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab153241400789138d13f362c43f7edecc0edfffce2afa6a68434000ecd8f69a", size = 10646324, upload-time = "2025-06-05T20:59:42.185Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/9c/b4c2acf24ea4426016d511dfdc787f4ce1ceb835f3c5fbdbcb32b1c63bda/ruff-0.11.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6c51f93029d54a910d3d24f7dd0bb909e31b6cd989a5e4ac513f4eb41629f0dc", size = 10174416, upload-time = "2025-06-05T20:59:44.319Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/10/e2e62f77c65ede8cd032c2ca39c41f48feabedb6e282bfd6073d81bb671d/ruff-0.11.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1808b3ed53e1a777c2ef733aca9051dc9bf7c99b26ece15cb59a0320fbdbd629", size = 11724197, upload-time = "2025-06-05T20:59:46.935Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/f0/466fe8469b85c561e081d798c45f8a1d21e0b4a5ef795a1d7f1a9a9ec182/ruff-0.11.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:d28ce58b5ecf0f43c1b71edffabe6ed7f245d5336b17805803312ec9bc665933", size = 12511615, upload-time = "2025-06-05T20:59:49.534Z" },
-    { url = "https://files.pythonhosted.org/packages/17/0e/cefe778b46dbd0cbcb03a839946c8f80a06f7968eb298aa4d1a4293f3448/ruff-0.11.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55e4bc3a77842da33c16d55b32c6cac1ec5fb0fbec9c8c513bdce76c4f922165", size = 12117080, upload-time = "2025-06-05T20:59:51.654Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/2c/caaeda564cbe103bed145ea557cb86795b18651b0f6b3ff6a10e84e5a33f/ruff-0.11.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:633bf2c6f35678c56ec73189ba6fa19ff1c5e4807a78bf60ef487b9dd272cc71", size = 11326315, upload-time = "2025-06-05T20:59:54.469Z" },
-    { url = "https://files.pythonhosted.org/packages/75/f0/782e7d681d660eda8c536962920c41309e6dd4ebcea9a2714ed5127d44bd/ruff-0.11.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ffbc82d70424b275b089166310448051afdc6e914fdab90e08df66c43bb5ca9", size = 11555640, upload-time = "2025-06-05T20:59:56.986Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/d4/3d580c616316c7f07fb3c99dbecfe01fbaea7b6fd9a82b801e72e5de742a/ruff-0.11.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:4a9ddd3ec62a9a89578c85842b836e4ac832d4a2e0bfaad3b02243f930ceafcc", size = 10507364, upload-time = "2025-06-05T20:59:59.154Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/dc/195e6f17d7b3ea6b12dc4f3e9de575db7983db187c378d44606e5d503319/ruff-0.11.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d237a496e0778d719efb05058c64d28b757c77824e04ffe8796c7436e26712b7", size = 10141462, upload-time = "2025-06-05T21:00:01.481Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/8e/39a094af6967faa57ecdeacb91bedfb232474ff8c3d20f16a5514e6b3534/ruff-0.11.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:26816a218ca6ef02142343fd24c70f7cd8c5aa6c203bca284407adf675984432", size = 11121028, upload-time = "2025-06-05T21:00:04.06Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/c0/b0b508193b0e8a1654ec683ebab18d309861f8bd64e3a2f9648b80d392cb/ruff-0.11.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:51c3f95abd9331dc5b87c47ac7f376db5616041173826dfd556cfe3d4977f492", size = 11602992, upload-time = "2025-06-05T21:00:06.249Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/91/263e33ab93ab09ca06ce4f8f8547a858cc198072f873ebc9be7466790bae/ruff-0.11.13-py3-none-win32.whl", hash = "sha256:96c27935418e4e8e77a26bb05962817f28b8ef3843a6c6cc49d8783b5507f250", size = 10474944, upload-time = "2025-06-05T21:00:08.459Z" },
-    { url = "https://files.pythonhosted.org/packages/46/f4/7c27734ac2073aae8efb0119cae6931b6fb48017adf048fdf85c19337afc/ruff-0.11.13-py3-none-win_amd64.whl", hash = "sha256:29c3189895a8a6a657b7af4e97d330c8a3afd2c9c8f46c81e2fc5a31866517e3", size = 11548669, upload-time = "2025-06-05T21:00:11.147Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/bf/b273dd11673fed8a6bd46032c0ea2a04b2ac9bfa9c628756a5856ba113b0/ruff-0.11.13-py3-none-win_arm64.whl", hash = "sha256:b4385285e9179d608ff1d2fb9922062663c658605819a6876d8beef0c30b7f3b", size = 10683928, upload-time = "2025-06-05T21:00:13.758Z" },
+version = "0.15.12"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/99/43/3291f1cc9106f4c63bdce7a8d0df5047fe8422a75b091c16b5e9355e0b11/ruff-0.15.12.tar.gz", hash = "sha256:ecea26adb26b4232c0c2ca19ccbc0083a68344180bba2a600605538ce51a40a6", size = 4643852, upload-time = "2026-04-24T18:17:14.305Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c3/6e/e78ffb61d4686f3d96ba3df2c801161843746dcbcbb17a1e927d4829312b/ruff-0.15.12-py3-none-linux_armv6l.whl", hash = "sha256:f86f176e188e94d6bdbc09f09bfd9dc729059ad93d0e7390b5a73efe19f8861c", size = 10640713, upload-time = "2026-04-24T18:17:22.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/08/a317bc231fb9e7b93e4ef3089501e51922ff88d6936ce5cf870c4fe55419/ruff-0.15.12-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e3bcd123364c3770b8e1b7baaf343cc99a35f197c5c6e8af79015c666c423a6c", size = 11069267, upload-time = "2026-04-24T18:17:30.105Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/a4/f828e9718d3dce1f5f11c39c4f65afd32783c8b2aebb2e3d259e492c47bd/ruff-0.15.12-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fe87510d000220aa1ed530d4448a7c696a0cae1213e5ec30e5874287b66557b5", size = 10397182, upload-time = "2026-04-24T18:17:07.177Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e0/3310fc6d1b5e1fdea22bf3b1b807c7e187b581021b0d7d4514cccdb5fb71/ruff-0.15.12-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:84a1630093121375a3e2a95b4a6dc7b59e2b4ee76216e32d81aae550a832d002", size = 10758012, upload-time = "2026-04-24T18:16:55.759Z" },
+    { url = "https://files.pythonhosted.org/packages/11/c1/a606911aee04c324ddaa883ae418f3569792fd3c4a10c50e0dd0a2311e1e/ruff-0.15.12-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fb129f40f114f089ebe0ca56c0d251cf2061b17651d464bb6478dc01e69f11f5", size = 10447479, upload-time = "2026-04-24T18:16:51.677Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/68/4201e8444f0894f21ab4aeeaee68aa4f10b51613514a20d80bd628d57e88/ruff-0.15.12-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b0c862b172d695db7598426b8af465e7e9ac00a3ea2a3630ee67eb82e366aaa6", size = 11234040, upload-time = "2026-04-24T18:17:16.529Z" },
+    { url = "https://files.pythonhosted.org/packages/34/ff/8a6d6cf4ccc23fd67060874e832c18919d1557a0611ebef03fdb01fff11e/ruff-0.15.12-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2849ea9f3484c3aca43a82f484210370319e7170df4dfe4843395ddf6c57bc33", size = 12087377, upload-time = "2026-04-24T18:17:04.944Z" },
+    { url = "https://files.pythonhosted.org/packages/85/f6/c669cf73f5152f623d34e69866a46d5e6185816b19fcd5b6dd8a2d299922/ruff-0.15.12-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e77c7e51c07fe396826d5969a5b846d9cd4c402535835fb6e21ce8b28fef847", size = 11367784, upload-time = "2026-04-24T18:17:25.409Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/39/c61d193b8a1daaa8977f7dea9e8d8ba866e02ea7b65d32f6861693aa4c12/ruff-0.15.12-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:83b2f4f2f3b1026b5fb449b467d9264bf22067b600f7b6f41fc5958909f449d0", size = 11344088, upload-time = "2026-04-24T18:17:12.258Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/8d/49afab3645e31e12c590acb6d3b5b69d7aab5b81926dbaf7461f9441f37a/ruff-0.15.12-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:9ba3b8f1afd7e2e43d8943e55f249e13f9682fde09711644a6e7290eb4f3e339", size = 11271770, upload-time = "2026-04-24T18:17:02.457Z" },
+    { url = "https://files.pythonhosted.org/packages/46/06/33f41fe94403e2b755481cdfb9b7ef3e4e0ed031c4581124658d935d52b4/ruff-0.15.12-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e852ba9fdc890655e1d78f2df1499efbe0e54126bd405362154a75e2bde159c5", size = 10719355, upload-time = "2026-04-24T18:17:27.648Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/59/18aa4e014debbf559670e4048e39260a85c7fcee84acfd761ac01e7b8d35/ruff-0.15.12-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:dd8aed930da53780d22fc70bdf84452c843cf64f8cb4eb38984319c24c5cd5fd", size = 10462758, upload-time = "2026-04-24T18:17:32.347Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e7/cc9f16fd0f3b5fddcbd7ec3d6ae30c8f3fde1047f32a4093a98d633c6570/ruff-0.15.12-py3-none-musllinux_1_2_i686.whl", hash = "sha256:01da3988d225628b709493d7dc67c3b9b12c0210016b08690ef9bd27970b262b", size = 10953498, upload-time = "2026-04-24T18:17:20.674Z" },
+    { url = "https://files.pythonhosted.org/packages/72/7a/a9ba7f98c7a575978698f4230c5e8cc54bbc761af34f560818f933dafa0c/ruff-0.15.12-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:9cae0f92bd5700d1213188b31cd3bdd2b315361296d10b96b8e2337d3d11f53e", size = 11447765, upload-time = "2026-04-24T18:17:09.755Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/f9/0ae446942c846b8266059ad8a30702a35afae55f5cdc54c5adf8d7afdc27/ruff-0.15.12-py3-none-win32.whl", hash = "sha256:d0185894e038d7043ba8fd6aee7499ece6462dc0ea9f1e260c7451807c714c20", size = 10657277, upload-time = "2026-04-24T18:17:18.591Z" },
+    { url = "https://files.pythonhosted.org/packages/33/f1/9614e03e1cdcbf9437570b5400ced8a720b5db22b28d8e0f1bda429f660d/ruff-0.15.12-py3-none-win_amd64.whl", hash = "sha256:c87a162d61ab3adca47c03f7f717c68672edec7d1b5499e652331780fe74950d", size = 11837758, upload-time = "2026-04-24T18:17:00.113Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/98/6beb4b351e472e5f4c4613f7c35a5290b8be2497e183825310c4c3a3984b/ruff-0.15.12-py3-none-win_arm64.whl", hash = "sha256:a538f7a82d061cee7be55542aca1d86d1393d55d81d4fcc314370f4340930d4f", size = 11120821, upload-time = "2026-04-24T18:16:57.979Z" },
 ]
 
 [[package]]
@@ -682,7 +805,8 @@ dependencies = [
     { name = "click" },
     { name = "rich" },
     { name = "shellingham" },
-    { name = "typing-extensions" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.15'" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.15'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6c/89/c527e6c848739be8ceb5c44eb8208c52ea3515c6cf6406aa61932887bf58/typer-0.15.4.tar.gz", hash = "sha256:89507b104f9b6a0730354f27c39fae5b63ccd0c95b1ce1f1a6ba0cfd329997c3", size = 101559, upload-time = "2025-05-14T16:34:57.704Z" }
 wheels = [
@@ -702,17 +826,33 @@ wheels = [
 name = "typing-extensions"
 version = "4.13.2"
 source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.15'",
+]
 sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967, upload-time = "2025-04-10T14:19:05.416Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806, upload-time = "2025-04-10T14:19:03.967Z" },
 ]
 
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.15'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
 [[package]]
 name = "typing-inspection"
 version = "0.4.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.15'" },
+    { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.15'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" }
 wheels = [
@@ -735,7 +875,7 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
     { name = "h11" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a6/ae/9bbb19b9e1c450cf9ecaef06463e40234d98d95bf572fab11b4f19ae5ded/uvicorn-0.34.2.tar.gz", hash = "sha256:0e929828f6186353a80b58ea719861d2629d766293b6d19baf086ba31d4f3328", size = 76815, upload-time = "2025-04-19T06:02:50.101Z" }
 wheels = [