geny-executor 0.26.0__tar.gz → 0.26.2__tar.gz

{geny_executor-0.26.0 → geny_executor-0.26.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 0.26.0
+Version: 0.26.2
 Summary: Harness-engineered agent pipeline library with 16-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-0.26.0 → geny_executor-0.26.2}/pyproject.toml

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

{geny_executor-0.26.0 → geny_executor-0.26.2}/src/geny_executor/__init__.py

@@ -84,7 +84,7 @@ from geny_executor.memory import (
     GenyPresets,
 )
 
-__version__ = "0.26.0"
+__version__ = "0.26.2"
 
 __all__ = [
     # Core

{geny_executor-0.26.0 → geny_executor-0.26.2}/src/geny_executor/core/pipeline.py

@@ -317,6 +317,33 @@ class Pipeline:
         _register_external_tools(manifest, registry, adhoc_providers)
         pipeline._tool_registry = registry
 
+        # Stages that hold a tool-registry reference are instantiated at
+        # line 287 *before* `_register_external_tools` populates the
+        # shared registry. Unless we rebind post-hoc, those stages keep
+        # their construction-time references (None for SystemStage; a
+        # freshly-allocated empty `ToolRegistry()` for ToolStage) and
+        # never see the populated tools at execute time.
+        #
+        # SystemStage (``_tool_registry``): builds ``state.tools`` from
+        # the registry; a stale reference leaves ``state.tools`` empty
+        # so the API stage sends ``tools=None`` to Anthropic.
+        # ToolStage (``_registry``): the router looks up tool instances
+        # here; a stale empty reference makes every tool call resolve
+        # to ``unknown_tool`` even though the LLM was shown the schema.
+        #
+        # Both are rebound to the shared ``registry``. Callers that
+        # wired their own registry explicitly are left alone: for
+        # SystemStage, a non-None existing reference wins; for
+        # ToolStage, if the stage already holds the same object as
+        # ``registry`` (as happens when the caller passed it via the
+        # outer ``tool_registry`` kwarg), no rebind is needed.
+        for stage in pipeline._stages.values():
+            if hasattr(stage, "_tool_registry") and getattr(stage, "_tool_registry", None) is None:
+                stage._tool_registry = registry
+            if getattr(stage, "name", None) == "tool" and hasattr(stage, "_registry"):
+                if getattr(stage, "_registry") is not registry:
+                    stage._registry = registry
+
         return pipeline
 
     @classmethod

{geny_executor-0.26.0 → geny_executor-0.26.2}/tests/unit/test_adhoc_providers.py

@@ -221,6 +221,53 @@ class TestFromManifestExternalProviders:
         Pipeline.from_manifest(manifest, adhoc_providers=[provider], tool_registry=registry)
         assert set(registry.list_names()) == {"builtin", "alpha"}
 
+    def test_system_stage_sees_populated_registry_after_from_manifest(self):
+        """Regression: a manifest with s03_system + external tools must
+        leave SystemStage._tool_registry pointing at the populated
+        registry, not at None. Otherwise state.tools stays empty, the
+        LLM never learns about the tools, and the model falls back to
+        emitting XML-style tool calls as plain text."""
+        from geny_executor.core.environment import StageManifestEntry
+
+        entries = [StageManifestEntry(order=3, name="system")]
+        manifest = EnvironmentManifest(
+            stages=[e.to_dict() for e in entries],
+            tools=ToolsSnapshot(external=["alpha"]),
+        )
+        provider = _DictProvider({"alpha": _NamedTool("alpha")})
+        pipeline = Pipeline.from_manifest(manifest, adhoc_providers=[provider])
+
+        system_stage = pipeline.get_stage(3)
+        assert system_stage is not None
+        assert system_stage._tool_registry is pipeline.tool_registry
+        assert system_stage._tool_registry.get("alpha") is not None
+
+    def test_tool_stage_sees_populated_registry_after_from_manifest(self):
+        """Regression: a manifest with s10_tool + external tools must
+        leave ToolStage._registry pointing at the same populated
+        registry the pipeline exposes. ToolStage's __init__ defaults
+        to a freshly-allocated empty ToolRegistry(); without post-hoc
+        rebinding, the router's lookup returns `unknown_tool` for
+        every LLM-emitted tool_use block — the call fails instantly
+        (0 ms) even though the schema was delivered to the model."""
+        from geny_executor.core.environment import StageManifestEntry
+
+        entries = [
+            StageManifestEntry(order=3, name="system"),
+            StageManifestEntry(order=10, name="tool"),
+        ]
+        manifest = EnvironmentManifest(
+            stages=[e.to_dict() for e in entries],
+            tools=ToolsSnapshot(external=["alpha"]),
+        )
+        provider = _DictProvider({"alpha": _NamedTool("alpha")})
+        pipeline = Pipeline.from_manifest(manifest, adhoc_providers=[provider])
+
+        tool_stage = pipeline.get_stage(10)
+        assert tool_stage is not None
+        assert tool_stage._registry is pipeline.tool_registry
+        assert tool_stage._registry.get("alpha") is not None
+
 
 # ══════════════════════════════════════════════════════════
 # Pipeline.from_manifest_async — external + MCP coexist