prompture 0.0.46__py3-none-any.whl → 0.0.47__py3-none-any.whl

prompture/drivers/lmstudio_driver.py

@@ -123,7 +123,13 @@ class LMStudioDriver(Driver):
             raise RuntimeError(f"LM Studio request failed: {e}") from e
 
         # Extract text
-        text = response_data["choices"][0]["message"]["content"]
+        message = response_data["choices"][0]["message"]
+        text = message.get("content") or ""
+        reasoning_content = message.get("reasoning_content")
+
+        # Reasoning models (e.g. DeepSeek R1) may return content in reasoning_content
+        if not text and reasoning_content:
+            text = reasoning_content
 
         # Meta info
         usage = response_data.get("usage", {})
@@ -140,7 +146,10 @@ class LMStudioDriver(Driver):
             "model_name": merged_options.get("model", self.model),
         }
 
-        return {"text": text, "meta": meta}
+        result: dict[str, Any] = {"text": text, "meta": meta}
+        if reasoning_content is not None:
+            result["reasoning_content"] = reasoning_content
+        return result
 
     # -- Model management (LM Studio 0.4.0+) ----------------------------------
 

prompture/drivers/moonshot_driver.py

@@ -228,10 +228,11 @@ class MoonshotDriver(CostMixin, Driver):
 
         message = resp["choices"][0]["message"]
         text = message.get("content") or ""
+        reasoning_content = message.get("reasoning_content")
 
         # Reasoning models may return content in reasoning_content when content is empty
-        if not text and message.get("reasoning_content"):
-            text = message["reasoning_content"]
+        if not text and reasoning_content:
+            text = reasoning_content
 
         # Structured output fallback: if we used json_schema mode and got an
         # empty response, retry with json_object mode and schema in the prompt.
@@ -275,8 +276,9 @@ class MoonshotDriver(CostMixin, Driver):
                 resp = fb_resp
                 fb_message = fb_resp["choices"][0]["message"]
                 text = fb_message.get("content") or ""
-                if not text and fb_message.get("reasoning_content"):
-                    text = fb_message["reasoning_content"]
+                reasoning_content = fb_message.get("reasoning_content")
+                if not text and reasoning_content:
+                    text = reasoning_content
 
         total_cost = self._calculate_cost("moonshot", model, prompt_tokens, completion_tokens)
 
@@ -289,7 +291,10 @@ class MoonshotDriver(CostMixin, Driver):
             "model_name": model,
         }
 
-        return {"text": text, "meta": meta}
+        result: dict[str, Any] = {"text": text, "meta": meta}
+        if reasoning_content is not None:
+            result["reasoning_content"] = reasoning_content
+        return result
 
     # ------------------------------------------------------------------
     # Tool use
@@ -364,11 +369,12 @@ class MoonshotDriver(CostMixin, Driver):
         }
 
         choice = resp["choices"][0]
-        text = choice["message"].get("content") or ""
+        message = choice["message"]
+        text = message.get("content") or ""
         stop_reason = choice.get("finish_reason")
 
         tool_calls_out: list[dict[str, Any]] = []
-        for tc in choice["message"].get("tool_calls", []):
+        for tc in message.get("tool_calls", []):
             try:
                 args = json.loads(tc["function"]["arguments"])
             except (json.JSONDecodeError, TypeError):
@@ -381,13 +387,21 @@ class MoonshotDriver(CostMixin, Driver):
                 }
             )
 
-        return {
+        result: dict[str, Any] = {
             "text": text,
             "meta": meta,
             "tool_calls": tool_calls_out,
             "stop_reason": stop_reason,
         }
 
+        # Preserve reasoning_content for reasoning models so the
+        # conversation loop can include it when sending the assistant
+        # message back (Moonshot requires it on subsequent requests).
+        if message.get("reasoning_content") is not None:
+            result["reasoning_content"] = message["reasoning_content"]
+
+        return result
+
     # ------------------------------------------------------------------
     # Streaming
     # ------------------------------------------------------------------
@@ -430,6 +444,7 @@ class MoonshotDriver(CostMixin, Driver):
         response.raise_for_status()
 
         full_text = ""
+        full_reasoning = ""
         prompt_tokens = 0
         completion_tokens = 0
 
@@ -453,9 +468,11 @@ class MoonshotDriver(CostMixin, Driver):
             if choices:
                 delta = choices[0].get("delta", {})
                 content = delta.get("content") or ""
-                # Reasoning models stream thinking via reasoning_content
-                if not content:
-                    content = delta.get("reasoning_content") or ""
+                reasoning_chunk = delta.get("reasoning_content") or ""
+                if reasoning_chunk:
+                    full_reasoning += reasoning_chunk
+                if not content and reasoning_chunk:
+                    content = reasoning_chunk
                 if content:
                     full_text += content
                     yield {"type": "delta", "text": content}
@@ -463,7 +480,7 @@ class MoonshotDriver(CostMixin, Driver):
         total_tokens = prompt_tokens + completion_tokens
         total_cost = self._calculate_cost("moonshot", model, prompt_tokens, completion_tokens)
 
-        yield {
+        done_chunk: dict[str, Any] = {
             "type": "done",
             "text": full_text,
             "meta": {
@@ -475,3 +492,6 @@ class MoonshotDriver(CostMixin, Driver):
                 "model_name": model,
             },
         }
+        if full_reasoning:
+            done_chunk["reasoning_content"] = full_reasoning
+        yield done_chunk

prompture/drivers/ollama_driver.py

@@ -1,6 +1,7 @@
 import json
 import logging
 import os
+import uuid
 from collections.abc import Iterator
 from typing import Any, Optional
 
@@ -15,6 +16,7 @@ class OllamaDriver(Driver):
     supports_json_mode = True
     supports_json_schema = True
     supports_streaming = True
+    supports_tool_use = True
     supports_vision = True
 
     # Ollama is free – costs are always zero.
@@ -131,6 +133,95 @@ class OllamaDriver(Driver):
         # Ollama returns text in "response"
         return {"text": response_data.get("response", ""), "meta": meta}
 
+    # ------------------------------------------------------------------
+    # 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 calls via Ollama's /api/chat endpoint."""
+        merged_options = self.options.copy()
+        if options:
+            merged_options.update(options)
+
+        chat_endpoint = self.endpoint.replace("/api/generate", "/api/chat")
+
+        payload: dict[str, Any] = {
+            "model": merged_options.get("model", self.model),
+            "messages": messages,
+            "tools": tools,
+            "stream": False,
+        }
+
+        if "temperature" in merged_options:
+            payload["temperature"] = merged_options["temperature"]
+        if "top_p" in merged_options:
+            payload["top_p"] = merged_options["top_p"]
+        if "top_k" in merged_options:
+            payload["top_k"] = merged_options["top_k"]
+
+        try:
+            logger.debug(f"Sending tool use request to Ollama endpoint: {chat_endpoint}")
+            r = requests.post(chat_endpoint, json=payload, timeout=120)
+            r.raise_for_status()
+            response_data = r.json()
+
+            if not isinstance(response_data, dict):
+                raise ValueError(f"Expected dict response, got {type(response_data)}")
+        except requests.exceptions.ConnectionError:
+            raise
+        except requests.exceptions.HTTPError:
+            raise
+        except json.JSONDecodeError as e:
+            raise json.JSONDecodeError(f"Invalid JSON response from Ollama: {e.msg}", e.doc, e.pos) from e
+        except Exception as e:
+            raise RuntimeError(f"Ollama tool use request failed: {e}") from e
+
+        prompt_tokens = response_data.get("prompt_eval_count", 0)
+        completion_tokens = response_data.get("eval_count", 0)
+        total_tokens = prompt_tokens + completion_tokens
+
+        meta = {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+            "cost": 0.0,
+            "raw_response": response_data,
+            "model_name": merged_options.get("model", self.model),
+        }
+
+        message = response_data.get("message", {})
+        text = message.get("content") or ""
+        stop_reason = response_data.get("done_reason", "stop")
+
+        tool_calls_out: list[dict[str, Any]] = []
+        for tc in message.get("tool_calls", []):
+            func = tc.get("function", {})
+            # Ollama returns arguments as a dict already (no JSON string parsing needed)
+            args = func.get("arguments", {})
+            if isinstance(args, str):
+                try:
+                    args = json.loads(args)
+                except (json.JSONDecodeError, TypeError):
+                    args = {}
+            tool_calls_out.append({
+                # Ollama does not return tool_call IDs — generate one locally
+                "id": f"call_{uuid.uuid4().hex[:24]}",
+                "name": func.get("name", ""),
+                "arguments": args,
+            })
+
+        return {
+            "text": text,
+            "meta": meta,
+            "tool_calls": tool_calls_out,
+            "stop_reason": stop_reason,
+        }
+
     # ------------------------------------------------------------------
     # Streaming
     # ------------------------------------------------------------------

prompture/drivers/openrouter_driver.py

@@ -181,8 +181,18 @@ class OpenRouterDriver(CostMixin, Driver):
             "model_name": model,
         }
 
-        text = resp["choices"][0]["message"]["content"]
-        return {"text": text, "meta": meta}
+        message = resp["choices"][0]["message"]
+        text = message.get("content") or ""
+        reasoning_content = message.get("reasoning_content")
+
+        # Reasoning models may return content in reasoning_content when content is empty
+        if not text and reasoning_content:
+            text = reasoning_content
+
+        result: dict[str, Any] = {"text": text, "meta": meta}
+        if reasoning_content is not None:
+            result["reasoning_content"] = reasoning_content
+        return result
 
     # ------------------------------------------------------------------
     # Tool use
@@ -257,18 +267,23 @@ class OpenRouterDriver(CostMixin, Driver):
                 args = json.loads(tc["function"]["arguments"])
             except (json.JSONDecodeError, TypeError):
                 args = {}
-            tool_calls_out.append({
-                "id": tc["id"],
-                "name": tc["function"]["name"],
-                "arguments": args,
-            })
+            tool_calls_out.append(
+                {
+                    "id": tc["id"],
+                    "name": tc["function"]["name"],
+                    "arguments": args,
+                }
+            )
 
-        return {
+        result: dict[str, Any] = {
             "text": text,
             "meta": meta,
             "tool_calls": tool_calls_out,
             "stop_reason": stop_reason,
         }
+        if choice["message"].get("reasoning_content") is not None:
+            result["reasoning_content"] = choice["message"]["reasoning_content"]
+        return result
 
     # ------------------------------------------------------------------
     # Streaming
@@ -311,13 +326,14 @@ class OpenRouterDriver(CostMixin, Driver):
         response.raise_for_status()
 
         full_text = ""
+        full_reasoning = ""
         prompt_tokens = 0
         completion_tokens = 0
 
         for line in response.iter_lines(decode_unicode=True):
             if not line or not line.startswith("data: "):
                 continue
-            payload = line[len("data: "):]
+            payload = line[len("data: ") :]
             if payload.strip() == "[DONE]":
                 break
             try:
@@ -335,6 +351,11 @@ class OpenRouterDriver(CostMixin, Driver):
             if choices:
                 delta = choices[0].get("delta", {})
                 content = delta.get("content", "")
+                reasoning_chunk = delta.get("reasoning_content") or ""
+                if reasoning_chunk:
+                    full_reasoning += reasoning_chunk
+                if not content and reasoning_chunk:
+                    content = reasoning_chunk
                 if content:
                     full_text += content
                     yield {"type": "delta", "text": content}
@@ -342,7 +363,7 @@ class OpenRouterDriver(CostMixin, Driver):
         total_tokens = prompt_tokens + completion_tokens
         total_cost = self._calculate_cost("openrouter", model, prompt_tokens, completion_tokens)
 
-        yield {
+        done_chunk: dict[str, Any] = {
             "type": "done",
             "text": full_text,
             "meta": {
@@ -354,3 +375,6 @@ class OpenRouterDriver(CostMixin, Driver):
                 "model_name": model,
             },
         }
+        if full_reasoning:
+            done_chunk["reasoning_content"] = full_reasoning
+        yield done_chunk

prompture/simulated_tools.py

@@ -0,0 +1,115 @@
+"""Prompt-based tool calling for drivers without native tool use support.
+
+When a driver lacks ``supports_tool_use`` the conversation classes can
+fall back to *simulated* tool calling: the available tools are described
+in the system prompt, the model is asked to respond with a structured
+JSON object (either a tool call or a final answer), and Prompture
+parses + dispatches accordingly.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from .tools import clean_json_text
+from .tools_schema import ToolRegistry
+
+logger = logging.getLogger("prompture.simulated_tools")
+
+
+def build_tool_prompt(tools: ToolRegistry) -> str:
+    """Build a plain-text prompt section describing all registered tools.
+
+    The returned string should be appended to the system prompt so the
+    model knows which tools are available and how to call them.
+    """
+    lines = [
+        "You have access to the following tools:",
+        "",
+        tools.to_prompt_format(),
+        "",
+        "To use a tool, respond with ONLY a JSON object in this exact format:",
+        '{"type": "tool_call", "name": "<tool_name>", "arguments": {<args>}}',
+        "",
+        "When you have the final answer (after using tools or if no tool is needed), "
+        "respond with ONLY a JSON object in this format:",
+        '{"type": "final_answer", "content": "<your answer>"}',
+        "",
+        "IMPORTANT: Your entire response must be a single JSON object. "
+        "Do not include any other text, markdown, or explanation outside the JSON.",
+    ]
+    return "\n".join(lines)
+
+
+def parse_simulated_response(text: str, tools: ToolRegistry) -> dict[str, Any]:
+    """Parse the model's response into a tool call or final answer dict.
+
+    Returns one of:
+    - ``{"type": "tool_call", "name": str, "arguments": dict}``
+    - ``{"type": "final_answer", "content": str}``
+    """
+    cleaned = clean_json_text(text).strip()
+
+    # Try JSON parse
+    try:
+        obj = json.loads(cleaned)
+    except (json.JSONDecodeError, ValueError):
+        # Non-JSON text → treat as final answer
+        logger.debug("Response is not valid JSON, treating as final answer")
+        return {"type": "final_answer", "content": text.strip()}
+
+    if not isinstance(obj, dict):
+        return {"type": "final_answer", "content": text.strip()}
+
+    # Explicit type discriminator
+    resp_type = obj.get("type")
+
+    if resp_type == "tool_call":
+        return {
+            "type": "tool_call",
+            "name": obj.get("name", ""),
+            "arguments": obj.get("arguments", {}),
+        }
+
+    if resp_type == "final_answer":
+        return {
+            "type": "final_answer",
+            "content": obj.get("content", ""),
+        }
+
+    # Infer type from keys when "type" is missing
+    if "name" in obj and "arguments" in obj:
+        logger.debug("Inferred tool_call from keys (no 'type' field)")
+        return {
+            "type": "tool_call",
+            "name": obj["name"],
+            "arguments": obj.get("arguments", {}),
+        }
+
+    if "content" in obj:
+        logger.debug("Inferred final_answer from keys (no 'type' field)")
+        return {
+            "type": "final_answer",
+            "content": obj["content"],
+        }
+
+    # Unrecognised JSON structure → final answer with the raw text
+    return {"type": "final_answer", "content": text.strip()}
+
+
+def format_tool_result(tool_name: str, result: Any) -> str:
+    """Format a tool execution result as a user message for the next round."""
+    if isinstance(result, str):
+        result_str = result
+    else:
+        try:
+            result_str = json.dumps(result)
+        except (TypeError, ValueError):
+            result_str = str(result)
+
+    return (
+        f"Tool '{tool_name}' returned:\n{result_str}\n\n"
+        "Continue using the JSON format. Either call another tool or provide your final answer."
+    )

prompture/tools_schema.py

@@ -109,6 +109,24 @@ class ToolDefinition:
             "input_schema": self.parameters,
         }
 
+    def to_prompt_format(self) -> str:
+        """Plain-text description suitable for prompt-based tool calling."""
+        lines = [f"Tool: {self.name}", f"  Description: {self.description}", "  Parameters:"]
+        props = self.parameters.get("properties", {})
+        required = set(self.parameters.get("required", []))
+        if not props:
+            lines.append("    (none)")
+        else:
+            for pname, pschema in props.items():
+                ptype = pschema.get("type", "string")
+                req_label = "required" if pname in required else "optional"
+                desc = pschema.get("description", "")
+                line = f"    - {pname} ({ptype}, {req_label})"
+                if desc:
+                    line += f": {desc}"
+                lines.append(line)
+        return "\n".join(lines)
+
 
 def tool_from_function(
     fn: Callable[..., Any], *, name: str | None = None, description: str | None = None
@@ -244,6 +262,10 @@ class ToolRegistry:
     def to_anthropic_format(self) -> list[dict[str, Any]]:
         return [td.to_anthropic_format() for td in self._tools.values()]
 
+    def to_prompt_format(self) -> str:
+        """Join all tool descriptions into a single plain-text block."""
+        return "\n\n".join(td.to_prompt_format() for td in self._tools.values())
+
     # ------------------------------------------------------------------
     # Execution
     # ------------------------------------------------------------------

{prompture-0.0.46.dist-info → prompture-0.0.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.46
+Version: 0.0.47
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT
@@ -83,7 +83,7 @@ print(person.name)  # Maria
 - **Stepwise extraction** — Per-field prompts with smart type coercion (shorthand numbers, multilingual booleans, dates)
 - **Field registry** — 50+ predefined extraction fields with template variables and Pydantic integration
 - **Conversations** — Stateful multi-turn sessions with sync and async support
-- **Tool use** — Function calling and streaming across supported providers
+- **Tool use** — Function calling and streaming across supported providers, with automatic prompt-based simulation for models without native tool support
 - **Caching** — Built-in response cache with memory, SQLite, and Redis backends
 - **Plugin system** — Register custom drivers via entry points
 - **Usage tracking** — Token counts and cost calculation on every call
@@ -296,6 +296,39 @@ response = conv.send("What is the capital of France?")
 follow_up = conv.send("What about Germany?")  # retains context
 ```
 
+### Tool Use
+
+Register Python functions as tools the LLM can call during a conversation:
+
+```python
+from prompture import Conversation, ToolRegistry
+
+registry = ToolRegistry()
+
+@registry.tool
+def get_weather(city: str, units: str = "celsius") -> str:
+    """Get the current weather for a city."""
+    return f"Weather in {city}: 22 {units}"
+
+conv = Conversation("openai/gpt-4", tools=registry)
+result = conv.ask("What's the weather in London?")
+```
+
+For models without native function calling (Ollama, LM Studio, etc.), Prompture automatically simulates tool use by describing tools in the prompt and parsing structured JSON responses:
+
+```python
+# Auto-detect: uses native tool calling if available, simulation otherwise
+conv = Conversation("ollama/llama3.1:8b", tools=registry, simulated_tools="auto")
+
+# Force simulation even on capable models
+conv = Conversation("openai/gpt-4", tools=registry, simulated_tools=True)
+
+# Disable tool use entirely
+conv = Conversation("openai/gpt-4", tools=registry, simulated_tools=False)
+```
+
+The simulation loop describes tools in the system prompt, asks the model to respond with JSON (`tool_call` or `final_answer`), executes tools, and feeds results back — all transparent to the caller.
+
 ### Model Discovery
 
 Auto-detect available models from configured providers:

{prompture-0.0.46.dist-info → prompture-0.0.47.dist-info}/RECORD

@@ -1,16 +1,16 @@
 prompture/__init__.py,sha256=cJnkefDpiyFbU77juw4tXPdKJQWoJ-c6XBFt2v-e5Q4,7455
-prompture/_version.py,sha256=Zfksky0dIFN2RZprnAMflcd2YbMf3D0JpTlHasmdh24,706
+prompture/_version.py,sha256=ToAw384WWguTEmRR8YKQKk9ZB9M3thyPsfPaIkOPqog,706
 prompture/agent.py,sha256=-8qdo_Lz20GGssCe5B_QPxb5Kct71YtKHh5vZgrSYik,34748
 prompture/agent_types.py,sha256=Icl16PQI-ThGLMFCU43adtQA6cqETbsPn4KssKBI4xc,4664
 prompture/async_agent.py,sha256=_6_IRb-LGzZxGxfPVy43SIWByUoQfN-5XnUWahVP6r8,33110
-prompture/async_conversation.py,sha256=m9sdKBu1wxo5veGwO6g6Zvf1sBzpuxP-mSIEeNKlBjQ,31155
+prompture/async_conversation.py,sha256=tzOy2jiCOVkRHIJ9H6VeRwwcUtbjF33--igdxMC6F7s,34811
 prompture/async_core.py,sha256=hbRXLvsBJv3JAnUwGZbazsL6x022FrsJU6swmZolgxY,29745
 prompture/async_driver.py,sha256=4VQ9Q_tI6Ufw6W1CYJ5j8hVtgVdqFGuk6e2tLaSceWE,8581
 prompture/async_groups.py,sha256=pceKrt0UayQjMLFs1dFGoxOHpgD948aEjIY61r608C4,22459
 prompture/cache.py,sha256=4dfQDMsEZ9JMQDXLOkiugPmmMJQIfKVE8rTAKDH4oL8,14401
 prompture/callbacks.py,sha256=JPDqWGzPIzv44l54ocmezlYVBnbKPDEEXRrLdluWGAo,1731
 prompture/cli.py,sha256=tNiIddRmgC1BomjY5O1VVVAwvqHVzF8IHmQrM-cG2wQ,2902
-prompture/conversation.py,sha256=kBflwh7Qmw1I_jcUGyV36oskdVz4SYDSw_dCjemRRRc,32756
+prompture/conversation.py,sha256=uxstayJjgY6a39DtU0YxQl0Dt3JBo2UVCyMPJW95MNI,36428
 prompture/core.py,sha256=5FHwX7fNPwFHMbFCMvV-RH7LpPpTToLAmcyDnKbrN0E,57202
 prompture/cost_mixin.py,sha256=Qx7gPgPsWgTHiaFeI7q_p9cfe95ccjgN8Mi56d_AVX0,4563
 prompture/discovery.py,sha256=K-svbO-qJraHinCbFVS64vEo5McWX5pURv26ZMmuL6U,10295
@@ -29,41 +29,42 @@ prompture/serialization.py,sha256=m4cdAQJspitMcfwRgecElkY2SBt3BjEwubbhS3W-0s0,74
 prompture/server.py,sha256=W6Kn6Et8nG5twXjD2wKn_N9yplGjz5Z-2naeI_UPd1Y,6198
 prompture/session.py,sha256=FldK3cKq_jO0-beukVOhIiwsYWb6U_lLBlAERx95aaM,3821
 prompture/settings.py,sha256=2cTuko8PLhq0SbBMtqmjBgzl9jv6SgoXeaUEhmm4G4Y,2562
+prompture/simulated_tools.py,sha256=oL6W6hAEKXZHBfb8b-UDPfm3V4nSqXu7eG8IpvwtqKg,3901
 prompture/tools.py,sha256=PmFbGHTWYWahpJOG6BLlM0Y-EG6S37IFW57C-8GdsXo,36449
-prompture/tools_schema.py,sha256=c1ag6kyIGgZxWbZRsaHl72cAelb34J_JomyW1h5Atw0,7964
+prompture/tools_schema.py,sha256=wuVfPyCKVWlhUDRsXWArtGpxkQRqNWyKeLJuXn_6X8k,8986
 prompture/validator.py,sha256=FY_VjIVEbjG2nwzh-r6l23Kt3UzaLyCis8_pZMNGHBA,993
 prompture/aio/__init__.py,sha256=bKqTu4Jxld16aP_7SP9wU5au45UBIb041ORo4E4HzVo,1810
 prompture/drivers/__init__.py,sha256=r8wBYGKD7C7v4CqcyRNoaITzGVyxasoiAU6jBYsPZio,8178
 prompture/drivers/airllm_driver.py,sha256=SaTh7e7Plvuct_TfRqQvsJsKHvvM_3iVqhBtlciM-Kw,3858
 prompture/drivers/async_airllm_driver.py,sha256=1hIWLXfyyIg9tXaOE22tLJvFyNwHnOi1M5BIKnV8ysk,908
-prompture/drivers/async_azure_driver.py,sha256=uXPMStCn5jMnLFpiLYBvTheZm2dNlwKmSLWL3J2s8es,4544
+prompture/drivers/async_azure_driver.py,sha256=s__y_EGQkK7UZjxiyF08uql8F09cnbJ0q7aFuxzreIw,7328
 prompture/drivers/async_claude_driver.py,sha256=oawbFVVMtRlikQOmu3jRjbdpoeu95JqTF1YHLKO3ybE,10576
 prompture/drivers/async_google_driver.py,sha256=LTUgCXJjzuTDGzsCsmY2-xH2KdTLJD7htwO49ZNFOdE,13711
-prompture/drivers/async_grok_driver.py,sha256=s3bXEGhVrMyw10CowkBhs5522mhipWJyWWu-xVixzyg,3538
-prompture/drivers/async_groq_driver.py,sha256=pjAh_bgZWSWaNSm5XrU-u3gRV6YSGwNG5NfAbkYeJ84,3067
+prompture/drivers/async_grok_driver.py,sha256=lj160GHARe0fqTms4ovWhkpgt0idsGt55xnuc6JlH1w,7413
+prompture/drivers/async_groq_driver.py,sha256=5G0rXAEAmsLNftI9YfGAh4E8X3B4Hb6_0cXBhf9LZMk,6348
 prompture/drivers/async_hugging_driver.py,sha256=IblxqU6TpNUiigZ0BCgNkAgzpUr2FtPHJOZnOZMnHF0,2152
-prompture/drivers/async_lmstudio_driver.py,sha256=rPn2qVPm6UE2APzAn7ZHYTELUwr0dQMi8XHv6gAhyH8,5782
+prompture/drivers/async_lmstudio_driver.py,sha256=4bz8NFFiZiFFkzlYDcS7abnwmEbbvbKb-CQhHeTGlU8,6102
 prompture/drivers/async_local_http_driver.py,sha256=qoigIf-w3_c2dbVdM6m1e2RMAWP4Gk4VzVs5hM3lPvQ,1609
 prompture/drivers/async_modelscope_driver.py,sha256=wzHYGLf9qE9KXRFZYtN1hZS10Bw1m1Wy6HcmyUD67HM,10170
-prompture/drivers/async_moonshot_driver.py,sha256=Jl6rGlW3SsneFfmBiDo0RBZQN5c3-08kwax369me01E,14798
-prompture/drivers/async_ollama_driver.py,sha256=FaSXtFXrgeVHIe0b90Vg6rGeSTWLpPnjaThh9Ai7qQo,5042
+prompture/drivers/async_moonshot_driver.py,sha256=a9gr3T_4NiDFd7foM1mSHJRvXYb43iqqJnQ0FVRyI2E,15669
+prompture/drivers/async_ollama_driver.py,sha256=pFtCvh5bHe_qwGy-jIJbyG_zmnPbNbagJCGxCTJMdPU,8244
 prompture/drivers/async_openai_driver.py,sha256=COa_JE-AgKowKJpmRnfDJp4RSQKZel_7WswxOzvLksM,9044
-prompture/drivers/async_openrouter_driver.py,sha256=GnOMY67CCV3HV83lCC-CxcngwrUnuc7G-AX7fb1DYpg,10698
+prompture/drivers/async_openrouter_driver.py,sha256=N7s72HuXHLs_RWmJO9P3pCayWE98ommfqVeAfru8Bl0,11758
 prompture/drivers/async_registry.py,sha256=JFEnXNPm-8AAUCiNLoKuYBSCYEK-4BmAen5t55QrMvg,5223
 prompture/drivers/async_zai_driver.py,sha256=zXHxske1CtK8dDTGY-D_kiyZZ_NfceNTJlyTpKn0R4c,10727
-prompture/drivers/azure_driver.py,sha256=zwCRNJRm18XEfYeqpFCDLMEEyY0vIGdqrwKk9ng6s4s,5798
+prompture/drivers/azure_driver.py,sha256=gQFffA29gOr-GZ25fNXTokV8-mEmffeV9CT_UBZ3yXc,8565
 prompture/drivers/claude_driver.py,sha256=C8Av3DXP2x3f35jEv8BRwEM_4vh0cfmLsy3t5dsR6aM,11837
 prompture/drivers/google_driver.py,sha256=Zck5VUsW37kDgohXz3cUWRmZ88OfhmTpVD-qzAVMp-8,16318
-prompture/drivers/grok_driver.py,sha256=CzAXKAbbWmbE8qLFZxxoEhf4Qzbtc9YqDX7kkCsE4dk,5320
-prompture/drivers/groq_driver.py,sha256=61LKHhYyRiFkHKbLKFYX10fqjpL_INtPY_Zeb55AV0o,4221
+prompture/drivers/grok_driver.py,sha256=fxl5Gx9acFq7BlOh_N9U66oJvG3y8YX4QuSAgZWHJmU,8963
+prompture/drivers/groq_driver.py,sha256=7YEok1BQlsDZGkA-l9yrjTDapqIWX3yq_Ctgbhu8jSI,7490
 prompture/drivers/hugging_driver.py,sha256=gZir3XnM77VfYIdnu3S1pRftlZJM6G3L8bgGn5esg-Q,2346
-prompture/drivers/lmstudio_driver.py,sha256=9ZnJ1l5LuWAjkH2WKfFjZprNMVIXoSC7qXDNDTxm-tA,6748
+prompture/drivers/lmstudio_driver.py,sha256=nZ5SvBC0kTDNDzsupIW_H7YK92dcYta_xSPUNs52gyM,7154
 prompture/drivers/local_http_driver.py,sha256=QJgEf9kAmy8YZ5fb8FHnWuhoDoZYNd8at4jegzNVJH0,1658
 prompture/drivers/modelscope_driver.py,sha256=yTxTG7j5f7zz4CjbrV8J0VKeoBmxv69F40bfp8nq6AE,10651
-prompture/drivers/moonshot_driver.py,sha256=MtlvtUUwE4WtzCKo_pJJ5wATB-h2GU4zY9jbGo3a_-g,18264
-prompture/drivers/ollama_driver.py,sha256=k9xeUwFp91OrDbjkbYI-F8CDFy5ew-zQ0btXqwbXXWM,10220
+prompture/drivers/moonshot_driver.py,sha256=cm1XpU6EPFjcZaneXjfetRNSUxN9daP6hkJ1y99kqLI,19123
+prompture/drivers/ollama_driver.py,sha256=SJtMRtAr8geUB4y5GIZxPr-RJ0C3q7yqigYei2b4luM,13710
 prompture/drivers/openai_driver.py,sha256=DqdMhxF8M2HdOY5vfsFrz0h23lqBoQlbxV3xUdHvZho,10548
-prompture/drivers/openrouter_driver.py,sha256=DaG1H99s8GaOgJXZK4TP28HM7U4wiLu9wHXzWZleW_U,12589
+prompture/drivers/openrouter_driver.py,sha256=m2I5E9L5YYE_bV8PruKnAwjL63SIFEXevN_ThUzxQaA,13657
 prompture/drivers/registry.py,sha256=Dg_5w9alnIPKhOnsR9Xspuf5T7roBGu0r_L2Cf-UhXs,9926
 prompture/drivers/vision_helpers.py,sha256=l5iYXHJLR_vLFvqDPPPK1QqK7YPKh5GwocpbSyt0R04,5403
 prompture/drivers/zai_driver.py,sha256=Wkur0HfwKJt8ugYErpvz1Gy6e9an8vt4R7U3i6HWV_s,11038
@@ -76,9 +77,9 @@ prompture/scaffold/templates/env.example.j2,sha256=eESKr1KWgyrczO6d-nwAhQwSpf_G-
 prompture/scaffold/templates/main.py.j2,sha256=TEgc5OvsZOEX0JthkSW1NI_yLwgoeVN_x97Ibg-vyWY,2632
 prompture/scaffold/templates/models.py.j2,sha256=JrZ99GCVK6TKWapskVRSwCssGrTu5cGZ_r46fOhY2GE,858
 prompture/scaffold/templates/requirements.txt.j2,sha256=m3S5fi1hq9KG9l_9j317rjwWww0a43WMKd8VnUWv2A4,102
-prompture-0.0.46.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
-prompture-0.0.46.dist-info/METADATA,sha256=CpjLp4ff432DdZCNmJciCbk_-pv7CXRHx2LYLP1jybA,10837
-prompture-0.0.46.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-prompture-0.0.46.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
-prompture-0.0.46.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
-prompture-0.0.46.dist-info/RECORD,,
+prompture-0.0.47.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
+prompture-0.0.47.dist-info/METADATA,sha256=MY7C3DjGuhpY6ZlPEmg-58aSmJ4RdZ4WRuYtXiWFinM,12148
+prompture-0.0.47.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+prompture-0.0.47.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
+prompture-0.0.47.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
+prompture-0.0.47.dist-info/RECORD,,