prompture 1.13.12.dev1__tar.gz → 1.13.12.dev2__tar.gz

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.13.12.dev1
+Version: 1.13.12.dev2
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT

prompture-1.13.12.dev2/VERSION

@@ -0,0 +1 @@
+1.13.11

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.13.12.dev1'
-__version_tuple__ = version_tuple = (1, 13, 12, 'dev1')
+__version__ = version = '1.13.12.dev2'
+__version_tuple__ = version_tuple = (1, 13, 12, 'dev2')
 
 __commit_id__ = commit_id = None

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture/drivers/async_claude_driver.py

@@ -32,6 +32,7 @@ from .async_base import AsyncDriver
 from .base import _normalize_stop_reason, _translate_tool_choice
 from .claude_driver import (
     ClaudeDriver,
+    _acreate_message,
     _apply_anthropic_reporting_options,
     _apply_temperature,
     _build_anthropic_json_mode_tool_def,
@@ -117,7 +118,7 @@ class AsyncClaudeDriver(_ClaudeModelRules, CostMixin, AsyncDriver):
 
         client = self.client
 
-        system_content, api_messages = _extract_anthropic_system_and_messages(messages)
+        system_content, api_messages = _extract_anthropic_system_and_messages(self._prepare_messages(messages))
 
         cache_kwargs = _cache_opts(opts, model)
         wrapped_system = _apply_cache_control_to_system(system_content, **cache_kwargs)
@@ -158,10 +159,11 @@ class AsyncClaudeDriver(_ClaudeModelRules, CostMixin, AsyncDriver):
         with capture_rate_limits() as limits:
             if options.get("json_mode"):
                 if json_mode_tools is not None:
-                    resp = await client.messages.create(  # type: ignore[call-overload]
-                        **common_kwargs,
-                        tools=json_mode_tools,
-                        tool_choice={"type": "tool", "name": "extract_json"},
+                    resp = await _acreate_message(
+                        client,
+                        {**common_kwargs, "tools": json_mode_tools,
+                         "tool_choice": {"type": "tool", "name": "extract_json"}},
+                        opts,
                     )
                     text = ""
                     for block in resp.content:
@@ -169,10 +171,10 @@ class AsyncClaudeDriver(_ClaudeModelRules, CostMixin, AsyncDriver):
                             text = json.dumps(_json_mode_input(block.input, options["json_schema"]))
                             break
                 else:
-                    resp = await client.messages.create(**common_kwargs)
+                    resp = await _acreate_message(client, common_kwargs, opts)
                     text = _first_text(resp.content)
             else:
-                resp = await client.messages.create(**common_kwargs)
+                resp = await _acreate_message(client, common_kwargs, opts)
                 text = _first_text(resp.content)
 
         reasoning_content = ClaudeDriver._extract_thinking(resp.content)
@@ -196,9 +198,9 @@ class AsyncClaudeDriver(_ClaudeModelRules, CostMixin, AsyncDriver):
         """Clamp the requested max_tokens to the model's known output cap.
 
         Callers commonly pass a generous default (e.g. 65536). Anthropic
-        rejects values above the model ceiling (Claude 4 family: 64000),
-        and the SDK refuses long non-streaming requests outright - so
-        clamp when the capabilities KB knows the real limit.
+        rejects values above the model ceiling (Claude 4 family: 64000), so
+        clamp when the capabilities KB knows the real limit. (Requests this
+        large go over the streaming transport, see ``_acreate_message``.)
         """
         requested = int(opts.get("max_tokens") or 512)
         try:
@@ -239,7 +241,7 @@ class AsyncClaudeDriver(_ClaudeModelRules, CostMixin, AsyncDriver):
 
         client = self.client
 
-        system_content, api_messages = _extract_anthropic_system_and_messages(messages)
+        system_content, api_messages = _extract_anthropic_system_and_messages(self._prepare_messages(messages))
         cache_kwargs = _cache_opts(opts, model)
         anthropic_tools = _apply_cache_control_to_tools(_convert_tools_to_anthropic(tools), **cache_kwargs)
         wrapped_system = _apply_cache_control_to_system(system_content, **cache_kwargs)
@@ -267,7 +269,7 @@ class AsyncClaudeDriver(_ClaudeModelRules, CostMixin, AsyncDriver):
 
         _apply_anthropic_reporting_options(kwargs, opts)
         with capture_rate_limits() as limits:
-            resp = await client.messages.create(**kwargs)
+            resp = await _acreate_message(client, kwargs, opts)
 
         meta = usage_meta(self, "claude", model, resp.usage, response=resp, options=opts)
         meta["raw_response"] = as_dict(resp)
@@ -309,7 +311,7 @@ class AsyncClaudeDriver(_ClaudeModelRules, CostMixin, AsyncDriver):
         supports_temperature = self._get_model_config("claude", model)["supports_temperature"]
         client = self.client
 
-        system_content, api_messages = _extract_anthropic_system_and_messages(messages)
+        system_content, api_messages = _extract_anthropic_system_and_messages(self._prepare_messages(messages))
         cache_kwargs = _cache_opts(opts, model)
         wrapped_system = _apply_cache_control_to_system(system_content, **cache_kwargs)
         api_messages = _apply_cache_control_to_messages(
@@ -408,7 +410,7 @@ class AsyncClaudeDriver(_ClaudeModelRules, CostMixin, AsyncDriver):
         supports_temperature = self._get_model_config("claude", model)["supports_temperature"]
         client = self.client
 
-        system_content, api_messages = _extract_anthropic_system_and_messages(messages)
+        system_content, api_messages = _extract_anthropic_system_and_messages(self._prepare_messages(messages))
         cache_kwargs = _cache_opts(opts, model)
         anthropic_tools = _apply_cache_control_to_tools(_convert_tools_to_anthropic(tools), **cache_kwargs)
         wrapped_system = _apply_cache_control_to_system(system_content, **cache_kwargs)

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture/drivers/async_groq_driver.py

@@ -239,5 +239,7 @@ class AsyncGroqDriver(CostMixin, AsyncDriver):
 
         from ._openai_compat_stream import astream_openai_compat_tool_call
 
-        async for ev in astream_openai_compat_tool_call(self, messages, tools, options, provider="groq"):
+        async for ev in astream_openai_compat_tool_call(
+            self, self._prepare_messages(messages), tools, options, provider="groq"
+        ):
             yield ev

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture/drivers/async_openai_driver.py

@@ -318,5 +318,7 @@ class AsyncOpenAIDriver(CostMixin, AsyncDriver):
 
         from ._openai_compat_stream import astream_openai_compat_tool_call
 
-        async for ev in astream_openai_compat_tool_call(self, messages, tools, options, provider="openai"):
+        async for ev in astream_openai_compat_tool_call(
+            self, self._prepare_messages(messages), tools, options, provider="openai"
+        ):
             yield ev

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture/drivers/claude_driver.py

@@ -95,6 +95,42 @@ def _first_text(content: list[Any]) -> str:
     return "" if first is None or getattr(first, "type", None) == "thinking" else getattr(first, "text", "")
 
 
+# A request that may generate for minutes goes over the streaming API and is collected into
+# the same ``Message`` that ``messages.create()`` returns. A non-streaming request sends no
+# bytes until the whole reply is ready, so a network that closes a silent connection (NAT
+# gateways and load balancers commonly do after 60 s) drops a long generation with "Server
+# disconnected without sending a response"; the SDK also refuses non-streaming requests whose
+# ``max_tokens`` could run past ten minutes. Short requests keep ``create()``. The
+# ``stream_transport`` option forces it either way.
+STREAM_TRANSPORT_ABOVE_MAX_TOKENS = 4096
+
+
+def _stream_transport(kwargs: dict[str, Any], options: dict[str, Any]) -> bool:
+    forced = options.get("stream_transport")
+    if forced is not None:
+        return bool(forced)
+    try:
+        return int(kwargs.get("max_tokens") or 0) > STREAM_TRANSPORT_ABOVE_MAX_TOKENS
+    except (TypeError, ValueError):
+        return False
+
+
+def _create_message(client: Any, kwargs: dict[str, Any], options: dict[str, Any]) -> Any:
+    """``client.messages.create(**kwargs)``, streamed under the hood for long requests."""
+    if not _stream_transport(kwargs, options):
+        return client.messages.create(**kwargs)
+    with client.messages.stream(**kwargs) as stream:
+        return stream.get_final_message()
+
+
+async def _acreate_message(client: Any, kwargs: dict[str, Any], options: dict[str, Any]) -> Any:
+    """Async :func:`_create_message`."""
+    if not _stream_transport(kwargs, options):
+        return await client.messages.create(**kwargs)
+    async with client.messages.stream(**kwargs) as stream:
+        return await stream.get_final_message()
+
+
 class _ClaudeModelRules:
     """Model rules the capabilities KB may not know yet (new models arrive before models.dev has them)."""
 
@@ -568,10 +604,11 @@ class ClaudeDriver(_ClaudeModelRules, CostMixin, Driver):
         with capture_rate_limits() as limits:
             if options.get("json_mode"):
                 if json_mode_tools is not None:
-                    resp = client.messages.create(  # type: ignore[call-overload]
-                        **common_kwargs,
-                        tools=json_mode_tools,
-                        tool_choice={"type": "tool", "name": "extract_json"},
+                    resp = _create_message(
+                        client,
+                        {**common_kwargs, "tools": json_mode_tools,
+                         "tool_choice": {"type": "tool", "name": "extract_json"}},
+                        opts,
                     )
                     text = ""
                     for block in resp.content:
@@ -579,10 +616,10 @@ class ClaudeDriver(_ClaudeModelRules, CostMixin, Driver):
                             text = json.dumps(_json_mode_input(block.input, options["json_schema"]))
                             break
                 else:
-                    resp = client.messages.create(**common_kwargs)
+                    resp = _create_message(client, common_kwargs, opts)
                     text = _first_text(resp.content)
             else:
-                resp = client.messages.create(**common_kwargs)
+                resp = _create_message(client, common_kwargs, opts)
                 text = _first_text(resp.content)
 
         reasoning_content = self._extract_thinking(resp.content)
@@ -618,9 +655,9 @@ class ClaudeDriver(_ClaudeModelRules, CostMixin, Driver):
         """Clamp the requested max_tokens to the model's known output cap.
 
         Callers commonly pass a generous default (e.g. 65536). Anthropic
-        rejects values above the model ceiling (Claude 4 family: 64000),
-        and the SDK refuses long non-streaming requests outright - so
-        clamp when the capabilities KB knows the real limit.
+        rejects values above the model ceiling (Claude 4 family: 64000), so
+        clamp when the capabilities KB knows the real limit. (Requests this
+        large go over the streaming transport, see ``_create_message``.)
         """
         requested = int(opts.get("max_tokens") or 512)
         try:
@@ -662,7 +699,7 @@ class ClaudeDriver(_ClaudeModelRules, CostMixin, Driver):
         client = anthropic.Anthropic(api_key=self.api_key)
         attach_rate_limit_hook(client)
 
-        system_content, api_messages = _extract_anthropic_system_and_messages(messages)
+        system_content, api_messages = _extract_anthropic_system_and_messages(self._prepare_messages(messages))
         cache_kwargs = _cache_opts(opts, model)
         anthropic_tools = _apply_cache_control_to_tools(_convert_tools_to_anthropic(tools), **cache_kwargs)
         wrapped_system = _apply_cache_control_to_system(system_content, **cache_kwargs)
@@ -690,7 +727,7 @@ class ClaudeDriver(_ClaudeModelRules, CostMixin, Driver):
 
         _apply_anthropic_reporting_options(kwargs, opts)
         with capture_rate_limits() as limits:
-            resp = client.messages.create(**kwargs)
+            resp = _create_message(client, kwargs, opts)
 
         meta = usage_meta(self, "claude", model, resp.usage, response=resp, options=opts)
         meta["raw_response"] = as_dict(resp)
@@ -733,7 +770,7 @@ class ClaudeDriver(_ClaudeModelRules, CostMixin, Driver):
         client = anthropic.Anthropic(api_key=self.api_key)
         attach_rate_limit_hook(client)
 
-        system_content, api_messages = _extract_anthropic_system_and_messages(messages)
+        system_content, api_messages = _extract_anthropic_system_and_messages(self._prepare_messages(messages))
         cache_kwargs = _cache_opts(opts, model)
         wrapped_system = _apply_cache_control_to_system(system_content, **cache_kwargs)
         json_mode_tools = None
@@ -870,7 +907,7 @@ class ClaudeDriver(_ClaudeModelRules, CostMixin, Driver):
         client = anthropic.Anthropic(api_key=self.api_key)
         attach_rate_limit_hook(client)
 
-        system_content, api_messages = _extract_anthropic_system_and_messages(messages)
+        system_content, api_messages = _extract_anthropic_system_and_messages(self._prepare_messages(messages))
         cache_kwargs = _cache_opts(opts, model)
         anthropic_tools = _apply_cache_control_to_tools(_convert_tools_to_anthropic(tools), **cache_kwargs)
         wrapped_system = _apply_cache_control_to_system(system_content, **cache_kwargs)

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture/drivers/groq_driver.py

@@ -270,4 +270,6 @@ class GroqDriver(CostMixin, Driver):
 
         from ._openai_compat_stream import stream_openai_compat_tool_call
 
-        yield from stream_openai_compat_tool_call(self, messages, tools, options, provider="groq")
+        yield from stream_openai_compat_tool_call(
+            self, self._prepare_messages(messages), tools, options, provider="groq"
+        )

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture/drivers/openai_driver.py

@@ -479,4 +479,6 @@ class OpenAIDriver(CostMixin, Driver):
 
         from ._openai_compat_stream import stream_openai_compat_tool_call
 
-        yield from stream_openai_compat_tool_call(self, messages, tools, options, provider="openai")
+        yield from stream_openai_compat_tool_call(
+            self, self._prepare_messages(messages), tools, options, provider="openai"
+        )

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture/drivers/vision_helpers.py

@@ -59,7 +59,9 @@ def _prepare_claude_vision_messages(messages: list[dict[str, Any]]) -> list[dict
             continue
         new_blocks: list[dict[str, Any]] = []
         for block in content:
-            if isinstance(block, dict) and block.get("type") == "image":
+            # A block already in Anthropic's shape (its source a plain dict)
+            # passes through, so preparing twice is harmless.
+            if isinstance(block, dict) and block.get("type") == "image" and not isinstance(block.get("source"), dict):
                 source = block["source"]
                 if source.source_type == "url" and source.url:
                     new_blocks.append(

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture/groups/async_groups.py

@@ -209,9 +209,19 @@ class ParallelGroup:
             success=len(errors) == 0,
         )
 
-    def run(self, prompt: str = "", *, deps: Any = None) -> GroupResult:
-        """Sync wrapper around :meth:`run_async`."""
-        return asyncio.run(self.run_async(prompt, deps=deps))
+    def run(self, prompt: str = "", *, deps: Any = None) -> Any:
+        """Run the group: the :class:`GroupResult` outside an event loop, an awaitable inside one.
+
+        Every async group awaits ``child.run(...)``, so a ParallelGroup nested in an
+        ``AsyncSequentialGroup`` or ``AsyncLoopGroup`` is called from a running loop, where
+        ``asyncio.run()`` raises. There it hands back :meth:`run_async`'s coroutine for the
+        parent to await; called from plain sync code it still runs to completion.
+        """
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(self.run_async(prompt, deps=deps))
+        return self.run_async(prompt, deps=deps)
 
 
 # ------------------------------------------------------------------

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.13.12.dev1
+Version: 1.13.12.dev2
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT

{prompture-1.13.12.dev1 → prompture-1.13.12.dev2}/prompture.egg-info/scm_file_list.json

@@ -819,6 +819,7 @@
     "tests/test_claude_fable_json_mode.py",
     "tests/test_claude_json_mode_input.py",
     "tests/test_claude_prompt_caching.py",
+    "tests/test_claude_stream_transport.py",
     "tests/test_claude_temperature_kwarg.py",
     "tests/test_cli.py",
     "tests/test_cli_delegate.py",

prompture-1.13.12.dev1/VERSION

@@ -1 +0,0 @@
-1.13.0