prompture 0.0.47.dev2__py3-none-any.whl → 0.0.48__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.47.dev2'
-__version_tuple__ = version_tuple = (0, 0, 47, 'dev2')
+__version__ = version = '0.0.48'
+__version_tuple__ = version_tuple = (0, 0, 48)
 
 __commit_id__ = commit_id = None

prompture/async_conversation.py

@@ -109,6 +109,9 @@ class AsyncConversation:
         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())
         self._auto_save = Path(auto_save) if auto_save else None
@@ -121,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."""
@@ -326,6 +334,8 @@ class AsyncConversation:
         If tools are registered and the driver supports tool use,
         dispatches to the async tool execution loop.
         """
+        self._last_reasoning = None
+
         # Route to appropriate tool handling
         if self._tools:
             use_native = getattr(self._driver, "supports_tool_use", False)
@@ -340,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})
@@ -372,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
 
@@ -526,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)
@@ -563,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})
@@ -597,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

@@ -112,6 +112,9 @@ class Conversation:
         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())
         self._auto_save = Path(auto_save) if auto_save else None
@@ -124,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."""
@@ -340,6 +348,8 @@ class Conversation:
             images: Optional list of images to include (bytes, path, URL,
                 base64 string, or :class:`ImageContent`).
         """
+        self._last_reasoning = None
+
         # Route to appropriate tool handling
         if self._tools:
             use_native = getattr(self._driver, "supports_tool_use", False)
@@ -354,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)
@@ -389,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
 
@@ -553,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)
@@ -594,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
@@ -632,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_claude_driver.py

@@ -99,6 +99,13 @@ class AsyncClaudeDriver(CostMixin, AsyncDriver):
             resp = await client.messages.create(**common_kwargs)
             text = resp.content[0].text
 
+        # Extract reasoning/thinking content from content blocks
+        reasoning_content = ClaudeDriver._extract_thinking(resp.content)
+
+        # Fallback: use reasoning as text if content is empty
+        if not text and reasoning_content:
+            text = reasoning_content
+
         prompt_tokens = resp.usage.input_tokens
         completion_tokens = resp.usage.output_tokens
         total_tokens = prompt_tokens + completion_tokens
@@ -114,7 +121,10 @@ class AsyncClaudeDriver(CostMixin, AsyncDriver):
             "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
 
     # ------------------------------------------------------------------
     # Helpers
@@ -211,12 +221,17 @@ class AsyncClaudeDriver(CostMixin, AsyncDriver):
                     "arguments": block.input,
                 })
 
-        return {
+        reasoning_content = ClaudeDriver._extract_thinking(resp.content)
+
+        result: dict[str, Any] = {
             "text": text,
             "meta": meta,
             "tool_calls": tool_calls_out,
             "stop_reason": resp.stop_reason,
         }
+        if reasoning_content is not None:
+            result["reasoning_content"] = reasoning_content
+        return result
 
     # ------------------------------------------------------------------
     # Streaming
@@ -247,6 +262,7 @@ class AsyncClaudeDriver(CostMixin, AsyncDriver):
             kwargs["system"] = system_content
 
         full_text = ""
+        full_reasoning = ""
         prompt_tokens = 0
         completion_tokens = 0
 
@@ -254,10 +270,16 @@ class AsyncClaudeDriver(CostMixin, AsyncDriver):
             async for event in stream:
                 if hasattr(event, "type"):
                     if event.type == "content_block_delta" and hasattr(event, "delta"):
-                        delta_text = getattr(event.delta, "text", "")
-                        if delta_text:
-                            full_text += delta_text
-                            yield {"type": "delta", "text": delta_text}
+                        delta_type = getattr(event.delta, "type", "")
+                        if delta_type == "thinking_delta":
+                            thinking_text = getattr(event.delta, "thinking", "")
+                            if thinking_text:
+                                full_reasoning += thinking_text
+                        else:
+                            delta_text = getattr(event.delta, "text", "")
+                            if delta_text:
+                                full_text += delta_text
+                                yield {"type": "delta", "text": delta_text}
                     elif event.type == "message_delta" and hasattr(event, "usage"):
                         completion_tokens = getattr(event.usage, "output_tokens", 0)
                     elif event.type == "message_start" and hasattr(event, "message"):
@@ -268,7 +290,7 @@ class AsyncClaudeDriver(CostMixin, AsyncDriver):
         total_tokens = prompt_tokens + completion_tokens
         total_cost = self._calculate_cost("claude", model, prompt_tokens, completion_tokens)
 
-        yield {
+        done_chunk: dict[str, Any] = {
             "type": "done",
             "text": full_text,
             "meta": {
@@ -280,3 +302,6 @@ class AsyncClaudeDriver(CostMixin, AsyncDriver):
                 "model_name": model,
             },
         }
+        if full_reasoning:
+            done_chunk["reasoning_content"] = full_reasoning
+        yield done_chunk

prompture/drivers/async_grok_driver.py

@@ -95,8 +95,17 @@ 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
@@ -173,15 +182,20 @@ class AsyncGrokDriver(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,
-            })
-
-        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/async_groq_driver.py

@@ -88,8 +88,16 @@ 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
@@ -152,15 +160,21 @@ class AsyncGroqDriver(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,
-                })
-
-        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/async_lmstudio_driver.py

@@ -98,7 +98,12 @@ class AsyncLMStudioDriver(AsyncDriver):
         if "choices" not in response_data or not response_data["choices"]:
             raise ValueError(f"Unexpected response format: {response_data}")
 
-        text = response_data["choices"][0]["message"]["content"]
+        message = response_data["choices"][0]["message"]
+        text = message.get("content") or ""
+        reasoning_content = message.get("reasoning_content")
+
+        if not text and reasoning_content:
+            text = reasoning_content
 
         usage = response_data.get("usage", {})
         prompt_tokens = usage.get("prompt_tokens", 0)
@@ -114,7 +119,10 @@ class AsyncLMStudioDriver(AsyncDriver):
             "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/async_moonshot_driver.py

@@ -138,10 +138,11 @@ class AsyncMoonshotDriver(CostMixin, AsyncDriver):
 
         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.
@@ -184,8 +185,9 @@ class AsyncMoonshotDriver(CostMixin, AsyncDriver):
                     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)
 
@@ -198,7 +200,10 @@ class AsyncMoonshotDriver(CostMixin, AsyncDriver):
             "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
@@ -334,6 +339,7 @@ class AsyncMoonshotDriver(CostMixin, AsyncDriver):
             data["temperature"] = opts["temperature"]
 
         full_text = ""
+        full_reasoning = ""
         prompt_tokens = 0
         completion_tokens = 0
 
@@ -368,9 +374,11 @@ class AsyncMoonshotDriver(CostMixin, AsyncDriver):
                 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}
@@ -378,7 +386,7 @@ class AsyncMoonshotDriver(CostMixin, AsyncDriver):
         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": {
@@ -390,3 +398,6 @@ class AsyncMoonshotDriver(CostMixin, AsyncDriver):
                 "model_name": model,
             },
         }
+        if full_reasoning:
+            done_chunk["reasoning_content"] = full_reasoning
+        yield done_chunk

prompture/drivers/async_ollama_driver.py

@@ -81,7 +81,16 @@ class AsyncOllamaDriver(AsyncDriver):
             "model_name": merged_options.get("model", self.model),
         }
 
-        return {"text": response_data.get("response", ""), "meta": meta}
+        text = response_data.get("response", "")
+        reasoning_content = response_data.get("thinking") or 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
@@ -139,8 +148,12 @@ class AsyncOllamaDriver(AsyncDriver):
 
         message = response_data.get("message", {})
         text = message.get("content") or ""
+        reasoning_content = message.get("thinking") or None
         stop_reason = response_data.get("done_reason", "stop")
 
+        if not text and reasoning_content:
+            text = reasoning_content
+
         tool_calls_out: list[dict[str, Any]] = []
         for tc in message.get("tool_calls", []):
             func = tc.get("function", {})
@@ -158,12 +171,15 @@ class AsyncOllamaDriver(AsyncDriver):
                 "arguments": args,
             })
 
-        return {
+        result: dict[str, Any] = {
             "text": text,
             "meta": meta,
             "tool_calls": tool_calls_out,
             "stop_reason": stop_reason,
         }
+        if reasoning_content is not None:
+            result["reasoning_content"] = reasoning_content
+        return result
 
     async def generate_messages(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
         """Use Ollama's /api/chat endpoint for multi-turn conversations."""
@@ -217,4 +233,12 @@ class AsyncOllamaDriver(AsyncDriver):
 
         message = response_data.get("message", {})
         text = message.get("content", "")
-        return {"text": text, "meta": meta}
+        reasoning_content = message.get("thinking") or 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

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