prompture 0.0.34__tar.gz → 0.0.34.dev1__tar.gz

{prompture-0.0.34 → prompture-0.0.34.dev1}/PKG-INFO

@@ -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.dev1/VERSION

@@ -0,0 +1 @@
+0.0.29.dev1

{prompture-0.0.34 → prompture-0.0.34.dev1}/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-0.0.34 → prompture-0.0.34.dev1}/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-0.0.34.dev1/prompture/drivers/__init__.py

@@ -0,0 +1,132 @@
+from typing import Optional
+
+from ..settings import settings
+from .airllm_driver import AirLLMDriver
+from .async_airllm_driver import AsyncAirLLMDriver
+from .async_azure_driver import AsyncAzureDriver
+from .async_claude_driver import AsyncClaudeDriver
+from .async_google_driver import AsyncGoogleDriver
+from .async_grok_driver import AsyncGrokDriver
+from .async_groq_driver import AsyncGroqDriver
+from .async_hugging_driver import AsyncHuggingFaceDriver
+from .async_lmstudio_driver import AsyncLMStudioDriver
+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 .async_registry import ASYNC_DRIVER_REGISTRY, get_async_driver, get_async_driver_for_model
+from .azure_driver import AzureDriver
+from .claude_driver import ClaudeDriver
+from .google_driver import GoogleDriver
+from .grok_driver import GrokDriver
+from .groq_driver import GroqDriver
+from .lmstudio_driver import LMStudioDriver
+from .local_http_driver import LocalHTTPDriver
+from .ollama_driver import OllamaDriver
+from .openai_driver import OpenAIDriver
+from .openrouter_driver import OpenRouterDriver
+
+# 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
+    ),
+    "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,
+    ),
+}
+
+
+def get_driver(provider_name: Optional[str] = None):
+    """
+    Factory to get a driver instance based on the provider name (legacy style).
+    Uses default model from settings if not overridden.
+    """
+    provider = (provider_name or settings.ai_provider or "ollama").strip().lower()
+    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):
+    """
+    Factory to get a driver instance based on a full model string.
+    Format: provider/model_id
+    Example: "openai/gpt-4-turbo-preview"
+
+    Args:
+        model_str: Model identifier string. Can be either:
+                   - Full format: "provider/model" (e.g. "openai/gpt-4")
+                   - Provider only: "provider" (e.g. "openai")
+
+    Returns:
+        A configured driver instance for the specified provider/model.
+
+    Raises:
+        ValueError: If provider is invalid or format is incorrect.
+    """
+    if not isinstance(model_str, str):
+        raise ValueError("Model string must be a string, got {type(model_str)}")
+
+    if not model_str:
+        raise ValueError("Model string cannot be empty")
+
+    # Extract provider and model ID
+    parts = model_str.split("/", 1)
+    provider = parts[0].lower()
+    model_id = parts[1] if len(parts) > 1 else None
+
+    # 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 DRIVER_REGISTRY[provider](model_id)
+
+
+__all__ = [
+    # Async drivers
+    "ASYNC_DRIVER_REGISTRY",
+    # Sync drivers
+    "AirLLMDriver",
+    "AsyncAirLLMDriver",
+    "AsyncAzureDriver",
+    "AsyncClaudeDriver",
+    "AsyncGoogleDriver",
+    "AsyncGrokDriver",
+    "AsyncGroqDriver",
+    "AsyncHuggingFaceDriver",
+    "AsyncLMStudioDriver",
+    "AsyncLocalHTTPDriver",
+    "AsyncOllamaDriver",
+    "AsyncOpenAIDriver",
+    "AsyncOpenRouterDriver",
+    "AzureDriver",
+    "ClaudeDriver",
+    "GoogleDriver",
+    "GrokDriver",
+    "GroqDriver",
+    "LMStudioDriver",
+    "LocalHTTPDriver",
+    "OllamaDriver",
+    "OpenAIDriver",
+    "OpenRouterDriver",
+    "get_async_driver",
+    "get_async_driver_for_model",
+    "get_driver",
+    "get_driver_for_model",
+]

prompture-0.0.34.dev1/prompture/drivers/async_registry.py

@@ -0,0 +1,80 @@
+"""Async driver registry — mirrors the sync DRIVER_REGISTRY."""
+
+from __future__ import annotations
+
+from ..settings import settings
+from .async_airllm_driver import AsyncAirLLMDriver
+from .async_azure_driver import AsyncAzureDriver
+from .async_claude_driver import AsyncClaudeDriver
+from .async_google_driver import AsyncGoogleDriver
+from .async_grok_driver import AsyncGrokDriver
+from .async_groq_driver import AsyncGroqDriver
+from .async_lmstudio_driver import AsyncLMStudioDriver
+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
+
+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
+    ),
+    "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
+    ),
+    "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,
+    ),
+}
+
+
+def get_async_driver(provider_name: str | None = None):
+    """Factory to get an async driver instance based on the provider name.
+
+    Uses default model from settings if not overridden.
+    """
+    provider = (provider_name or settings.ai_provider or "ollama").strip().lower()
+    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):
+    """Factory to get an async driver instance based on a full model string.
+
+    Format: ``provider/model_id``
+    Example: ``"openai/gpt-4-turbo-preview"``
+    """
+    if not isinstance(model_str, str):
+        raise ValueError("Model string must be a string, got {type(model_str)}")
+
+    if not model_str:
+        raise ValueError("Model string cannot be empty")
+
+    parts = model_str.split("/", 1)
+    provider = parts[0].lower()
+    model_id = parts[1] if len(parts) > 1 else None
+
+    if provider not in ASYNC_DRIVER_REGISTRY:
+        raise ValueError(f"Unsupported provider '{provider}'")
+
+    return ASYNC_DRIVER_REGISTRY[provider](model_id)

{prompture-0.0.34 → prompture-0.0.34.dev1}/prompture.egg-info/PKG-INFO

@@ -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 → prompture-0.0.34.dev1}/prompture.egg-info/SOURCES.txt

@@ -104,5 +104,4 @@ prompture/drivers/lmstudio_driver.py
 prompture/drivers/local_http_driver.py
 prompture/drivers/ollama_driver.py
 prompture/drivers/openai_driver.py
-prompture/drivers/openrouter_driver.py
-prompture/drivers/registry.py
+prompture/drivers/openrouter_driver.py

{prompture-0.0.34 → prompture-0.0.34.dev1}/pyproject.toml

@@ -45,15 +45,6 @@ prompture = "prompture.cli:cli"
 [project.urls]
 Homepage = "https://github.com/jhd3197/prompture"
 
-# Entry point groups for plugin driver discovery
-# Third-party packages can register drivers by defining entry points in these groups:
-#
-# [project.entry-points."prompture.drivers"]
-# my_provider = "my_package.drivers:create_driver"
-#
-# [project.entry-points."prompture.async_drivers"]
-# my_provider = "my_package.drivers:create_async_driver"
-
 [tool.setuptools.packages.find]
 include = ["prompture*"]
 exclude = ["prompture-env*"]

prompture-0.0.34/VERSION

@@ -1 +0,0 @@
-0.0.34

prompture-0.0.34/prompture/drivers/__init__.py

@@ -1,224 +0,0 @@
-"""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
-from .airllm_driver import AirLLMDriver
-from .async_airllm_driver import AsyncAirLLMDriver
-from .async_azure_driver import AsyncAzureDriver
-from .async_claude_driver import AsyncClaudeDriver
-from .async_google_driver import AsyncGoogleDriver
-from .async_grok_driver import AsyncGrokDriver
-from .async_groq_driver import AsyncGroqDriver
-from .async_hugging_driver import AsyncHuggingFaceDriver
-from .async_lmstudio_driver import AsyncLMStudioDriver
-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 .async_registry import ASYNC_DRIVER_REGISTRY, get_async_driver, get_async_driver_for_model
-from .azure_driver import AzureDriver
-from .claude_driver import ClaudeDriver
-from .google_driver import GoogleDriver
-from .grok_driver import GrokDriver
-from .groq_driver import GroqDriver
-from .lmstudio_driver import LMStudioDriver
-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(
-        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(
-        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):
-    """
-    Factory to get a driver instance based on the provider name (legacy style).
-    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
-
-
-def get_driver_for_model(model_str: str):
-    """
-    Factory to get a driver instance based on a full model string.
-    Format: provider/model_id
-    Example: "openai/gpt-4-turbo-preview"
-
-    Args:
-        model_str: Model identifier string. Can be either:
-                   - Full format: "provider/model" (e.g. "openai/gpt-4")
-                   - Provider only: "provider" (e.g. "openai")
-
-    Returns:
-        A configured driver instance for the specified provider/model.
-
-    Raises:
-        ValueError: If provider is invalid or format is incorrect.
-    """
-    if not isinstance(model_str, str):
-        raise ValueError("Model string must be a string, got {type(model_str)}")
-
-    if not model_str:
-        raise ValueError("Model string cannot be empty")
-
-    # Extract provider and model ID
-    parts = model_str.split("/", 1)
-    provider = parts[0].lower()
-    model_id = parts[1] if len(parts) > 1 else None
-
-    # Get factory (validates provider exists)
-    factory = get_driver_factory(provider)
-
-    # Create driver with model ID if provided, otherwise use default
-    return factory(model_id)
-
-
-__all__ = [
-    "ASYNC_DRIVER_REGISTRY",
-    # Legacy registry dicts (for backwards compatibility)
-    "DRIVER_REGISTRY",
-    # Sync drivers
-    "AirLLMDriver",
-    # Async drivers
-    "AsyncAirLLMDriver",
-    "AsyncAzureDriver",
-    "AsyncClaudeDriver",
-    "AsyncGoogleDriver",
-    "AsyncGrokDriver",
-    "AsyncGroqDriver",
-    "AsyncHuggingFaceDriver",
-    "AsyncLMStudioDriver",
-    "AsyncLocalHTTPDriver",
-    "AsyncOllamaDriver",
-    "AsyncOpenAIDriver",
-    "AsyncOpenRouterDriver",
-    "AzureDriver",
-    "ClaudeDriver",
-    "GoogleDriver",
-    "GrokDriver",
-    "GroqDriver",
-    "LMStudioDriver",
-    "LocalHTTPDriver",
-    "OllamaDriver",
-    "OpenAIDriver",
-    "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-0.0.34/prompture/drivers/async_registry.py

@@ -1,129 +0,0 @@
-"""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"
-"""
-
-from __future__ import annotations
-
-from ..settings import settings
-from .async_airllm_driver import AsyncAirLLMDriver
-from .async_azure_driver import AsyncAzureDriver
-from .async_claude_driver import AsyncClaudeDriver
-from .async_google_driver import AsyncGoogleDriver
-from .async_grok_driver import AsyncGrokDriver
-from .async_groq_driver import AsyncGroqDriver
-from .async_lmstudio_driver import AsyncLMStudioDriver
-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(
-        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(
-        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(
-        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):
-    """Factory to get an async driver instance based on the provider name.
-
-    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()
-
-
-def get_async_driver_for_model(model_str: str):
-    """Factory to get an async driver instance based on a full model string.
-
-    Format: ``provider/model_id``
-    Example: ``"openai/gpt-4-turbo-preview"``
-    """
-    if not isinstance(model_str, str):
-        raise ValueError("Model string must be a string, got {type(model_str)}")
-
-    if not model_str:
-        raise ValueError("Model string cannot be empty")
-
-    parts = model_str.split("/", 1)
-    provider = parts[0].lower()
-    model_id = parts[1] if len(parts) > 1 else None
-
-    factory = get_async_driver_factory(provider)
-    return factory(model_id)