geny-executor 2.41.0__tar.gz → 2.43.0__tar.gz

{geny_executor-2.41.0 → geny_executor-2.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.41.0
+Version: 2.43.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
@@ -37,12 +37,16 @@ Requires-Dist: psycopg[binary]>=3.1
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: websockets>=12.0
+Provides-Extra: browser
+Requires-Dist: an-web>=0.9.1; (python_version >= '3.12') and extra == 'browser'
 Provides-Extra: dev
 Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
 Requires-Dist: pytest-cov>=5.0; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: edit2docs>=0.4.0; extra == 'docs'
 Description-Content-Type: text/markdown
 
 # geny-executor

{geny_executor-2.41.0 → geny_executor-2.43.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.41.0"
+version = "2.43.0"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "Apache-2.0"
@@ -77,6 +77,15 @@ dependencies = [
 # and lint. End-users never need these; they stay as an extras group
 # so the runtime install footprint isn't bloated by pytest/ruff.
 [project.optional-dependencies]
+# Browser* built-ins — an-web semantic web engine (embedded V8; needs
+# Python >= 3.12 and glibc, so it stays out of the core install).
+browser = [
+    "an-web>=0.9.1; python_version >= '3.12'",
+]
+# Doc* built-ins — edit2docs document engine (docx/xlsx/pptx).
+docs = [
+    "edit2docs>=0.4.0",
+]
 dev = [
     "pytest>=8.0",
     "pytest-asyncio>=0.24",

{geny_executor-2.41.0 → geny_executor-2.43.0}/src/geny_executor/core/environment.py

@@ -80,6 +80,16 @@ class ToolsSnapshot:
     manifest only records *which provider-backed names are active* for
     this environment. The pipeline resolves each name against the
     ``adhoc_providers`` passed to :meth:`Pipeline.from_manifest`.
+
+    ``core_overrides`` (2.42.0) flips individual tools between *core*
+    (schema shipped to the LLM on every request) and *deferred*
+    (registered + dispatchable, but only discoverable at runtime via
+    the ``ToolSearch`` built-in). Defaults when a name is absent:
+    framework built-ins are core, everything else (external / provider
+    / MCP tools) is deferred. Keys are exact tool names; a trailing
+    ``*`` matches by prefix (e.g. ``"mcp__github__*": true`` promotes a
+    whole MCP server whose tool names are only known after discovery).
+    Exact keys win over wildcard keys.
     """
 
     built_in: List[str] = field(default_factory=list)
@@ -87,6 +97,7 @@ class ToolsSnapshot:
     mcp_servers: List[Dict[str, Any]] = field(default_factory=list)
     external: List[str] = field(default_factory=list)
     scope: Dict[str, Any] = field(default_factory=dict)
+    core_overrides: Dict[str, bool] = field(default_factory=dict)
 
     def to_dict(self) -> Dict[str, Any]:
         return {
@@ -95,6 +106,7 @@ class ToolsSnapshot:
             "mcp_servers": list(self.mcp_servers),
             "external": list(self.external),
             "scope": dict(self.scope),
+            "core_overrides": dict(self.core_overrides),
         }
 
     @classmethod
@@ -105,6 +117,9 @@ class ToolsSnapshot:
             mcp_servers=data.get("mcp_servers", []),
             external=data.get("external", []),
             scope=data.get("scope", {}),
+            core_overrides={
+                str(k): bool(v) for k, v in (data.get("core_overrides") or {}).items()
+            },
         )
 
 

{geny_executor-2.41.0 → geny_executor-2.43.0}/src/geny_executor/core/pipeline.py

@@ -444,6 +444,64 @@ class DroppedStage:
     error: str
 
 
+def _resolve_core_flag(
+    name: str,
+    overrides: Mapping[str, bool],
+    default: bool,
+) -> bool:
+    """Resolve a tool's core/deferred exposure from ``manifest.tools.core_overrides``.
+
+    Exact-name keys win; otherwise the longest matching trailing-``*``
+    prefix key applies (``"mcp__github__*"`` — MCP tool names are only
+    known after discovery, so per-server toggles need the wildcard);
+    otherwise *default* (built-ins: core, everything else: deferred).
+    """
+    if name in overrides:
+        return bool(overrides[name])
+    best_len = -1
+    best_val = default
+    for key, val in overrides.items():
+        if key.endswith("*") and name.startswith(key[:-1]) and len(key) > best_len:
+            best_len = len(key)
+            best_val = bool(val)
+    return best_val
+
+
+def _core_overrides_from_manifest(manifest: "EnvironmentManifest") -> Dict[str, bool]:
+    """Read ``manifest.tools.core_overrides`` defensively (old manifests lack it)."""
+    raw = getattr(manifest.tools, "core_overrides", None) or {}
+    return {str(k): bool(v) for k, v in raw.items()} if isinstance(raw, Mapping) else {}
+
+
+def _ensure_tool_search_reachable(registry: "ToolRegistry") -> None:
+    """Guarantee deferred tools stay discoverable.
+
+    A registry that holds deferred (non-core) tools without an exposed
+    ``ToolSearch`` would strand them — the LLM could never learn they
+    exist. Auto-register the built-in ``ToolSearch`` as core in that
+    case, and force it back to core if a manifest override demoted it
+    while deferred tools remain.
+    """
+    if not registry.list_deferred():
+        return
+    existing = registry.get("ToolSearch")
+    if existing is None:
+        from geny_executor.tools.built_in.tool_search_tool import ToolSearchTool
+
+        registry.register(ToolSearchTool(), core=True)
+        logger.info(
+            "ToolSearch auto-registered (core): %d deferred tool(s) need a discovery path",
+            len(registry.list_deferred()),
+        )
+    elif not registry.is_core("ToolSearch"):
+        registry.set_core("ToolSearch", True)
+        logger.warning(
+            "ToolSearch forced back to core — %d deferred tool(s) would be "
+            "unreachable with it deferred/demoted",
+            len(registry.list_deferred()),
+        )
+
+
 def _register_built_in_tools(
     manifest: "EnvironmentManifest",
     registry: "ToolRegistry",
@@ -484,6 +542,8 @@ def _register_built_in_tools(
     if names == ["*"]:
         names = list(BUILT_IN_TOOL_CLASSES.keys())
 
+    core_overrides = _core_overrides_from_manifest(manifest)
+
     for name in names:
         cls = BUILT_IN_TOOL_CLASSES.get(name)
         if cls is None:
@@ -499,7 +559,9 @@ def _register_built_in_tools(
             if report is not None:
                 report.shadowed.append(name)
             continue
-        registry.register(cls())
+        # Framework built-ins are core (upfront schema) by default;
+        # manifest.tools.core_overrides can defer individual names.
+        registry.register(cls(), core=_resolve_core_flag(name, core_overrides, True))
         if report is not None:
             report.resolved.append(name)
 
@@ -541,6 +603,8 @@ def _register_external_tools(
     if not raw_entries:
         return
 
+    core_overrides = _core_overrides_from_manifest(manifest)
+
     # Normalize entries → (name, required). Malformed entries warn and
     # count as unresolved-but-unnamed; they cannot be required because
     # we cannot even tell what the author wanted.
@@ -627,7 +691,13 @@ def _register_external_tools(
                 # intentionally hardened by the host).
                 report.shadowed.append(name)
             report.resolved.append(name)
-        registry.register(tool)
+        # Host-supplied (external) tools are deferred by default — the
+        # LLM discovers them via ToolSearch. core_overrides opts a name
+        # into upfront exposure; an external entry shadowing a framework
+        # built-in keeps the built-in's core default so the replacement
+        # is invisible to the model.
+        default_core = registry.is_core(name) if registry.get(name) is not None else False
+        registry.register(tool, core=_resolve_core_flag(name, core_overrides, default_core))
 
 
 def _gate_unconfigured_tools(
@@ -1248,6 +1318,9 @@ class Pipeline:
         # (no-op when satisfied_config is None). Runs after both registration
         # passes so it sees the full built-in + external surface.
         _gate_unconfigured_tools(registry, satisfied_config, resolution_report)
+        # Deferred tools need a live discovery path; from_manifest_async
+        # re-checks after providers + MCP land more registrations.
+        _ensure_tool_search_reachable(registry)
         pipeline.tool_resolution_report = resolution_report
         pipeline._tool_registry = registry
         # Retain the adhoc providers so the self-modifying-environment controller
@@ -1430,9 +1503,16 @@ class Pipeline:
         # MCP adapters arrive. Name collisions at this layer are logged
         # by ``register_providers``; MCP registrations would still fail
         # cleanly via the registry's own dedupe if they conflicted.
+        # Provider-shipped tools are deferred by default (ToolSearch
+        # discovery); manifest.tools.core_overrides opts names in.
+        core_overrides = _core_overrides_from_manifest(manifest)
         started_providers: List["ToolProvider"] = []
         if tool_providers:
-            started_providers = await register_providers(list(tool_providers), registry)
+            started_providers = await register_providers(
+                list(tool_providers),
+                registry,
+                core_resolver=lambda name: _resolve_core_flag(name, core_overrides, False),
+            )
 
         manager = MCPManager()
 
@@ -1481,8 +1561,15 @@ class Pipeline:
                 try:
                     await manager.connect_all(configs)
                     adapters = await manager.discover_all()
+                    # MCP tools are deferred by default (ToolSearch
+                    # discovery); core_overrides opts names in — the
+                    # trailing-* form covers whole servers whose tool
+                    # names are only known after discovery.
                     for adapter in adapters:
-                        registry.register(adapter)
+                        registry.register(
+                            adapter,
+                            core=_resolve_core_flag(adapter.name, core_overrides, False),
+                        )
                 except BaseException:
                     # Unwind providers if MCP bring-up fails mid-flight so no
                     # half-started resources leak out.
@@ -1492,6 +1579,10 @@ class Pipeline:
                     await manager.disconnect_all()
                     raise
 
+        # Providers + MCP may have added deferred tools after the sync
+        # from_manifest pass — re-check the discovery path.
+        _ensure_tool_search_reachable(registry)
+
         pipeline._mcp_manager = manager
         pipeline._tool_registry = registry
         pipeline._tool_providers = started_providers

{geny_executor-2.41.0 → geny_executor-2.43.0}/src/geny_executor/stages/s03_system/artifact/default/stage.py

@@ -164,14 +164,24 @@ class SystemStage(Stage[Any, Any]):
         # Register tools in state if registry provided. Snapshotted on the first
         # turn, then rebuilt only when the live registry's version moves — so a
         # tool/skill enabled/disabled/created mid-session (self-modifying
-        # environment), or an MCP re-seed, takes effect on the next turn. The
-        # version guard keeps the steady-state cost at one int compare per turn.
+        # environment), an MCP re-seed, or a ToolSearch activation takes effect
+        # on the next iteration. The version guard keeps the steady-state cost
+        # at one int compare per turn.
+        #
+        # Only *exposed* tools ship to the model: core tools plus deferred
+        # tools a ToolSearch hit activated. Deferred tools stay registered
+        # (Stage 10 can still dispatch them) but their schemas stay out of
+        # the request payload until discovered — that's the token contract.
         if self._tool_registry is not None:
             reg_version = getattr(self._tool_registry, "version", None)
             if not state.tools or (
                 reg_version is not None and reg_version != state.tools_version
             ):
-                state.tools = self._tool_registry.to_api_format()
+                try:
+                    state.tools = self._tool_registry.to_api_format(exposed_only=True)
+                except TypeError:
+                    # Host passed a registry-alike without exposure support.
+                    state.tools = self._tool_registry.to_api_format()
                 if reg_version is not None:
                     state.tools_version = reg_version
 

{geny_executor-2.41.0 → geny_executor-2.43.0}/src/geny_executor/stages/s10_tool/artifact/default/stage.py

@@ -208,6 +208,9 @@ class ToolStage(Stage[Any, Any]):
             # can see the live tool descriptors + shared state. Tools
             # MUST NOT mutate — use state_mutations / state_apply instead.
             state_view=state,
+            # The live registry — ToolSearch searches the FULL catalogue
+            # through it (deferred tools included) and activates matches.
+            tool_registry=self._registry,
             # Phase 5: propagate the host-attached HookRunner so the
             # router can fire PRE_TOOL_USE / POST_TOOL_USE / POST_TOOL_
             # FAILURE around dispatch. ``None`` is the default no-op.

{geny_executor-2.41.0 → geny_executor-2.43.0}/src/geny_executor/tools/base.py

@@ -157,6 +157,12 @@ class ToolContext:
     # means the host did not enable self-modification. Typed ``Any`` to avoid a
     # core import cycle.
     environment: Optional[Any] = None
+    # The live ToolRegistry backing this session (set by Stage 10). ToolSearch
+    # reads the FULL catalogue from it — including deferred tools whose schemas
+    # are not in ``state.tools`` — and promotes matches via ``activate()``.
+    # ``None`` (default) preserves the state_view/built-in fallback path.
+    # Typed ``Any`` to avoid importing the registry from this base module.
+    tool_registry: Optional[Any] = None
     extras: Dict[str, Any] = field(default_factory=dict)
 
 

{geny_executor-2.41.0 → geny_executor-2.43.0}/src/geny_executor/tools/built_in/__init__.py

@@ -95,6 +95,30 @@ from geny_executor.tools.built_in.env_tools import EnvTool
 # from ``ctx.extras['google']``; gated via required_config_keys → hidden until the
 # host marks ``feature:google_connected`` satisfied.
 from geny_executor.tools.built_in.google_tools import GOOGLE_TOOL_CLASSES
+# Browser — AI-native web exploration on the an-web engine (semantic snapshots,
+# per-session tabs, embedded V8; no Chromium). an-web itself imports lazily —
+# 'pip install geny-executor[browser]' (Python >= 3.12).
+from geny_executor.tools.built_in.browser_tools import (
+    BROWSER_TOOL_CLASSES,
+    BrowserActTool,
+    BrowserBackTool,
+    BrowserCloseTool,
+    BrowserEvalTool,
+    BrowserExtractTool,
+    BrowserNavigateTool,
+    BrowserSnapshotTool,
+)
+# Doc — office documents (docx/xlsx/pptx) on the edit2docs engine: addressable
+# outlines, deterministic edits, generation. Lazy import — 'pip install
+# geny-executor[docs]'.
+from geny_executor.tools.built_in.doc_tools import (
+    DOC_TOOL_CLASSES,
+    DocAnalyzeTool,
+    DocApplyEditsTool,
+    DocEditTool,
+    DocGenerateTool,
+    DocPreviewTool,
+)
 # NOT in BUILT_IN_TOOL_CLASSES: SandboxExecTool is instantiated per Sandbox Tool
 # Pack (with a spec + a live SandboxHandle), not activated by a manifest name.
 from geny_executor.tools.built_in.sandbox_exec_tool import SandboxExecTool
@@ -154,6 +178,11 @@ BUILT_IN_TOOL_CLASSES: Dict[str, Type[Tool]] = {
     # Google Workspace (gated on feature:google_connected — hidden until the host
     # injects OAuth creds + marks Google connected).
     **GOOGLE_TOOL_CLASSES,
+    # Browser (an-web) — semantic web exploration; degrades to an install-hint
+    # error when the optional an-web dependency is absent.
+    **BROWSER_TOOL_CLASSES,
+    # Doc (edit2docs) — office document engine; same lazy-import contract.
+    **DOC_TOOL_CLASSES,
 }
 
 
@@ -166,6 +195,12 @@ BUILT_IN_TOOL_FEATURES: Dict[str, List[str]] = {
     "filesystem": ["Read", "Write", "Edit", "Glob", "Grep", "NotebookEdit"],
     "shell": ["Bash"],
     "web": ["WebFetch", "WebSearch"],
+    # Interactive web exploration (an-web engine) — JS-rendered pages,
+    # per-session tabs, semantic snapshots. Distinct from "web" (one-shot
+    # fetch/search) so hosts can enable them independently.
+    "browser": list(BROWSER_TOOL_CLASSES.keys()),
+    # Office documents (edit2docs engine) — outline/edit/preview/generate.
+    "documents": list(DOC_TOOL_CLASSES.keys()),
     "workflow": ["TodoWrite"],
     "meta": ["ToolSearch", "EnterPlanMode", "ExitPlanMode"],
     "agent": ["Agent"],
@@ -248,6 +283,20 @@ def get_builtin_tools(
 
 __all__ = [
     "AgentTool",
+    "BROWSER_TOOL_CLASSES",
+    "DOC_TOOL_CLASSES",
+    "DocAnalyzeTool",
+    "DocApplyEditsTool",
+    "DocEditTool",
+    "DocGenerateTool",
+    "DocPreviewTool",
+    "BrowserActTool",
+    "BrowserBackTool",
+    "BrowserCloseTool",
+    "BrowserEvalTool",
+    "BrowserExtractTool",
+    "BrowserNavigateTool",
+    "BrowserSnapshotTool",
     "SubAgentSpawnTool",
     "SubAgentAssignTool",
     "SubAgentListTool",