Termination Patterns¶

from rlm_code.rlm.termination import FINAL

# Direct string answer
FINAL("The answer is 42")

# Dictionary answer
FINAL({"sentiment": "positive", "confidence": 0.95})

# List answer
FINAL(["item1", "item2", "item3"])

from rlm_code.rlm.termination import FINAL_VAR

# In REPL code generated by the LLM:
result = analyze_document(context)
summary = result["summary"]
FINAL_VAR("summary")

from rlm_code.rlm.termination import detect_final_in_text

# Detect in LLM prose
result = detect_final_in_text('Based on my analysis, FINAL("42")')
assert result.detected is True
assert result.final_type == "direct"
assert result.content == "42"

# Detect variable reference
result = detect_final_in_text('I have stored the answer. FINAL_VAR("result")')
assert result.detected is True
assert result.final_type == "variable"
assert result.content == "result"

# No termination signal
result = detect_final_in_text("Let me continue analyzing...")
assert result.detected is False

from rlm_code.rlm.termination import detect_final_in_code

# Detect in code
result = detect_final_in_code('answer = 42\nFINAL(answer)')
assert result.detected is True
assert result.final_type == "direct"

# Detect variable reference in code
result = detect_final_in_code('FINAL_VAR("my_result")')
assert result.detected is True
assert result.final_type == "variable"
assert result.content == "my_result"

from rlm_code.rlm.termination import resolve_final_var

namespace = {"result": 42, "data": [1, 2, 3]}

value = resolve_final_var("result", namespace)
assert value == 42

# Missing variable raises KeyError with helpful message
try:
    resolve_final_var("missing_var", namespace)
except KeyError as e:
    print(e)
    # "FINAL_VAR referenced variable 'missing_var' not found in REPL namespace.
    #  Available variables: ['result', 'data']"

from rlm_code.rlm.termination import extract_code_blocks

response = """
Let me analyze the data.

```python
result = sum(data)
print(result)
```

And then finalize:

```repl
FINAL(result)
```
"""

blocks = extract_code_blocks(response)
# Returns: ['result = sum(data)\nprint(result)', 'FINAL(result)']

from rlm_code.rlm.termination import format_final_answer

# String passthrough
assert format_final_answer("hello") == "hello"

# Dict with "answer" key -- extracts the value
assert format_final_answer({"answer": 42}) == "42"

# Dict without "answer" key -- JSON formatted
result = format_final_answer({"key": "value", "count": 10})
# Returns: '{\n  "key": "value",\n  "count": 10\n}'

# List -- joined by newlines
assert format_final_answer(["line1", "line2"]) == "line1\nline2"

# Other types -- str() conversion
assert format_final_answer(42) == "42"

from rlm_code.rlm.termination import FinalOutput, FINAL

# Typically not instantiated directly -- use FINAL() or FINAL_VAR()
try:
    FINAL("The answer is 42")
except FinalOutput as e:
    print(e.output)
    # {"answer": "The answer is 42", "type": "direct"}

from rlm_code.rlm.termination import FinalDetection

# Constructed by detect_final_in_text() and detect_final_in_code()
detection = FinalDetection(
    detected=True,
    final_type="direct",
    content="42",
    raw_match='FINAL("42")',
)

from rlm_code.rlm.termination import (
    FINAL, FINAL_VAR, FinalOutput,
    detect_final_in_code, detect_final_in_text,
    extract_code_blocks, format_final_answer,
    resolve_final_var,
)

# Inside the REPL execution loop:
try:
    exec(code, namespace)
except FinalOutput as e:
    if e.output["type"] == "variable":
        # Resolve the variable from namespace
        answer = resolve_final_var(e.output["var"], namespace)
    else:
        # Direct answer
        answer = e.output["answer"]

    formatted = format_final_answer(answer)
    # Return formatted answer as the run result

# LLM-generated REPL code:
data = [1, 2, 3, 4, 5]
total = sum(data)
average = total / len(data)
FINAL(f"The average is {average}")

# LLM-generated REPL code for large output:
import json

results = {}
for key in context.keys():
    results[key] = analyze(context[key])

# Store in variable to avoid token-window bloat
final_report = json.dumps(results, indent=2)
FINAL_VAR("final_report")

# LLM-generated REPL code with recursive LLM calls:
chunks = [context[i:i+1000] for i in range(0, len(context), 1000)]
summaries = []

for chunk in chunks:
    summary = llm_query(f"Summarize: {chunk}")
    summaries.append(summary)

combined = "\n".join(summaries)
final_answer = llm_query(f"Synthesize these summaries: {combined}")
FINAL(final_answer)

# LLM-generated REPL code with conditional FINAL:
word_count = len(context.split())

if word_count < 100:
    FINAL("Document too short for meaningful analysis")

# If we get here, document is long enough
analysis = perform_detailed_analysis(context)
FINAL_VAR("analysis")