prompture 0.0.29.dev8__py3-none-any.whl → 0.0.38.dev2__py3-none-any.whl

prompture/drivers/google_driver.py

@@ -1,46 +1,60 @@
-import os
 import logging
+import os
+import uuid
+from collections.abc import Iterator
+from typing import Any, Optional
+
 import google.generativeai as genai
-from typing import Any, Dict
+
+from ..cost_mixin import CostMixin
 from ..driver import Driver
 
 logger = logging.getLogger(__name__)
 
 
-class GoogleDriver(Driver):
+class GoogleDriver(CostMixin, Driver):
     """Driver for Google's Generative AI API (Gemini)."""
 
+    supports_json_mode = True
+    supports_json_schema = True
+    supports_vision = True
+    supports_tool_use = True
+    supports_streaming = True
+
     # Based on current Gemini pricing (as of 2025)
     # Source: https://cloud.google.com/vertex-ai/pricing#gemini_models
+    _PRICING_UNIT = 1_000_000
     MODEL_PRICING = {
         "gemini-1.5-pro": {
             "prompt": 0.00025,  # $0.25/1M chars input
-            "completion": 0.0005  # $0.50/1M chars output
+            "completion": 0.0005,  # $0.50/1M chars output
         },
         "gemini-1.5-pro-vision": {
             "prompt": 0.00025,  # $0.25/1M chars input
-            "completion": 0.0005  # $0.50/1M chars output
+            "completion": 0.0005,  # $0.50/1M chars output
         },
         "gemini-2.5-pro": {
             "prompt": 0.0004,  # $0.40/1M chars input
-            "completion": 0.0008  # $0.80/1M chars output
+            "completion": 0.0008,  # $0.80/1M chars output
         },
         "gemini-2.5-flash": {
             "prompt": 0.0004,  # $0.40/1M chars input
-            "completion": 0.0008  # $0.80/1M chars output
+            "completion": 0.0008,  # $0.80/1M chars output
         },
         "gemini-2.5-flash-lite": {
             "prompt": 0.0002,  # $0.20/1M chars input
-            "completion": 0.0004  # $0.40/1M chars output
+            "completion": 0.0004,  # $0.40/1M chars output
         },
-         "gemini-2.0-flash": {
+        "gemini-2.0-flash": {
             "prompt": 0.0004,  # $0.40/1M chars input
-            "completion": 0.0008  # $0.80/1M chars output
+            "completion": 0.0008,  # $0.80/1M chars output
         },
         "gemini-2.0-flash-lite": {
             "prompt": 0.0002,  # $0.20/1M chars input
-            "completion": 0.0004  # $0.40/1M chars output
+            "completion": 0.0004,  # $0.40/1M chars output
         },
+        "gemini-1.5-flash": {"prompt": 0.00001875, "completion": 0.000075},
+        "gemini-1.5-flash-8b": {"prompt": 0.00001, "completion": 0.00004},
     }
 
     def __init__(self, api_key: str | None = None, model: str = "gemini-1.5-pro"):
@@ -55,13 +69,14 @@ class GoogleDriver(Driver):
             raise ValueError("Google API key not found. Set GOOGLE_API_KEY env var or pass api_key to constructor")
 
         self.model = model
+        # Warn if model is not in pricing table but allow it (might be new)
         if model not in self.MODEL_PRICING:
-            raise ValueError(f"Unsupported model: {model}. Must be one of: {list(self.MODEL_PRICING.keys())}")
+            logger.warning(f"Model {model} not found in pricing table. Cost calculations will be 0.")
 
         # Configure google.generativeai
         genai.configure(api_key=self.api_key)
-        self.options: Dict[str, Any] = {}
-        
+        self.options: dict[str, Any] = {}
+
         # Validate connection and model availability
         self._validate_connection()
 
@@ -75,48 +90,159 @@ class GoogleDriver(Driver):
             logger.warning(f"Could not validate connection to Google API: {e}")
             raise
 
-    def generate(self, prompt: str, options: Dict[str, Any] = None) -> Dict[str, Any]:
-        """Generate text using Google's Generative AI.
+    def _calculate_cost_chars(self, prompt_chars: int, completion_chars: int) -> float:
+        """Calculate cost from character counts.
 
-        Args:
-            prompt: The input prompt
-            options: Additional options to pass to the model
+        Live rates use token-based pricing (estimate ~4 chars/token).
+        Hardcoded MODEL_PRICING uses per-1M-character rates.
+        """
+        from ..model_rates import get_model_rates
+
+        live_rates = get_model_rates("google", self.model)
+        if live_rates:
+            est_prompt_tokens = prompt_chars / 4
+            est_completion_tokens = completion_chars / 4
+            prompt_cost = (est_prompt_tokens / 1_000_000) * live_rates["input"]
+            completion_cost = (est_completion_tokens / 1_000_000) * live_rates["output"]
+        else:
+            model_pricing = self.MODEL_PRICING.get(self.model, {"prompt": 0, "completion": 0})
+            prompt_cost = (prompt_chars / 1_000_000) * model_pricing["prompt"]
+            completion_cost = (completion_chars / 1_000_000) * model_pricing["completion"]
+        return round(prompt_cost + completion_cost, 6)
+
+    def _extract_usage_metadata(self, response: Any, messages: list[dict[str, Any]]) -> dict[str, Any]:
+        """Extract token counts from response, falling back to character estimation."""
+        usage = getattr(response, "usage_metadata", None)
+        if usage:
+            prompt_tokens = getattr(usage, "prompt_token_count", 0) or 0
+            completion_tokens = getattr(usage, "candidates_token_count", 0) or 0
+            total_tokens = getattr(usage, "total_token_count", 0) or (prompt_tokens + completion_tokens)
+            cost = self._calculate_cost("google", self.model, prompt_tokens, completion_tokens)
+        else:
+            # Fallback: estimate from character counts
+            total_prompt_chars = 0
+            for msg in messages:
+                c = msg.get("content", "")
+                if isinstance(c, str):
+                    total_prompt_chars += len(c)
+                elif isinstance(c, list):
+                    for part in c:
+                        if isinstance(part, str):
+                            total_prompt_chars += len(part)
+                        elif isinstance(part, dict) and "text" in part:
+                            total_prompt_chars += len(part["text"])
+            completion_chars = len(response.text) if response.text else 0
+            prompt_tokens = total_prompt_chars // 4
+            completion_tokens = completion_chars // 4
+            total_tokens = prompt_tokens + completion_tokens
+            cost = self._calculate_cost_chars(total_prompt_chars, completion_chars)
+
+        return {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+            "cost": round(cost, 6),
+        }
+
+    supports_messages = True
+
+    def _prepare_messages(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        from .vision_helpers import _prepare_google_vision_messages
 
-        Returns:
-            Dict containing generated text and metadata
+        return _prepare_google_vision_messages(messages)
+
+    def _build_generation_args(
+        self, messages: list[dict[str, Any]], options: Optional[dict[str, Any]] = None
+    ) -> tuple[Any, dict[str, Any]]:
+        """Parse messages and options into (gen_input, kwargs) for generate_content.
+
+        Returns the content input and a dict of keyword arguments
+        (generation_config, safety_settings, model kwargs including system_instruction).
         """
         merged_options = self.options.copy()
         if options:
             merged_options.update(options)
 
+        generation_config = merged_options.get("generation_config", {})
+        safety_settings = merged_options.get("safety_settings", {})
+
+        if "temperature" in merged_options and "temperature" not in generation_config:
+            generation_config["temperature"] = merged_options["temperature"]
+        if "max_tokens" in merged_options and "max_output_tokens" not in generation_config:
+            generation_config["max_output_tokens"] = merged_options["max_tokens"]
+        if "top_p" in merged_options and "top_p" not in generation_config:
+            generation_config["top_p"] = merged_options["top_p"]
+        if "top_k" in merged_options and "top_k" not in generation_config:
+            generation_config["top_k"] = merged_options["top_k"]
+
+        # Native JSON mode support
+        if merged_options.get("json_mode"):
+            generation_config["response_mime_type"] = "application/json"
+            json_schema = merged_options.get("json_schema")
+            if json_schema:
+                generation_config["response_schema"] = json_schema
+
+        # Convert messages to Gemini format
+        system_instruction = None
+        contents: list[dict[str, Any]] = []
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            if role == "system":
+                system_instruction = content if isinstance(content, str) else str(content)
+            else:
+                gemini_role = "model" if role == "assistant" else "user"
+                if msg.get("_vision_parts"):
+                    contents.append({"role": gemini_role, "parts": content})
+                else:
+                    contents.append({"role": gemini_role, "parts": [content]})
+
+        # For a single message, unwrap only if it has exactly one string part
+        if len(contents) == 1:
+            parts = contents[0]["parts"]
+            if len(parts) == 1 and isinstance(parts[0], str):
+                gen_input = parts[0]
+            else:
+                gen_input = contents
+        else:
+            gen_input = contents
+
+        model_kwargs: dict[str, Any] = {}
+        if system_instruction:
+            model_kwargs["system_instruction"] = system_instruction
+
+        gen_kwargs: dict[str, Any] = {
+            "generation_config": generation_config if generation_config else None,
+            "safety_settings": safety_settings if safety_settings else None,
+        }
+
+        return gen_input, gen_kwargs, model_kwargs
+
+    def generate(self, prompt: str, options: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        messages = [{"role": "user", "content": prompt}]
+        return self._do_generate(messages, options)
+
+    def generate_messages(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
+        return self._do_generate(self._prepare_messages(messages), options)
+
+    def _do_generate(self, messages: list[dict[str, str]], options: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        gen_input, gen_kwargs, model_kwargs = self._build_generation_args(messages, options)
+
         try:
             logger.debug(f"Initializing {self.model} for generation")
-            model = genai.GenerativeModel(self.model)
+            model = genai.GenerativeModel(self.model, **model_kwargs)
+
+            logger.debug(f"Generating with model {self.model}")
+            response = model.generate_content(gen_input, **gen_kwargs)
 
-            # Generate response
-            logger.debug(f"Generating with prompt: {prompt}")
-            response = model.generate_content(prompt)
-            
             if not response.text:
                 raise ValueError("Empty response from model")
 
-            # Calculate token usage and cost
-            # Note: Using character count as proxy since Google charges per character
-            prompt_chars = len(prompt)
-            completion_chars = len(response.text)
-            
-            # Calculate costs
-            model_pricing = self.MODEL_PRICING[self.model]
-            prompt_cost = (prompt_chars / 1_000_000) * model_pricing["prompt"]
-            completion_cost = (completion_chars / 1_000_000) * model_pricing["completion"]
-            total_cost = prompt_cost + completion_cost
+            usage_meta = self._extract_usage_metadata(response, messages)
 
             meta = {
-                "prompt_chars": prompt_chars,
-                "completion_chars": completion_chars,
-                "total_chars": prompt_chars + completion_chars,
-                "cost": total_cost,
-                "raw_response": response.prompt_feedback,
+                **usage_meta,
+                "raw_response": response.prompt_feedback if hasattr(response, "prompt_feedback") else None,
                 "model_name": self.model,
             }
 
@@ -124,4 +250,131 @@ class GoogleDriver(Driver):
 
         except Exception as e:
             logger.error(f"Google API request failed: {e}")
-            raise RuntimeError(f"Google API request failed: {e}")
+            raise RuntimeError(f"Google API request failed: {e}") from e
+
+    # ------------------------------------------------------------------
+    # Tool use
+    # ------------------------------------------------------------------
+
+    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/function calls."""
+        gen_input, gen_kwargs, model_kwargs = self._build_generation_args(
+            self._prepare_messages(messages), options
+        )
+
+        # Convert tools from OpenAI format to Gemini function declarations
+        function_declarations = []
+        for t in tools:
+            if "type" in t and t["type"] == "function":
+                fn = t["function"]
+                decl = {
+                    "name": fn["name"],
+                    "description": fn.get("description", ""),
+                }
+                params = fn.get("parameters")
+                if params:
+                    decl["parameters"] = params
+                function_declarations.append(decl)
+            elif "name" in t:
+                # Already in a generic format
+                decl = {"name": t["name"], "description": t.get("description", "")}
+                params = t.get("parameters") or t.get("input_schema")
+                if params:
+                    decl["parameters"] = params
+                function_declarations.append(decl)
+
+        try:
+            model = genai.GenerativeModel(self.model, **model_kwargs)
+
+            gemini_tools = [genai.types.Tool(function_declarations=function_declarations)]
+            response = model.generate_content(gen_input, tools=gemini_tools, **gen_kwargs)
+
+            usage_meta = self._extract_usage_metadata(response, messages)
+            meta = {
+                **usage_meta,
+                "raw_response": response.prompt_feedback if hasattr(response, "prompt_feedback") else None,
+                "model_name": self.model,
+            }
+
+            text = ""
+            tool_calls_out: list[dict[str, Any]] = []
+            stop_reason = "stop"
+
+            for candidate in response.candidates:
+                for part in candidate.content.parts:
+                    if hasattr(part, "text") and part.text:
+                        text += part.text
+                    if hasattr(part, "function_call") and part.function_call.name:
+                        fc = part.function_call
+                        tool_calls_out.append({
+                            "id": str(uuid.uuid4()),
+                            "name": fc.name,
+                            "arguments": dict(fc.args) if fc.args else {},
+                        })
+
+                finish_reason = getattr(candidate, "finish_reason", None)
+                if finish_reason is not None:
+                    # Map Gemini finish reasons to standard stop reasons
+                    reason_map = {1: "stop", 2: "max_tokens", 3: "safety", 4: "recitation", 5: "other"}
+                    stop_reason = reason_map.get(finish_reason, "stop")
+
+            if tool_calls_out:
+                stop_reason = "tool_use"
+
+            return {
+                "text": text,
+                "meta": meta,
+                "tool_calls": tool_calls_out,
+                "stop_reason": stop_reason,
+            }
+
+        except Exception as e:
+            logger.error(f"Google API tool call request failed: {e}")
+            raise RuntimeError(f"Google API tool call request failed: {e}") from e
+
+    # ------------------------------------------------------------------
+    # Streaming
+    # ------------------------------------------------------------------
+
+    def generate_messages_stream(
+        self,
+        messages: list[dict[str, Any]],
+        options: dict[str, Any],
+    ) -> Iterator[dict[str, Any]]:
+        """Yield response chunks via Gemini streaming API."""
+        gen_input, gen_kwargs, model_kwargs = self._build_generation_args(
+            self._prepare_messages(messages), options
+        )
+
+        try:
+            model = genai.GenerativeModel(self.model, **model_kwargs)
+            response = model.generate_content(gen_input, stream=True, **gen_kwargs)
+
+            full_text = ""
+            for chunk in response:
+                chunk_text = getattr(chunk, "text", None) or ""
+                if chunk_text:
+                    full_text += chunk_text
+                    yield {"type": "delta", "text": chunk_text}
+
+            # After iteration completes, resolve() has been called on the response
+            usage_meta = self._extract_usage_metadata(response, messages)
+
+            yield {
+                "type": "done",
+                "text": full_text,
+                "meta": {
+                    **usage_meta,
+                    "raw_response": {},
+                    "model_name": self.model,
+                },
+            }
+
+        except Exception as e:
+            logger.error(f"Google API streaming request failed: {e}")
+            raise RuntimeError(f"Google API streaming request failed: {e}") from e

prompture/drivers/grok_driver.py

@@ -1,15 +1,22 @@
 """xAI Grok driver.
 Requires the `requests` package. Uses GROK_API_KEY env var.
 """
+
 import os
-from typing import Any, Dict
+from typing import Any
+
 import requests
 
+from ..cost_mixin import CostMixin
 from ..driver import Driver
 
 
-class GrokDriver(Driver):
+class GrokDriver(CostMixin, Driver):
+    supports_json_mode = True
+    supports_vision = True
+
     # Pricing per 1M tokens based on xAI's documentation
+    _PRICING_UNIT = 1_000_000
     MODEL_PRICING = {
         "grok-code-fast-1": {
             "prompt": 0.20,
@@ -72,19 +79,21 @@ class GrokDriver(Driver):
         self.model = model
         self.api_base = "https://api.x.ai/v1"
 
-    def generate(self, prompt: str, options: Dict[str, Any]) -> Dict[str, Any]:
-        """Generate completion using Grok API.
+    supports_messages = True
 
-        Args:
-            prompt: Input prompt
-            options: Generation options
-
-        Returns:
-            Dict containing generated text and metadata
-        
-        Raises:
-            RuntimeError: If API key is missing or request fails
-        """
+    def _prepare_messages(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        from .vision_helpers import _prepare_openai_vision_messages
+
+        return _prepare_openai_vision_messages(messages)
+
+    def generate(self, prompt: str, options: dict[str, Any]) -> dict[str, Any]:
+        messages = [{"role": "user", "content": prompt}]
+        return self._do_generate(messages, options)
+
+    def generate_messages(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
+        return self._do_generate(self._prepare_messages(messages), options)
+
+    def _do_generate(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
         if not self.api_key:
             raise RuntimeError("GROK_API_KEY environment variable is required")
 
@@ -101,7 +110,7 @@ class GrokDriver(Driver):
         # Base request payload
         payload = {
             "model": model,
-            "messages": [{"role": "user", "content": prompt}],
+            "messages": messages,
         }
 
         # Add token limit with correct parameter name
@@ -111,33 +120,27 @@ class GrokDriver(Driver):
         if supports_temperature and "temperature" in opts:
             payload["temperature"] = opts["temperature"]
 
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
-        }
+        # Native JSON mode support
+        if options.get("json_mode"):
+            payload["response_format"] = {"type": "json_object"}
+
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
 
         try:
-            response = requests.post(
-                f"{self.api_base}/chat/completions",
-                headers=headers,
-                json=payload
-            )
+            response = requests.post(f"{self.api_base}/chat/completions", headers=headers, json=payload)
             response.raise_for_status()
             resp = response.json()
         except requests.exceptions.RequestException as e:
-            raise RuntimeError(f"Grok API request failed: {str(e)}")
+            raise RuntimeError(f"Grok API request failed: {e!s}") from e
 
         # Extract usage info
         usage = resp.get("usage", {})
         prompt_tokens = usage.get("prompt_tokens", 0)
-        completion_tokens = usage.get("completion_tokens", 0) 
+        completion_tokens = usage.get("completion_tokens", 0)
         total_tokens = usage.get("total_tokens", 0)
 
-        # Calculate cost
-        model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
-        prompt_cost = (prompt_tokens / 1000000) * model_pricing["prompt"]
-        completion_cost = (completion_tokens / 1000000) * model_pricing["completion"]
-        total_cost = prompt_cost + completion_cost
+        # Calculate cost via shared mixin
+        total_cost = self._calculate_cost("grok", model, prompt_tokens, completion_tokens)
 
         # Standardized meta object
         meta = {
@@ -150,4 +153,4 @@ class GrokDriver(Driver):
         }
 
         text = resp["choices"][0]["message"]["content"]
-        return {"text": text, "meta": meta}
+        return {"text": text, "meta": meta}

prompture/drivers/groq_driver.py

@@ -1,18 +1,23 @@
 """Groq driver for prompture.
 Requires the `groq` package. Uses GROQ_API_KEY env var.
 """
+
 import os
-from typing import Any, Dict
+from typing import Any
 
 try:
     import groq
 except Exception:
     groq = None
 
+from ..cost_mixin import CostMixin
 from ..driver import Driver
 
 
-class GroqDriver(Driver):
+class GroqDriver(CostMixin, Driver):
+    supports_json_mode = True
+    supports_vision = True
+
     # Approximate pricing per 1K tokens (to be updated with official pricing)
     # Each model entry defines token parameters and temperature support
     MODEL_PRICING = {
@@ -32,7 +37,7 @@ class GroqDriver(Driver):
 
     def __init__(self, api_key: str | None = None, model: str = "llama2-70b-4096"):
         """Initialize Groq driver.
-        
+
         Args:
             api_key: Groq API key (defaults to GROQ_API_KEY env var)
             model: Model to use (defaults to llama2-70b-4096)
@@ -44,20 +49,21 @@ class GroqDriver(Driver):
         else:
             self.client = None
 
-    def generate(self, prompt: str, options: Dict[str, Any]) -> Dict[str, Any]:
-        """Generate completion using Groq API.
-        
-        Args:
-            prompt: Input prompt
-            options: Generation options
-            
-        Returns:
-            Dict containing generated text and metadata
-            
-        Raises:
-            RuntimeError: If groq package is not installed
-            groq.error.*: Various Groq API errors
-        """
+    supports_messages = True
+
+    def _prepare_messages(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        from .vision_helpers import _prepare_openai_vision_messages
+
+        return _prepare_openai_vision_messages(messages)
+
+    def generate(self, prompt: str, options: dict[str, Any]) -> dict[str, Any]:
+        messages = [{"role": "user", "content": prompt}]
+        return self._do_generate(messages, options)
+
+    def generate_messages(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
+        return self._do_generate(self._prepare_messages(messages), options)
+
+    def _do_generate(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
         if self.client is None:
             raise RuntimeError("groq package is not installed")
 
@@ -74,7 +80,7 @@ class GroqDriver(Driver):
         # Base kwargs for API call
         kwargs = {
             "model": model,
-            "messages": [{"role": "user", "content": prompt}],
+            "messages": messages,
         }
 
         # Set token limit with correct parameter name
@@ -84,23 +90,24 @@ class GroqDriver(Driver):
         if supports_temperature and "temperature" in opts:
             kwargs["temperature"] = opts["temperature"]
 
+        # Native JSON mode support
+        if options.get("json_mode"):
+            kwargs["response_format"] = {"type": "json_object"}
+
         try:
             resp = self.client.chat.completions.create(**kwargs)
-        except Exception as e:
+        except Exception:
             # Re-raise any Groq API errors
             raise
 
         # Extract usage statistics
         usage = getattr(resp, "usage", None)
         prompt_tokens = getattr(usage, "prompt_tokens", 0)
-        completion_tokens = getattr(usage, "completion_tokens", 0) 
+        completion_tokens = getattr(usage, "completion_tokens", 0)
         total_tokens = getattr(usage, "total_tokens", 0)
 
-        # Calculate costs
-        model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
-        prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
-        completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
-        total_cost = prompt_cost + completion_cost
+        # Calculate cost via shared mixin
+        total_cost = self._calculate_cost("groq", model, prompt_tokens, completion_tokens)
 
         # Standard metadata object
         meta = {
@@ -114,4 +121,4 @@ class GroqDriver(Driver):
 
         # Extract generated text
         text = resp.choices[0].message.content
-        return {"text": text, "meta": meta}
+        return {"text": text, "meta": meta}