"""Baseline LLM-as-agent loop for RealSR v3. This is just ONE agent's orchestration: drive a chat model turn-by-turn. The FIXED, reusable parts live in the harness and are imported here, so any other agent (e.g. an evolving / search agent with its own loop) can reuse exactly the same interface: - `prompts.load_system_prompt` / `task.get_task_prompt` — the instruction text - `agent_protocol.step(response, sandbox, run_experiment)` — parse the model's tool tag, run it ( sandbox / ), and return the submission or the feedback to append. (see harness/AGENT_INTERFACE.md) Swap `call_llm_api` for any client; reuse the rest. """ from __future__ import annotations import sys from pathlib import Path from typing import Any, Callable, Dict, List, Tuple # The fixed interface (prompts + tool-call protocol) lives in the sibling harness. _HARNESS = Path(__file__).resolve().parent.parent / "harness" if str(_HARNESS) not in sys.path: sys.path.insert(0, str(_HARNESS)) from call_llm_api import call_llm_api # noqa: E402 (baseline-specific client) from prompts import load_system_prompt # noqa: E402 (harness) import agent_protocol as proto # noqa: E402 (harness) _NUMERIC_USAGE_KEYS = ("prompt_tokens", "prompt_cached_tokens", "completion_tokens", "reasoning_tokens", "total_tokens") FINAL_ACTION_MSG = ( "Only one action remains. You must submit the final answer now using exactly " "one `...` block. Do not call `` or " "``, and do not include prose outside the XML block." ) FINAL_RETRY_MSG = ( "Your previous response did not submit a final formula. Output exactly one " "complete `...` block now. Do not call " "`` or ``, and do not include prose outside the XML block." ) SIMULATOR_EXPERIMENT_REQUIRED_MSG = ( "This is a simulator-backed task and you have not run any successful " "`` yet. You must probe the simulator at least once before " "submitting. Output exactly one `{...}` block now." ) def _call_llm_and_record(messages: List[Dict[str, str]], model_name: str, trial_info: Dict[str, Any]) -> Tuple[List[Dict[str, str]], dict, str]: response_text, reasoning_response, usage = call_llm_api( messages, model_name=model_name, trial_info=trial_info) if response_text is None: response_text = "" if isinstance(usage, int): usage = {"completion_tokens": usage, "total_tokens": usage, "prompt_tokens": 0, "reasoning_tokens": 0, "prompt_cached_tokens": 0} elif not isinstance(usage, dict): usage = {"completion_tokens": 0, "total_tokens": 0, "prompt_tokens": 0, "reasoning_tokens": 0, "prompt_cached_tokens": 0} else: usage = dict(usage) reasoning_content = str(reasoning_response or "") usage["reasoning_content"] = reasoning_content usage["reasoning_content_chars"] = len(reasoning_content) # Save provider reasoning in usage_per_turn, but never feed it back to the model. messages.append({"role": "assistant", "content": response_text}) return messages, usage, response_text def _accumulate_usage(usage_total: dict, usage_per_turn: List[dict], usage: dict) -> None: for k in _NUMERIC_USAGE_KEYS: usage_total[k] += int(usage.get(k, 0) or 0) reasoning_content = str(usage.get("reasoning_content") or "") usage_total["reasoning_content_chars"] = ( int(usage_total.get("reasoning_content_chars", 0) or 0) + int(usage.get("reasoning_content_chars") or len(reasoning_content)) ) per_turn = {k: int(usage.get(k, 0) or 0) for k in _NUMERIC_USAGE_KEYS} per_turn["finish_reason"] = usage.get("finish_reason") per_turn["reasoning_content"] = reasoning_content per_turn["reasoning_content_chars"] = int( usage.get("reasoning_content_chars") or len(reasoning_content) ) usage_per_turn.append(per_turn) def _append_user_nudge(messages: List[Dict[str, str]], text: str) -> None: if messages and messages[-1]["role"] == "user": messages[-1]["content"] += "\n\n" + text else: messages.append({"role": "user", "content": text}) def _build_result(status: str, submitted: str, rounds: int, usage_total: dict, usage_per_turn: List[dict], messages: list, n_experiments: int, n_python_calls: int) -> Dict[str, Any]: return { "status": status, "submitted_equation": submitted, "rounds": rounds, "total_tokens": usage_total["total_tokens"], "usage_total": usage_total, "usage_per_turn": usage_per_turn, "n_experiments": n_experiments, "n_python_calls": n_python_calls, "chat_history": messages, } def _build_python_sandbox(task: Any) -> Dict[str, Any]: """Build the current sandbox from task state. Simulator tasks mutate `task.train` after each ; rebuilding here makes the full cumulative experiment log visible to later turns. """ X, y, g = task.train_arrays() sandbox = proto.build_sandbox( train_df=task.train.copy(), X_train=X, y_train=y, group_ids=g, input_cols=task.input_cols, target_col=task.target_col, ) experiment_log = getattr(task, "experiment_log", None) if experiment_log is not None: sandbox["experiment_log"] = list(experiment_log) experiment_caps = getattr(task, "experiment_caps", None) if callable(experiment_caps): sandbox["experiment_caps"] = experiment_caps() return sandbox def conduct_exploration(task: Any, model_name: str, max_turns: int = 30, trial_info: Dict[str, Any] | None = None, checkpoint_fn: Callable[[Dict[str, Any]], None] | None = None ) -> Dict[str, Any]: """Run the multi-turn baseline agent and return a trial dict (with `submitted_equation`).""" sys_prompt = load_system_prompt(is_simulator=hasattr(task, "run_experiment"), has_group_id=getattr(task, "has_group_id", False)) messages: List[Dict[str, str]] = [ {"role": "system", "content": sys_prompt}, {"role": "user", "content": task.get_task_prompt(max_turns=max_turns)}, ] # Preloaded sandbox. For simulator tasks this is refreshed after # every successful so Python sees the cumulative lab notebook. sandbox = _build_python_sandbox(task) run_experiment = getattr(task, "run_experiment", None) requires_experiment = run_experiment is not None usage_total = {k: 0 for k in _NUMERIC_USAGE_KEYS} usage_per_turn: List[dict] = [] n_experiments = n_python_calls = 0 def _checkpoint_result(result: Dict[str, Any]) -> None: if checkpoint_fn is None: return experiment_log = getattr(task, "experiment_log", None) if experiment_log is not None: result["experiment_log"] = list(experiment_log) experiment_caps = getattr(task, "experiment_caps", None) if callable(experiment_caps): result["experiment_caps"] = experiment_caps() try: result["train_rows_current"] = len(task.train) except Exception: pass checkpoint_fn(result) def _checkpoint(status: str, submitted: str, rounds: int) -> Dict[str, Any]: result = _build_result(status, submitted, rounds, usage_total, usage_per_turn, messages, n_experiments, n_python_calls) _checkpoint_result(result) return result for turn in range(max_turns): is_final_action = turn == max_turns - 1 if is_final_action and requires_experiment and n_experiments == 0: _append_user_nudge(messages, SIMULATOR_EXPERIMENT_REQUIRED_MSG) elif is_final_action: _append_user_nudge(messages, FINAL_ACTION_MSG) messages, usage, response_text = _call_llm_and_record(messages, model_name, trial_info or {}) _accumulate_usage(usage_total, usage_per_turn, usage) if "model" in usage and "model" not in usage_total: usage_total["model"] = usage["model"] usage_total["api_source"] = usage.get("api_source") _checkpoint("running_llm_response", "", turn + 1) if is_final_action: if requires_experiment and n_experiments == 0: res = proto.step(response_text, sandbox, run_experiment=run_experiment) if res["action"] == "experiment" and res.get("ok"): n_experiments += 1 sandbox = _build_python_sandbox(task) messages.append({ "role": "user", "content": res.get("feedback", SIMULATOR_EXPERIMENT_REQUIRED_MSG), }) _checkpoint("running", "", turn + 1) continue ok, submitted = proto.parse_final_formula(response_text) if ok: return _checkpoint("completed", submitted, turn + 1) _append_user_nudge(messages, FINAL_RETRY_MSG) messages, usage, response_text = _call_llm_and_record( messages, model_name, trial_info or {}) _accumulate_usage(usage_total, usage_per_turn, usage) ok, submitted = proto.parse_final_formula(response_text) return _checkpoint("completed_forced_final" if ok else "max_turns_reached", submitted, turn + 2) res = proto.step(response_text, sandbox, run_experiment=run_experiment) if res["action"] == "submit": if requires_experiment and n_experiments == 0: messages.append({"role": "user", "content": SIMULATOR_EXPERIMENT_REQUIRED_MSG}) _checkpoint("running", "", turn + 1) continue return _checkpoint("completed", res["submission"], turn + 1) if res["action"] == "python": n_python_calls += 1 elif res["action"] == "experiment" and res.get("ok"): n_experiments += 1 sandbox = _build_python_sandbox(task) messages.append({"role": "user", "content": res["feedback"]}) _checkpoint("running", "", turn + 1) _append_user_nudge(messages, FINAL_RETRY_MSG) messages, usage, response_text = _call_llm_and_record(messages, model_name, trial_info or {}) _accumulate_usage(usage_total, usage_per_turn, usage) ok, submitted = proto.parse_final_formula(response_text) return _checkpoint("completed_forced_final" if ok else "max_turns_reached", submitted, 1 if max_turns <= 0 else max_turns + 1)