prompture 0.0.38.dev2__tar.gz → 0.0.39__tar.gz

{prompture-0.0.38.dev2/prompture.egg-info → prompture-0.0.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.38.dev2
+Version: 0.0.39
 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.39/VERSION

@@ -0,0 +1 @@
+0.0.39

{prompture-0.0.38.dev2 → prompture-0.0.39}/prompture/__init__.py

@@ -111,7 +111,13 @@ from .image import (
     make_image,
 )
 from .logging import JSONFormatter, configure_logging
-from .model_rates import get_model_info, get_model_rates, refresh_rates_cache
+from .model_rates import (
+    ModelCapabilities,
+    get_model_capabilities,
+    get_model_info,
+    get_model_rates,
+    refresh_rates_cache,
+)
 from .persistence import ConversationStore
 from .persona import (
     PERSONAS,
@@ -213,6 +219,7 @@ __all__ = [
     "LocalHTTPDriver",
     "LoopGroup",
     "MemoryCacheBackend",
+    "ModelCapabilities",
     "ModelRetry",
     "OllamaDriver",
     "OpenAIDriver",
@@ -255,6 +262,7 @@ __all__ = [
     "get_driver_for_model",
     "get_field_definition",
     "get_field_names",
+    "get_model_capabilities",
     "get_model_info",
     "get_model_rates",
     "get_persona",

{prompture-0.0.38.dev2 → prompture-0.0.39}/prompture/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.38.dev2'
-__version_tuple__ = version_tuple = (0, 0, 38, 'dev2')
+__version__ = version = '0.0.39'
+__version_tuple__ = version_tuple = (0, 0, 39)
 
 __commit_id__ = commit_id = None

{prompture-0.0.38.dev2 → prompture-0.0.39}/prompture/async_driver.py

@@ -166,6 +166,45 @@ class AsyncDriver:
         except Exception:
             logger.exception("Callback %s raised an exception", event)
 
+    def _validate_model_capabilities(
+        self,
+        provider: str,
+        model: str,
+        *,
+        using_tool_use: bool = False,
+        using_json_schema: bool = False,
+        using_vision: bool = False,
+    ) -> None:
+        """Log warnings when the model may not support a requested feature.
+
+        Uses models.dev metadata as a secondary signal.  Warnings only — the
+        API is the final authority and models.dev data may be stale.
+        """
+        from .model_rates import get_model_capabilities
+
+        caps = get_model_capabilities(provider, model)
+        if caps is None:
+            return
+
+        if using_tool_use and caps.supports_tool_use is False:
+            logger.warning(
+                "Model %s/%s may not support tool use according to models.dev metadata",
+                provider,
+                model,
+            )
+        if using_json_schema and caps.supports_structured_output is False:
+            logger.warning(
+                "Model %s/%s may not support structured output / JSON schema according to models.dev metadata",
+                provider,
+                model,
+            )
+        if using_vision and caps.supports_vision is False:
+            logger.warning(
+                "Model %s/%s may not support vision/image inputs according to models.dev metadata",
+                provider,
+                model,
+            )
+
     def _check_vision_support(self, messages: list[dict[str, Any]]) -> None:
         """Raise if messages contain image blocks and the driver lacks vision support."""
         if self.supports_vision:

{prompture-0.0.38.dev2 → prompture-0.0.39}/prompture/cost_mixin.py

@@ -49,3 +49,40 @@ class CostMixin:
             completion_cost = (completion_tokens / unit) * model_pricing["completion"]
 
         return round(prompt_cost + completion_cost, 6)
+
+    def _get_model_config(self, provider: str, model: str) -> dict[str, Any]:
+        """Merge live models.dev capabilities with hardcoded ``MODEL_PRICING``.
+
+        Returns a dict with:
+        - ``tokens_param`` — always from hardcoded ``MODEL_PRICING`` (API-specific)
+        - ``supports_temperature`` — prefers live data, falls back to hardcoded, default ``True``
+        - ``context_window`` — from live data only (``None`` if unavailable)
+        - ``max_output_tokens`` — from live data only (``None`` if unavailable)
+        """
+        from .model_rates import get_model_capabilities
+
+        hardcoded = self.MODEL_PRICING.get(model, {})
+
+        # tokens_param is always from hardcoded config (API-specific, not in models.dev)
+        tokens_param = hardcoded.get("tokens_param", "max_tokens")
+
+        # Start with hardcoded supports_temperature, default True
+        supports_temperature = hardcoded.get("supports_temperature", True)
+
+        context_window: int | None = None
+        max_output_tokens: int | None = None
+
+        # Override with live data when available
+        caps = get_model_capabilities(provider, model)
+        if caps is not None:
+            if caps.supports_temperature is not None:
+                supports_temperature = caps.supports_temperature
+            context_window = caps.context_window
+            max_output_tokens = caps.max_output_tokens
+
+        return {
+            "tokens_param": tokens_param,
+            "supports_temperature": supports_temperature,
+            "context_window": context_window,
+            "max_output_tokens": max_output_tokens,
+        }

{prompture-0.0.38.dev2 → prompture-0.0.39}/prompture/discovery.py

@@ -1,7 +1,11 @@
 """Discovery module for auto-detecting available models."""
 
+from __future__ import annotations
+
+import dataclasses
 import logging
 import os
+from typing import Any, overload
 
 import requests
 
@@ -22,23 +26,34 @@ from .settings import settings
 logger = logging.getLogger(__name__)
 
 
-def get_available_models() -> list[str]:
-    """
-    Auto-detects all available models based on configured drivers and environment variables.
+@overload
+def get_available_models(*, include_capabilities: bool = False) -> list[str]: ...
+
+
+@overload
+def get_available_models(*, include_capabilities: bool = True) -> list[dict[str, Any]]: ...
 
-    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.
+
+def get_available_models(*, include_capabilities: bool = False) -> list[str] | list[dict[str, Any]]:
+    """Auto-detect 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.
+
+    Args:
+        include_capabilities: When ``True``, return enriched dicts with
+            ``model``, ``provider``, ``model_id``, and ``capabilities``
+            fields instead of plain ``"provider/model_id"`` strings.
 
     Returns:
-        A list of unique model strings in the format "provider/model_id".
+        A sorted list of unique model strings (default) or enriched dicts.
     """
     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
-    # and instantiate for dynamic checks if needed.
     provider_classes = {
         "openai": OpenAIDriver,
         "azure": AzureDriver,
@@ -54,11 +69,6 @@ def get_available_models() -> list[str]:
 
     for provider, driver_cls in provider_classes.items():
         try:
-            # 1. Check if the provider is configured (has API key or endpoint)
-            # 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":
@@ -87,13 +97,10 @@ def get_available_models() -> list[str]:
                 if settings.grok_api_key or os.getenv("GROK_API_KEY"):
                     is_configured = True
             elif provider == "ollama":
-                # Ollama is always considered "configured" as it defaults to localhost
-                # 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" and (settings.local_http_endpoint or os.getenv("LOCAL_HTTP_ENDPOINT")):
+            elif provider == "local_http" and os.getenv("LOCAL_HTTP_ENDPOINT"):
                 is_configured = True
 
             if not is_configured:
@@ -101,36 +108,20 @@ def get_available_models() -> list[str]:
 
             configured_providers.add(provider)
 
-            # 2. Static Detection: Get models from MODEL_PRICING
+            # Static Detection: Get models from MODEL_PRICING
             if hasattr(driver_cls, "MODEL_PRICING"):
                 pricing = driver_cls.MODEL_PRICING
                 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?
-                    # 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"
-                    # 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
+            # Dynamic Detection: Specific logic for Ollama
             if provider == "ollama":
                 try:
                     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"
 
@@ -141,8 +132,6 @@ def get_available_models() -> list[str]:
                         for model in models:
                             name = model.get("name")
                             if name:
-                                # Ollama model names often include tags like "llama3:latest"
-                                # We can keep them as is.
                                 available_models.add(f"ollama/{name}")
                 except Exception as e:
                     logger.debug(f"Failed to fetch Ollama models: {e}")
@@ -184,4 +173,30 @@ def get_available_models() -> list[str]:
             for model_id in get_all_provider_models(api_name):
                 available_models.add(f"{prompture_name}/{model_id}")
 
-    return sorted(list(available_models))
+    sorted_models = sorted(available_models)
+
+    if not include_capabilities:
+        return sorted_models
+
+    # Build enriched dicts with capabilities from models.dev
+    from .model_rates import get_model_capabilities
+
+    enriched: list[dict[str, Any]] = []
+    for model_str in sorted_models:
+        parts = model_str.split("/", 1)
+        provider = parts[0]
+        model_id = parts[1] if len(parts) > 1 else parts[0]
+
+        caps = get_model_capabilities(provider, model_id)
+        caps_dict = dataclasses.asdict(caps) if caps is not None else None
+
+        enriched.append(
+            {
+                "model": model_str,
+                "provider": provider,
+                "model_id": model_id,
+                "capabilities": caps_dict,
+            }
+        )
+
+    return enriched

{prompture-0.0.38.dev2 → prompture-0.0.39}/prompture/driver.py

@@ -173,6 +173,45 @@ class Driver:
         except Exception:
             logger.exception("Callback %s raised an exception", event)
 
+    def _validate_model_capabilities(
+        self,
+        provider: str,
+        model: str,
+        *,
+        using_tool_use: bool = False,
+        using_json_schema: bool = False,
+        using_vision: bool = False,
+    ) -> None:
+        """Log warnings when the model may not support a requested feature.
+
+        Uses models.dev metadata as a secondary signal.  Warnings only — the
+        API is the final authority and models.dev data may be stale.
+        """
+        from .model_rates import get_model_capabilities
+
+        caps = get_model_capabilities(provider, model)
+        if caps is None:
+            return
+
+        if using_tool_use and caps.supports_tool_use is False:
+            logger.warning(
+                "Model %s/%s may not support tool use according to models.dev metadata",
+                provider,
+                model,
+            )
+        if using_json_schema and caps.supports_structured_output is False:
+            logger.warning(
+                "Model %s/%s may not support structured output / JSON schema according to models.dev metadata",
+                provider,
+                model,
+            )
+        if using_vision and caps.supports_vision is False:
+            logger.warning(
+                "Model %s/%s may not support vision/image inputs according to models.dev metadata",
+                provider,
+                model,
+            )
+
     def _check_vision_support(self, messages: list[dict[str, Any]]) -> None:
         """Raise if messages contain image blocks and the driver lacks vision support."""
         if self.supports_vision:

{prompture-0.0.38.dev2 → prompture-0.0.39}/prompture/drivers/async_azure_driver.py

@@ -70,9 +70,9 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
             raise RuntimeError("openai package (>=1.0.0) with AsyncAzureOpenAI not installed")
 
         model = options.get("model", self.model)
-        model_info = self.MODEL_PRICING.get(model, {})
-        tokens_param = model_info.get("tokens_param", "max_tokens")
-        supports_temperature = model_info.get("supports_temperature", True)
+        model_config = self._get_model_config("azure", model)
+        tokens_param = model_config["tokens_param"]
+        supports_temperature = model_config["supports_temperature"]
 
         opts = {"temperature": 1.0, "max_tokens": 512, **options}
 
@@ -113,7 +113,7 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
             "prompt_tokens": prompt_tokens,
             "completion_tokens": completion_tokens,
             "total_tokens": total_tokens,
-            "cost": total_cost,
+            "cost": round(total_cost, 6),
             "raw_response": resp.model_dump(),
             "model_name": model,
             "deployment_id": self.deployment_id,

prompture-0.0.39/prompture/drivers/async_claude_driver.py

@@ -0,0 +1,282 @@
+"""Async Anthropic Claude driver. Requires the ``anthropic`` package."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import AsyncIterator
+from typing import Any
+
+try:
+    import anthropic
+except Exception:
+    anthropic = None
+
+from ..async_driver import AsyncDriver
+from ..cost_mixin import CostMixin
+from .claude_driver import ClaudeDriver
+
+
+class AsyncClaudeDriver(CostMixin, AsyncDriver):
+    supports_json_mode = True
+    supports_json_schema = True
+    supports_tool_use = True
+    supports_streaming = True
+    supports_vision = True
+
+    MODEL_PRICING = ClaudeDriver.MODEL_PRICING
+
+    def __init__(self, api_key: str | None = None, model: str = "claude-3-5-haiku-20241022"):
+        self.api_key = api_key or os.getenv("CLAUDE_API_KEY")
+        self.model = model or os.getenv("CLAUDE_MODEL_NAME", "claude-3-5-haiku-20241022")
+
+    supports_messages = True
+
+    def _prepare_messages(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        from .vision_helpers import _prepare_claude_vision_messages
+
+        return _prepare_claude_vision_messages(messages)
+
+    async def generate(self, prompt: str, options: dict[str, Any]) -> dict[str, Any]:
+        messages = [{"role": "user", "content": prompt}]
+        return await self._do_generate(messages, options)
+
+    async def generate_messages(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
+        return await self._do_generate(self._prepare_messages(messages), options)
+
+    async def _do_generate(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
+        if anthropic is None:
+            raise RuntimeError("anthropic package not installed")
+
+        opts = {**{"temperature": 0.0, "max_tokens": 512}, **options}
+        model = options.get("model", self.model)
+
+        # Validate capabilities against models.dev metadata
+        self._validate_model_capabilities(
+            "claude",
+            model,
+            using_json_schema=bool(options.get("json_schema")),
+        )
+
+        client = anthropic.AsyncAnthropic(api_key=self.api_key)
+
+        # Anthropic requires system messages as a top-level parameter
+        system_content, api_messages = self._extract_system_and_messages(messages)
+
+        # Build common kwargs
+        common_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": api_messages,
+            "temperature": opts["temperature"],
+            "max_tokens": opts["max_tokens"],
+        }
+        if system_content:
+            common_kwargs["system"] = system_content
+
+        # Native JSON mode: use tool-use for schema enforcement
+        if options.get("json_mode"):
+            json_schema = options.get("json_schema")
+            if json_schema:
+                tool_def = {
+                    "name": "extract_json",
+                    "description": "Extract structured data matching the schema",
+                    "input_schema": json_schema,
+                }
+                resp = await client.messages.create(
+                    **common_kwargs,
+                    tools=[tool_def],
+                    tool_choice={"type": "tool", "name": "extract_json"},
+                )
+                text = ""
+                for block in resp.content:
+                    if block.type == "tool_use":
+                        text = json.dumps(block.input)
+                        break
+            else:
+                resp = await client.messages.create(**common_kwargs)
+                text = resp.content[0].text
+        else:
+            resp = await client.messages.create(**common_kwargs)
+            text = resp.content[0].text
+
+        prompt_tokens = resp.usage.input_tokens
+        completion_tokens = resp.usage.output_tokens
+        total_tokens = prompt_tokens + completion_tokens
+
+        total_cost = self._calculate_cost("claude", model, prompt_tokens, completion_tokens)
+
+        meta = {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+            "cost": round(total_cost, 6),
+            "raw_response": dict(resp),
+            "model_name": model,
+        }
+
+        return {"text": text, "meta": meta}
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _extract_system_and_messages(
+        self, messages: list[dict[str, Any]]
+    ) -> tuple[str | None, list[dict[str, Any]]]:
+        """Separate system message from conversation messages for Anthropic API."""
+        system_content = None
+        api_messages: list[dict[str, Any]] = []
+        for msg in messages:
+            if msg.get("role") == "system":
+                system_content = msg.get("content", "")
+            else:
+                api_messages.append(msg)
+        return system_content, api_messages
+
+    # ------------------------------------------------------------------
+    # Tool use
+    # ------------------------------------------------------------------
+
+    async def generate_messages_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        options: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Generate a response that may include tool calls (Anthropic)."""
+        if anthropic is None:
+            raise RuntimeError("anthropic package not installed")
+
+        opts = {**{"temperature": 0.0, "max_tokens": 512}, **options}
+        model = options.get("model", self.model)
+
+        self._validate_model_capabilities("claude", model, using_tool_use=True)
+
+        client = anthropic.AsyncAnthropic(api_key=self.api_key)
+
+        system_content, api_messages = self._extract_system_and_messages(messages)
+
+        # Convert tools from OpenAI format to Anthropic format if needed
+        anthropic_tools = []
+        for t in tools:
+            if "type" in t and t["type"] == "function":
+                # OpenAI format -> Anthropic format
+                fn = t["function"]
+                anthropic_tools.append({
+                    "name": fn["name"],
+                    "description": fn.get("description", ""),
+                    "input_schema": fn.get("parameters", {"type": "object", "properties": {}}),
+                })
+            elif "input_schema" in t:
+                # Already Anthropic format
+                anthropic_tools.append(t)
+            else:
+                anthropic_tools.append(t)
+
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": api_messages,
+            "temperature": opts["temperature"],
+            "max_tokens": opts["max_tokens"],
+            "tools": anthropic_tools,
+        }
+        if system_content:
+            kwargs["system"] = system_content
+
+        resp = await client.messages.create(**kwargs)
+
+        prompt_tokens = resp.usage.input_tokens
+        completion_tokens = resp.usage.output_tokens
+        total_tokens = prompt_tokens + completion_tokens
+        total_cost = self._calculate_cost("claude", model, prompt_tokens, completion_tokens)
+
+        meta = {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+            "cost": round(total_cost, 6),
+            "raw_response": dict(resp),
+            "model_name": model,
+        }
+
+        text = ""
+        tool_calls_out: list[dict[str, Any]] = []
+        for block in resp.content:
+            if block.type == "text":
+                text += block.text
+            elif block.type == "tool_use":
+                tool_calls_out.append({
+                    "id": block.id,
+                    "name": block.name,
+                    "arguments": block.input,
+                })
+
+        return {
+            "text": text,
+            "meta": meta,
+            "tool_calls": tool_calls_out,
+            "stop_reason": resp.stop_reason,
+        }
+
+    # ------------------------------------------------------------------
+    # Streaming
+    # ------------------------------------------------------------------
+
+    async def generate_messages_stream(
+        self,
+        messages: list[dict[str, Any]],
+        options: dict[str, Any],
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Yield response chunks via Anthropic streaming API."""
+        if anthropic is None:
+            raise RuntimeError("anthropic package not installed")
+
+        opts = {**{"temperature": 0.0, "max_tokens": 512}, **options}
+        model = options.get("model", self.model)
+        client = anthropic.AsyncAnthropic(api_key=self.api_key)
+
+        system_content, api_messages = self._extract_system_and_messages(messages)
+
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": api_messages,
+            "temperature": opts["temperature"],
+            "max_tokens": opts["max_tokens"],
+        }
+        if system_content:
+            kwargs["system"] = system_content
+
+        full_text = ""
+        prompt_tokens = 0
+        completion_tokens = 0
+
+        async with client.messages.stream(**kwargs) as stream:
+            async for event in stream:
+                if hasattr(event, "type"):
+                    if event.type == "content_block_delta" and hasattr(event, "delta"):
+                        delta_text = getattr(event.delta, "text", "")
+                        if delta_text:
+                            full_text += delta_text
+                            yield {"type": "delta", "text": delta_text}
+                    elif event.type == "message_delta" and hasattr(event, "usage"):
+                        completion_tokens = getattr(event.usage, "output_tokens", 0)
+                    elif event.type == "message_start" and hasattr(event, "message"):
+                        usage = getattr(event.message, "usage", None)
+                        if usage:
+                            prompt_tokens = getattr(usage, "input_tokens", 0)
+
+        total_tokens = prompt_tokens + completion_tokens
+        total_cost = self._calculate_cost("claude", model, prompt_tokens, completion_tokens)
+
+        yield {
+            "type": "done",
+            "text": full_text,
+            "meta": {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+                "cost": round(total_cost, 6),
+                "raw_response": {},
+                "model_name": model,
+            },
+        }

{prompture-0.0.38.dev2 → prompture-0.0.39}/prompture/drivers/async_google_driver.py

@@ -169,6 +169,13 @@ class AsyncGoogleDriver(CostMixin, AsyncDriver):
     ) -> dict[str, Any]:
         gen_input, gen_kwargs, model_kwargs = self._build_generation_args(messages, options)
 
+        # Validate capabilities against models.dev metadata
+        self._validate_model_capabilities(
+            "google",
+            self.model,
+            using_json_schema=bool((options or {}).get("json_schema")),
+        )
+
         try:
             model = genai.GenerativeModel(self.model, **model_kwargs)
             response = await model.generate_content_async(gen_input, **gen_kwargs)
@@ -201,6 +208,9 @@ class AsyncGoogleDriver(CostMixin, AsyncDriver):
         options: dict[str, Any],
     ) -> dict[str, Any]:
         """Generate a response that may include tool/function calls (async)."""
+        model = options.get("model", self.model)
+        self._validate_model_capabilities("google", model, using_tool_use=True)
+
         gen_input, gen_kwargs, model_kwargs = self._build_generation_args(
             self._prepare_messages(messages), options
         )