geny-executor 2.2.1__tar.gz → 2.3.0__tar.gz

{geny_executor-2.2.1 → geny_executor-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.2.1
+Version: 2.3.0
 Summary: Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.2.1 → geny_executor-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.2.1"
+version = "2.3.0"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "MIT"

{geny_executor-2.2.1 → geny_executor-2.3.0}/src/geny_executor/__init__.py

@@ -116,7 +116,7 @@ from geny_executor.stages.s12_agent.subagent_type import (
     resolve_subagent_provider,
 )
 
-__version__ = "2.2.1"
+__version__ = "2.3.0"
 
 __all__ = [
     # Core

{geny_executor-2.2.1 → geny_executor-2.3.0}/src/geny_executor/core/pipeline.py

@@ -2654,6 +2654,24 @@ class Pipeline:
         if provider_name:
             state.shared[SharedKeys.PRIMARY_PROVIDER] = provider_name
 
+        # Tool dispatch handle (2.3.0): Stage 6's tool_loop="internal"
+        # strategy dispatches through Stage 10's exact machinery via
+        # this state-carried handle. Rebuilt every run (two attribute
+        # writes) so a PipelineMutator stage replacement is picked up
+        # at the next turn boundary; None when no Tool stage exists —
+        # the strategy then degrades to pipeline behaviour with a
+        # one-time warning.
+        tool_stage = next(
+            (s for s in self._stages.values() if getattr(s, "name", "") == "tool"),
+            None,
+        )
+        if tool_stage is not None and hasattr(tool_stage, "build_dispatch_context"):
+            from geny_executor.stages.s10_tool.dispatcher import ToolDispatcher
+
+            state.tool_dispatcher = ToolDispatcher(tool_stage)
+        else:
+            state.tool_dispatcher = None
+
         self._has_started = True
         return state
 

{geny_executor-2.2.1 → geny_executor-2.3.0}/src/geny_executor/core/state.py

@@ -196,6 +196,16 @@ class PipelineState:
     pending_tool_calls: List[Dict[str, Any]] = field(default_factory=list)
     tool_results: List[Dict[str, Any]] = field(default_factory=list)
 
+    # ── Tool dispatch handle (2.3.0) ──
+    # Installed by ``Pipeline._init_state`` whenever a Tool stage is
+    # registered: a :class:`~geny_executor.stages.s10_tool.dispatcher.
+    # ToolDispatcher` wrapping that stage's registry + permission
+    # machinery. Consumed by Stage 6's ``tool_loop="internal"`` strategy
+    # so internally-resolved tool calls take the EXACT dispatch path
+    # Stage 10 would. Lifetime: refreshed every run (sticky across the
+    # run only); never serialized.
+    tool_dispatcher: Optional[Any] = field(default=None, repr=False, compare=False)
+
     # ── Agent orchestration ──
     delegate_requests: List[Dict[str, Any]] = field(default_factory=list)
     agent_results: List[Dict[str, Any]] = field(default_factory=list)

{geny_executor-2.2.1 → geny_executor-2.3.0}/src/geny_executor/events/catalog.py

@@ -47,7 +47,9 @@ from typing import Any, Dict, List
 #: Bumped when the catalogue gains members (append-only). Hosts can pin
 #: a minimum version to assert the names they consume exist.
 #: v2: + ``agent.delegations_capped`` (Stage 12 max_delegations wiring).
-EVENT_CATALOG_VERSION = 2
+#: v3: + ``api.internal_loop_capped`` (2.3.0 Stage 6 internal agentic
+#: loop hit its turn/budget cap and degraded to the pipeline path).
+EVENT_CATALOG_VERSION = 3
 
 
 class EventTypes(str, Enum):
@@ -122,6 +124,12 @@ class EventTypes(str, Enum):
     API_INPUT_JSON_DELTA = "api.input_json_delta"
     API_CONTENT_BLOCK_STOP = "api.content_block_stop"
     API_TOOL_RESULT = "api.tool_result"
+    # 2.3.0: the Stage 6 internal agentic loop (tool_loop="internal")
+    # stopped resolving tool calls because it hit its turn or budget
+    # cap; the last response is returned with its tool_use blocks
+    # intact so Stage 9/10 pick them up — graceful degradation to the
+    # pipeline path, announced rather than silent.
+    API_INTERNAL_LOOP_CAPPED = "api.internal_loop_capped"
 
     # ── Stage 7: Token ──
     TOKEN_TRACKED = "token.tracked"
@@ -136,6 +144,14 @@ class EventTypes(str, Enum):
     # ── Stage 10: Tool ──
     TOOL_EXECUTE_START = "tool.execute_start"
     TOOL_EXECUTE_COMPLETE = "tool.execute_complete"
+    # Per-call timing pair emitted by the executor strategies around each
+    # individual dispatch (Stage 10 batches AND Stage 6 internal-loop
+    # dispatches — both run through the same executors). Catalogued in
+    # 2.3.0: they had always been emitted through the on_event callback,
+    # which the AST completeness test cannot see — the indirect-emission
+    # blind spot the catalogue's own docstring warns about.
+    TOOL_CALL_START = "tool.call_start"
+    TOOL_CALL_COMPLETE = "tool.call_complete"
 
     # ── Stage 11: Tool review ──
     TOOL_REVIEW_FLAG = "tool_review.flag"
@@ -383,7 +399,11 @@ PAYLOADS: Dict[EventTypes, Dict[str, str]] = {
         "id": "str|None — tool_use block id",
         "name": "str|None — tool name",
         "input": "dict — tool input (may be partial until input_json_delta completes)",
-        "source": "str — 'cli' (executed inside a CLI backend) | 'api' (Stage 10 will dispatch)",
+        "source": (
+            "str — 'cli' (executed inside a CLI backend) | 'api' (Stage 10 "
+            "will dispatch) | 'internal' (the Stage 6 internal loop is about "
+            "to dispatch it)"
+        ),
     },
     EventTypes.API_CLI_TOOL_CALL: {
         "id": "str|None",
@@ -399,7 +419,11 @@ PAYLOADS: Dict[EventTypes, Dict[str, str]] = {
         "tool_use_id": "str — id of the tool_use this result answers",
         "content": "Any — tool result content as the backend reported it",
         "is_error": "bool",
-        "source": "str — 'cli' | 'api'",
+        "source": "str — 'cli' | 'api' | 'internal' (Stage 6 internal loop dispatched it)",
+    },
+    EventTypes.API_INTERNAL_LOOP_CAPPED: {
+        "turns": "int — inner tool turns the loop completed before stopping",
+        "reason": "str — 'max_inner_turns' | 'cost_budget'",
     },
     EventTypes.TOKEN_TRACKED: {
         "input_tokens": "int",
@@ -432,6 +456,17 @@ PAYLOADS: Dict[EventTypes, Dict[str, str]] = {
         "count": "int",
         "errors": "int — results flagged is_error",
     },
+    EventTypes.TOOL_CALL_START: {
+        "tool_use_id": "str",
+        "name": "str",
+        "input": "dict",
+    },
+    EventTypes.TOOL_CALL_COMPLETE: {
+        "tool_use_id": "str",
+        "name": "str",
+        "is_error": "bool",
+        "duration_ms": "int",
+    },
     EventTypes.TOOL_REVIEW_FLAG: {
         "reviewer": "str — ReviewFlag.to_dict()",
         "severity": "str",

{geny_executor-2.2.1 → geny_executor-2.3.0}/src/geny_executor/stages/s06_api/__init__.py

@@ -1,12 +1,19 @@
 """Stage 6: API — Anthropic Messages API call."""
 
-from geny_executor.stages.s06_api.interface import APIProvider, ModelRouter, RetryStrategy
+from geny_executor.stages.s06_api.interface import (
+    APIProvider,
+    ModelRouter,
+    RetryStrategy,
+    ToolLoopStrategy,
+)
 from geny_executor.stages.s06_api.artifact.default import (
     APIStage,
     AdaptiveModelRouter,
     AnthropicProvider,
+    InternalAgenticLoop,
     MockProvider,
     PassthroughRouter,
+    PipelineToolLoop,
     RecordingProvider,
     ExponentialBackoffRetry,
     NoRetry,
@@ -27,6 +34,9 @@ __all__ = [
     "ModelRouter",
     "AdaptiveModelRouter",
     "PassthroughRouter",
+    "ToolLoopStrategy",
+    "PipelineToolLoop",
+    "InternalAgenticLoop",
     "APIRequest",
     "APIResponse",
     "ContentBlock",

{geny_executor-2.2.1 → geny_executor-2.3.0}/src/geny_executor/stages/s06_api/artifact/default/__init__.py

@@ -15,6 +15,10 @@ from geny_executor.stages.s06_api.artifact.default.router import (
     AdaptiveModelRouter,
     PassthroughRouter,
 )
+from geny_executor.stages.s06_api.artifact.default.tool_loop import (
+    InternalAgenticLoop,
+    PipelineToolLoop,
+)
 
 # Canonical alias
 Stage = APIStage
@@ -30,4 +34,6 @@ __all__ = [
     "RateLimitAwareRetry",
     "AdaptiveModelRouter",
     "PassthroughRouter",
+    "InternalAgenticLoop",
+    "PipelineToolLoop",
 ]

{geny_executor-2.2.1 → geny_executor-2.3.0}/src/geny_executor/stages/s06_api/artifact/default/stage.py

@@ -26,7 +26,12 @@ from geny_executor.core.stage import Stage
 from geny_executor.core.state import PipelineState
 from geny_executor.core.config import ModelConfig
 from geny_executor.llm_client import BaseClient, ClientCapabilities, ClientRegistry
-from geny_executor.stages.s06_api.interface import APIProvider, ModelRouter, RetryStrategy
+from geny_executor.stages.s06_api.interface import (
+    APIProvider,
+    ModelRouter,
+    RetryStrategy,
+    ToolLoopStrategy,
+)
 from geny_executor.stages.s06_api.artifact.default.retry import (
     ExponentialBackoffRetry,
     NoRetry,
@@ -36,6 +41,11 @@ from geny_executor.stages.s06_api.artifact.default.router import (
     AdaptiveModelRouter,
     PassthroughRouter,
 )
+from geny_executor.stages.s06_api.artifact.default.tool_loop import (
+    InternalAgenticLoop,
+    PipelineToolLoop,
+    assistant_content_blocks,
+)
 from geny_executor.stages.s06_api.types import APIRequest, APIResponse
 
 
@@ -106,6 +116,7 @@ class APIStage(Stage[Any, APIResponse]):
         retry: Optional[RetryStrategy] = None,
         *,
         router: Optional[ModelRouter] = None,
+        tool_loop: Optional[ToolLoopStrategy] = None,
         api_key: str = "",
         base_url: Optional[str] = None,
         default_headers: Optional[Dict[str, str]] = None,
@@ -163,6 +174,23 @@ class APIStage(Stage[Any, APIResponse]):
                 },
                 description="Adaptive model selection per call (passthrough = no override)",
             ),
+            # 2.3.0: where the agentic tool loop runs. "pipeline" (the
+            # default) is the historical shape — one call per pipeline
+            # iteration, Stage 9/10/16 own the loop. "internal" resolves
+            # tool calls inside this stage, CLI-style. See tool_loop.py.
+            "tool_loop": StrategySlot(
+                name="tool_loop",
+                strategy=tool_loop or PipelineToolLoop(),
+                registry={
+                    "pipeline": PipelineToolLoop,
+                    "internal": InternalAgenticLoop,
+                },
+                description=(
+                    "Where the agentic tool loop runs (pipeline = Stage "
+                    "9/10/16 round-trips; internal = resolve tool calls "
+                    "inside this stage, CLI-style)"
+                ),
+            ),
         }
 
     @property
@@ -173,6 +201,10 @@ class APIStage(Stage[Any, APIResponse]):
     def _router(self) -> ModelRouter:
         return self._slots["router"].strategy  # type: ignore[return-value]
 
+    @property
+    def _tool_loop(self) -> ToolLoopStrategy:
+        return self._slots["tool_loop"].strategy  # type: ignore[return-value]
+
     @property
     def name(self) -> str:
         return "api"
@@ -366,64 +398,81 @@ class APIStage(Stage[Any, APIResponse]):
         client = self._resolve_client(state)
         use_stream = self._resolve_stream(state)
 
-        state.add_event(
-            "api.request",
-            {
-                "model": cfg.model,
-                "provider": getattr(client, "provider", ""),
-                "message_count": len(state.messages),
-                "has_tools": bool(state.tools),
-                "has_thinking": cfg.thinking_enabled,
-                "stream": use_stream,
-            },
-        )
+        # One retry-wrapped client call, shared with the tool_loop slot
+        # (2.3.0). The closure owns the per-call api.request /
+        # api.response / api.error event contract so EVERY call — the
+        # single pipeline-mode call and each inner call of an internal
+        # agentic loop — is individually visible to hosts with its own
+        # usage numbers. ``extra_messages`` are loop-local tool
+        # exchanges appended after ``state.messages`` for this call
+        # only (the internal loop records them onto the state once, at
+        # loop end).
+        async def call_once(
+            extra_messages: Optional[List[Dict[str, Any]]] = None,
+        ) -> APIResponse:
+            state.add_event(
+                "api.request",
+                {
+                    "model": cfg.model,
+                    "provider": getattr(client, "provider", ""),
+                    "message_count": len(state.messages) + len(extra_messages or []),
+                    "has_tools": bool(state.tools),
+                    "has_thinking": cfg.thinking_enabled,
+                    "stream": use_stream,
+                },
+            )
+            try:
+                if use_stream:
+                    response = await self._call_streaming_with_retry(
+                        client, cfg, state, extra_messages=extra_messages
+                    )
+                else:
+                    response = await self._call_with_retry(
+                        client, cfg, state, extra_messages=extra_messages
+                    )
+            except APIError as e:
+                # Structured error envelope (2.2.0, audit §3.2 / Tier 1-1):
+                # before this event, a host UI that wanted "auth failed,
+                # category fatal, on the CLI backend" had to regex the
+                # exception string out of pipeline.error — Geny's
+                # llm_patches module existed solely to absorb that. The
+                # stable code/category land in the stream BEFORE the
+                # exception propagates, so transcripts always carry the
+                # classification even when a retry wrapper upstream
+                # swallows or rewraps the exception object itself.
+                error_payload: Dict[str, Any] = {
+                    "code": e.code.value if e.code is not None else "exec.unknown",
+                    "category": e.category.value,
+                    "provider": getattr(client, "provider", ""),
+                    "message": str(e),
+                }
+                # CLI-backed clients know their binary version after the
+                # first handshake; every 2.1.x CLI incident was version
+                # skew, so record it at the moment of failure when known.
+                cli_version = getattr(client, "_cli_version_value", None)
+                if cli_version:
+                    error_payload["cli_version"] = str(cli_version)
+                state.add_event("api.error", error_payload)
+                raise
+            state.add_event(
+                "api.response",
+                {
+                    "stop_reason": response.stop_reason,
+                    "text_length": len(response.text),
+                    "tool_calls": len(response.tool_calls),
+                    "input_tokens": response.usage.input_tokens,
+                    "output_tokens": response.usage.output_tokens,
+                },
+            )
+            return response
 
-        try:
-            if use_stream:
-                response = await self._call_streaming_with_retry(client, cfg, state)
-            else:
-                response = await self._call_with_retry(client, cfg, state)
-        except APIError as e:
-            # Structured error envelope (2.2.0, audit §3.2 / Tier 1-1):
-            # before this event, a host UI that wanted "auth failed,
-            # category fatal, on the CLI backend" had to regex the
-            # exception string out of pipeline.error — Geny's
-            # llm_patches module existed solely to absorb that. The
-            # stable code/category land in the stream BEFORE the
-            # exception propagates, so transcripts always carry the
-            # classification even when a retry wrapper upstream
-            # swallows or rewraps the exception object itself.
-            error_payload: Dict[str, Any] = {
-                "code": e.code.value if e.code is not None else "exec.unknown",
-                "category": e.category.value,
-                "provider": getattr(client, "provider", ""),
-                "message": str(e),
-            }
-            # CLI-backed clients know their binary version after the
-            # first handshake; every 2.1.x CLI incident was version
-            # skew, so record it at the moment of failure when known.
-            cli_version = getattr(client, "_cli_version_value", None)
-            if cli_version:
-                error_payload["cli_version"] = str(cli_version)
-            state.add_event("api.error", error_payload)
-            raise
+        response = await self._tool_loop.run(call=call_once, client=client, state=state)
 
         state.last_api_response = response
 
         assistant_content = self._build_assistant_content(response)
         state.add_message("assistant", assistant_content)
 
-        state.add_event(
-            "api.response",
-            {
-                "stop_reason": response.stop_reason,
-                "text_length": len(response.text),
-                "tool_calls": len(response.tool_calls),
-                "input_tokens": response.usage.input_tokens,
-                "output_tokens": response.usage.output_tokens,
-            },
-        )
-
         return response
 
     def _build_request(self, state: PipelineState) -> APIRequest:
@@ -459,10 +508,22 @@ class APIStage(Stage[Any, APIResponse]):
 
     # ── Retry wrappers ──
 
-    def _call_kwargs(self, cfg: Any, state: PipelineState) -> Dict[str, Any]:
+    def _call_kwargs(
+        self,
+        cfg: Any,
+        state: PipelineState,
+        *,
+        extra_messages: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        # ``extra_messages`` (2.3.0): the internal tool loop's pending
+        # exchange rides AFTER the state history for this call only —
+        # state.messages stays untouched until the loop commits it.
+        messages = list(state.messages)
+        if extra_messages:
+            messages.extend(extra_messages)
         kwargs: Dict[str, Any] = {
             "model_config": cfg,
-            "messages": list(state.messages),
+            "messages": messages,
             "purpose": "api",
         }
         if state.system:
@@ -509,10 +570,15 @@ class APIStage(Stage[Any, APIResponse]):
             )
 
     async def _call_with_retry(
-        self, client: BaseClient, cfg: Any, state: PipelineState
+        self,
+        client: BaseClient,
+        cfg: Any,
+        state: PipelineState,
+        *,
+        extra_messages: Optional[List[Dict[str, Any]]] = None,
     ) -> APIResponse:
         last_error: Optional[Exception] = None
-        kwargs = self._call_kwargs(cfg, state)
+        kwargs = self._call_kwargs(cfg, state, extra_messages=extra_messages)
         self._apply_timeout_kwarg(kwargs, client, state, "create_message")
 
         for attempt in range(self._retry.max_retries + 1):
@@ -557,13 +623,18 @@ class APIStage(Stage[Any, APIResponse]):
         )
 
     async def _call_streaming_with_retry(
-        self, client: BaseClient, cfg: Any, state: PipelineState
+        self,
+        client: BaseClient,
+        cfg: Any,
+        state: PipelineState,
+        *,
+        extra_messages: Optional[List[Dict[str, Any]]] = None,
     ) -> APIResponse:
         last_error: Optional[Exception] = None
 
         for attempt in range(self._retry.max_retries + 1):
             try:
-                return await self._call_streaming(client, cfg, state)
+                return await self._call_streaming(client, cfg, state, extra_messages=extra_messages)
             except APIError as e:
                 last_error = e
                 if not self._retry.should_retry(e.category, attempt):
@@ -603,7 +674,12 @@ class APIStage(Stage[Any, APIResponse]):
         )
 
     async def _call_streaming(
-        self, client: BaseClient, cfg: Any, state: PipelineState
+        self,
+        client: BaseClient,
+        cfg: Any,
+        state: PipelineState,
+        *,
+        extra_messages: Optional[List[Dict[str, Any]]] = None,
     ) -> APIResponse:
         """Drain the client's canonical chunk stream into state events.
 
@@ -646,7 +722,7 @@ class APIStage(Stage[Any, APIResponse]):
         ``llm_client.unknown_wire_shape`` sink event.
         """
         response: Optional[APIResponse] = None
-        kwargs = self._call_kwargs(cfg, state)
+        kwargs = self._call_kwargs(cfg, state, extra_messages=extra_messages)
         self._apply_timeout_kwarg(kwargs, client, state, "create_message_stream")
 
         # CLI/subprocess backends run their own tool loop — a tool_use
@@ -702,20 +778,10 @@ class APIStage(Stage[Any, APIResponse]):
     # ── Response formatting ──
 
     def _build_assistant_content(self, response: APIResponse) -> List[Dict[str, Any]]:
-        """Build assistant content for message history."""
-        blocks: List[Dict[str, Any]] = []
-        for block in response.content:
-            if block.raw:
-                blocks.append(block.raw)
-            elif block.type == "text":
-                blocks.append({"type": "text", "text": block.text or ""})
-            elif block.type == "tool_use":
-                blocks.append(
-                    {
-                        "type": "tool_use",
-                        "id": block.tool_use_id,
-                        "name": block.tool_name,
-                        "input": block.tool_input,
-                    }
-                )
-        return blocks
+        """Build assistant content for message history.
+
+        Delegates to the module-level renderer shared with the internal
+        tool loop (2.3.0) so the recorded history shape cannot drift
+        between the single-call and internal-loop paths.
+        """
+        return assistant_content_blocks(response)