prompture 1.0.47.dev1__tar.gz → 1.0.48.dev2__tar.gz

{prompture-1.0.47.dev1 → prompture-1.0.48.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.0.47.dev1
+Version: 1.0.48.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.0.47.dev1 → prompture-1.0.48.dev2}/prompture/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.47.dev1'
-__version_tuple__ = version_tuple = (1, 0, 47, 'dev1')
+__version__ = version = '1.0.48.dev2'
+__version_tuple__ = version_tuple = (1, 0, 48, 'dev2')
 
 __commit_id__ = commit_id = None

{prompture-1.0.47.dev1 → prompture-1.0.48.dev2}/prompture/agents/tools_schema.py

@@ -22,6 +22,7 @@ Example::
 from __future__ import annotations
 
 import inspect
+import json
 import logging
 from dataclasses import dataclass, field
 from typing import Any, Callable, get_type_hints
@@ -470,6 +471,36 @@ class ToolRegistry:
         """Join all tool descriptions into a single plain-text block."""
         return "\n\n".join(td.to_prompt_format() for td in self._tools.values())
 
+    # ------------------------------------------------------------------
+    # Argument validation
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _validate_arguments(td: ToolDefinition, arguments: dict[str, Any]) -> str | None:
+        """Return an LLM-friendly error message if required arguments are missing, else ``None``."""
+        schema = td.parameters
+        if not schema or not isinstance(schema, dict):
+            return None
+        required = schema.get("required", [])
+        properties = schema.get("properties", {})
+        missing = [p for p in required if p not in arguments]
+        if not missing:
+            return None
+        parts = []
+        for p in missing:
+            prop = properties.get(p, {})
+            ptype = prop.get("type", "any")
+            desc = prop.get("description", "")
+            detail = f"  - {p} ({ptype})"
+            if desc:
+                detail += f": {desc}"
+            parts.append(detail)
+        return (
+            f"Missing required argument(s) for '{td.name}'. "
+            f"You must provide:\n" + "\n".join(parts) + "\n"
+            f"You sent: {json.dumps(arguments) if arguments else '{} (empty)'}"
+        )
+
     # ------------------------------------------------------------------
     # Execution
     # ------------------------------------------------------------------
@@ -483,6 +514,9 @@ class ToolRegistry:
         td = self._tools.get(name)
         if td is None:
             raise KeyError(f"Tool not registered: {name!r}")
+        error = self._validate_arguments(td, arguments)
+        if error:
+            return error
         return td.function(**arguments)
 
     async def aexecute(self, name: str, arguments: dict[str, Any]) -> Any:
@@ -500,6 +534,9 @@ class ToolRegistry:
         td = self._tools.get(name)
         if td is None:
             raise KeyError(f"Tool not registered: {name!r}")
+        error = self._validate_arguments(td, arguments)
+        if error:
+            return error
         # Prefer dedicated async wrapper (set by tukuy bridge)
         async_fn = getattr(td.function, "_async_fn", None)
         if async_fn is not None:

{prompture-1.0.47.dev1 → prompture-1.0.48.dev2}/prompture/drivers/async_grok_driver.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import json
 import logging
 import os
 from typing import Any
@@ -11,6 +10,7 @@ import httpx
 
 from ..infra.cost_mixin import CostMixin
 from .async_base import AsyncDriver
+from .base import _parse_tool_arguments
 from .grok_driver import GrokDriver
 
 logger = logging.getLogger(__name__)
@@ -181,25 +181,7 @@ class AsyncGrokDriver(CostMixin, AsyncDriver):
 
         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):
-                raw = tc["function"].get("arguments")
-                if stop_reason == "length":
-                    logger.warning(
-                        "Tool arguments for %s were truncated due to max_tokens limit. "
-                        "Increase max_tokens in options to allow longer tool outputs. "
-                        "Truncated arguments: %r",
-                        tc["function"]["name"],
-                        raw[:200] if raw else raw,
-                    )
-                else:
-                    logger.warning(
-                        "Failed to parse tool arguments for %s: %r",
-                        tc["function"]["name"],
-                        raw,
-                    )
-                args = {}
+            args = _parse_tool_arguments(tc["function"]["arguments"], tc["function"]["name"], stop_reason)
             tool_calls_out.append(
                 {
                     "id": tc["id"],

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

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import json
 import logging
 import os
 from typing import Any
@@ -14,6 +13,7 @@ except Exception:
 
 from ..infra.cost_mixin import CostMixin
 from .async_base import AsyncDriver
+from .base import _parse_tool_arguments
 from .groq_driver import GroqDriver
 
 logger = logging.getLogger(__name__)
@@ -159,25 +159,7 @@ class AsyncGroqDriver(CostMixin, AsyncDriver):
         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):
-                    raw = tc.function.arguments
-                    if stop_reason == "length":
-                        logger.warning(
-                            "Tool arguments for %s were truncated due to max_tokens limit. "
-                            "Increase max_tokens in options to allow longer tool outputs. "
-                            "Truncated arguments: %r",
-                            tc.function.name,
-                            raw[:200] if raw else raw,
-                        )
-                    else:
-                        logger.warning(
-                            "Failed to parse tool arguments for %s: %r",
-                            tc.function.name,
-                            raw,
-                        )
-                    args = {}
+                args = _parse_tool_arguments(tc.function.arguments, tc.function.name, stop_reason)
                 tool_calls_out.append(
                     {
                         "id": tc.id,

{prompture-1.0.47.dev1 → prompture-1.0.48.dev2}/prompture/drivers/async_moonshot_driver.py

@@ -19,6 +19,7 @@ import httpx
 
 from ..infra.cost_mixin import CostMixin, prepare_strict_schema
 from .async_base import AsyncDriver
+from .base import _parse_tool_arguments
 from .moonshot_driver import MoonshotDriver
 
 logger = logging.getLogger("prompture.drivers.moonshot")
@@ -297,25 +298,7 @@ class AsyncMoonshotDriver(CostMixin, AsyncDriver):
 
         tool_calls_out: list[dict[str, Any]] = []
         for tc in message.get("tool_calls", []):
-            try:
-                args = json.loads(tc["function"]["arguments"])
-            except (json.JSONDecodeError, TypeError):
-                raw = tc["function"].get("arguments")
-                if stop_reason == "length":
-                    logger.warning(
-                        "Tool arguments for %s were truncated due to max_tokens limit. "
-                        "Increase max_tokens in options to allow longer tool outputs. "
-                        "Truncated arguments: %r",
-                        tc["function"]["name"],
-                        raw[:200] if raw else raw,
-                    )
-                else:
-                    logger.warning(
-                        "Failed to parse tool arguments for %s: %r",
-                        tc["function"]["name"],
-                        raw,
-                    )
-                args = {}
+            args = _parse_tool_arguments(tc["function"]["arguments"], tc["function"]["name"], stop_reason)
             tool_calls_out.append(
                 {
                     "id": tc["id"],

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

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import json
 import logging
 import os
 from collections.abc import AsyncIterator
@@ -15,6 +14,7 @@ except Exception:
 
 from ..infra.cost_mixin import CostMixin, prepare_strict_schema
 from .async_base import AsyncDriver
+from .base import _parse_tool_arguments
 from .openai_driver import OpenAIDriver
 
 logger = logging.getLogger(__name__)
@@ -176,25 +176,7 @@ class AsyncOpenAIDriver(CostMixin, AsyncDriver):
         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):
-                    raw = tc.function.arguments
-                    if stop_reason == "length":
-                        logger.warning(
-                            "Tool arguments for %s were truncated due to max_tokens limit. "
-                            "Increase max_tokens in options to allow longer tool outputs. "
-                            "Truncated arguments: %r",
-                            tc.function.name,
-                            raw[:200] if raw else raw,
-                        )
-                    else:
-                        logger.warning(
-                            "Failed to parse tool arguments for %s: %r",
-                            tc.function.name,
-                            raw,
-                        )
-                    args = {}
+                args = _parse_tool_arguments(tc.function.arguments, tc.function.name, stop_reason)
                 tool_calls_out.append(
                     {
                         "id": tc.id,

{prompture-1.0.47.dev1 → prompture-1.0.48.dev2}/prompture/drivers/async_openrouter_driver.py

@@ -12,6 +12,7 @@ import httpx
 
 from ..infra.cost_mixin import CostMixin, prepare_strict_schema
 from .async_base import AsyncDriver
+from .base import _parse_tool_arguments
 from .openrouter_driver import OpenRouterDriver
 
 logger = logging.getLogger(__name__)
@@ -204,25 +205,7 @@ class AsyncOpenRouterDriver(CostMixin, AsyncDriver):
 
         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):
-                raw = tc["function"].get("arguments")
-                if stop_reason == "length":
-                    logger.warning(
-                        "Tool arguments for %s were truncated due to max_tokens limit. "
-                        "Increase max_tokens in options to allow longer tool outputs. "
-                        "Truncated arguments: %r",
-                        tc["function"]["name"],
-                        raw[:200] if raw else raw,
-                    )
-                else:
-                    logger.warning(
-                        "Failed to parse tool arguments for %s: %r",
-                        tc["function"]["name"],
-                        raw,
-                    )
-                args = {}
+            args = _parse_tool_arguments(tc["function"]["arguments"], tc["function"]["name"], stop_reason)
             tool_calls_out.append(
                 {
                     "id": tc["id"],

{prompture-1.0.47.dev1 → prompture-1.0.48.dev2}/prompture/drivers/base.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import logging
 import time
 from abc import ABC, abstractmethod
@@ -20,6 +21,51 @@ from ..infra.callbacks import DriverCallbacks
 logger = logging.getLogger("prompture.driver")
 
 
+# ------------------------------------------------------------------
+# Shared tool-argument parser for OpenAI-compatible drivers
+# ------------------------------------------------------------------
+
+
+def _parse_tool_arguments(raw_args: Any, tool_name: str, stop_reason: str | None = None) -> dict[str, Any]:
+    """Parse tool call arguments, handling both string and dict formats.
+
+    Some providers return ``arguments`` as a JSON string, others as an
+    already-parsed dict.  Calling ``json.loads()`` on a dict raises
+    ``TypeError`` which previously caused a silent fallback to ``{}``.
+    """
+    if isinstance(raw_args, dict):
+        return raw_args
+    if isinstance(raw_args, str):
+        try:
+            parsed = json.loads(raw_args)
+            return parsed if isinstance(parsed, dict) else {}
+        except json.JSONDecodeError:
+            if stop_reason == "length":
+                logger.warning(
+                    "Tool arguments for %s were truncated due to max_tokens limit. "
+                    "Increase max_tokens in options to allow longer tool outputs. "
+                    "Truncated arguments: %r",
+                    tool_name,
+                    raw_args[:200] if raw_args else raw_args,
+                )
+            else:
+                logger.warning(
+                    "Failed to parse tool arguments for %s: %r",
+                    tool_name,
+                    raw_args[:200] if raw_args else raw_args,
+                )
+            return {}
+    if raw_args is None:
+        return {}
+    logger.warning(
+        "Unexpected argument type %s for tool %s: %r",
+        type(raw_args).__name__,
+        tool_name,
+        raw_args,
+    )
+    return {}
+
+
 # ------------------------------------------------------------------
 # Shared helper for OpenAI-compatible /v1/models endpoints
 # ------------------------------------------------------------------

{prompture-1.0.47.dev1 → prompture-1.0.48.dev2}/prompture/drivers/grok_driver.py

@@ -2,7 +2,6 @@
 Requires the `requests` package. Uses GROK_API_KEY env var.
 """
 
-import json
 import logging
 import os
 from typing import Any
@@ -10,7 +9,7 @@ from typing import Any
 import requests
 
 from ..infra.cost_mixin import CostMixin
-from .base import Driver
+from .base import Driver, _parse_tool_arguments
 
 logger = logging.getLogger(__name__)
 
@@ -245,25 +244,7 @@ class GrokDriver(CostMixin, Driver):
 
         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):
-                raw = tc["function"].get("arguments")
-                if stop_reason == "length":
-                    logger.warning(
-                        "Tool arguments for %s were truncated due to max_tokens limit. "
-                        "Increase max_tokens in options to allow longer tool outputs. "
-                        "Truncated arguments: %r",
-                        tc["function"]["name"],
-                        raw[:200] if raw else raw,
-                    )
-                else:
-                    logger.warning(
-                        "Failed to parse tool arguments for %s: %r",
-                        tc["function"]["name"],
-                        raw,
-                    )
-                args = {}
+            args = _parse_tool_arguments(tc["function"]["arguments"], tc["function"]["name"], stop_reason)
             tool_calls_out.append(
                 {
                     "id": tc["id"],

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

@@ -2,7 +2,6 @@
 Requires the `groq` package. Uses GROQ_API_KEY env var.
 """
 
-import json
 import logging
 import os
 from typing import Any
@@ -13,7 +12,7 @@ except Exception:
     groq = None  # type: ignore[assignment]
 
 from ..infra.cost_mixin import CostMixin
-from .base import Driver
+from .base import Driver, _parse_tool_arguments
 
 logger = logging.getLogger(__name__)
 
@@ -203,25 +202,7 @@ class GroqDriver(CostMixin, Driver):
         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):
-                    raw = tc.function.arguments
-                    if stop_reason == "length":
-                        logger.warning(
-                            "Tool arguments for %s were truncated due to max_tokens limit. "
-                            "Increase max_tokens in options to allow longer tool outputs. "
-                            "Truncated arguments: %r",
-                            tc.function.name,
-                            raw[:200] if raw else raw,
-                        )
-                    else:
-                        logger.warning(
-                            "Failed to parse tool arguments for %s: %r",
-                            tc.function.name,
-                            raw,
-                        )
-                    args = {}
+                args = _parse_tool_arguments(tc.function.arguments, tc.function.name, stop_reason)
                 tool_calls_out.append(
                     {
                         "id": tc.id,

{prompture-1.0.47.dev1 → prompture-1.0.48.dev2}/prompture/drivers/moonshot_driver.py

@@ -18,7 +18,7 @@ from typing import Any
 import requests
 
 from ..infra.cost_mixin import CostMixin, prepare_strict_schema
-from .base import Driver
+from .base import Driver, _parse_tool_arguments
 
 logger = logging.getLogger("prompture.drivers.moonshot")
 
@@ -416,25 +416,7 @@ class MoonshotDriver(CostMixin, Driver):
 
         tool_calls_out: list[dict[str, Any]] = []
         for tc in message.get("tool_calls", []):
-            try:
-                args = json.loads(tc["function"]["arguments"])
-            except (json.JSONDecodeError, TypeError):
-                raw = tc["function"].get("arguments")
-                if stop_reason == "length":
-                    logger.warning(
-                        "Tool arguments for %s were truncated due to max_tokens limit. "
-                        "Increase max_tokens in options to allow longer tool outputs. "
-                        "Truncated arguments: %r",
-                        tc["function"]["name"],
-                        raw[:200] if raw else raw,
-                    )
-                else:
-                    logger.warning(
-                        "Failed to parse tool arguments for %s: %r",
-                        tc["function"]["name"],
-                        raw,
-                    )
-                args = {}
+            args = _parse_tool_arguments(tc["function"]["arguments"], tc["function"]["name"], stop_reason)
             tool_calls_out.append(
                 {
                     "id": tc["id"],

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

@@ -2,7 +2,6 @@
 Requires the `openai` package. Uses OPENAI_API_KEY env var.
 """
 
-import json
 import logging
 import os
 from collections.abc import Iterator
@@ -14,7 +13,7 @@ except Exception:
     OpenAI = None  # type: ignore[misc, assignment]
 
 from ..infra.cost_mixin import CostMixin, prepare_strict_schema
-from .base import Driver
+from .base import Driver, _parse_tool_arguments
 
 logger = logging.getLogger(__name__)
 
@@ -234,25 +233,7 @@ class OpenAIDriver(CostMixin, Driver):
         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):
-                    raw = tc.function.arguments
-                    if stop_reason == "length":
-                        logger.warning(
-                            "Tool arguments for %s were truncated due to max_tokens limit. "
-                            "Increase max_tokens in options to allow longer tool outputs. "
-                            "Truncated arguments: %r",
-                            tc.function.name,
-                            raw[:200] if raw else raw,
-                        )
-                    else:
-                        logger.warning(
-                            "Failed to parse tool arguments for %s: %r",
-                            tc.function.name,
-                            raw,
-                        )
-                    args = {}
+                args = _parse_tool_arguments(tc.function.arguments, tc.function.name, stop_reason)
                 tool_calls_out.append(
                     {
                         "id": tc.id,

{prompture-1.0.47.dev1 → prompture-1.0.48.dev2}/prompture/drivers/openrouter_driver.py

@@ -12,7 +12,7 @@ from typing import Any
 import requests
 
 from ..infra.cost_mixin import CostMixin, prepare_strict_schema
-from .base import Driver
+from .base import Driver, _parse_tool_arguments
 
 logger = logging.getLogger(__name__)
 
@@ -281,25 +281,7 @@ class OpenRouterDriver(CostMixin, Driver):
 
         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):
-                raw = tc["function"].get("arguments")
-                if stop_reason == "length":
-                    logger.warning(
-                        "Tool arguments for %s were truncated due to max_tokens limit. "
-                        "Increase max_tokens in options to allow longer tool outputs. "
-                        "Truncated arguments: %r",
-                        tc["function"]["name"],
-                        raw[:200] if raw else raw,
-                    )
-                else:
-                    logger.warning(
-                        "Failed to parse tool arguments for %s: %r",
-                        tc["function"]["name"],
-                        raw,
-                    )
-                args = {}
+            args = _parse_tool_arguments(tc["function"]["arguments"], tc["function"]["name"], stop_reason)
             tool_calls_out.append(
                 {
                     "id": tc["id"],

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

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