code-coordinator 0.5.113__tar.gz → 0.5.114__tar.gz

{code_coordinator-0.5.113 → code_coordinator-0.5.114}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.113
+Version: 0.5.114
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.113 → code_coordinator-0.5.114}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.113
+Version: 0.5.114
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.113 → code_coordinator-0.5.114}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.113",
+  "tag": "0.5.114",
   "distance": 0,
-  "node": "ga030a27e286c5012119c4cdbfb871f070e331e8a",
+  "node": "g3415bd29a5ed645fb1b607710d503c75830b4bfc",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-16"

{code_coordinator-0.5.113 → code_coordinator-0.5.114}/coord/config.py

@@ -3321,6 +3321,51 @@ def _expand_env_vars(value: str) -> str:
     return _ENV_VAR_RE.sub(_replace, value)
 
 
+#: Matches exactly what opencode's own ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX``
+#: parser (#2321) accepts as a *string form* of a number: one or more ASCII
+#: digits, nothing else — no sign, no decimal point, no whitespace, no
+#: underscore digit-grouping. Combined with the ``> 0`` check below this
+#: mirrors opencode's own rule (integer, ``> 0``) closely enough to reject
+#: every value opencode is documented to silently discard: ``"131072 "``
+#: (trailing whitespace), ``"131_072"`` (underscore grouping — Python's
+#: ``int()`` would accept this but JS ``Number()`` coercion does not),
+#: ``"0"`` (fails ``> 0``), ``"1.5"`` (decimal point), and ``"unlimited"``
+#: (non-numeric).
+_OPENCODE_OUTPUT_TOKEN_MAX_RE = re.compile(r"[0-9]+")
+
+#: The env var name gated by :data:`_OPENCODE_OUTPUT_TOKEN_MAX_RE` — kept as
+#: a constant rather than a literal so config.py and opencode.py can be
+#: grepped for the exact same string (deliberately NOT imported from
+#: coord.providers.opencode: config.py must not depend on provider modules).
+OPENCODE_OUTPUT_TOKEN_MAX_ENV_VAR = "OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"
+
+
+def _validate_opencode_output_token_max_env(value: str, *, context: str) -> None:
+    """Reject an ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX`` override that
+    opencode's own parser would silently discard (#2321).
+
+    opencode's env-var parser demands an integer ``> 0``; anything else
+    (a non-numeric string, a decimal, a value with surrounding whitespace
+    or underscore digit-grouping, zero or negative) maps to ``undefined``
+    internally, which silently restores opencode's 32,000-token default
+    with **no warning anywhere** — exactly the failure mode #2321 exists
+    to end. Config-parse time is the only point where "silently reverted
+    to 32,000" can be turned into a loud, actionable error instead of a
+    truncated worker run discovered hours later.
+
+    Raises:
+        ConfigError: when *value* is not a bare positive-integer string.
+    """
+    if not _OPENCODE_OUTPUT_TOKEN_MAX_RE.fullmatch(value) or int(value) <= 0:
+        raise ConfigError(
+            f"{context} must be a positive integer string with no "
+            "surrounding whitespace, sign, decimal point, or underscores "
+            "(opencode's OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX parser "
+            "silently discards anything else and reverts to its 32000 "
+            f"default) — got {value!r}"
+        )
+
+
 _PORTAL_PLAIN_STR_FIELDS = ("base_url",)
 _PORTAL_SECRET_STR_FIELDS = ("bridge_client_id", "bridge_client_secret")
 
@@ -3471,6 +3516,20 @@ def _parse_providers(raw: Any) -> ProvidersConfig:
         # Expand ${VAR} in env values.
         env: dict[str, str] = {k: _expand_env_vars(v) for k, v in env_raw.items()}
 
+        # #2321: an operator override of opencode's output-token-cap knob
+        # must be a value opencode's own parser will actually honour — see
+        # _validate_opencode_output_token_max_env for why a bad value here
+        # (e.g. a trailing space) is worse than a normal type error: it
+        # doesn't fail, it silently reverts to the 32000 default.
+        if OPENCODE_OUTPUT_TOKEN_MAX_ENV_VAR in env:
+            _validate_opencode_output_token_max_env(
+                env[OPENCODE_OUTPUT_TOKEN_MAX_ENV_VAR],
+                context=(
+                    f"providers.definitions[{def_name!r}].env"
+                    f"[{OPENCODE_OUTPUT_TOKEN_MAX_ENV_VAR!r}]"
+                ),
+            )
+
         extra_args_raw = def_raw.get("extra_args", []) or []
         if not isinstance(extra_args_raw, list) or not all(
             isinstance(a, str) for a in extra_args_raw

{code_coordinator-0.5.113 → code_coordinator-0.5.114}/coord/providers/opencode.py

@@ -76,6 +76,12 @@ Differences from :class:`~.claude.ClaudeProvider`:
 * ``env()`` always sets ``OPENCODE_CONFIG_DIR`` (agent-file discovery, see
   above) and ``OPENCODE_CONFIG`` (the OpenRouter upstream-routing pin, see
   ``coord/agents/opencode/routing.jsonc`` and :data:`ROUTING_PIN_PATH`).
+* ``env()`` also seeds ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX`` to
+  :data:`OUTPUT_TOKEN_MAX_DEFAULT` (#2321) — unlike the two variables
+  above, this one *is* operator-overridable (it's a tuning knob, not a
+  safety mechanism); see :meth:`env`'s docstring for why it sits on the
+  opposite side of ``self._env`` from ``OPENCODE_CONFIG_DIR``/
+  ``OPENCODE_CONFIG``.
 """
 
 from __future__ import annotations
@@ -148,6 +154,46 @@ AGENTS_ROOT = Path(__file__).resolve().parent.parent / "agents" / "opencode"
 #: onto the worker's environment as ``OPENCODE_CONFIG`` by :meth:`env`.
 ROUTING_PIN_PATH = AGENTS_ROOT / "routing.jsonc"
 
+#: Default value for ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX`` (#2321).
+#:
+#: opencode caps every request's output tokens at 32,000 (its internal
+#: ``OY = 32000`` default) unless this environment variable overrides it —
+#: and on a reasoning model that 32,000-token budget is *shared* with the
+#: model's own reasoning, so a long reasoning block can consume the whole
+#: cap before a single tool call is emitted.  This is not hypothetical:
+#: space-invaders#1 (``8c95182b0749``) spent all 32,000 tokens on one
+#: 113 KB reasoning block, was truncated (``"reason":"length"``), emitted
+#: no tool call, and exited 0 with nothing on disk — the run this issue is
+#: named for.
+#:
+#: opencode computes the *effective* cap as
+#: ``min(model.limit.output, $OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX)`` —
+#: it is a ceiling suggestion, not a per-model override.  Raising it can
+#: never push a model's output above what that model's own
+#: ``limit.output`` allows; it can only stop opencode's own 32,000
+#: default from clamping a model that allows more.  That makes a single
+#: generous constant safe across every model dispatched through this
+#: provider — no need to look up ``limit.output`` per model at dispatch
+#: time.
+#:
+#: Chosen as 384,000 — the largest ``limit.output`` among the opencode
+#: model definitions coord currently routes through (``oc-cheap`` /
+#: ``opencode/deepseek-v4-flash`` and ``oc-heavy`` /
+#: ``opencode/deepseek-v4-pro``, both 384,000; ``oc-mid`` /
+#: ``opencode/glm-5.2`` is lower at 131,072 and is naturally clamped to
+#: its own true ceiling by the ``min()`` above — never pushed past it).
+#:
+#: Both fleet binaries already read this variable (1.18.11 on dellserver —
+#: the machine that hit the space-invaders#1 truncation — and 1.18.12 on
+#: precision), and it is not gated behind ``OPENCODE_EXPERIMENTAL`` the
+#: way other ``experimental*``-named flags are (that gating uses a
+#: different internal helper; this flag's parser reads the env var
+#: directly, unconditionally). No version-floor probe is needed here and
+#: none should be added later on speculation: on a binary that predates
+#: this flag it is simply inert and the cap silently stays at 32,000 —
+#: never a hard failure.
+OUTPUT_TOKEN_MAX_DEFAULT = 384_000
+
 
 class OpenCodeAgentNotFoundError(RuntimeError):
     """Raised when no committed opencode agent definition exists for a
@@ -641,35 +687,62 @@ class OpenCodeProvider(Provider):
     def env(self) -> dict[str, str]:
         """Extra environment variables for the worker subprocess.
 
-        Two parts:
-
-        1. ``ProviderDef.env`` (already ``${VAR}``-expanded by config
+        Three parts, deliberately split across **both sides** of
+        ``self._env`` — that asymmetry is the whole point, see below:
+
+        1. **#2321, seeded BEFORE ``self._env``, operator-overridable:**
+           ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX`` defaults to
+           :data:`OUTPUT_TOKEN_MAX_DEFAULT` (see that constant for the
+           full rationale). Unlike part 3 below, this is a *tuning knob*,
+           not a safety mechanism — an operator has a legitimate reason to
+           pin it lower (e.g. to cap cost) or higher (a future model with
+           a larger ``limit.output``), so it is seeded first and then
+           allowed to be shadowed by ``self._env`` like any other
+           ``ProviderDef.env`` entry.  ``coord/config.py``'s
+           ``_parse_providers`` rejects a value at config-parse time that
+           opencode's own parser would silently discard (non-integer,
+           ``<= 0``, or containing whitespace/underscores) — see that
+           function for the validation opencode itself performs.
+        2. ``ProviderDef.env`` (already ``${VAR}``-expanded by config
            parsing, #1706) — how an operator points a named ``opencode``
            provider definition at a specific set of credentials without
-           baking them into the machine's agent unit.
-        2. **#1705, always set, not operator-overridable:**
-           ``OPENCODE_CONFIG_DIR`` (:data:`AGENTS_ROOT` — where the
-           committed per-spec-type agent files live, see the module
-           docstring for why an env var rather than a worktree file copy)
-           and ``OPENCODE_CONFIG`` (:data:`ROUTING_PIN_PATH` — the
-           OpenRouter routing pin, see ``coord/agents/opencode/routing.jsonc``).
-           These are applied **after** ``self._env`` so a
-           ``ProviderDef.env`` entry cannot accidentally (or maliciously,
-           via a compromised ``coordinator.yml`` edit that isn't the
-           security-reviewed agent-file path) shadow the deny-list
-           discovery mechanism — see :class:`OpenCodeAgentNotFoundError`'s
-           docstring for why silently losing this would be bad.  Verified
-           empirically that ``OPENCODE_CONFIG_DIR`` is inert for a provider
-           the operator hasn't configured credentials for (real opencode
-           1.18.11 run against a non-OpenRouter model with both variables
-           set completed normally) — see
+           baking them into the machine's agent unit.  This is also where
+           an operator's override of part 1 above lands, since dict
+           ``.update()`` here happens after the default is seeded.
+        3. **#1705, always set AFTER ``self._env``, NOT
+           operator-overridable:** ``OPENCODE_CONFIG_DIR``
+           (:data:`AGENTS_ROOT` — where the committed per-spec-type agent
+           files live, see the module docstring for why an env var rather
+           than a worktree file copy) and ``OPENCODE_CONFIG``
+           (:data:`ROUTING_PIN_PATH` — the OpenRouter routing pin, see
+           ``coord/agents/opencode/routing.jsonc``).  These are applied
+           **after** ``self._env`` so a ``ProviderDef.env`` entry cannot
+           accidentally (or maliciously, via a compromised
+           ``coordinator.yml`` edit that isn't the security-reviewed
+           agent-file path) shadow the deny-list discovery mechanism —
+           see :class:`OpenCodeAgentNotFoundError`'s docstring for why
+           silently losing this would be bad.  Verified empirically that
+           ``OPENCODE_CONFIG_DIR`` is inert for a provider the operator
+           hasn't configured credentials for (real opencode 1.18.11 run
+           against a non-OpenRouter model with both variables set
+           completed normally) — see
            ``test_opencode_routing_pin_inert_without_openrouter_credential_end_to_end``.
 
+        The asymmetry: part 1 is a default an operator must be able to
+        override (seeded *before* the merge, operator wins); part 3 is a
+        safety mechanism an operator must never be able to override (set
+        *after* the merge, coord wins).  Do not "fix" this into a single
+        consistent ordering — the two groups need opposite precedence on
+        purpose.
+
         Returns a fresh dict each call.
         """
-        merged = dict(self._env)
-        merged["OPENCODE_CONFIG_DIR"] = str(AGENTS_ROOT)
-        merged["OPENCODE_CONFIG"] = str(ROUTING_PIN_PATH)
+        merged: dict[str, str] = {
+            "OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX": str(OUTPUT_TOKEN_MAX_DEFAULT),
+        }
+        merged.update(self._env)  # operator wins over the tuning-knob default
+        merged["OPENCODE_CONFIG_DIR"] = str(AGENTS_ROOT)  # coord wins, unchanged
+        merged["OPENCODE_CONFIG"] = str(ROUTING_PIN_PATH)  # coord wins, unchanged
         return merged
 
     def parse_log(

{code_coordinator-0.5.113 → code_coordinator-0.5.114}/tests/test_config.py

@@ -1349,6 +1349,93 @@ def test_providers_definition_env_non_string_value_raises(tmp_path: Path) -> Non
         load(p)
 
 
+# ── providers.definitions[*].env OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX (#2321) ─
+
+
+def test_providers_output_token_max_valid_value_accepted(tmp_path: Path) -> None:
+    """A bare positive-integer string is accepted and stored verbatim."""
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        _MIN_CONFIG
+        + "providers:\n"
+        "  definitions:\n"
+        "    oc:\n"
+        "      type: opencode\n"
+        "      env:\n"
+        "        OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX: '131072'\n"
+    )
+    cfg = load(p)
+    env = cfg.providers.definitions["oc"].env
+    assert env["OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"] == "131072"
+
+
+@pytest.mark.parametrize(
+    "bad_value",
+    [
+        "131072 ",  # trailing whitespace — opencode's parser silently discards
+        " 131072",  # leading whitespace
+        "131_072",  # underscore digit-grouping — Number() coercion rejects
+        "0",  # not > 0
+        "-1",  # not > 0, has a sign
+        "1.5",  # decimal point
+        "unlimited",  # non-numeric
+        "",  # empty
+    ],
+)
+def test_providers_output_token_max_bad_value_raises(
+    tmp_path: Path, bad_value: str
+) -> None:
+    """A value opencode's own parser would silently discard is rejected
+    loudly at config-parse time (#2321) instead of silently reverting to
+    the 32000 default with no warning."""
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        _MIN_CONFIG
+        + "providers:\n"
+        "  definitions:\n"
+        "    oc:\n"
+        "      type: opencode\n"
+        "      env:\n"
+        f"        OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX: {bad_value!r}\n"
+    )
+    with pytest.raises(ConfigError, match="OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"):
+        load(p)
+
+
+def test_providers_output_token_max_absent_does_not_raise(tmp_path: Path) -> None:
+    """Not setting the key at all is fine — env() supplies its own default."""
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        _MIN_CONFIG
+        + "providers:\n"
+        "  definitions:\n"
+        "    oc:\n"
+        "      type: opencode\n"
+    )
+    cfg = load(p)
+    assert "OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX" not in cfg.providers.definitions["oc"].env
+
+
+def test_providers_output_token_max_validated_after_var_expansion(
+    tmp_path: Path, monkeypatch
+) -> None:
+    """The value is validated AFTER ${VAR} expansion — an expanded bad
+    value is caught, not just a literal one."""
+    monkeypatch.setenv("COORD_TEST_BAD_TOKEN_MAX", "not-a-number")
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        _MIN_CONFIG
+        + "providers:\n"
+        "  definitions:\n"
+        "    oc:\n"
+        "      type: opencode\n"
+        "      env:\n"
+        "        OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX: '${COORD_TEST_BAD_TOKEN_MAX}'\n"
+    )
+    with pytest.raises(ConfigError, match="OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"):
+        load(p)
+
+
 def test_providers_extra_args_non_string_element_raises(tmp_path: Path) -> None:
     """extra_args elements must be strings."""
     p = tmp_path / "coordinator.yml"

{code_coordinator-0.5.113 → code_coordinator-0.5.114}/tests/test_providers.py

@@ -52,6 +52,7 @@ from coord.providers.claude import ClaudeProvider
 from coord.providers.opencode import (
     AGENTS_ROOT,
     DEFAULT_OPENCODE_BINARY,
+    OUTPUT_TOKEN_MAX_DEFAULT,
     RESULT_MARKER,
     ROUTING_PIN_PATH,
     OpenCodeAgentNotFoundError,
@@ -1538,6 +1539,39 @@ def test_opencode_env_definition_cannot_shadow_config_dir() -> None:
     assert env["OPENCODE_CONFIG"] == str(ROUTING_PIN_PATH)
 
 
+def test_opencode_env_sets_output_token_max_default() -> None:
+    """#2321: env() always seeds OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX to
+    OUTPUT_TOKEN_MAX_DEFAULT, even with no ProviderDef.env configured —
+    without this every opencode worker is silently capped at opencode's
+    32,000-token default, shared with reasoning-model thinking tokens."""
+    env = OpenCodeProvider().env()
+    assert env["OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"] == str(OUTPUT_TOKEN_MAX_DEFAULT)
+
+
+def test_opencode_env_output_token_max_is_positive_integer_string() -> None:
+    """Sanity: the default itself must satisfy opencode's own parser rule
+    (integer, > 0, no extra characters) or every dispatch would silently
+    fall back to 32000 — the exact failure mode #2321 exists to end."""
+    value = OpenCodeProvider().env()["OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"]
+    assert value.isdigit()
+    assert int(value) > 0
+
+
+def test_opencode_env_output_token_max_operator_override_wins() -> None:
+    """#2321: unlike OPENCODE_CONFIG_DIR/OPENCODE_CONFIG, this variable IS
+    operator-overridable — it's a tuning knob (e.g. to cap cost), not a
+    safety mechanism, so a ProviderDef.env entry must win over the
+    built-in default."""
+    provider = OpenCodeProvider(
+        env={"OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX": "50000"}
+    )
+    env = provider.env()
+    assert env["OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"] == "50000"
+    # And the non-overridable variables are still coord-controlled.
+    assert env["OPENCODE_CONFIG_DIR"] == str(AGENTS_ROOT)
+    assert env["OPENCODE_CONFIG"] == str(ROUTING_PIN_PATH)
+
+
 # ── parse_log ─────────────────────────────────────────────────────────────────