runsight-core 0.2.2__tar.gz → 0.2.3__tar.gz

{runsight_core-0.2.2 → runsight_core-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runsight-core
-Version: 0.2.2
+Version: 0.2.3
 Summary: Runsight Agent OS Core Engine
 License-Expression: Apache-2.0
 Requires-Python: >=3.11

{runsight_core-0.2.2 → runsight_core-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "runsight-core"
-version = "0.2.2"
+version = "0.2.3"
 description = "Runsight Agent OS Core Engine"
 requires-python = ">=3.11"
 license = "Apache-2.0"

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core/blocks/_registry.py

@@ -33,7 +33,16 @@ def register_block_def(block_type: str, def_cls: Type["Any"]) -> None:
 
 
 def register_block_builder(block_type: str, builder: Callable) -> None:
-    """Register a builder callable for *block_type*."""
+    """Register a builder callable for *block_type*.
+
+    Raises ``ValueError`` if *block_type* is already registered with a
+    **different** callable (re-registering the same callable is idempotent).
+    """
+    existing = BLOCK_BUILDER_REGISTRY.get(block_type)
+    if existing is not None and existing is not builder:
+        raise ValueError(
+            f"Duplicate block-builder registration for '{block_type}': {existing!r} vs {builder!r}"
+        )
     BLOCK_BUILDER_REGISTRY[block_type] = builder
 
 

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core/blocks/code.py

@@ -334,6 +334,7 @@ def build(
     souls_map: Dict[str, Any],
     runner: Any,
     all_blocks: Dict[str, Any],
+    **_: Any,
 ) -> CodeBlock:
     """Build a CodeBlock from a block definition."""
     if not block_def.code:

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core/blocks/dispatch.py

@@ -219,6 +219,7 @@ def build(
     souls_map: Dict[str, Any],
     runner: Any,
     all_blocks: Dict[str, Any],
+    **_: Any,
 ) -> DispatchBlock:
     """Build a DispatchBlock from a block definition."""
     if not block_def.exits:

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core/blocks/gate.py

@@ -169,6 +169,7 @@ def build(
     souls_map: Dict[str, Any],
     runner: Any,
     all_blocks: Dict[str, Any],
+    **_: Any,
 ) -> GateBlock:
     """Build a GateBlock from a block definition."""
     if block_def.soul_ref is None:

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core/blocks/linear.py

@@ -112,6 +112,7 @@ def build(
     souls_map: Dict[str, Any],
     runner: Any,
     all_blocks: Dict[str, Any],
+    **_: Any,
 ) -> LinearBlock:
     """Build a LinearBlock from a block definition."""
     if block_def.soul_ref is None:

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core/blocks/loop.py

@@ -294,6 +294,7 @@ def build(
     souls_map: Dict[str, Any],
     runner: Any,
     all_blocks: Dict[str, Any],
+    **_: Any,
 ) -> LoopBlock:
     """Build a LoopBlock from a block definition."""
     break_condition = None

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core/blocks/synthesize.py

@@ -119,6 +119,7 @@ def build(
     souls_map: Dict[str, Any],
     runner: Any,
     all_blocks: Dict[str, Any],
+    **_: Any,
 ) -> SynthesizeBlock:
     """Build a SynthesizeBlock from a block definition."""
     if block_def.soul_ref is None:

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core/blocks/workflow_block.py

@@ -17,7 +17,7 @@ from runsight_core.state import BlockResult, WorkflowState
 if TYPE_CHECKING:
     from runsight_core.workflow import Workflow
     from runsight_core.yaml.registry import WorkflowRegistry
-    from runsight_core.yaml.schema import WorkflowInterfaceDef
+    from runsight_core.yaml.schema import RunsightWorkflowFile, WorkflowInterfaceDef
 
 
 class WorkflowBlock(BaseBlock):
@@ -392,6 +392,56 @@ from runsight_core.blocks._registry import register_block_def as _register_block
 _register_block_def("workflow", WorkflowBlockDef)
 
 
+def _validate_workflow_block_contract(
+    block_id: str,
+    block_def: Any,
+    child_file: "RunsightWorkflowFile",
+) -> None:
+    child_interface = child_file.interface
+    if child_interface is None:
+        raise ValueError(
+            f"WorkflowBlock '{block_id}': child workflow '{block_def.workflow_ref}' "
+            "must declare an interface"
+        )
+
+    declared_inputs = {item.name: item for item in child_interface.inputs}
+    declared_outputs = {item.name for item in child_interface.outputs}
+
+    for binding_name in (block_def.inputs or {}).keys():
+        if binding_name not in declared_inputs:
+            raise ValueError(
+                f"WorkflowBlock '{block_id}': unknown interface input '{binding_name}'. "
+                f"Declared child inputs: {sorted(declared_inputs)}"
+            )
+
+    missing_required = [
+        item.name
+        for item in child_interface.inputs
+        if item.required and item.default is None and item.name not in (block_def.inputs or {})
+    ]
+    if missing_required:
+        raise ValueError(
+            f"WorkflowBlock '{block_id}': missing required interface inputs {missing_required}"
+        )
+
+    for binding_name in (block_def.outputs or {}).values():
+        if binding_name not in declared_outputs:
+            raise ValueError(
+                f"WorkflowBlock '{block_id}': unknown interface output '{binding_name}'. "
+                f"Declared child outputs: {sorted(declared_outputs)}"
+            )
+
+
+def _resolve_workflow_block_max_depth(
+    file_def: Any,
+    block_def: Any,
+) -> int:
+    """Resolve the max_depth value a workflow block will enforce at runtime."""
+    if block_def.max_depth is not None:
+        return block_def.max_depth
+    return file_def.config.get("max_workflow_depth", 10)
+
+
 # -- Builder function --------------------------------------------------------
 
 
@@ -401,17 +451,50 @@ def build(
     souls_map: Dict[str, Any],
     runner: Any,
     all_blocks: Dict[str, Any],
+    *,
+    workflow_registry: "WorkflowRegistry" | None = None,
+    api_keys: Dict[str, str] | None = None,
+    workflow_base_dir: str = ".",
+    parent_file_def: Any | None = None,
+    **_: Any,
 ) -> WorkflowBlock:
-    """Build a WorkflowBlock from a block definition.
+    """Build a WorkflowBlock from a block definition."""
+    if getattr(block_def, "workflow_ref", None) is None:
+        raise ValueError(f"WorkflowBlock '{block_id}': workflow_ref is required")
+    if workflow_registry is None:
+        raise ValueError(
+            f"WorkflowBlock '{block_id}': workflow_registry must be provided "
+            "when building workflow blocks"
+        )
 
-    Note: In practice, the workflow block is handled as a special case in
-    parse_workflow_yaml because it requires a WorkflowRegistry for recursive
-    parsing. This build() function exists for API consistency and can be
-    used when the child_workflow is already resolved.
-    """
-    raise NotImplementedError(
-        f"WorkflowBlock '{block_id}' must be built via the special-case "
-        f"handler in parse_workflow_yaml, not via the generic builder registry."
+    # Import the parser lazily to keep block registration free of parser cycles.
+    from runsight_core.yaml.parser import parse_workflow_yaml
+
+    child_file = workflow_registry.get(block_def.workflow_ref)
+    _validate_workflow_block_contract(block_id, block_def, child_file)
+
+    child_raw = child_file.model_dump() if hasattr(child_file, "model_dump") else child_file
+    child_wf = parse_workflow_yaml(
+        child_raw,
+        workflow_registry=workflow_registry,
+        api_keys=api_keys,
+        _base_dir=workflow_base_dir,
+    )
+
+    max_depth = (
+        _resolve_workflow_block_max_depth(parent_file_def, block_def)
+        if parent_file_def is not None
+        else block_def.max_depth or 10
+    )
+    return WorkflowBlock(
+        block_id=block_id,
+        child_workflow=child_wf,
+        inputs=block_def.inputs or {},
+        outputs=block_def.outputs or {},
+        workflow_ref=block_def.workflow_ref,
+        max_depth=max_depth,
+        interface=child_file.interface,
+        on_error=block_def.on_error,
     )
 
 

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core/yaml/parser.py

@@ -386,45 +386,10 @@ from runsight_core.yaml.schema import rebuild_block_def_union as _rebuild  # noq
 _rebuild()
 del _rebuild
 
-
-def _validate_workflow_block_contract(
-    block_id: str,
-    block_def: Any,
-    child_file: RunsightWorkflowFile,
-) -> None:
-    child_interface = child_file.interface
-    if child_interface is None:
-        raise ValueError(
-            f"WorkflowBlock '{block_id}': child workflow '{block_def.workflow_ref}' "
-            "must declare an interface"
-        )
-
-    declared_inputs = {item.name: item for item in child_interface.inputs}
-    declared_outputs = {item.name for item in child_interface.outputs}
-
-    for binding_name in (block_def.inputs or {}).keys():
-        if binding_name not in declared_inputs:
-            raise ValueError(
-                f"WorkflowBlock '{block_id}': unknown interface input '{binding_name}'. "
-                f"Declared child inputs: {sorted(declared_inputs)}"
-            )
-
-    missing_required = [
-        item.name
-        for item in child_interface.inputs
-        if item.required and item.default is None and item.name not in (block_def.inputs or {})
-    ]
-    if missing_required:
-        raise ValueError(
-            f"WorkflowBlock '{block_id}': missing required interface inputs {missing_required}"
-        )
-
-    for binding_name in (block_def.outputs or {}).values():
-        if binding_name not in declared_outputs:
-            raise ValueError(
-                f"WorkflowBlock '{block_id}': unknown interface output '{binding_name}'. "
-                f"Declared child outputs: {sorted(declared_outputs)}"
-            )
+from runsight_core.blocks.workflow_block import (  # noqa: E402
+    _resolve_workflow_block_max_depth,
+    _validate_workflow_block_contract,
+)
 
 
 def _validate_workflow_block_runtime_placement(
@@ -436,16 +401,6 @@ def _validate_workflow_block_runtime_placement(
     return None
 
 
-def _resolve_workflow_block_max_depth(
-    file_def: RunsightWorkflowFile,
-    block_def: Any,
-) -> int:
-    """Resolve the max_depth value a workflow block will enforce at runtime."""
-    if block_def.max_depth is not None:
-        return block_def.max_depth
-    return file_def.config.get("max_workflow_depth", 10)
-
-
 def validate_workflow_call_contracts(
     file_def: RunsightWorkflowFile,
     *,
@@ -643,53 +598,6 @@ def parse_workflow_yaml(
     # Step 5: Build all blocks (single pass)
     built_blocks: Dict[str, BaseBlock] = {}
     for block_id, block_def in file_def.blocks.items():
-        # Special case: WorkflowBlock (type: workflow)
-        # Handle before registry lookup to avoid "unknown type" error
-        if block_def.type == "workflow":
-            # Validate workflow_ref field (redundant check — already enforced by BlockDef validator)
-            if block_def.workflow_ref is None:
-                raise ValueError(f"WorkflowBlock '{block_id}': workflow_ref is required")
-
-            # Require workflow_registry parameter
-            if workflow_registry is None:
-                raise ValueError(
-                    f"WorkflowBlock '{block_id}': a WorkflowRegistry must be provided "
-                    f"to parse_workflow_yaml() when workflow blocks are used. "
-                    f"Pass workflow_registry=... parameter."
-                )
-
-            # Resolve child workflow file (registry returns RunsightWorkflowFile)
-            child_file = workflow_registry.get(block_def.workflow_ref)
-            _validate_workflow_block_contract(block_id, block_def, child_file)
-
-            # Normalize to dict so parse_workflow_yaml receives Union[str, Dict] not model instance
-            child_raw = child_file.model_dump() if hasattr(child_file, "model_dump") else child_file
-
-            # Recursively parse child workflow (passes registry + base_dir for nested workflows)
-            child_wf = parse_workflow_yaml(
-                child_raw,
-                workflow_registry=workflow_registry,
-                api_keys=api_keys,
-                _base_dir=workflow_base_dir,
-            )
-
-            # Instantiate WorkflowBlock
-            from runsight_core.blocks.workflow_block import WorkflowBlock
-
-            block = WorkflowBlock(
-                block_id=block_id,
-                child_workflow=child_wf,
-                inputs=block_def.inputs or {},
-                outputs=block_def.outputs or {},
-                workflow_ref=block_def.workflow_ref,
-                max_depth=_resolve_workflow_block_max_depth(file_def, block_def),
-                interface=child_file.interface,
-                on_error=block_def.on_error,
-            )
-
-            built_blocks[block_id] = block
-            continue  # Skip registry lookup
-
         from runsight_core.blocks._registry import get_builder
 
         builder = get_builder(block_def.type)
@@ -700,7 +608,17 @@ def parse_workflow_yaml(
                 f"Unknown block type '{block_def.type}' for block '{block_id}'. "
                 f"Available types: {sorted(BLOCK_BUILDER_REGISTRY.keys())}"
             )
-        built_blocks[block_id] = builder(block_id, block_def, souls_map, runner, built_blocks)
+        built_blocks[block_id] = builder(
+            block_id,
+            block_def,
+            souls_map,
+            runner,
+            built_blocks,
+            workflow_registry=workflow_registry,
+            api_keys=api_keys,
+            workflow_base_dir=workflow_base_dir,
+            parent_file_def=file_def,
+        )
 
     # Step 6.2: Bridge _declared_exits from schema to runtime blocks
     for block_id, block_def in file_def.blocks.items():

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runsight-core
-Version: 0.2.2
+Version: 0.2.3
 Summary: Runsight Agent OS Core Engine
 License-Expression: Apache-2.0
 Requires-Python: >=3.11

{runsight_core-0.2.2 → runsight_core-0.2.3}/src/runsight_core.egg-info/SOURCES.txt

@@ -213,6 +213,7 @@ tests/test_run701_state_isolation_verification.py
 tests/test_run702_mixed_pipeline_e2e.py
 tests/test_run703_dispatch_in_loop_e2e.py
 tests/test_run704_error_route_output_mapping_e2e.py
+tests/test_run774_workflow_block_builder_path.py
 tests/test_run787_discovery_foundation.py
 tests/test_run788_workflow_repo_soul_scanner.py
 tests/test_run789_tool_scanner_callers.py

{runsight_core-0.2.2 → runsight_core-0.2.3}/tests/test_run219_auto_registration.py

@@ -101,6 +101,44 @@ class TestBlockDefRegistry:
         # Cleanup
         BLOCK_BUILDER_REGISTRY.pop("test_builder_type", None)
 
+    def test_register_block_builder_is_idempotent_for_same_callable(self):
+        """register_block_builder permits re-registering the same callable."""
+        from runsight_core.blocks._registry import (
+            BLOCK_BUILDER_REGISTRY,
+            register_block_builder,
+        )
+
+        def fake_builder():
+            pass
+
+        try:
+            register_block_builder("same_builder_type", fake_builder)
+            register_block_builder("same_builder_type", fake_builder)
+            assert BLOCK_BUILDER_REGISTRY.get("same_builder_type") is fake_builder
+        finally:
+            BLOCK_BUILDER_REGISTRY.pop("same_builder_type", None)
+
+    def test_register_block_builder_rejects_different_duplicate(self):
+        """register_block_builder rejects silent builder replacement."""
+        from runsight_core.blocks._registry import (
+            BLOCK_BUILDER_REGISTRY,
+            register_block_builder,
+        )
+
+        def first_builder():
+            pass
+
+        def second_builder():
+            pass
+
+        try:
+            register_block_builder("conflicting_builder_type", first_builder)
+            with pytest.raises(ValueError, match="Duplicate block-builder registration"):
+                register_block_builder("conflicting_builder_type", second_builder)
+            assert BLOCK_BUILDER_REGISTRY.get("conflicting_builder_type") is first_builder
+        finally:
+            BLOCK_BUILDER_REGISTRY.pop("conflicting_builder_type", None)
+
     def test_get_all_block_types_returns_dict(self):
         """get_all_block_types() returns a dict snapshot of registered types."""
         from runsight_core.blocks._registry import get_all_block_types

runsight_core-0.2.3/tests/test_run774_workflow_block_builder_path.py

@@ -0,0 +1,189 @@
+"""
+Failing tests for RUN-774: route workflow blocks through the registered builder.
+
+These tests pin the remaining actionable debt in the workflow-block parser path:
+- parse_workflow_yaml should use the registered "workflow" builder, not a parser-only special case
+- the registered builder should be able to construct a real WorkflowBlock when given parser context
+- missing WorkflowRegistry should fail with an actionable ValueError from the builder path
+- workflow blocks referenced from LoopBlock.inner_block_refs should still come through the builder path
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+from runsight_core import LoopBlock, WorkflowBlock
+from runsight_core.blocks._registry import BLOCK_BUILDER_REGISTRY
+from runsight_core.workflow import Workflow
+from runsight_core.yaml.parser import parse_workflow_yaml
+from runsight_core.yaml.registry import WorkflowRegistry
+from runsight_core.yaml.schema import RunsightWorkflowFile
+
+_EMPTY_INTERFACE = {"inputs": [], "outputs": []}
+
+
+def _child_workflow_file() -> RunsightWorkflowFile:
+    child_dict = {
+        "version": "1.0",
+        "interface": _EMPTY_INTERFACE,
+        "blocks": {
+            "child_step": {
+                "type": "code",
+                "code": "def main(data):\n    return {'child_step': 'done'}",
+            }
+        },
+        "workflow": {
+            "name": "child_workflow",
+            "entry": "child_step",
+            "transitions": [{"from": "child_step", "to": None}],
+        },
+    }
+    return RunsightWorkflowFile.model_validate(child_dict)
+
+
+def _parent_workflow_dict() -> dict[str, Any]:
+    return {
+        "version": "1.0",
+        "config": {
+            "max_workflow_depth": 7,
+        },
+        "blocks": {
+            "invoke_child": {
+                "type": "workflow",
+                "workflow_ref": "child_workflow",
+            },
+            "loop_block": {
+                "type": "loop",
+                "inner_block_refs": ["invoke_child"],
+                "max_rounds": 1,
+            },
+        },
+        "workflow": {
+            "name": "parent_workflow",
+            "entry": "invoke_child",
+            "transitions": [
+                {"from": "invoke_child", "to": "loop_block"},
+                {"from": "loop_block", "to": None},
+            ],
+        },
+    }
+
+
+def test_parse_workflow_yaml_routes_workflow_blocks_through_registered_builder_even_inside_loops(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    """Parsing should invoke the registered workflow builder instead of a parser special case."""
+    child_file = _child_workflow_file()
+    registry = WorkflowRegistry(allow_filesystem_fallback=False)
+    registry.register("child_workflow", child_file)
+
+    calls: list[dict[str, Any]] = []
+
+    def spy_builder(
+        block_id: str,
+        block_def: Any,
+        souls_map: dict[str, Any],
+        runner: Any,
+        all_blocks: dict[str, Any],
+        **parser_context: Any,
+    ) -> WorkflowBlock:
+        calls.append(
+            {
+                "block_id": block_id,
+                "block_def": block_def,
+                "souls_map": souls_map,
+                "runner": runner,
+                "all_blocks": dict(all_blocks),
+                "parser_context": parser_context,
+            }
+        )
+        child_workflow = parse_workflow_yaml(
+            child_file.model_dump(),
+            workflow_registry=parser_context["workflow_registry"],
+            api_keys=parser_context.get("api_keys"),
+            _base_dir=parser_context["workflow_base_dir"],
+        )
+        parent_file_def = parser_context["parent_file_def"]
+        max_depth = (
+            block_def.max_depth
+            if block_def.max_depth is not None
+            else parent_file_def.config.get("max_workflow_depth", 10)
+        )
+        return WorkflowBlock(
+            block_id=block_id,
+            child_workflow=child_workflow,
+            inputs=block_def.inputs or {},
+            outputs=block_def.outputs or {},
+            workflow_ref=block_def.workflow_ref,
+            max_depth=max_depth,
+            interface=child_file.interface,
+            on_error=block_def.on_error,
+        )
+
+    monkeypatch.setitem(BLOCK_BUILDER_REGISTRY, "workflow", spy_builder)
+
+    parent_workflow = parse_workflow_yaml(
+        _parent_workflow_dict(),
+        workflow_registry=registry,
+        _base_dir=str(tmp_path),
+    )
+
+    assert calls, "parse_workflow_yaml did not call the registered workflow builder"
+    assert isinstance(parent_workflow, Workflow)
+    assert isinstance(parent_workflow.blocks["invoke_child"], WorkflowBlock)
+    assert parent_workflow.blocks["invoke_child"].child_workflow.name == "child_workflow"
+    assert isinstance(parent_workflow.blocks["loop_block"], LoopBlock)
+    assert parent_workflow.blocks["loop_block"].inner_block_refs == ["invoke_child"]
+
+
+def test_registered_workflow_builder_accepts_parser_context_and_builds_real_workflow_block(
+    tmp_path: Path,
+) -> None:
+    """The registered workflow builder should build a real WorkflowBlock with parser context."""
+    child_file = _child_workflow_file()
+    registry = WorkflowRegistry(allow_filesystem_fallback=False)
+    registry.register("child_workflow", child_file)
+    parent_file = RunsightWorkflowFile.model_validate(_parent_workflow_dict())
+    block_def = parent_file.blocks["invoke_child"]
+    builder = BLOCK_BUILDER_REGISTRY["workflow"]
+
+    block = builder(
+        "invoke_child",
+        block_def,
+        {},
+        MagicMock(),
+        {},
+        workflow_registry=registry,
+        api_keys={},
+        workflow_base_dir=str(tmp_path),
+        parent_file_def=parent_file,
+    )
+
+    assert isinstance(block, WorkflowBlock)
+    assert block.child_workflow.name == "child_workflow"
+    assert block.workflow_ref == "child_workflow"
+    assert block.max_depth == 7
+
+
+def test_registered_workflow_builder_requires_workflow_registry_with_actionable_value_error(
+    tmp_path: Path,
+) -> None:
+    """The builder should fail explicitly when workflow_registry is missing."""
+    parent_file = RunsightWorkflowFile.model_validate(_parent_workflow_dict())
+    block_def = parent_file.blocks["invoke_child"]
+    builder = BLOCK_BUILDER_REGISTRY["workflow"]
+
+    with pytest.raises(ValueError, match="WorkflowRegistry|workflow_registry|registry"):
+        builder(
+            "invoke_child",
+            block_def,
+            {},
+            MagicMock(),
+            {},
+            api_keys={},
+            workflow_base_dir=str(tmp_path),
+            parent_file_def=parent_file,
+        )