selectools 1.1.0__tar.gz → 1.2.0__tar.gz

{selectools-1.1.0/src/selectools.egg-info → selectools-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: selectools
-Version: 1.1.0
+Version: 1.2.0
 Summary: Production-ready Python framework for AI agents with multi-agent graphs, hybrid RAG, guardrails, audit logging, 50 evaluators, and a visual builder. Supports OpenAI, Anthropic, Gemini, Ollama. By NichevLabs.
 Author-email: John Nichev <johnnichev@gmail.com>
 Maintainer-email: NichevLabs <support@nichevlabs.com>

{selectools-1.1.0 → selectools-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "selectools"
-version = "1.1.0"
+version = "1.2.0"
 description = "Production-ready Python framework for AI agents with multi-agent graphs, hybrid RAG, guardrails, audit logging, 50 evaluators, and a visual builder. Supports OpenAI, Anthropic, Gemini, Ollama. By NichevLabs."
 readme = "README.md"
 requires-python = ">=3.10"

{selectools-1.1.0 → selectools-1.2.0}/src/selectools/__init__.py

@@ -1,6 +1,6 @@
 """Public exports for the selectools package."""
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 # Import submodules (lazy loading for optional dependencies)
 from . import embeddings, evals, guardrails, models, observe, patterns, rag, toolbox

{selectools-1.1.0 → selectools-1.2.0}/src/selectools/agent/_tool_executor.py

@@ -861,6 +861,11 @@ class _ToolExecutorMixin:
             cached_entry = self._check_tool_cache(tool, parameters)
             if cached_entry is not None:
                 raw, compressed = cached_entry
+                # Guardrails run on cache hits too — an entry written before
+                # a guardrail was configured must not bypass the stage.
+                guarded = self._run_tool_result_guardrails(tool_name, raw, trace, run_ctx=run_ctx)
+                if guarded != raw:
+                    raw, compressed = guarded, None
                 return _Result(
                     tc, raw, False, 0.0, tool, 0, cached=True, cached_compressed=compressed
                 )
@@ -886,7 +891,10 @@ class _ToolExecutorMixin:
             try:
                 result = self._execute_tool_with_timeout(tool, parameters, chunk_cb)
                 result = self._screen_tool_result(tool_name, result)
+                # Cache the pre-guardrail value: guardrails run at use time
+                # (fresh AND cached), so config changes apply retroactively.
                 self._store_tool_cache(tool, parameters, result)
+                result = self._run_tool_result_guardrails(tool_name, result, trace, run_ctx=run_ctx)
                 dur = time.time() - start
                 if run_id:
                     self._notify_observers(
@@ -1103,6 +1111,13 @@ class _ToolExecutorMixin:
             cached_entry = self._check_tool_cache(tool, parameters)
             if cached_entry is not None:
                 raw, compressed = cached_entry
+                # Guardrails run on cache hits too — an entry written before
+                # a guardrail was configured must not bypass the stage.
+                guarded = await self._arun_tool_result_guardrails(
+                    tool_name, raw, trace, run_ctx=run_ctx
+                )
+                if guarded != raw:
+                    raw, compressed = guarded, None
                 return _Result(
                     tc, raw, False, 0.0, tool, 0, cached=True, cached_compressed=compressed
                 )
@@ -1130,7 +1145,12 @@ class _ToolExecutorMixin:
             try:
                 result = await self._aexecute_tool_with_timeout(tool, parameters, chunk_cb)
                 result = self._screen_tool_result(tool_name, result)
+                # Cache the pre-guardrail value: guardrails run at use time
+                # (fresh AND cached), so config changes apply retroactively.
                 self._store_tool_cache(tool, parameters, result)
+                result = await self._arun_tool_result_guardrails(
+                    tool_name, result, trace, run_ctx=run_ctx
+                )
                 dur = time.time() - start
                 if run_id:
                     self._notify_observers(
@@ -1437,6 +1457,13 @@ class _ToolExecutorMixin:
         cached_entry = self._check_tool_cache(tool, parameters)
         if cached_entry is not None:
             cached_raw, cached_compressed = cached_entry
+            # Guardrails run on cache hits too — an entry written before a
+            # guardrail was configured must not bypass the stage.
+            guarded = self._run_tool_result_guardrails(
+                tool_name, cached_raw, ctx.trace, run_ctx=ctx
+            )
+            if guarded != cached_raw:
+                cached_raw, cached_compressed = guarded, None
             ctx.trace.add(
                 TraceStep(
                     type=StepType.CACHE_HIT,
@@ -1475,15 +1502,16 @@ class _ToolExecutorMixin:
 
             result = self._execute_tool_with_timeout(tool, parameters, chunk_callback)
             result = self._screen_tool_result(tool_name, result)
+            # Cache the pre-guardrail value: guardrails run at use time
+            # (fresh AND cached), so config changes apply retroactively.
+            self._store_tool_cache(tool, parameters, result)
+            result = self._run_tool_result_guardrails(tool_name, result, ctx.trace, run_ctx=ctx)
             duration = time.time() - start_time
 
             self._notify_observers(
                 "on_tool_end", ctx.run_id, call_id, tool_name, result, duration * 1000
             )
 
-            # Store in tool result cache
-            self._store_tool_cache(tool, parameters, result)
-
             ctx.trace.add(
                 TraceStep(
                     type=StepType.TOOL_EXECUTION,
@@ -1673,6 +1701,13 @@ class _ToolExecutorMixin:
         cached_entry = self._check_tool_cache(tool, parameters)
         if cached_entry is not None:
             cached_raw, cached_compressed = cached_entry
+            # Guardrails run on cache hits too — an entry written before a
+            # guardrail was configured must not bypass the stage.
+            guarded = await self._arun_tool_result_guardrails(
+                tool_name, cached_raw, ctx.trace, run_ctx=ctx
+            )
+            if guarded != cached_raw:
+                cached_raw, cached_compressed = guarded, None
             ctx.trace.add(
                 TraceStep(
                     type=StepType.CACHE_HIT,
@@ -1714,6 +1749,12 @@ class _ToolExecutorMixin:
 
             result = await self._aexecute_tool_with_timeout(tool, parameters, chunk_callback)
             result = self._screen_tool_result(tool_name, result)
+            # Cache the pre-guardrail value: guardrails run at use time
+            # (fresh AND cached), so config changes apply retroactively.
+            self._store_tool_cache(tool, parameters, result)
+            result = await self._arun_tool_result_guardrails(
+                tool_name, result, ctx.trace, run_ctx=ctx
+            )
             duration = time.time() - start_time
 
             self._notify_observers(
@@ -1723,9 +1764,6 @@ class _ToolExecutorMixin:
                 "on_tool_end", ctx.run_id, call_id, tool_name, result, duration * 1000
             )
 
-            # Store in tool result cache
-            self._store_tool_cache(tool, parameters, result)
-
             ctx.trace.add(
                 TraceStep(
                     type=StepType.TOOL_EXECUTION,

{selectools-1.1.0 → selectools-1.2.0}/src/selectools/agent/config_groups.py

@@ -24,7 +24,7 @@ Usage::
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
 
 from ..stability import beta, stable
 
@@ -37,6 +37,7 @@ if TYPE_CHECKING:
     from ..policy import ToolPolicy
     from ..providers.base import Provider
     from ..sessions import SessionStore
+    from ..types import Message
     from ..unified_memory import UnifiedMemory
 
 
@@ -192,12 +193,43 @@ class StructuredOutputConfig:
             produces the validated structured final answer. In ``astream()``
             the synthesis JSON is delivered only via the terminal
             ``AgentResult`` (``.content`` / ``.parsed``), never leaked as
-            content chunks. Costs one extra provider call per run.
-            Default: False.
+            content chunks. Costs at most one extra provider call per run
+            (see ``reuse_loop_answer`` / ``should_finalize`` /
+            ``single_pass`` for the paths that avoid it). Default: False.
+        reuse_loop_answer: In ``final_turn_only`` mode, when the loop's
+            converged answer validates against the schema, use it directly
+            and skip the synthesis call entirely (v1.2, issue #164). The
+            gate is conservative: the WHOLE answer must be a single JSON
+            object (fragments embedded in prose never qualify), Pydantic
+            schemas validate fully, and dict schemas must carry every
+            top-level ``required`` key. Anything else falls back to the
+            synthesis call. Default: True.
+        should_finalize: Optional predicate ``(messages, last_response_text)
+            -> bool`` consulted in ``final_turn_only`` mode when the
+            converged answer did NOT validate. Return ``False`` to skip the
+            synthesis call for turns that need no structured output — the
+            run finishes with ``parsed=None`` and
+            ``AgentResult.structured_status == "skipped"``. A validating
+            answer wins before the predicate runs (even with
+            ``reuse_loop_answer=False``). Like ``stop_condition``, an
+            exception raised by the predicate propagates and aborts the run.
+            Default: None (always finalize, the v1.1 behavior).
+        single_pass: In ``final_turn_only`` mode with a provider that
+            advertises ``supports_native_structured_output_with_tools``
+            (OpenAI/Azure), carry the schema natively on the loop calls so
+            the converged answer IS the structured object — combined with
+            ``reuse_loop_answer`` this eliminates the synthesis call (v1.2,
+            issue #166). Providers without combined support fall back to the
+            separate synthesis call. NOTE: in ``astream()`` the final answer
+            is then JSON and streams as content chunks (like plain native
+            mode). Default: False.
     """
 
     native: bool = True
     final_turn_only: bool = False
+    reuse_loop_answer: bool = True
+    should_finalize: Optional[Callable[[List["Message"], str], bool]] = None
+    single_pass: bool = False
 
 
 @stable