geny-executor 2.26.0__tar.gz → 2.28.0__tar.gz

{geny_executor-2.26.0 → geny_executor-2.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.26.0
+Version: 2.28.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.26.0 → geny_executor-2.28.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.26.0"
+version = "2.28.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.26.0 → geny_executor-2.28.0}/src/geny_executor/core/environment_control.py

@@ -37,6 +37,56 @@ logger = logging.getLogger(__name__)
 EnvPersistence = Callable[[Dict[str, Any]], Awaitable[None]]
 
 
+# ── editable env-config surface ────────────────────────────────────────
+# Model generation knobs that ``PipelineConfig.apply_to_state`` stamps onto
+# state EVERY turn — so editing them on the live config takes effect next turn.
+# The MODEL ID and PROVIDER are deliberately absent: those are "core" and stay
+# locked (a session must not silently switch which model it is).
+_TUNABLE_MODEL_KEYS: Dict[str, type] = {
+    "temperature": float,
+    "max_tokens": int,
+    "top_p": float,
+    "top_k": int,
+    "thinking_enabled": bool,
+    "thinking_budget_tokens": int,
+}
+# Top-level PipelineConfig limits re-applied to state every run.
+_TUNABLE_PIPELINE_KEYS: Dict[str, type] = {
+    "max_iterations": int,
+    "cost_budget_usd": float,
+    "context_window_budget": int,
+    "single_turn": bool,
+}
+# Never editable at runtime — identity / credentials / wiring.
+_CORE_LOCKED_KEYS = frozenset(
+    {"model", "provider", "api_key", "base_url", "name", "credentials"}
+)
+# extras keys that are runtime HANDLES (objects), not editable settings. The
+# value-is-a-dict heuristic already excludes most; this names the known ones
+# defensively so they never surface as "settings" even if dict-shaped.
+_RESERVED_EXTRAS_KEYS = frozenset(
+    {
+        "workspace_stack", "task_registry", "task_runner", "cron_store",
+        "cron_runner", "agent_orchestrator", "subagent_manager", "mcp_manager",
+        "mcp_config", "notification_endpoints", "env_extras",
+    }
+)
+_SECRET_NAME_HINTS = ("key", "token", "secret", "password", "passwd", "credential")
+
+
+def _coerce(value: Any, typ: type) -> Any:
+    """Best-effort coerce a JSON value to the config field's type."""
+    if typ is bool:
+        if isinstance(value, bool):
+            return value
+        return str(value).strip().lower() in ("1", "true", "yes", "on")
+    if typ is int:
+        return int(float(value))
+    if typ is float:
+        return float(value)
+    return value
+
+
 @dataclass
 class EnvChangeEntry:
     """One change-log entry for an environment mutation."""
@@ -75,6 +125,9 @@ class PipelineEnvironment:
         skill_registry: Optional[Any] = None,
         skill_fork_runner: Optional[Any] = None,
         persistence: Optional[EnvPersistence] = None,
+        tool_context: Optional[Any] = None,
+        config: Optional[Any] = None,
+        settings_schemas: Optional[List[Dict[str, Any]]] = None,
     ) -> None:
         self._registry = registry
         self._providers: Tuple[Any, ...] = tuple(providers or ())
@@ -82,6 +135,19 @@ class PipelineEnvironment:
         self._skill_registry = skill_registry
         self._skill_fork_runner = skill_fork_runner
         self._persistence = persistence
+        # Live tool-dispatch context — its ``.extras`` carries per-tool
+        # settings (e.g. ``extras["web_search"]["brave_api_key"]``). Editing
+        # this dict takes effect on the next tool call (the Tool stage reads
+        # ``self._context.extras`` live per dispatch).
+        self._tool_context = tool_context
+        # The running PipelineConfig — model tunables (temperature / max_tokens
+        # / thinking) + pipeline limits (max_iterations) are applied to state
+        # every turn, so editing them here takes effect next turn.
+        self._config = config
+        # Optional host-supplied descriptor of the configurable tool settings
+        # (groups + fields + which fields are secret) for richer discovery +
+        # accurate secret masking. The executor stays host-agnostic without it.
+        self._settings_schemas: List[Dict[str, Any]] = list(settings_schemas or [])
         self._log: List[EnvChangeEntry] = []
         self._seq = 0
         # Session-authored skills (create_skill/edit_skill) — kept so the
@@ -99,6 +165,20 @@ class PipelineEnvironment:
         """Set/replace the host persistence callback (``env_save``)."""
         self._persistence = persistence
 
+    def attach_tool_context(self, tool_context: Optional[Any]) -> None:
+        """Re-point at the live tool-dispatch context (its ``.extras`` holds
+        the editable per-tool settings). Called when a host swaps the context
+        via attach_runtime/refresh_runtime."""
+        self._tool_context = tool_context
+
+    def attach_config(self, config: Optional[Any]) -> None:
+        """Re-point at the running PipelineConfig (model tunables + limits)."""
+        self._config = config
+
+    def attach_settings_schemas(self, schemas: Optional[List[Dict[str, Any]]]) -> None:
+        """Set/replace the host descriptor of configurable tool settings."""
+        self._settings_schemas = list(schemas or [])
+
     # ── change log ────────────────────────────────────────────────────
     def _record(self, action: str, target: str, detail: str, ok: bool = True) -> None:
         self._seq += 1
@@ -159,6 +239,8 @@ class PipelineEnvironment:
             "available_tools": self.available_tools(),
             "active_skills": self.active_skills(),
             "available_skills": self.available_skills(),
+            "setting_groups": self._setting_groups(),
+            "config": {**self.get_config().get("model", {}), **self.get_config().get("pipeline", {})},
             "changes": len(self._log),
             "persistable": self._persistence is not None,
         }
@@ -231,8 +313,9 @@ class PipelineEnvironment:
             msg = f"tool '{name}' is not active"
             self._record("disable_tool", name, msg, ok=False)
             return False, msg
-        # Guard the self-modification tools so a session can't strand itself.
-        if name.startswith("env_"):
+        # Guard the self-modification tool so a session can't strand itself
+        # (the built-in dispatcher is named "env"; older builds used "env_*").
+        if name == "env" or name.startswith("env_"):
             msg = f"refusing to disable the environment control tool '{name}'"
             self._record("disable_tool", name, msg, ok=False)
             return False, msg
@@ -371,6 +454,165 @@ class PipelineEnvironment:
         self._record("edit_skill", sid, msg)
         return True, msg
 
+    # ── tool settings (values tools need — e.g. API keys) ─────────────
+    def _extras(self) -> Optional[Dict[str, Any]]:
+        ctx = self._tool_context
+        if ctx is None:
+            return None
+        ex = getattr(ctx, "extras", None)
+        if ex is None:  # late-attached context with no extras dict yet
+            ex = {}
+            try:
+                ctx.extras = ex  # type: ignore[attr-defined]
+            except Exception:  # noqa: BLE001
+                return None
+        return ex if isinstance(ex, dict) else None
+
+    def _setting_groups(self) -> List[str]:
+        """extras keys that are editable setting groups (dict-shaped, not a
+        reserved runtime handle, not an internal ``__key__``)."""
+        ex = self._extras()
+        if not ex:
+            return []
+        groups = []
+        for k, v in ex.items():
+            if k in _RESERVED_EXTRAS_KEYS or str(k).startswith("__"):
+                continue
+            if isinstance(v, dict):
+                groups.append(k)
+        return sorted(groups)
+
+    def _schema_for(self, group: str) -> Optional[Dict[str, Any]]:
+        for sch in self._settings_schemas:
+            if sch.get("key") == group:
+                return sch
+        return None
+
+    def _is_secret(self, group: str, field: str) -> bool:
+        sch = self._schema_for(group)
+        if sch:
+            for f in sch.get("fields", []) or []:
+                if f.get("name") == field:
+                    return bool(f.get("secret") or f.get("secure"))
+        low = field.lower()
+        return any(h in low for h in _SECRET_NAME_HINTS)
+
+    @staticmethod
+    def _mask(value: Any) -> str:
+        s = str(value)
+        if not s:
+            return ""
+        return "•" * 6 + (s[-4:] if len(s) > 4 else "")
+
+    def get_settings(self, *, reveal: bool = False) -> Dict[str, Any]:
+        """Current per-tool settings (secrets masked unless ``reveal``), plus
+        any host-declared schema so the agent can discover what's configurable."""
+        out: Dict[str, Any] = {"groups": {}, "schemas": self._settings_schemas}
+        ex = self._extras()
+        if ex is None:
+            out["note"] = "no settings context is available in this environment"
+            return out
+        for group in self._setting_groups():
+            vals = {}
+            for field, raw in (ex.get(group) or {}).items():
+                if not reveal and self._is_secret(group, field):
+                    vals[field] = self._mask(raw) if raw not in (None, "") else ""
+                else:
+                    vals[field] = raw
+            out["groups"][group] = vals
+        return out
+
+    def set_setting(self, key: str, field: str, value: Any) -> Tuple[bool, str]:
+        """Set a single tool-setting value (e.g. an API key). Takes effect on
+        the next call of the tool that reads ``extras[key][field]``."""
+        ex = self._extras()
+        if ex is None:
+            msg = "no settings context is available in this environment"
+            self._record("set_setting", f"{key}.{field}", msg, ok=False)
+            return False, msg
+        key = str(key).strip()
+        field = str(field).strip()
+        if not key or not field:
+            return False, "both 'key' and 'field' are required"
+        if key in _RESERVED_EXTRAS_KEYS or key.startswith("__"):
+            msg = f"'{key}' is a protected runtime handle, not an editable setting"
+            self._record("set_setting", f"{key}.{field}", msg, ok=False)
+            return False, msg
+        group = ex.get(key)
+        if not isinstance(group, dict):
+            group = {}
+            ex[key] = group
+        group[field] = value
+        shown = self._mask(value) if self._is_secret(key, field) else value
+        msg = f"set {key}.{field} = {shown}"
+        self._record("set_setting", f"{key}.{field}", msg)
+        return True, msg
+
+    # ── env config (model tunables + pipeline limits; core stays locked) ─
+    def get_config(self) -> Dict[str, Any]:
+        """Editable config knobs + their current values, plus the locked core
+        (model / provider) so the agent knows what it may and may not change."""
+        model_vals: Dict[str, Any] = {}
+        pipe_vals: Dict[str, Any] = {}
+        core: Dict[str, Any] = {}
+        cfg = self._config
+        if cfg is not None:
+            mc = getattr(cfg, "model", None)
+            if mc is not None:
+                for k in _TUNABLE_MODEL_KEYS:
+                    if hasattr(mc, k):
+                        model_vals[k] = getattr(mc, k)
+                core["model"] = getattr(mc, "model", None)
+            for k in _TUNABLE_PIPELINE_KEYS:
+                if hasattr(cfg, k):
+                    pipe_vals[k] = getattr(cfg, k)
+        return {
+            "model": model_vals,
+            "pipeline": pipe_vals,
+            "locked": sorted(_CORE_LOCKED_KEYS),
+            "core": core,
+        }
+
+    def set_config(self, key: str, value: Any) -> Tuple[bool, str]:
+        """Edit one tunable config knob. Refuses core/locked keys (model,
+        provider, credentials). Takes effect next turn."""
+        key = str(key).strip()
+        if key in _CORE_LOCKED_KEYS:
+            msg = f"'{key}' is a core setting and cannot be changed at runtime"
+            self._record("set_config", key, msg, ok=False)
+            return False, msg
+        cfg = self._config
+        if cfg is None:
+            msg = "no config is available in this environment"
+            self._record("set_config", key, msg, ok=False)
+            return False, msg
+        try:
+            if key in _TUNABLE_MODEL_KEYS:
+                mc = getattr(cfg, "model", None)
+                if mc is None:
+                    return False, "no model config available"
+                coerced = _coerce(value, _TUNABLE_MODEL_KEYS[key])
+                setattr(mc, key, coerced)
+            elif key in _TUNABLE_PIPELINE_KEYS:
+                coerced = _coerce(value, _TUNABLE_PIPELINE_KEYS[key])
+                setattr(cfg, key, coerced)
+            else:
+                msg = f"'{key}' is not an editable config knob"
+                self._record("set_config", key, msg, ok=False)
+                return False, msg
+        except Exception as exc:  # noqa: BLE001
+            msg = f"could not set {key}: {exc}"
+            self._record("set_config", key, msg, ok=False)
+            return False, msg
+        msg = f"set config {key} = {coerced}"
+        self._record("set_config", key, msg)
+        return True, msg
+
+    def _config_overrides(self) -> Dict[str, Any]:
+        """The tunable config values (for the overlay) — restored on resume."""
+        snap = self.get_config()
+        return {"model": snap.get("model", {}), "pipeline": snap.get("pipeline", {})}
+
     # ── persistence (save the evolved env overlay) ────────────────────
     def overlay(self) -> Dict[str, Any]:
         """Serialise the session-scoped environment overlay (what changed)
@@ -380,6 +622,12 @@ class PipelineEnvironment:
             "active_tools": self.active_tools(),
             "active_skills": self.active_skills(),
             "authored_skills": list(self._authored_skills.values()),
+            # Real (unmasked) values so a resume restores working settings —
+            # stored in the session's own scoped storage, like the manifest.
+            "tool_settings": {g: dict(self._extras().get(g, {})) for g in self._setting_groups()}
+            if self._extras() is not None
+            else {},
+            "config": self._config_overrides(),
             "changelog": self.changelog(),
         }
 

{geny_executor-2.26.0 → geny_executor-2.28.0}/src/geny_executor/core/pipeline.py

@@ -735,6 +735,7 @@ class Pipeline:
         #   _environment — the live PipelineEnvironment controller (lazy).
         self._adhoc_providers: List[Any] = []
         self._env_persistence: Any = None
+        self._env_settings_schemas: Any = None
         self._environment: Any = None
         self._has_started: bool = (
             False  # flips once run()/run_stream() begins; gates attach_runtime
@@ -1487,6 +1488,7 @@ class Pipeline:
         subagent_registry: Optional[Any] = None,
         sandbox: Optional[Any] = None,
         env_persistence: Optional[Any] = None,
+        env_settings_schemas: Optional[Any] = None,
         override_manifest: bool = False,
     ) -> None:
         """Inject session-scoped runtime objects into a manifest-built pipeline.
@@ -1640,6 +1642,7 @@ class Pipeline:
             subagent_registry=subagent_registry,
             sandbox=sandbox,
             env_persistence=env_persistence,
+            env_settings_schemas=env_settings_schemas,
             override_manifest=override_manifest,
         )
 
@@ -1700,6 +1703,7 @@ class Pipeline:
         subagent_registry: Optional[Any] = None,
         sandbox: Optional[Any] = None,
         env_persistence: Optional[Any] = None,
+        env_settings_schemas: Optional[Any] = None,
         override_manifest: bool = False,
     ) -> None:
         """Shared wiring behind :meth:`attach_runtime` / :meth:`refresh_runtime`.
@@ -1738,6 +1742,13 @@ class Pipeline:
             if self._environment is not None:
                 self._environment.attach_persistence(env_persistence)
 
+        if env_settings_schemas is not None:
+            # Host descriptor of configurable tool settings (groups + fields +
+            # which are secret) for accurate masking / discovery by env_get_settings.
+            self._env_settings_schemas = env_settings_schemas
+            if self._environment is not None:
+                self._environment.attach_settings_schemas(env_settings_schemas)
+
         if tool_context is not None:
             self._set_tool_stage_context(tool_context)
             # A host-supplied tool_context replaces the Tool stage's context —
@@ -1992,6 +2003,10 @@ class Pipeline:
             skill_registry=getattr(sp, "_registry", None) if sp else None,
             skill_fork_runner=getattr(sp, "_fork_runner", None) if sp else None,
             persistence=self._env_persistence,
+            # Model tunables + pipeline limits (core model/provider stay locked).
+            config=self._config,
+            # Host descriptor of configurable tool settings (optional).
+            settings_schemas=getattr(self, "_env_settings_schemas", None),
         )
 
     def _init_environment_controller(self) -> None:
@@ -2021,6 +2036,10 @@ class Pipeline:
                 ctx = ToolContext()
                 stage._context = ctx
             ctx.environment = environment
+            # Give the controller the SAME context object so its setting edits
+            # land on the dict the dispatch reads live (build_dispatch_context).
+            if environment is not None and hasattr(environment, "attach_tool_context"):
+                environment.attach_tool_context(ctx)
             return
 
     def _set_stage_slot_strategy(self, *, stage_name: str, slot_name: str, strategy: Any) -> None:

{geny_executor-2.26.0 → geny_executor-2.28.0}/src/geny_executor/skills/bundled/environment/REFERENCE.md

@@ -59,11 +59,44 @@ write actions return a short status string (and set an error flag on failure).
 - Updates only the provided fields. If the skill is active, its surfaced tool is
   refreshed to the new body.
 
+## Tool settings (values tools need — API keys, backends, URLs)
+
+These are the variables a tool reads at run time (e.g. the web_search backend +
+its API key). They live in the tool-dispatch context's `extras[group][field]`.
+
+### `get_settings`
+- args: `{ "reveal": <bool?> }` — set `reveal: true` to see secret values
+  unmasked (default masks them).
+- returns: `{ "groups": { "<group>": { "<field>": value }, ... },
+  "schemas": [...] }`. `schemas` (when the host declares them) lists each
+  group's fields + which are secret.
+
+### `set_setting`
+- args: `{ "key": "<group, e.g. web_search>", "field": "<e.g. brave_api_key>",
+  "value": <any> }`
+- Sets one value. Effective on the NEXT call of the tool that reads it. Refuses
+  protected runtime handles (`workspace_stack`, `task_registry`, …).
+
+## Config (tunable knobs; core stays locked)
+
+### `get_config`
+- args: none
+- returns: `{ "model": {temperature, max_tokens, top_p, top_k, thinking_enabled,
+  thinking_budget_tokens}, "pipeline": {max_iterations, cost_budget_usd,
+  context_window_budget, single_turn}, "locked": [...], "core": {model} }`.
+
+### `set_config`
+- args: `{ "key": "<knob>", "value": <number/bool> }`
+- Edits one tunable knob (values coerced to the field's type). Takes effect next
+  turn. **Refuses** core keys: `model`, `provider`, `api_key`, `base_url`,
+  `credentials`, `name` — the model identity and credentials cannot be changed
+  at runtime.
+
 ## Persistence
 
 ### `save`
 - args: none
 - Persists the overlay (prompt + active tools + active skills + authored skills
-  + changelog) for THIS session via the host's persistence callback, so it is
-  restored on resume. Returns an error string if no persistence is configured
-  (changes still remain live for the current session).
+  + tool_settings + config + changelog) for THIS session via the host's
+  persistence callback, so it is restored on resume. Returns an error string if
+  no persistence is configured (changes still remain live for the session).

{geny_executor-2.26.0 → geny_executor-2.28.0}/src/geny_executor/skills/bundled/environment/SKILL.md

@@ -36,6 +36,17 @@ template) and take effect **from the next turn**. Every change is logged.
   "description": "one line — when to use it", "body": "# Title\n\nstep-by-step
   instructions"})`. It is enabled immediately. Edit later with
   `env(action="edit_skill", args={"skill_id": "...", "body": "..."})`.
+- **Inspect tool settings** — `env(action="get_settings")`. Shows the
+  configurable values tools need (e.g. a search backend + API key); secrets are
+  masked. `args.schemas` describes what each group accepts when the host declares it.
+- **Set a tool's value** (API key, backend, URL, …) — `env(action="set_setting",
+  args={"key": "web_search", "field": "brave_api_key", "value": "..."})`. Takes
+  effect on the next call of that tool.
+- **Inspect tunable config** — `env(action="get_config")`. Model knobs
+  (temperature, max_tokens, thinking…) + pipeline limits (max_iterations); plus
+  the LOCKED core (model, provider) you cannot change.
+- **Set a config knob** — `env(action="set_config", args={"key": "temperature",
+  "value": 0.7})`. Takes effect next turn. Core keys (model/provider) are refused.
 - **Review your changes** — `env(action="changelog")`.
 - **Save** — `env(action="save")`. Persists your evolved environment for THIS
   session so it is restored next time. (If saving isn't configured the call

{geny_executor-2.26.0 → geny_executor-2.28.0}/src/geny_executor/stages/s03_system/artifact/default/builders.py

@@ -46,9 +46,19 @@ class MutablePromptBuilder(PromptBuilder):
     edited — so it is a safe drop-in default.
     """
 
-    def __init__(self, prompt: str = "", sections: Optional[List[str]] = None):
+    def __init__(
+        self,
+        prompt: str = "",
+        sections: Optional[List[str]] = None,
+        blocks: Optional[List[PromptBlock]] = None,
+    ):
         self._base = prompt
         self._sections: List[str] = [str(s) for s in (sections or [])]
+        # Dynamic blocks (e.g. datetime / memory) rendered per turn AFTER the
+        # editable base + sections. The session edits the base; these keep
+        # working. Lets a host (Geny) use MutablePromptBuilder in place of a
+        # ComposablePromptBuilder without losing its dynamic content.
+        self._blocks: List[PromptBlock] = list(blocks or [])
 
     @property
     def name(self) -> str:
@@ -82,16 +92,30 @@ class MutablePromptBuilder(PromptBuilder):
         """Drop all appended sections (keeps the base)."""
         self._sections = []
 
-    def current_text(self) -> str:
-        """The fully-rendered prompt as it stands now."""
-        return self._render()
+    def add_block(self, block: PromptBlock) -> "MutablePromptBuilder":
+        """Append a dynamic block (rendered per turn). Chainable."""
+        self._blocks.append(block)
+        return self
 
-    def _render(self) -> str:
+    def current_text(self) -> str:
+        """The editable prompt (base + appended sections) as it stands now.
+        Excludes dynamic blocks — that's the part the session owns/edits."""
         parts = [self._base, *self._sections]
         return "\n\n".join(p for p in parts if p and p.strip())
 
+    def _render(self, state: Optional[PipelineState]) -> str:
+        parts: List[str] = [self._base, *self._sections]
+        for block in self._blocks:
+            try:
+                rendered = block.render(state)  # type: ignore[arg-type]
+            except Exception:  # noqa: BLE001 — a broken block never breaks the prompt
+                continue
+            if rendered:
+                parts.append(rendered if isinstance(rendered, str) else str(rendered))
+        return "\n\n".join(p for p in parts if p and p.strip())
+
     def build(self, state: PipelineState) -> str:
-        return self._render()
+        return self._render(state)
 
 
 class PersonaBlock(PromptBlock):

{geny_executor-2.26.0 → geny_executor-2.28.0}/src/geny_executor/stages/s10_tool/artifact/default/stage.py

@@ -218,6 +218,17 @@ class ToolStage(Stage[Any, Any]):
             # (the default) means no matrix is configured and dispatch
             # behaves exactly as it did pre-Phase-7.
             permission_rules=list(getattr(self._context, "permission_rules", None) or []),
+            # Host-attached tool settings (e.g. ``extras["web_search"]
+            # ["brave_api_key"]``) read LIVE off ``self._context`` each
+            # dispatch — so a value edited at runtime (the ``env`` tool's
+            # set_setting) is visible on the very next tool call. Shallow-
+            # copied so a buggy tool can't drop session-wide keys; nested
+            # setting dicts stay shared (the edit path the controller uses).
+            extras=dict(getattr(self._context, "extras", None) or {}),
+            # The self-modifying-environment controller — likewise read live
+            # so the built-in ``env`` tool reaches it through real dispatch
+            # (not just direct calls). Without this it would see ``None``.
+            environment=getattr(self._context, "environment", None),
         )
 
         # 2.2.0 (audit §1-5 — policy via config): the permission posture

{geny_executor-2.26.0 → geny_executor-2.28.0}/src/geny_executor/tools/built_in/env_tools.py

@@ -46,6 +46,10 @@ _ACTIONS = {
         ("skill_id", "description", "body", "allowed_tools"),
     ),
     "edit_skill": ("edit_skill", False, ("skill_id", "description", "body", "allowed_tools")),
+    "get_settings": ("get_settings", False, ("reveal",)),
+    "set_setting": ("set_setting", False, ("key", "field", "value")),
+    "get_config": ("get_config", False, ()),
+    "set_config": ("set_config", False, ("key", "value")),
     "changelog": ("changelog", False, ("limit",)),
     "save": ("save", True, ()),
 }
@@ -100,7 +104,7 @@ class EnvTool(Tool):
 
     def capabilities(self, input: Dict[str, Any]) -> ToolCapabilities:
         action = (input or {}).get("action")
-        read_only = action in ("view", "get_prompt", "changelog")
+        read_only = action in ("view", "get_prompt", "changelog", "get_settings", "get_config")
         # Env edits change the active toolset/prompt — never run them in parallel
         # with other tools.
         return ToolCapabilities(concurrency_safe=False, read_only=read_only)

{geny_executor-2.26.0 → geny_executor-2.28.0}/tests/unit/test_self_modifying_env.py

@@ -148,3 +148,82 @@ async def test_env_save_calls_host_persistence_with_overlay() -> None:
     assert "web_search" in saved["active_tools"]
     actions = {c["action"] for c in saved["changelog"]}
     assert {"set_prompt", "enable_tool"} <= actions
+
+
+# ── dispatch-path wiring: the env tool + tool settings must survive the
+#    per-call ToolContext that the Tool stage builds (build_dispatch_context).
+
+
+def _tool_stage(pipeline: Pipeline):
+    return next(s for s in pipeline._stages.values() if getattr(s, "name", "") == "tool")
+
+
+@pytest.mark.asyncio
+async def test_env_controller_survives_dispatch_context() -> None:
+    """The env tool reads ctx.environment; the Tool stage builds a fresh
+    ToolContext per call — that context MUST carry environment + extras."""
+    from geny_executor.core.state import PipelineState
+
+    prov = _Provider({"read": _NamedTool("read")})
+    pipeline = await _build(prov)
+    stage = _tool_stage(pipeline)
+    # Seed a tool setting on the live stage context.
+    stage._context.extras = {"web_search": {"brave_api_key": "SEEDKEY"}}
+    pipeline._set_tool_stage_environment(pipeline.environment)
+
+    state = PipelineState(session_id="s1")
+    dispatch_ctx = stage.build_dispatch_context(state)
+    assert dispatch_ctx.environment is pipeline.environment   # env tool can reach it
+    assert dispatch_ctx.extras.get("web_search", {}).get("brave_api_key") == "SEEDKEY"
+
+
+@pytest.mark.asyncio
+async def test_set_setting_reaches_next_dispatch() -> None:
+    from geny_executor.core.state import PipelineState
+
+    prov = _Provider({"read": _NamedTool("read")})
+    pipeline = await _build(prov)
+    stage = _tool_stage(pipeline)
+    stage._context.extras = {}
+    pipeline._set_tool_stage_environment(pipeline.environment)
+    env = pipeline.environment
+
+    ok, _ = env.set_setting("web_search", "brave_api_key", "LIVEKEY")
+    assert ok
+    # The NEXT dispatch context sees the value the controller just wrote.
+    ctx = stage.build_dispatch_context(PipelineState(session_id="s1"))
+    assert ctx.extras["web_search"]["brave_api_key"] == "LIVEKEY"
+    # get_settings masks the secret by default but reveals on request.
+    masked = env.get_settings()["groups"]["web_search"]["brave_api_key"]
+    assert "LIVEKEY" not in masked and masked.endswith("EKEY")
+    assert env.get_settings(reveal=True)["groups"]["web_search"]["brave_api_key"] == "LIVEKEY"
+
+
+@pytest.mark.asyncio
+async def test_config_tunables_editable_core_locked() -> None:
+    prov = _Provider({"read": _NamedTool("read")})
+    pipeline = await _build(prov)
+    env = pipeline.environment
+
+    ok, _ = env.set_config("temperature", 0.7)
+    assert ok
+    assert pipeline._config.model.temperature == 0.7
+    ok, _ = env.set_config("max_iterations", 12)
+    assert ok
+    assert pipeline._config.max_iterations == 12
+    # Core stays locked.
+    ok, msg = env.set_config("model", "claude-opus-4-8")
+    assert not ok and "core" in msg.lower()
+    ok, msg = env.set_config("provider", "openai")
+    assert not ok
+    assert "model" in env.get_config()["locked"]
+
+
+@pytest.mark.asyncio
+async def test_env_tool_cannot_be_disabled() -> None:
+    prov = _Provider({"read": _NamedTool("read")})
+    pipeline = await _build(prov)
+    env = pipeline.environment
+    ok, msg = env.disable_tool("env")
+    assert not ok and "refusing" in msg.lower()
+    assert "env" in env.active_tools()