prompture 0.0.47.dev1__py3-none-any.whl → 0.0.47.dev3__py3-none-any.whl

prompture/drivers/async_openrouter_driver.py

@@ -122,8 +122,17 @@ class AsyncOpenRouterDriver(CostMixin, AsyncDriver):
             "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")
+
+        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
@@ -196,18 +205,23 @@ class AsyncOpenRouterDriver(CostMixin, AsyncDriver):
                 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
@@ -238,21 +252,25 @@ class AsyncOpenRouterDriver(CostMixin, AsyncDriver):
             data["temperature"] = opts["temperature"]
 
         full_text = ""
+        full_reasoning = ""
         prompt_tokens = 0
         completion_tokens = 0
 
-        async with httpx.AsyncClient() as client, client.stream(
-            "POST",
-            f"{self.base_url}/chat/completions",
-            headers=self.headers,
-            json=data,
-            timeout=120,
-        ) as response:
+        async with (
+            httpx.AsyncClient() as client,
+            client.stream(
+                "POST",
+                f"{self.base_url}/chat/completions",
+                headers=self.headers,
+                json=data,
+                timeout=120,
+            ) as response,
+        ):
             response.raise_for_status()
             async for line in response.aiter_lines():
                 if not line or not line.startswith("data: "):
                     continue
-                payload = line[len("data: "):]
+                payload = line[len("data: ") :]
                 if payload.strip() == "[DONE]":
                     break
                 try:
@@ -270,6 +288,11 @@ class AsyncOpenRouterDriver(CostMixin, AsyncDriver):
                 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}
@@ -277,7 +300,7 @@ class AsyncOpenRouterDriver(CostMixin, AsyncDriver):
         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": {
@@ -289,3 +312,6 @@ class AsyncOpenRouterDriver(CostMixin, AsyncDriver):
                 "model_name": model,
             },
         }
+        if full_reasoning:
+            done_chunk["reasoning_content"] = full_reasoning
+        yield done_chunk

prompture/drivers/grok_driver.py

@@ -154,8 +154,17 @@ class GrokDriver(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")
+
+        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
@@ -227,15 +236,20 @@ class GrokDriver(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,
-            })
-
-        return {
+            tool_calls_out.append(
+                {
+                    "id": tc["id"],
+                    "name": tc["function"]["name"],
+                    "arguments": args,
+                }
+            )
+
+        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

prompture/drivers/groq_driver.py

@@ -122,8 +122,16 @@ class GroqDriver(CostMixin, Driver):
         }
 
         # Extract generated text
-        text = resp.choices[0].message.content
-        return {"text": text, "meta": meta}
+        text = resp.choices[0].message.content or ""
+        reasoning_content = getattr(resp.choices[0].message, "reasoning_content", None)
+
+        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
@@ -186,15 +194,21 @@ class GroqDriver(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,
-                })
-
-        return {
+                tool_calls_out.append(
+                    {
+                        "id": tc.id,
+                        "name": tc.function.name,
+                        "arguments": args,
+                    }
+                )
+
+        result: dict[str, Any] = {
             "text": text,
             "meta": meta,
             "tool_calls": tool_calls_out,
             "stop_reason": stop_reason,
         }
+        reasoning_content = getattr(choice.message, "reasoning_content", None)
+        if reasoning_content is not None:
+            result["reasoning_content"] = reasoning_content
+        return result

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/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.47.dev1.dist-info → prompture-0.0.47.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.47.dev1
+Version: 0.0.47.dev3
 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: