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

prompture/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.46.dev1'
-__version_tuple__ = version_tuple = (0, 0, 46, 'dev1')
+__version__ = version = '0.0.47'
+__version_tuple__ = version_tuple = (0, 0, 47)
 
 __commit_id__ = commit_id = None

prompture/async_conversation.py

@@ -55,6 +55,7 @@ class AsyncConversation:
         callbacks: DriverCallbacks | None = None,
         tools: ToolRegistry | None = None,
         max_tool_rounds: int = 10,
+        simulated_tools: bool | Literal["auto"] = "auto",
         conversation_id: str | None = None,
         auto_save: str | Path | None = None,
         tags: list[str] | None = None,
@@ -106,6 +107,10 @@ class AsyncConversation:
         }
         self._tools = tools or ToolRegistry()
         self._max_tool_rounds = max_tool_rounds
+        self._simulated_tools = simulated_tools
+
+        # Reasoning content from last response
+        self._last_reasoning: str | None = None
 
         # Persistence
         self._conversation_id = conversation_id or str(uuid.uuid4())
@@ -119,6 +124,11 @@ class AsyncConversation:
     # Public helpers
     # ------------------------------------------------------------------
 
+    @property
+    def last_reasoning(self) -> str | None:
+        """The reasoning/thinking content from the last LLM response, if any."""
+        return self._last_reasoning
+
     @property
     def messages(self) -> list[dict[str, Any]]:
         """Read-only view of the conversation history."""
@@ -324,8 +334,15 @@ class AsyncConversation:
         If tools are registered and the driver supports tool use,
         dispatches to the async tool execution loop.
         """
-        if self._tools and getattr(self._driver, "supports_tool_use", False):
-            return await self._ask_with_tools(content, options, images=images)
+        self._last_reasoning = None
+
+        # Route to appropriate tool handling
+        if self._tools:
+            use_native = getattr(self._driver, "supports_tool_use", False)
+            if self._simulated_tools is True or (self._simulated_tools == "auto" and not use_native):
+                return await self._ask_with_simulated_tools(content, options, images=images)
+            elif use_native and self._simulated_tools is not True:
+                return await self._ask_with_tools(content, options, images=images)
 
         merged = {**self._options, **(options or {})}
         messages = self._build_messages(content, images=images)
@@ -333,6 +350,7 @@ class AsyncConversation:
 
         text = resp.get("text", "")
         meta = resp.get("meta", {})
+        self._last_reasoning = resp.get("reasoning_content")
 
         user_content = self._build_content_with_images(content, images)
         self._messages.append({"role": "user", "content": user_content})
@@ -365,6 +383,7 @@ class AsyncConversation:
             text = resp.get("text", "")
 
             if not tool_calls:
+                self._last_reasoning = resp.get("reasoning_content")
                 self._messages.append({"role": "assistant", "content": text})
                 return text
 
@@ -377,6 +396,11 @@ class AsyncConversation:
                 }
                 for tc in tool_calls
             ]
+            # Preserve reasoning_content for providers that require it
+            # on subsequent requests (e.g. Moonshot reasoning models).
+            if resp.get("reasoning_content") is not None:
+                assistant_msg["reasoning_content"] = resp["reasoning_content"]
+
             self._messages.append(assistant_msg)
             msgs.append(assistant_msg)
 
@@ -397,6 +421,63 @@ class AsyncConversation:
 
         raise RuntimeError(f"Tool execution loop exceeded {self._max_tool_rounds} rounds")
 
+    async def _ask_with_simulated_tools(
+        self,
+        content: str,
+        options: dict[str, Any] | None = None,
+        images: list[ImageInput] | None = None,
+    ) -> str:
+        """Async prompt-based tool calling for drivers without native tool use."""
+        from .simulated_tools import build_tool_prompt, format_tool_result, parse_simulated_response
+
+        merged = {**self._options, **(options or {})}
+        tool_prompt = build_tool_prompt(self._tools)
+
+        # Augment system prompt with tool descriptions
+        augmented_system = tool_prompt
+        if self._system_prompt:
+            augmented_system = f"{self._system_prompt}\n\n{tool_prompt}"
+
+        # Record user message in history
+        user_content = self._build_content_with_images(content, images)
+        self._messages.append({"role": "user", "content": user_content})
+
+        for _round in range(self._max_tool_rounds):
+            # Build messages with the augmented system prompt
+            msgs: list[dict[str, Any]] = []
+            msgs.append({"role": "system", "content": augmented_system})
+            msgs.extend(self._messages)
+
+            resp = await self._driver.generate_messages_with_hooks(msgs, merged)
+            text = resp.get("text", "")
+            meta = resp.get("meta", {})
+            self._accumulate_usage(meta)
+
+            parsed = parse_simulated_response(text, self._tools)
+
+            if parsed["type"] == "final_answer":
+                answer = parsed["content"]
+                self._messages.append({"role": "assistant", "content": answer})
+                return answer
+
+            # Tool call
+            tool_name = parsed["name"]
+            tool_args = parsed["arguments"]
+
+            # Record assistant's tool call as an assistant message
+            self._messages.append({"role": "assistant", "content": text})
+
+            try:
+                result = self._tools.execute(tool_name, tool_args)
+                result_msg = format_tool_result(tool_name, result)
+            except Exception as exc:
+                result_msg = format_tool_result(tool_name, f"Error: {exc}")
+
+            # Record tool result as a user message
+            self._messages.append({"role": "user", "content": result_msg})
+
+        raise RuntimeError(f"Simulated tool execution loop exceeded {self._max_tool_rounds} rounds")
+
     def _build_messages_raw(self) -> list[dict[str, Any]]:
         """Build messages array from system prompt + full history (including tool messages)."""
         msgs: list[dict[str, Any]] = []
@@ -457,6 +538,8 @@ class AsyncConversation:
         images: list[ImageInput] | None = None,
     ) -> dict[str, Any]:
         """Send a message with schema enforcement and get structured JSON back (async)."""
+        self._last_reasoning = None
+
         merged = {**self._options, **(options or {})}
 
         schema_string = json.dumps(json_schema, indent=2)
@@ -494,6 +577,7 @@ class AsyncConversation:
 
         text = resp.get("text", "")
         meta = resp.get("meta", {})
+        self._last_reasoning = resp.get("reasoning_content")
 
         user_content = self._build_content_with_images(content, images)
         self._messages.append({"role": "user", "content": user_content})
@@ -528,6 +612,7 @@ class AsyncConversation:
             "json_object": json_obj,
             "usage": usage,
             "output_format": output_format,
+            "reasoning": self._last_reasoning,
         }
 
         if output_format == "toon":

prompture/conversation.py

@@ -56,6 +56,7 @@ class Conversation:
         callbacks: DriverCallbacks | None = None,
         tools: ToolRegistry | None = None,
         max_tool_rounds: int = 10,
+        simulated_tools: bool | Literal["auto"] = "auto",
         conversation_id: str | None = None,
         auto_save: str | Path | None = None,
         tags: list[str] | None = None,
@@ -109,6 +110,10 @@ class Conversation:
         }
         self._tools = tools or ToolRegistry()
         self._max_tool_rounds = max_tool_rounds
+        self._simulated_tools = simulated_tools
+
+        # Reasoning content from last response
+        self._last_reasoning: str | None = None
 
         # Persistence
         self._conversation_id = conversation_id or str(uuid.uuid4())
@@ -122,6 +127,11 @@ class Conversation:
     # Public helpers
     # ------------------------------------------------------------------
 
+    @property
+    def last_reasoning(self) -> str | None:
+        """The reasoning/thinking content from the last LLM response, if any."""
+        return self._last_reasoning
+
     @property
     def messages(self) -> list[dict[str, Any]]:
         """Read-only view of the conversation history."""
@@ -338,8 +348,15 @@ class Conversation:
             images: Optional list of images to include (bytes, path, URL,
                 base64 string, or :class:`ImageContent`).
         """
-        if self._tools and getattr(self._driver, "supports_tool_use", False):
-            return self._ask_with_tools(content, options, images=images)
+        self._last_reasoning = None
+
+        # Route to appropriate tool handling
+        if self._tools:
+            use_native = getattr(self._driver, "supports_tool_use", False)
+            if self._simulated_tools is True or (self._simulated_tools == "auto" and not use_native):
+                return self._ask_with_simulated_tools(content, options, images=images)
+            elif use_native and self._simulated_tools is not True:
+                return self._ask_with_tools(content, options, images=images)
 
         merged = {**self._options, **(options or {})}
         messages = self._build_messages(content, images=images)
@@ -347,6 +364,7 @@ class Conversation:
 
         text = resp.get("text", "")
         meta = resp.get("meta", {})
+        self._last_reasoning = resp.get("reasoning_content")
 
         # Record in history — store content with images for context
         user_content = self._build_content_with_images(content, images)
@@ -382,6 +400,7 @@ class Conversation:
 
             if not tool_calls:
                 # No tool calls -> final response
+                self._last_reasoning = resp.get("reasoning_content")
                 self._messages.append({"role": "assistant", "content": text})
                 return text
 
@@ -395,6 +414,11 @@ class Conversation:
                 }
                 for tc in tool_calls
             ]
+            # Preserve reasoning_content for providers that require it
+            # on subsequent requests (e.g. Moonshot reasoning models).
+            if resp.get("reasoning_content") is not None:
+                assistant_msg["reasoning_content"] = resp["reasoning_content"]
+
             self._messages.append(assistant_msg)
             msgs.append(assistant_msg)
 
@@ -416,6 +440,63 @@ class Conversation:
 
         raise RuntimeError(f"Tool execution loop exceeded {self._max_tool_rounds} rounds")
 
+    def _ask_with_simulated_tools(
+        self,
+        content: str,
+        options: dict[str, Any] | None = None,
+        images: list[ImageInput] | None = None,
+    ) -> str:
+        """Prompt-based tool calling for drivers without native tool use."""
+        from .simulated_tools import build_tool_prompt, format_tool_result, parse_simulated_response
+
+        merged = {**self._options, **(options or {})}
+        tool_prompt = build_tool_prompt(self._tools)
+
+        # Augment system prompt with tool descriptions
+        augmented_system = tool_prompt
+        if self._system_prompt:
+            augmented_system = f"{self._system_prompt}\n\n{tool_prompt}"
+
+        # Record user message in history
+        user_content = self._build_content_with_images(content, images)
+        self._messages.append({"role": "user", "content": user_content})
+
+        for _round in range(self._max_tool_rounds):
+            # Build messages with the augmented system prompt
+            msgs: list[dict[str, Any]] = []
+            msgs.append({"role": "system", "content": augmented_system})
+            msgs.extend(self._messages)
+
+            resp = self._driver.generate_messages_with_hooks(msgs, merged)
+            text = resp.get("text", "")
+            meta = resp.get("meta", {})
+            self._accumulate_usage(meta)
+
+            parsed = parse_simulated_response(text, self._tools)
+
+            if parsed["type"] == "final_answer":
+                answer = parsed["content"]
+                self._messages.append({"role": "assistant", "content": answer})
+                return answer
+
+            # Tool call
+            tool_name = parsed["name"]
+            tool_args = parsed["arguments"]
+
+            # Record assistant's tool call as an assistant message
+            self._messages.append({"role": "assistant", "content": text})
+
+            try:
+                result = self._tools.execute(tool_name, tool_args)
+                result_msg = format_tool_result(tool_name, result)
+            except Exception as exc:
+                result_msg = format_tool_result(tool_name, f"Error: {exc}")
+
+            # Record tool result as a user message (all drivers understand user/assistant)
+            self._messages.append({"role": "user", "content": result_msg})
+
+        raise RuntimeError(f"Simulated tool execution loop exceeded {self._max_tool_rounds} rounds")
+
     def _build_messages_raw(self) -> list[dict[str, Any]]:
         """Build messages array from system prompt + full history (including tool messages)."""
         msgs: list[dict[str, Any]] = []
@@ -484,6 +565,8 @@ class Conversation:
         context clean for subsequent turns.
         """
 
+        self._last_reasoning = None
+
         merged = {**self._options, **(options or {})}
 
         # Build the full prompt with schema instructions inline (handled by ask_for_json)
@@ -525,6 +608,7 @@ class Conversation:
 
         text = resp.get("text", "")
         meta = resp.get("meta", {})
+        self._last_reasoning = resp.get("reasoning_content")
 
         # Store original content (without schema boilerplate) for cleaner context
         # Include images in history so subsequent turns can reference them
@@ -563,6 +647,7 @@ class Conversation:
             "json_object": json_obj,
             "usage": usage,
             "output_format": output_format,
+            "reasoning": self._last_reasoning,
         }
 
         if output_format == "toon":

prompture/drivers/async_azure_driver.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import os
 from typing import Any
 
@@ -18,6 +19,7 @@ from .azure_driver import AzureDriver
 class AsyncAzureDriver(CostMixin, AsyncDriver):
     supports_json_mode = True
     supports_json_schema = True
+    supports_tool_use = True
     supports_vision = True
 
     MODEL_PRICING = AzureDriver.MODEL_PRICING
@@ -122,3 +124,78 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
 
         text = resp.choices[0].message.content
         return {"text": text, "meta": meta}
+
+    # ------------------------------------------------------------------
+    # 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."""
+        if self.client is None:
+            raise RuntimeError("openai package (>=1.0.0) with AsyncAzureOpenAI not installed")
+
+        model = options.get("model", self.model)
+        model_config = self._get_model_config("azure", model)
+        tokens_param = model_config["tokens_param"]
+        supports_temperature = model_config["supports_temperature"]
+
+        self._validate_model_capabilities("azure", model, using_tool_use=True)
+
+        opts = {"temperature": 1.0, "max_tokens": 512, **options}
+
+        kwargs: dict[str, Any] = {
+            "model": self.deployment_id,
+            "messages": messages,
+            "tools": tools,
+        }
+        kwargs[tokens_param] = opts.get("max_tokens", 512)
+
+        if supports_temperature and "temperature" in opts:
+            kwargs["temperature"] = opts["temperature"]
+
+        resp = await self.client.chat.completions.create(**kwargs)
+
+        usage = getattr(resp, "usage", None)
+        prompt_tokens = getattr(usage, "prompt_tokens", 0)
+        completion_tokens = getattr(usage, "completion_tokens", 0)
+        total_tokens = getattr(usage, "total_tokens", 0)
+        total_cost = self._calculate_cost("azure", 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": resp.model_dump(),
+            "model_name": model,
+            "deployment_id": self.deployment_id,
+        }
+
+        choice = resp.choices[0]
+        text = choice.message.content or ""
+        stop_reason = choice.finish_reason
+
+        tool_calls_out: list[dict[str, Any]] = []
+        if choice.message.tool_calls:
+            for tc in choice.message.tool_calls:
+                try:
+                    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 {
+            "text": text,
+            "meta": meta,
+            "tool_calls": tool_calls_out,
+            "stop_reason": stop_reason,
+        }

prompture/drivers/async_grok_driver.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import os
 from typing import Any
 
@@ -14,6 +15,7 @@ from .grok_driver import GrokDriver
 
 class AsyncGrokDriver(CostMixin, AsyncDriver):
     supports_json_mode = True
+    supports_tool_use = True
     supports_vision = True
 
     MODEL_PRICING = GrokDriver.MODEL_PRICING
@@ -93,5 +95,107 @@ class AsyncGrokDriver(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
+    # ------------------------------------------------------------------
+
+    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."""
+        if not self.api_key:
+            raise RuntimeError("GROK_API_KEY environment variable is required")
+
+        model = options.get("model", self.model)
+        model_config = self._get_model_config("grok", model)
+        tokens_param = model_config["tokens_param"]
+        supports_temperature = model_config["supports_temperature"]
+
+        self._validate_model_capabilities("grok", model, using_tool_use=True)
+
+        opts = {"temperature": 1.0, "max_tokens": 512, **options}
+
+        payload: dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "tools": tools,
+        }
+        payload[tokens_param] = opts.get("max_tokens", 512)
+
+        if supports_temperature and "temperature" in opts:
+            payload["temperature"] = opts["temperature"]
+
+        if "tool_choice" in options:
+            payload["tool_choice"] = options["tool_choice"]
+
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.api_base}/chat/completions", headers=headers, json=payload, timeout=120
+                )
+                response.raise_for_status()
+                resp = response.json()
+            except httpx.HTTPStatusError as e:
+                raise RuntimeError(f"Grok API request failed: {e!s}") from e
+            except Exception as e:
+                raise RuntimeError(f"Grok API request failed: {e!s}") from e
+
+        usage = resp.get("usage", {})
+        prompt_tokens = usage.get("prompt_tokens", 0)
+        completion_tokens = usage.get("completion_tokens", 0)
+        total_tokens = usage.get("total_tokens", 0)
+        total_cost = self._calculate_cost("grok", 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": resp,
+            "model_name": model,
+        }
+
+        choice = resp["choices"][0]
+        text = choice["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", []):
+            try:
+                args = json.loads(tc["function"]["arguments"])
+            except (json.JSONDecodeError, TypeError):
+                args = {}
+            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/async_groq_driver.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import os
 from typing import Any
 
@@ -17,6 +18,7 @@ from .groq_driver import GroqDriver
 
 class AsyncGroqDriver(CostMixin, AsyncDriver):
     supports_json_mode = True
+    supports_tool_use = True
     supports_vision = True
 
     MODEL_PRICING = GroqDriver.MODEL_PRICING
@@ -86,5 +88,93 @@ class AsyncGroqDriver(CostMixin, AsyncDriver):
             "model_name": model,
         }
 
-        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
+    # ------------------------------------------------------------------
+
+    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."""
+        if self.client is None:
+            raise RuntimeError("groq package is not installed")
+
+        model = options.get("model", self.model)
+        model_config = self._get_model_config("groq", model)
+        tokens_param = model_config["tokens_param"]
+        supports_temperature = model_config["supports_temperature"]
+
+        self._validate_model_capabilities("groq", model, using_tool_use=True)
+
+        opts = {"temperature": 0.7, "max_tokens": 512, **options}
+
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "tools": tools,
+        }
+        kwargs[tokens_param] = opts.get("max_tokens", 512)
+
+        if supports_temperature and "temperature" in opts:
+            kwargs["temperature"] = opts["temperature"]
+
+        resp = await self.client.chat.completions.create(**kwargs)
+
+        usage = getattr(resp, "usage", None)
+        prompt_tokens = getattr(usage, "prompt_tokens", 0)
+        completion_tokens = getattr(usage, "completion_tokens", 0)
+        total_tokens = getattr(usage, "total_tokens", 0)
+        total_cost = self._calculate_cost("groq", 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": resp.model_dump(),
+            "model_name": model,
+        }
+
+        choice = resp.choices[0]
+        text = choice.message.content or ""
+        stop_reason = choice.finish_reason
+
+        tool_calls_out: list[dict[str, Any]] = []
+        if choice.message.tool_calls:
+            for tc in choice.message.tool_calls:
+                try:
+                    args = json.loads(tc.function.arguments)
+                except (json.JSONDecodeError, TypeError):
+                    args = {}
+                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