prompture 0.0.34__py3-none-any.whl → 0.0.34.dev1__py3-none-any.whl

prompture/__init__.py

@@ -42,16 +42,6 @@ from .drivers import (
     OpenRouterDriver,
     get_driver,
     get_driver_for_model,
-    # Plugin registration API
-    is_async_driver_registered,
-    is_driver_registered,
-    list_registered_async_drivers,
-    list_registered_drivers,
-    load_entry_point_drivers,
-    register_async_driver,
-    register_driver,
-    unregister_async_driver,
-    unregister_driver,
 )
 from .field_definitions import (
     FIELD_DEFINITIONS,
@@ -153,25 +143,14 @@ __all__ = [
     "get_model_rates",
     "get_registry_snapshot",
     "get_required_fields",
-    # Plugin registration API
-    "is_async_driver_registered",
-    "is_driver_registered",
-    "list_registered_async_drivers",
-    "list_registered_drivers",
-    "load_entry_point_drivers",
-    # Other exports
     "manual_extract_and_jsonify",
     "normalize_enum_value",
     "refresh_rates_cache",
-    "register_async_driver",
-    "register_driver",
     "register_field",
     "render_output",
     "reset_registry",
     "run_suite_from_spec",
     "stepwise_extract_with_model",
-    "unregister_async_driver",
-    "unregister_driver",
     "validate_against_schema",
     "validate_enum_value",
 ]

prompture/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.34'
-__version_tuple__ = version_tuple = (0, 0, 34)
+__version__ = version = '0.0.34.dev1'
+__version_tuple__ = version_tuple = (0, 0, 34, 'dev1')
 
 __commit_id__ = commit_id = None

prompture/drivers/__init__.py

@@ -1,29 +1,3 @@
-"""Driver registry and factory functions.
-
-This module provides:
-- Built-in drivers for popular LLM providers
-- A pluggable registry system for custom drivers
-- Factory functions to instantiate drivers by provider/model name
-
-Custom Driver Registration:
-    from prompture import register_driver
-
-    def my_driver_factory(model=None):
-        return MyCustomDriver(model=model)
-
-    register_driver("my_provider", my_driver_factory)
-
-    # Now you can use it
-    driver = get_driver_for_model("my_provider/my-model")
-
-Entry Point Discovery:
-    Third-party packages can register drivers via entry points.
-    Add to your pyproject.toml:
-
-    [project.entry-points."prompture.drivers"]
-    my_provider = "my_package.drivers:my_driver_factory"
-"""
-
 from typing import Optional
 
 from ..settings import settings
@@ -51,85 +25,30 @@ from .local_http_driver import LocalHTTPDriver
 from .ollama_driver import OllamaDriver
 from .openai_driver import OpenAIDriver
 from .openrouter_driver import OpenRouterDriver
-from .registry import (
-    _get_sync_registry,
-    get_async_driver_factory,
-    get_driver_factory,
-    is_async_driver_registered,
-    is_driver_registered,
-    list_registered_async_drivers,
-    list_registered_drivers,
-    load_entry_point_drivers,
-    register_async_driver,
-    register_driver,
-    unregister_async_driver,
-    unregister_driver,
-)
 
-# Register built-in sync drivers
-register_driver(
-    "openai",
-    lambda model=None: OpenAIDriver(api_key=settings.openai_api_key, model=model or settings.openai_model),
-    overwrite=True,
-)
-register_driver(
-    "ollama",
-    lambda model=None: OllamaDriver(endpoint=settings.ollama_endpoint, model=model or settings.ollama_model),
-    overwrite=True,
-)
-register_driver(
-    "claude",
-    lambda model=None: ClaudeDriver(api_key=settings.claude_api_key, model=model or settings.claude_model),
-    overwrite=True,
-)
-register_driver(
-    "lmstudio",
-    lambda model=None: LMStudioDriver(endpoint=settings.lmstudio_endpoint, model=model or settings.lmstudio_model),
-    overwrite=True,
-)
-register_driver(
-    "azure",
-    lambda model=None: AzureDriver(
+# Central registry: maps provider → factory function
+DRIVER_REGISTRY = {
+    "openai": lambda model=None: OpenAIDriver(api_key=settings.openai_api_key, model=model or settings.openai_model),
+    "ollama": lambda model=None: OllamaDriver(endpoint=settings.ollama_endpoint, model=model or settings.ollama_model),
+    "claude": lambda model=None: ClaudeDriver(api_key=settings.claude_api_key, model=model or settings.claude_model),
+    "lmstudio": lambda model=None: LMStudioDriver(
+        endpoint=settings.lmstudio_endpoint, model=model or settings.lmstudio_model
+    ),
+    "azure": lambda model=None: AzureDriver(
         api_key=settings.azure_api_key, endpoint=settings.azure_api_endpoint, deployment_id=settings.azure_deployment_id
     ),
-    overwrite=True,
-)
-register_driver(
-    "local_http",
-    lambda model=None: LocalHTTPDriver(endpoint=settings.local_http_endpoint, model=model),
-    overwrite=True,
-)
-register_driver(
-    "google",
-    lambda model=None: GoogleDriver(api_key=settings.google_api_key, model=model or settings.google_model),
-    overwrite=True,
-)
-register_driver(
-    "groq",
-    lambda model=None: GroqDriver(api_key=settings.groq_api_key, model=model or settings.groq_model),
-    overwrite=True,
-)
-register_driver(
-    "openrouter",
-    lambda model=None: OpenRouterDriver(api_key=settings.openrouter_api_key, model=model or settings.openrouter_model),
-    overwrite=True,
-)
-register_driver(
-    "grok",
-    lambda model=None: GrokDriver(api_key=settings.grok_api_key, model=model or settings.grok_model),
-    overwrite=True,
-)
-register_driver(
-    "airllm",
-    lambda model=None: AirLLMDriver(
+    "local_http": lambda model=None: LocalHTTPDriver(endpoint=settings.local_http_endpoint, model=model),
+    "google": lambda model=None: GoogleDriver(api_key=settings.google_api_key, model=model or settings.google_model),
+    "groq": lambda model=None: GroqDriver(api_key=settings.groq_api_key, model=model or settings.groq_model),
+    "openrouter": lambda model=None: OpenRouterDriver(
+        api_key=settings.openrouter_api_key, model=model or settings.openrouter_model
+    ),
+    "grok": lambda model=None: GrokDriver(api_key=settings.grok_api_key, model=model or settings.grok_model),
+    "airllm": lambda model=None: AirLLMDriver(
         model=model or settings.airllm_model,
         compression=settings.airllm_compression,
     ),
-    overwrite=True,
-)
-
-# Backwards compatibility: expose registry dict (read-only view recommended)
-DRIVER_REGISTRY = _get_sync_registry()
+}
 
 
 def get_driver(provider_name: Optional[str] = None):
@@ -138,8 +57,9 @@ def get_driver(provider_name: Optional[str] = None):
     Uses default model from settings if not overridden.
     """
     provider = (provider_name or settings.ai_provider or "ollama").strip().lower()
-    factory = get_driver_factory(provider)
-    return factory()  # use default model from settings
+    if provider not in DRIVER_REGISTRY:
+        raise ValueError(f"Unknown provider: {provider_name}")
+    return DRIVER_REGISTRY[provider]()  # use default model from settings
 
 
 def get_driver_for_model(model_str: str):
@@ -170,20 +90,19 @@ def get_driver_for_model(model_str: str):
     provider = parts[0].lower()
     model_id = parts[1] if len(parts) > 1 else None
 
-    # Get factory (validates provider exists)
-    factory = get_driver_factory(provider)
+    # Validate provider
+    if provider not in DRIVER_REGISTRY:
+        raise ValueError(f"Unsupported provider '{provider}'")
 
     # Create driver with model ID if provided, otherwise use default
-    return factory(model_id)
+    return DRIVER_REGISTRY[provider](model_id)
 
 
 __all__ = [
+    # Async drivers
     "ASYNC_DRIVER_REGISTRY",
-    # Legacy registry dicts (for backwards compatibility)
-    "DRIVER_REGISTRY",
     # Sync drivers
     "AirLLMDriver",
-    # Async drivers
     "AsyncAirLLMDriver",
     "AsyncAzureDriver",
     "AsyncClaudeDriver",
@@ -208,17 +127,6 @@ __all__ = [
     "OpenRouterDriver",
     "get_async_driver",
     "get_async_driver_for_model",
-    # Factory functions
     "get_driver",
     "get_driver_for_model",
-    "is_async_driver_registered",
-    "is_driver_registered",
-    "list_registered_async_drivers",
-    "list_registered_drivers",
-    "load_entry_point_drivers",
-    "register_async_driver",
-    # Registry functions (public API)
-    "register_driver",
-    "unregister_async_driver",
-    "unregister_driver",
 ]

prompture/drivers/async_registry.py

@@ -1,15 +1,4 @@
-"""Async driver registry — mirrors the sync DRIVER_REGISTRY.
-
-This module provides async driver registration and factory functions.
-Custom async drivers can be registered via the ``register_async_driver()``
-function or discovered via entry points.
-
-Entry Point Discovery:
-    Add to your pyproject.toml:
-
-    [project.entry-points."prompture.async_drivers"]
-    my_provider = "my_package.drivers:my_async_driver_factory"
-"""
+"""Async driver registry — mirrors the sync DRIVER_REGISTRY."""
 
 from __future__ import annotations
 
@@ -25,78 +14,37 @@ from .async_local_http_driver import AsyncLocalHTTPDriver
 from .async_ollama_driver import AsyncOllamaDriver
 from .async_openai_driver import AsyncOpenAIDriver
 from .async_openrouter_driver import AsyncOpenRouterDriver
-from .registry import (
-    _get_async_registry,
-    get_async_driver_factory,
-    register_async_driver,
-)
 
-# Register built-in async drivers
-register_async_driver(
-    "openai",
-    lambda model=None: AsyncOpenAIDriver(api_key=settings.openai_api_key, model=model or settings.openai_model),
-    overwrite=True,
-)
-register_async_driver(
-    "ollama",
-    lambda model=None: AsyncOllamaDriver(endpoint=settings.ollama_endpoint, model=model or settings.ollama_model),
-    overwrite=True,
-)
-register_async_driver(
-    "claude",
-    lambda model=None: AsyncClaudeDriver(api_key=settings.claude_api_key, model=model or settings.claude_model),
-    overwrite=True,
-)
-register_async_driver(
-    "lmstudio",
-    lambda model=None: AsyncLMStudioDriver(endpoint=settings.lmstudio_endpoint, model=model or settings.lmstudio_model),
-    overwrite=True,
-)
-register_async_driver(
-    "azure",
-    lambda model=None: AsyncAzureDriver(
+ASYNC_DRIVER_REGISTRY = {
+    "openai": lambda model=None: AsyncOpenAIDriver(
+        api_key=settings.openai_api_key, model=model or settings.openai_model
+    ),
+    "ollama": lambda model=None: AsyncOllamaDriver(
+        endpoint=settings.ollama_endpoint, model=model or settings.ollama_model
+    ),
+    "claude": lambda model=None: AsyncClaudeDriver(
+        api_key=settings.claude_api_key, model=model or settings.claude_model
+    ),
+    "lmstudio": lambda model=None: AsyncLMStudioDriver(
+        endpoint=settings.lmstudio_endpoint, model=model or settings.lmstudio_model
+    ),
+    "azure": lambda model=None: AsyncAzureDriver(
         api_key=settings.azure_api_key, endpoint=settings.azure_api_endpoint, deployment_id=settings.azure_deployment_id
     ),
-    overwrite=True,
-)
-register_async_driver(
-    "local_http",
-    lambda model=None: AsyncLocalHTTPDriver(endpoint=settings.local_http_endpoint, model=model),
-    overwrite=True,
-)
-register_async_driver(
-    "google",
-    lambda model=None: AsyncGoogleDriver(api_key=settings.google_api_key, model=model or settings.google_model),
-    overwrite=True,
-)
-register_async_driver(
-    "groq",
-    lambda model=None: AsyncGroqDriver(api_key=settings.groq_api_key, model=model or settings.groq_model),
-    overwrite=True,
-)
-register_async_driver(
-    "openrouter",
-    lambda model=None: AsyncOpenRouterDriver(
+    "local_http": lambda model=None: AsyncLocalHTTPDriver(endpoint=settings.local_http_endpoint, model=model),
+    "google": lambda model=None: AsyncGoogleDriver(
+        api_key=settings.google_api_key, model=model or settings.google_model
+    ),
+    "groq": lambda model=None: AsyncGroqDriver(api_key=settings.groq_api_key, model=model or settings.groq_model),
+    "openrouter": lambda model=None: AsyncOpenRouterDriver(
         api_key=settings.openrouter_api_key, model=model or settings.openrouter_model
     ),
-    overwrite=True,
-)
-register_async_driver(
-    "grok",
-    lambda model=None: AsyncGrokDriver(api_key=settings.grok_api_key, model=model or settings.grok_model),
-    overwrite=True,
-)
-register_async_driver(
-    "airllm",
-    lambda model=None: AsyncAirLLMDriver(
+    "grok": lambda model=None: AsyncGrokDriver(api_key=settings.grok_api_key, model=model or settings.grok_model),
+    "airllm": lambda model=None: AsyncAirLLMDriver(
         model=model or settings.airllm_model,
         compression=settings.airllm_compression,
     ),
-    overwrite=True,
-)
-
-# Backwards compatibility: expose registry dict
-ASYNC_DRIVER_REGISTRY = _get_async_registry()
+}
 
 
 def get_async_driver(provider_name: str | None = None):
@@ -105,8 +53,9 @@ def get_async_driver(provider_name: str | None = None):
     Uses default model from settings if not overridden.
     """
     provider = (provider_name or settings.ai_provider or "ollama").strip().lower()
-    factory = get_async_driver_factory(provider)
-    return factory()
+    if provider not in ASYNC_DRIVER_REGISTRY:
+        raise ValueError(f"Unknown provider: {provider_name}")
+    return ASYNC_DRIVER_REGISTRY[provider]()
 
 
 def get_async_driver_for_model(model_str: str):
@@ -125,5 +74,7 @@ def get_async_driver_for_model(model_str: str):
     provider = parts[0].lower()
     model_id = parts[1] if len(parts) > 1 else None
 
-    factory = get_async_driver_factory(provider)
-    return factory(model_id)
+    if provider not in ASYNC_DRIVER_REGISTRY:
+        raise ValueError(f"Unsupported provider '{provider}'")
+
+    return ASYNC_DRIVER_REGISTRY[provider](model_id)

{prompture-0.0.34.dist-info → prompture-0.0.34.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.34
+Version: 0.0.34.dev1
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT

{prompture-0.0.34.dist-info → prompture-0.0.34.dev1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-prompture/__init__.py,sha256=RNmZAPgBKi7jyW4DUoR800UAdZx4S-H8INe8KOdsmgA,4547
-prompture/_version.py,sha256=lALZlyVk-nrQoV2VLZzOsgzhfEll5JRUW4TJRJXnR_o,706
+prompture/__init__.py,sha256=XLOuu8AnbAjEq7oKPyrIcXzoSFzfzjBfWmS4WjZlCpU,3945
+prompture/_version.py,sha256=oWvGRxkg4wF7c8HSUd3ltOCQNJfrhcDmrYXTODvTKeA,719
 prompture/async_conversation.py,sha256=Q4wJctjTffH55i5FnxV5tt0xB-WCJCfCmxeHLOisuP8,18807
 prompture/async_core.py,sha256=s8G0nGUGR1Bf_BQG9_FcQRpveSnJKkEwcWNfbAJaSkg,29208
 prompture/async_driver.py,sha256=8mV3wEQiGOGuegaAPJ6uT1lNXwFDmbUGKXZkHk9Baow,4630
@@ -20,7 +20,7 @@ prompture/settings.py,sha256=o-zsYpxRvSg-ICGWqqVNEoJG23GCMBLlkC7RPXpouSw,1976
 prompture/tools.py,sha256=PmFbGHTWYWahpJOG6BLlM0Y-EG6S37IFW57C-8GdsXo,36449
 prompture/validator.py,sha256=FY_VjIVEbjG2nwzh-r6l23Kt3UzaLyCis8_pZMNGHBA,993
 prompture/aio/__init__.py,sha256=bKqTu4Jxld16aP_7SP9wU5au45UBIb041ORo4E4HzVo,1810
-prompture/drivers/__init__.py,sha256=yj-z7_RMbfxP8zaKjQFZFcxGdf8Q2_KNQ6RTo7SPEpQ,6984
+prompture/drivers/__init__.py,sha256=5bNmiKaKYh1hanTa_SZ0akwEcOMVJoNSeMGBXb67VfM,5083
 prompture/drivers/airllm_driver.py,sha256=SaTh7e7Plvuct_TfRqQvsJsKHvvM_3iVqhBtlciM-Kw,3858
 prompture/drivers/async_airllm_driver.py,sha256=1hIWLXfyyIg9tXaOE22tLJvFyNwHnOi1M5BIKnV8ysk,908
 prompture/drivers/async_azure_driver.py,sha256=vRp1PlOB87OLUbEZJEp7En3tvadG956Q6AV2o9UmyLA,4196
@@ -34,7 +34,7 @@ prompture/drivers/async_local_http_driver.py,sha256=qoigIf-w3_c2dbVdM6m1e2RMAWP4
 prompture/drivers/async_ollama_driver.py,sha256=vRd2VIl412d6WVSo8vmZg0GBYUo7gBj-S2_55PpUWbk,4511
 prompture/drivers/async_openai_driver.py,sha256=jHtSA_MeeIwGeE9o9F1ZsKTNgGGA7xF3WbGZgD8ACEU,3305
 prompture/drivers/async_openrouter_driver.py,sha256=OKL4MfRAopXaMevf6A6WcAytyvWr0tWO_BmshdI0fSY,3516
-prompture/drivers/async_registry.py,sha256=gJDr60688MZx9rbP-I8Um1gLeDwfRynv5SHsYjHjEGk,4263
+prompture/drivers/async_registry.py,sha256=xI_QI8z56vg6qWy6mJTsIdtd16o3nilBZbVIbfArEKI,3393
 prompture/drivers/azure_driver.py,sha256=4IAzdKqcORgVEDUj6itkVmJUg1ayo4HXSfqLKzIGnlM,5460
 prompture/drivers/claude_driver.py,sha256=11nEiq0Ga-d-0vwxbWo-cAl4AjnYPLdRyPtucJs9xTA,4985
 prompture/drivers/google_driver.py,sha256=Ysa1ZZEAPEKHCJFCBiJtB4K-sGvsYti4hGBv_85nowY,8454
@@ -46,10 +46,9 @@ prompture/drivers/local_http_driver.py,sha256=QJgEf9kAmy8YZ5fb8FHnWuhoDoZYNd8at4
 prompture/drivers/ollama_driver.py,sha256=fNvHW5mp7cIwpZKCS5r7WAO-yTK01BKTKvotM_GJCE0,7229
 prompture/drivers/openai_driver.py,sha256=-mgieUBlNgjz5B6ejRwMPoIGgvEW2p5LLwS9j0B9hno,4815
 prompture/drivers/openrouter_driver.py,sha256=WH48KEkafuxFX6b55FzwT57tUlmbwYlHSeNsIxWvM4o,5141
-prompture/drivers/registry.py,sha256=Dg_5w9alnIPKhOnsR9Xspuf5T7roBGu0r_L2Cf-UhXs,9926
-prompture-0.0.34.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
-prompture-0.0.34.dist-info/METADATA,sha256=ceuWQGpjpKCnkdGgYVlHPfTD9G2Yw84go3AxIwzkvbo,18226
-prompture-0.0.34.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-prompture-0.0.34.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
-prompture-0.0.34.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
-prompture-0.0.34.dist-info/RECORD,,
+prompture-0.0.34.dev1.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
+prompture-0.0.34.dev1.dist-info/METADATA,sha256=aEHoj6Hw91QHAzbZ40RoW2RQ9K0RckRWEnsj-lr7c3c,18231
+prompture-0.0.34.dev1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+prompture-0.0.34.dev1.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
+prompture-0.0.34.dev1.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
+prompture-0.0.34.dev1.dist-info/RECORD,,

prompture/drivers/registry.py

@@ -1,306 +0,0 @@
-"""Driver registry with plugin support.
-
-This module provides a public API for registering custom drivers and
-supports auto-discovery of drivers via Python entry points.
-
-Example usage:
-    # Register a custom driver
-    from prompture import register_driver
-
-    def my_driver_factory(model=None):
-        return MyCustomDriver(model=model)
-
-    register_driver("my_provider", my_driver_factory)
-
-    # Now you can use it
-    driver = get_driver_for_model("my_provider/my-model")
-
-For entry point discovery, add to your package's pyproject.toml:
-    [project.entry-points."prompture.drivers"]
-    my_provider = "my_package.drivers:my_driver_factory"
-
-    [project.entry-points."prompture.async_drivers"]
-    my_provider = "my_package.drivers:my_async_driver_factory"
-"""
-
-from __future__ import annotations
-
-import logging
-import sys
-from typing import Callable
-
-logger = logging.getLogger("prompture.drivers.registry")
-
-# Type alias for driver factory functions
-# A factory takes an optional model name and returns a driver instance
-DriverFactory = Callable[[str | None], object]
-
-# Internal registries - populated by built-in drivers and plugins
-_SYNC_REGISTRY: dict[str, DriverFactory] = {}
-_ASYNC_REGISTRY: dict[str, DriverFactory] = {}
-
-# Track whether entry points have been loaded
-_entry_points_loaded = False
-
-
-def register_driver(name: str, factory: DriverFactory, *, overwrite: bool = False) -> None:
-    """Register a custom driver factory for a provider name.
-
-    Args:
-        name: Provider name (e.g., "my_provider"). Will be lowercased.
-        factory: A callable that takes an optional model name and returns
-                 a driver instance. The driver must implement the
-                 ``Driver`` interface (specifically ``generate()``).
-        overwrite: If True, allow overwriting an existing registration.
-                   Defaults to False.
-
-    Raises:
-        ValueError: If a driver with this name is already registered
-                    and overwrite=False.
-
-    Example:
-        >>> def my_factory(model=None):
-        ...     return MyDriver(model=model or "default-model")
-        >>> register_driver("my_provider", my_factory)
-        >>> driver = get_driver_for_model("my_provider/custom-model")
-    """
-    name = name.lower()
-    if name in _SYNC_REGISTRY and not overwrite:
-        raise ValueError(f"Driver '{name}' is already registered. Use overwrite=True to replace it.")
-    _SYNC_REGISTRY[name] = factory
-    logger.debug("Registered sync driver: %s", name)
-
-
-def register_async_driver(name: str, factory: DriverFactory, *, overwrite: bool = False) -> None:
-    """Register a custom async driver factory for a provider name.
-
-    Args:
-        name: Provider name (e.g., "my_provider"). Will be lowercased.
-        factory: A callable that takes an optional model name and returns
-                 an async driver instance. The driver must implement the
-                 ``AsyncDriver`` interface (specifically ``async generate()``).
-        overwrite: If True, allow overwriting an existing registration.
-                   Defaults to False.
-
-    Raises:
-        ValueError: If an async driver with this name is already registered
-                    and overwrite=False.
-
-    Example:
-        >>> def my_async_factory(model=None):
-        ...     return MyAsyncDriver(model=model or "default-model")
-        >>> register_async_driver("my_provider", my_async_factory)
-        >>> driver = get_async_driver_for_model("my_provider/custom-model")
-    """
-    name = name.lower()
-    if name in _ASYNC_REGISTRY and not overwrite:
-        raise ValueError(f"Async driver '{name}' is already registered. Use overwrite=True to replace it.")
-    _ASYNC_REGISTRY[name] = factory
-    logger.debug("Registered async driver: %s", name)
-
-
-def unregister_driver(name: str) -> bool:
-    """Unregister a sync driver by name.
-
-    Args:
-        name: Provider name to unregister.
-
-    Returns:
-        True if the driver was unregistered, False if it wasn't registered.
-    """
-    name = name.lower()
-    if name in _SYNC_REGISTRY:
-        del _SYNC_REGISTRY[name]
-        logger.debug("Unregistered sync driver: %s", name)
-        return True
-    return False
-
-
-def unregister_async_driver(name: str) -> bool:
-    """Unregister an async driver by name.
-
-    Args:
-        name: Provider name to unregister.
-
-    Returns:
-        True if the driver was unregistered, False if it wasn't registered.
-    """
-    name = name.lower()
-    if name in _ASYNC_REGISTRY:
-        del _ASYNC_REGISTRY[name]
-        logger.debug("Unregistered async driver: %s", name)
-        return True
-    return False
-
-
-def list_registered_drivers() -> list[str]:
-    """Return a sorted list of registered sync driver names."""
-    _ensure_entry_points_loaded()
-    return sorted(_SYNC_REGISTRY.keys())
-
-
-def list_registered_async_drivers() -> list[str]:
-    """Return a sorted list of registered async driver names."""
-    _ensure_entry_points_loaded()
-    return sorted(_ASYNC_REGISTRY.keys())
-
-
-def is_driver_registered(name: str) -> bool:
-    """Check if a sync driver is registered.
-
-    Args:
-        name: Provider name to check.
-
-    Returns:
-        True if the driver is registered.
-    """
-    _ensure_entry_points_loaded()
-    return name.lower() in _SYNC_REGISTRY
-
-
-def is_async_driver_registered(name: str) -> bool:
-    """Check if an async driver is registered.
-
-    Args:
-        name: Provider name to check.
-
-    Returns:
-        True if the async driver is registered.
-    """
-    _ensure_entry_points_loaded()
-    return name.lower() in _ASYNC_REGISTRY
-
-
-def get_driver_factory(name: str) -> DriverFactory:
-    """Get a registered sync driver factory by name.
-
-    Args:
-        name: Provider name.
-
-    Returns:
-        The factory function.
-
-    Raises:
-        ValueError: If the driver is not registered.
-    """
-    _ensure_entry_points_loaded()
-    name = name.lower()
-    if name not in _SYNC_REGISTRY:
-        raise ValueError(f"Unsupported provider '{name}'")
-    return _SYNC_REGISTRY[name]
-
-
-def get_async_driver_factory(name: str) -> DriverFactory:
-    """Get a registered async driver factory by name.
-
-    Args:
-        name: Provider name.
-
-    Returns:
-        The factory function.
-
-    Raises:
-        ValueError: If the async driver is not registered.
-    """
-    _ensure_entry_points_loaded()
-    name = name.lower()
-    if name not in _ASYNC_REGISTRY:
-        raise ValueError(f"Unsupported provider '{name}'")
-    return _ASYNC_REGISTRY[name]
-
-
-def load_entry_point_drivers() -> tuple[int, int]:
-    """Load drivers from installed packages via entry points.
-
-    This function scans for packages that define entry points in the
-    ``prompture.drivers`` and ``prompture.async_drivers`` groups.
-
-    Returns:
-        A tuple of (sync_count, async_count) indicating how many drivers
-        were loaded from entry points.
-
-    Example pyproject.toml for a plugin package:
-        [project.entry-points."prompture.drivers"]
-        my_provider = "my_package.drivers:create_my_driver"
-
-        [project.entry-points."prompture.async_drivers"]
-        my_provider = "my_package.drivers:create_my_async_driver"
-    """
-    global _entry_points_loaded
-
-    sync_count = 0
-    async_count = 0
-
-    # Python 3.9+ has importlib.metadata in stdlib
-    # Python 3.8 needs importlib_metadata backport
-    if sys.version_info >= (3, 10):
-        from importlib.metadata import entry_points
-
-        sync_eps = entry_points(group="prompture.drivers")
-        async_eps = entry_points(group="prompture.async_drivers")
-    else:
-        from importlib.metadata import entry_points
-
-        all_eps = entry_points()
-        sync_eps = all_eps.get("prompture.drivers", [])
-        async_eps = all_eps.get("prompture.async_drivers", [])
-
-    # Load sync drivers
-    for ep in sync_eps:
-        try:
-            # Skip if already registered (built-in drivers take precedence)
-            if ep.name.lower() in _SYNC_REGISTRY:
-                logger.debug("Skipping entry point driver '%s' (already registered)", ep.name)
-                continue
-
-            factory = ep.load()
-            _SYNC_REGISTRY[ep.name.lower()] = factory
-            sync_count += 1
-            logger.info("Loaded sync driver from entry point: %s", ep.name)
-        except Exception:
-            logger.exception("Failed to load sync driver entry point: %s", ep.name)
-
-    # Load async drivers
-    for ep in async_eps:
-        try:
-            # Skip if already registered (built-in drivers take precedence)
-            if ep.name.lower() in _ASYNC_REGISTRY:
-                logger.debug("Skipping entry point async driver '%s' (already registered)", ep.name)
-                continue
-
-            factory = ep.load()
-            _ASYNC_REGISTRY[ep.name.lower()] = factory
-            async_count += 1
-            logger.info("Loaded async driver from entry point: %s", ep.name)
-        except Exception:
-            logger.exception("Failed to load async driver entry point: %s", ep.name)
-
-    _entry_points_loaded = True
-    return (sync_count, async_count)
-
-
-def _ensure_entry_points_loaded() -> None:
-    """Ensure entry points have been loaded (lazy initialization)."""
-    global _entry_points_loaded
-    if not _entry_points_loaded:
-        load_entry_point_drivers()
-
-
-def _get_sync_registry() -> dict[str, DriverFactory]:
-    """Get the internal sync registry dict (for internal use by drivers/__init__.py)."""
-    _ensure_entry_points_loaded()
-    return _SYNC_REGISTRY
-
-
-def _get_async_registry() -> dict[str, DriverFactory]:
-    """Get the internal async registry dict (for internal use by drivers/async_registry.py)."""
-    _ensure_entry_points_loaded()
-    return _ASYNC_REGISTRY
-
-
-def _reset_registries() -> None:
-    """Reset registries to empty state (for testing only)."""
-    global _entry_points_loaded
-    _SYNC_REGISTRY.clear()
-    _ASYNC_REGISTRY.clear()
-    _entry_points_loaded = False