prompture 0.0.33.dev2__py3-none-any.whl → 0.0.34.dev1__py3-none-any.whl

prompture/cost_mixin.py

@@ -0,0 +1,51 @@
+"""Shared cost-calculation mixin for LLM drivers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class CostMixin:
+    """Mixin that provides ``_calculate_cost`` to sync and async drivers.
+
+    Drivers that charge per-token should inherit from this mixin alongside
+    their base class (``Driver`` or ``AsyncDriver``).  Free/local drivers
+    (Ollama, LM Studio, LocalHTTP, HuggingFace, AirLLM) can skip it.
+    """
+
+    # Subclasses must define MODEL_PRICING as a class attribute.
+    MODEL_PRICING: dict[str, dict[str, Any]] = {}
+
+    # Divisor for hardcoded MODEL_PRICING rates.
+    # Most drivers use per-1K-token pricing (1_000).
+    # Grok uses per-1M-token pricing (1_000_000).
+    # Google uses per-1M-character pricing (1_000_000).
+    _PRICING_UNIT: int = 1_000
+
+    def _calculate_cost(
+        self,
+        provider: str,
+        model: str,
+        prompt_tokens: int | float,
+        completion_tokens: int | float,
+    ) -> float:
+        """Calculate USD cost for a generation call.
+
+        Resolution order:
+        1. Live rates from ``model_rates.get_model_rates()`` (per 1M tokens).
+        2. Hardcoded ``MODEL_PRICING`` on the driver class (unit set by ``_PRICING_UNIT``).
+        3. Zero if neither source has data.
+        """
+        from .model_rates import get_model_rates
+
+        live_rates = get_model_rates(provider, model)
+        if live_rates:
+            prompt_cost = (prompt_tokens / 1_000_000) * live_rates["input"]
+            completion_cost = (completion_tokens / 1_000_000) * live_rates["output"]
+        else:
+            unit = self._PRICING_UNIT
+            model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
+            prompt_cost = (prompt_tokens / unit) * model_pricing["prompt"]
+            completion_cost = (completion_tokens / unit) * model_pricing["completion"]
+
+        return round(prompt_cost + completion_cost, 6)

prompture/discovery.py

@@ -1,39 +1,40 @@
 """Discovery module for auto-detecting available models."""
+
+import logging
 import os
+
 import requests
-import logging
-from typing import List, Dict, Any, Set
 
 from .drivers import (
-    DRIVER_REGISTRY,
-    OpenAIDriver,
     AzureDriver,
     ClaudeDriver,
     GoogleDriver,
-    GroqDriver,
-    OpenRouterDriver,
     GrokDriver,
-    OllamaDriver,
+    GroqDriver,
     LMStudioDriver,
     LocalHTTPDriver,
+    OllamaDriver,
+    OpenAIDriver,
+    OpenRouterDriver,
 )
 from .settings import settings
 
 logger = logging.getLogger(__name__)
 
-def get_available_models() -> List[str]:
+
+def get_available_models() -> list[str]:
     """
     Auto-detects all available models based on configured drivers and environment variables.
-    
+
     Iterates through supported providers and checks if they are configured (e.g. API key present).
     For static drivers, returns models from their MODEL_PRICING keys.
     For dynamic drivers (like Ollama), attempts to fetch available models from the endpoint.
-    
+
     Returns:
         A list of unique model strings in the format "provider/model_id".
     """
-    available_models: Set[str] = set()
-    configured_providers: Set[str] = set()
+    available_models: set[str] = set()
+    configured_providers: set[str] = set()
 
     # Map of provider name to driver class
     # We need to map the registry keys to the actual classes to check MODEL_PRICING
@@ -57,16 +58,18 @@ def get_available_models() -> List[str]:
             # We can check this by looking at the settings or env vars that the driver uses.
             # A simple way is to try to instantiate it with defaults, but that might fail if keys are missing.
             # Instead, let's check the specific requirements for each known provider.
-            
+
             is_configured = False
-            
+
             if provider == "openai":
                 if settings.openai_api_key or os.getenv("OPENAI_API_KEY"):
                     is_configured = True
             elif provider == "azure":
-                if (settings.azure_api_key or os.getenv("AZURE_API_KEY")) and \
-                   (settings.azure_api_endpoint or os.getenv("AZURE_API_ENDPOINT")) and \
-                   (settings.azure_deployment_id or os.getenv("AZURE_DEPLOYMENT_ID")):
+                if (
+                    (settings.azure_api_key or os.getenv("AZURE_API_KEY"))
+                    and (settings.azure_api_endpoint or os.getenv("AZURE_API_ENDPOINT"))
+                    and (settings.azure_deployment_id or os.getenv("AZURE_DEPLOYMENT_ID"))
+                ):
                     is_configured = True
             elif provider == "claude":
                 if settings.claude_api_key or os.getenv("CLAUDE_API_KEY"):
@@ -88,11 +91,10 @@ def get_available_models() -> List[str]:
                 # We will check connectivity later
                 is_configured = True
             elif provider == "lmstudio":
-                 # LM Studio is similar to Ollama, defaults to localhost
-                 is_configured = True
-            elif provider == "local_http":
-                 if settings.local_http_endpoint or os.getenv("LOCAL_HTTP_ENDPOINT"):
-                     is_configured = True
+                # LM Studio is similar to Ollama, defaults to localhost
+                is_configured = True
+            elif provider == "local_http" and (settings.local_http_endpoint or os.getenv("LOCAL_HTTP_ENDPOINT")):
+                is_configured = True
 
             if not is_configured:
                 continue
@@ -102,34 +104,36 @@ def get_available_models() -> List[str]:
             # 2. Static Detection: Get models from MODEL_PRICING
             if hasattr(driver_cls, "MODEL_PRICING"):
                 pricing = driver_cls.MODEL_PRICING
-                for model_id in pricing.keys():
+                for model_id in pricing:
                     # Skip "default" or generic keys if they exist
                     if model_id == "default":
                         continue
-                    
-                    # For Azure, the model_id in pricing is usually the base model name, 
-                    # but the user needs to use the deployment ID. 
-                    # However, our Azure driver implementation uses the deployment_id from init 
-                    # as the "model" for the request, but expects the user to pass a model name 
-                    # that maps to pricing? 
+
+                    # For Azure, the model_id in pricing is usually the base model name,
+                    # but the user needs to use the deployment ID.
+                    # However, our Azure driver implementation uses the deployment_id from init
+                    # as the "model" for the request, but expects the user to pass a model name
+                    # that maps to pricing?
                     # Looking at AzureDriver:
                     # kwargs = {"model": self.deployment_id, ...}
                     # model = options.get("model", self.model) -> used for pricing lookup
-                    # So we should list the keys in MODEL_PRICING as available "models" 
+                    # So we should list the keys in MODEL_PRICING as available "models"
                     # even though for Azure specifically it's a bit weird because of deployment IDs.
                     # But for general discovery, listing supported models is correct.
-                    
+
                     available_models.add(f"{provider}/{model_id}")
 
             # 3. Dynamic Detection: Specific logic for Ollama
             if provider == "ollama":
                 try:
-                    endpoint = settings.ollama_endpoint or os.getenv("OLLAMA_ENDPOINT", "http://localhost:11434/api/generate")
+                    endpoint = settings.ollama_endpoint or os.getenv(
+                        "OLLAMA_ENDPOINT", "http://localhost:11434/api/generate"
+                    )
                     # We need the base URL for tags, usually http://localhost:11434/api/tags
                     # The configured endpoint might be .../api/generate or .../api/chat
                     base_url = endpoint.split("/api/")[0]
                     tags_url = f"{base_url}/api/tags"
-                    
+
                     resp = requests.get(tags_url, timeout=2)
                     if resp.status_code == 200:
                         data = resp.json()
@@ -142,15 +146,16 @@ def get_available_models() -> List[str]:
                                 available_models.add(f"ollama/{name}")
                 except Exception as e:
                     logger.debug(f"Failed to fetch Ollama models: {e}")
-            
+
             # Future: Add dynamic detection for LM Studio if they have an endpoint for listing models
-            
+
         except Exception as e:
             logger.warning(f"Error detecting models for provider {provider}: {e}")
             continue
 
     # Enrich with live model list from models.dev cache
-    from .model_rates import get_all_provider_models, PROVIDER_MAP
+    from .model_rates import PROVIDER_MAP, get_all_provider_models
+
     for prompture_name, api_name in PROVIDER_MAP.items():
         if prompture_name in configured_providers:
             for model_id in get_all_provider_models(api_name):

prompture/driver.py

@@ -1,7 +1,15 @@
-"""Driver base class for LLM adapters.
-"""
+"""Driver base class for LLM adapters."""
+
 from __future__ import annotations
-from typing import Any, Dict
+
+import logging
+import time
+from typing import Any
+
+from .callbacks import DriverCallbacks
+
+logger = logging.getLogger("prompture.driver")
+
 
 class Driver:
     """Adapter base. Implementar generate(prompt, options) -> {"text": ... , "meta": {...}}
@@ -20,5 +28,117 @@ class Driver:
     additional provider-specific metadata while the core fields provide
     standardized access to token usage and cost information.
     """
-    def generate(self, prompt: str, options: Dict[str,Any]) -> Dict[str,Any]:
-        raise NotImplementedError
+
+    supports_json_mode: bool = False
+    supports_json_schema: bool = False
+    supports_messages: bool = False
+
+    callbacks: DriverCallbacks | None = None
+
+    def generate(self, prompt: str, options: dict[str, Any]) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def generate_messages(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
+        """Generate a response from a list of conversation messages.
+
+        Each message is a dict with ``"role"`` (``"system"``, ``"user"``, or
+        ``"assistant"``) and ``"content"`` keys.
+
+        The default implementation flattens the messages into a single prompt
+        string and delegates to :meth:`generate`.  Drivers that natively
+        support message arrays should override this method and set
+        ``supports_messages = True``.
+        """
+        prompt = self._flatten_messages(messages)
+        return self.generate(prompt, options)
+
+    # ------------------------------------------------------------------
+    # Hook-aware wrappers
+    # ------------------------------------------------------------------
+
+    def generate_with_hooks(self, prompt: str, options: dict[str, Any]) -> dict[str, Any]:
+        """Wrap :meth:`generate` with on_request / on_response / on_error callbacks."""
+        driver_name = getattr(self, "model", self.__class__.__name__)
+        self._fire_callback(
+            "on_request",
+            {"prompt": prompt, "messages": None, "options": options, "driver": driver_name},
+        )
+        t0 = time.perf_counter()
+        try:
+            resp = self.generate(prompt, options)
+        except Exception as exc:
+            self._fire_callback(
+                "on_error",
+                {"error": exc, "prompt": prompt, "messages": None, "options": options, "driver": driver_name},
+            )
+            raise
+        elapsed_ms = (time.perf_counter() - t0) * 1000
+        self._fire_callback(
+            "on_response",
+            {
+                "text": resp.get("text", ""),
+                "meta": resp.get("meta", {}),
+                "driver": driver_name,
+                "elapsed_ms": elapsed_ms,
+            },
+        )
+        return resp
+
+    def generate_messages_with_hooks(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
+        """Wrap :meth:`generate_messages` with callbacks."""
+        driver_name = getattr(self, "model", self.__class__.__name__)
+        self._fire_callback(
+            "on_request",
+            {"prompt": None, "messages": messages, "options": options, "driver": driver_name},
+        )
+        t0 = time.perf_counter()
+        try:
+            resp = self.generate_messages(messages, options)
+        except Exception as exc:
+            self._fire_callback(
+                "on_error",
+                {"error": exc, "prompt": None, "messages": messages, "options": options, "driver": driver_name},
+            )
+            raise
+        elapsed_ms = (time.perf_counter() - t0) * 1000
+        self._fire_callback(
+            "on_response",
+            {
+                "text": resp.get("text", ""),
+                "meta": resp.get("meta", {}),
+                "driver": driver_name,
+                "elapsed_ms": elapsed_ms,
+            },
+        )
+        return resp
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _fire_callback(self, event: str, payload: dict[str, Any]) -> None:
+        """Invoke a single callback, swallowing and logging any exception."""
+        if self.callbacks is None:
+            return
+        cb = getattr(self.callbacks, event, None)
+        if cb is None:
+            return
+        try:
+            cb(payload)
+        except Exception:
+            logger.exception("Callback %s raised an exception", event)
+
+    @staticmethod
+    def _flatten_messages(messages: list[dict[str, str]]) -> str:
+        """Join messages into a single prompt string with role prefixes."""
+        parts: list[str] = []
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            if role == "system":
+                parts.append(f"[System]: {content}")
+            elif role == "assistant":
+                parts.append(f"[Assistant]: {content}")
+            else:
+                parts.append(f"[User]: {content}")
+        return "\n\n".join(parts)

prompture/drivers/__init__.py

@@ -1,60 +1,49 @@
-from .openai_driver import OpenAIDriver
-from .local_http_driver import LocalHTTPDriver
-from .ollama_driver import OllamaDriver
-from .claude_driver import ClaudeDriver
+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 .lmstudio_driver import LMStudioDriver
+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 .grok_driver import GrokDriver
-from .airllm_driver import AirLLMDriver
-from ..settings import settings
-
 
 # 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
-    ),
+    "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
+        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
+        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
+        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,
@@ -62,7 +51,7 @@ DRIVER_REGISTRY = {
 }
 
 
-def get_driver(provider_name: str = None):
+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.
@@ -78,21 +67,21 @@ 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")
 
@@ -104,23 +93,40 @@ def get_driver_for_model(model_str: str):
     # 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__ = [
-    "OpenAIDriver",
-    "LocalHTTPDriver",
-    "OllamaDriver",
-    "ClaudeDriver",
-    "LMStudioDriver",
+    # 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",
-    "GrokDriver",
-    "AirLLMDriver",
+    "get_async_driver",
+    "get_async_driver_for_model",
     "get_driver",
     "get_driver_for_model",
 ]

prompture/drivers/airllm_driver.py

@@ -1,6 +1,7 @@
 import logging
+from typing import Any, Optional
+
 from ..driver import Driver
-from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -13,12 +14,9 @@ class AirLLMDriver(Driver):
     ``generate()`` call so the rest of Prompture works without it installed.
     """
 
-    MODEL_PRICING = {
-        "default": {"prompt": 0.0, "completion": 0.0}
-    }
+    MODEL_PRICING = {"default": {"prompt": 0.0, "completion": 0.0}}
 
-    def __init__(self, model: str = "meta-llama/Llama-2-7b-hf",
-                 compression: Optional[str] = None):
+    def __init__(self, model: str = "meta-llama/Llama-2-7b-hf", compression: Optional[str] = None):
         """
         Args:
             model: HuggingFace repo ID (e.g. ``"meta-llama/Llama-2-70b-hf"``).
@@ -26,7 +24,7 @@ class AirLLMDriver(Driver):
         """
         self.model = model
         self.compression = compression
-        self.options: Dict[str, Any] = {}
+        self.options: dict[str, Any] = {}
         self._llm = None
         self._tokenizer = None
 
@@ -42,9 +40,8 @@ class AirLLMDriver(Driver):
             from airllm import AutoModel
         except ImportError:
             raise ImportError(
-                "The 'airllm' package is required for the AirLLM driver. "
-                "Install it with: pip install prompture[airllm]"
-            )
+                "The 'airllm' package is required for the AirLLM driver. Install it with: pip install prompture[airllm]"
+            ) from None
 
         try:
             from transformers import AutoTokenizer
@@ -52,12 +49,11 @@ class AirLLMDriver(Driver):
             raise ImportError(
                 "The 'transformers' package is required for the AirLLM driver. "
                 "Install it with: pip install transformers"
-            )
+            ) from None
 
-        logger.info(f"Loading AirLLM model: {self.model} "
-                     f"(compression={self.compression})")
+        logger.info(f"Loading AirLLM model: {self.model} (compression={self.compression})")
 
-        load_kwargs: Dict[str, Any] = {}
+        load_kwargs: dict[str, Any] = {}
         if self.compression:
             load_kwargs["compression"] = self.compression
 
@@ -68,7 +64,7 @@ class AirLLMDriver(Driver):
     # ------------------------------------------------------------------
     # Driver interface
     # ------------------------------------------------------------------
-    def generate(self, prompt: str, options: Dict[str, Any] = None) -> Dict[str, Any]:
+    def generate(self, prompt: str, options: Optional[dict[str, Any]] = None) -> dict[str, Any]:
         self._ensure_loaded()
 
         merged_options = self.options.copy()
@@ -78,14 +74,11 @@ class AirLLMDriver(Driver):
         max_new_tokens = merged_options.get("max_new_tokens", 256)
 
         # Tokenize
-        input_ids = self._tokenizer(
-            prompt, return_tensors="pt"
-        ).input_ids
+        input_ids = self._tokenizer(prompt, return_tensors="pt").input_ids
 
         prompt_tokens = input_ids.shape[1]
 
-        logger.debug(f"AirLLM generating with max_new_tokens={max_new_tokens}, "
-                      f"prompt_tokens={prompt_tokens}")
+        logger.debug(f"AirLLM generating with max_new_tokens={max_new_tokens}, prompt_tokens={prompt_tokens}")
 
         # Generate
         output_ids = self._llm.generate(

prompture/drivers/async_airllm_driver.py

@@ -0,0 +1,26 @@
+"""Async AirLLM driver — wraps the sync GPU-bound driver with asyncio.to_thread."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from ..async_driver import AsyncDriver
+from .airllm_driver import AirLLMDriver
+
+
+class AsyncAirLLMDriver(AsyncDriver):
+    """Async wrapper around :class:`AirLLMDriver`.
+
+    AirLLM is GPU-bound with no native async API, so we delegate to
+    ``asyncio.to_thread()`` to avoid blocking the event loop.
+    """
+
+    MODEL_PRICING = AirLLMDriver.MODEL_PRICING
+
+    def __init__(self, model: str = "meta-llama/Llama-2-7b-hf", compression: str | None = None):
+        self.model = model
+        self._sync_driver = AirLLMDriver(model=model, compression=compression)
+
+    async def generate(self, prompt: str, options: dict[str, Any] | None = None) -> dict[str, Any]:
+        return await asyncio.to_thread(self._sync_driver.generate, prompt, options)