Merge pull request #1 from popuku-dog/feat/configurable-max-output-chars

feat(config): expose dspy.RLM max_output_chars as a budget knob

Author: qazbnm456

CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `rlm-kit`. Format loosely follows
 [Keep a Changelog](https://keepachangelog.com/). Versions track
 `rlm_kit/__init__.__version__` and `pyproject.toml` (kept in sync).
 
+## [Unreleased]
+
+### Added
+
+- **`max_output_chars` is now configurable** (`RLMConfig.max_output_chars`, env
+  `RLM_MAX_OUTPUT_CHARS`, default `10000` — dspy's own default, so behaviour is
+  unchanged). dspy.RLM head+tail-truncates each REPL output to this many CHARACTERS
+  before it enters the planner prompt — the planner never sees the omitted middle.
+  Previously the knob was pinned at dspy's default; now it rides the same best-effort
+  passthrough as `max_iterations` / `max_llm_calls`. (Distinct from `max_tokens`,
+  which caps the model's own generation.)
+
 ## [0.2.0] — 2026-06-21
 
 Harness-engineering layer, plus the first round of hardening surfaced by

rlm_kit/config.py

@@ -97,6 +97,12 @@ class RLMConfig:
     max_iterations: int = 10
     max_llm_calls: int = 30
 
+    # Head+tail cap (in CHARACTERS — unrelated to ``max_tokens``) that dspy.RLM applies to each
+    # REPL output before it enters the planner prompt; the planner never sees the omitted middle.
+    # Default matches dspy's own. Raise it when the planner must read large printed results whole,
+    # but prefer slicing/summarising in REPL code — retained chars cost prompt tokens every turn.
+    max_output_chars: int = 10_000
+
     # Retry policy in _retry.py: how many times to run the WHOLE task (a full RLM trajectory) until
     # its output coerces into output_model. Default 1 = no retry, because a retry re-runs the entire
     # RLM from scratch — silently MULTIPLYING the max_iterations budget (3 retries ⇒ up to 3×
@@ -158,6 +164,8 @@ def from_env(cls) -> "RLMConfig":
         - ``RLM_ALLOW_INSECURE_SANDBOX`` (default ``false``).
         - ``RLM_MAX_ITERATIONS`` (default ``10``).
         - ``RLM_MAX_LLM_CALLS`` (default ``30``).
+        - ``RLM_MAX_OUTPUT_CHARS`` (default ``10000``) — head+tail character cap on REPL
+          output fed back to the planner (distinct from ``RLM_MAX_TOKENS``).
         - ``RLM_MAX_RETRIES`` (default ``3``).
         - ``RLM_OBSERVE`` (default ``false``).
         """
@@ -183,6 +191,7 @@ def from_env(cls) -> "RLMConfig":
             allow_insecure_sandbox=_env_bool("RLM_ALLOW_INSECURE_SANDBOX", False),
             max_iterations=_env_int("RLM_MAX_ITERATIONS", 10),
             max_llm_calls=_env_int("RLM_MAX_LLM_CALLS", 30),
+            max_output_chars=_env_int("RLM_MAX_OUTPUT_CHARS", 10_000),
             max_retries=_env_int("RLM_MAX_RETRIES", 1),
             observe=_env_bool("RLM_OBSERVE", False),
         )

rlm_kit/task.py

@@ -157,9 +157,11 @@ def _build_rlm(self) -> "dspy.RLM":
 
         # Budget controls are passed best-effort: dspy's exact kwarg names have
         # shifted across releases, so tolerate their absence rather than crash.
+        # (All-or-nothing: one unknown kwarg drops the whole dict to dspy defaults.)
         budget = {
             "max_iterations": self._config.max_iterations,
             "max_llm_calls": self._config.max_llm_calls,
+            "max_output_chars": self._config.max_output_chars,
         }
         try:
             return dspy.RLM(signature, **kwargs, **budget)

tests/test_config.py

@@ -17,6 +17,7 @@
     "RLM_ALLOW_INSECURE_SANDBOX",
     "RLM_MAX_ITERATIONS",
     "RLM_MAX_LLM_CALLS",
+    "RLM_MAX_OUTPUT_CHARS",
     "RLM_MAX_RETRIES",
     "RLM_OBSERVE",
 ]
@@ -40,6 +41,7 @@ def test_defaults():
     assert cfg.max_retries == 1   # default: no whole-RLM retry (it would multiply the iteration budget)
     assert cfg.max_iterations == 10
     assert cfg.max_llm_calls == 30
+    assert cfg.max_output_chars == 10_000  # matches dspy.RLM's own default
 
 
 def test_sub_model_defaults_to_main(monkeypatch):
@@ -106,6 +108,12 @@ def test_max_tokens_from_env(monkeypatch):
     assert RLMConfig.from_env().max_tokens == 4096       # explicit override
 
 
+def test_max_output_chars_from_env(monkeypatch):
+    assert RLMConfig.from_env().max_output_chars == 10_000   # unset → dspy's default
+    monkeypatch.setenv("RLM_MAX_OUTPUT_CHARS", "50000")
+    assert RLMConfig.from_env().max_output_chars == 50_000   # explicit override
+
+
 def test_unknown_adapter_rejected():
     with pytest.raises(ValueError):
         RLMConfig(main_model="m", sub_model="m", adapter="bogus")

tests/test_integration_dspy.py

@@ -51,6 +51,7 @@ class T(RLMTask):
     # Budget kwargs were accepted by the real constructor (no TypeError fallback).
     assert rlm.max_iterations == 10
     assert rlm.max_llm_calls == 30
+    assert rlm.max_output_chars == 10_000
 
 
 def test_custom_output_type_resolves_without_frame_help():