Drop in a screenshot and convert it to clean code (HTML/Tailwind/React/Vue)
Python
add caching-related tools and remove prompt_cache_key
Abi Raja1a6f88bce3cb
diff --git a/backend/agent/providers/openai.py b/backend/agent/providers/openai.pyindex 571ef411..980db4d0 100644--- a/backend/agent/providers/openai.py+++ b/backend/agent/providers/openai.py@@ -1,6 +1,5 @@# pyright: reportUnknownVariableType=falseimport copy-import hashlibimport jsonimport uuidfrom dataclasses import dataclass, field@@ -123,30 +122,6 @@ def serialize_openai_tools(})return serialized---def _build_prompt_cache_key(- model: Llm,- input_items: List[Dict[str, Any]],- tools: List[Dict[str, Any]],-) -> str:- cache_identity = {- "version": 1,- "model": get_openai_api_name(model),- "reasoning_effort": get_openai_reasoning_effort(model),- "input": input_items,- "tools": tools,- }- payload = json.dumps(- cache_identity,- sort_keys=True,- separators=(",", ":"),- ensure_ascii=False,- )- digest = hashlib.sha256(payload.encode("utf-8")).hexdigest()[:24]- return f"s2c-openai-session-v1-{digest}"--@dataclassclass OpenAIResponsesParseState:assistant_text: str = ""@@ -448,11 +423,6 @@ class OpenAIProviderSession(ProviderSession):self._input_items: List[Dict[str, Any]] = [_convert_message_to_responses_input(message) for message in prompt_messages]- self._prompt_cache_key = _build_prompt_cache_key(- model=model,- input_items=self._input_items,- tools=self._tools,- )async def stream_turn(self, on_event: EventSink) -> ProviderTurn:model_name = get_openai_api_name(self._model)@@ -463,7 +433,6 @@ class OpenAIProviderSession(ProviderSession):"tool_choice": "auto","stream": True,"max_output_tokens": 50000,- "prompt_cache_key": self._prompt_cache_key,}if model_name == "gpt-5.4-2026-03-05":params["prompt_cache_retention"] = "24h"diff --git a/backend/fs_logging/openai_input_compare.py b/backend/fs_logging/openai_input_compare.pynew file mode 100644index 00000000..133c5bac--- /dev/null+++ b/backend/fs_logging/openai_input_compare.py@@ -0,0 +1,240 @@+import json+from dataclasses import dataclass+from typing import Any, TypeAlias, cast++from fs_logging.openai_input_formatting import (+ summarize_responses_input_item,+ to_serializable,+)++JSONScalar: TypeAlias = None | bool | int | float | str+JSONValue: TypeAlias = JSONScalar | list["JSONValue"] | dict[str, "JSONValue"]+++@dataclass(frozen=True)+class OpenAIInputDifference:+ item_index: int+ path: str+ left_summary: str+ right_summary: str+ left_value: Any+ right_value: Any+++@dataclass(frozen=True)+class OpenAIInputComparison:+ common_prefix_items: int+ left_item_count: int+ right_item_count: int+ difference: OpenAIInputDifference | None+++def _extract_input_items(payload: Any) -> list[JSONValue]:+ serialized = cast(JSONValue, to_serializable(payload))+ if isinstance(serialized, list):+ return serialized+ if isinstance(serialized, dict):+ serialized_dict = cast(dict[str, JSONValue], serialized)+ input_items = serialized_dict.get("input")+ if isinstance(input_items, list):+ return cast(list[JSONValue], input_items)+ raise ValueError("Expected a raw input array or a request payload with an 'input' list")+++def _as_json_dict(value: JSONValue) -> dict[str, JSONValue]:+ return cast(dict[str, JSONValue], value)+++def _as_json_list(value: JSONValue) -> list[JSONValue]:+ return cast(list[JSONValue], value)+++def _append_dict_path(path: str, key: str) -> str:+ if not path:+ return key+ return f"{path}.{key}"+++def _append_list_path(path: str, index: int) -> str:+ return f"{path}[{index}]"+++def _find_first_value_difference(+ left: JSONValue,+ right: JSONValue,+ path: str = "",+) -> tuple[str, JSONValue, JSONValue] | None:+ if type(left) is not type(right):+ return path, left, right++ if isinstance(left, dict):+ left_dict = _as_json_dict(left)+ right_dict = _as_json_dict(right)+ left_keys = list(left_dict.keys())+ right_keys = list(right_dict.keys())+ for index in range(min(len(left_keys), len(right_keys))):+ left_key = left_keys[index]+ right_key = right_keys[index]+ if left_key != right_key:+ key_path = _append_dict_path(path, left_key)+ return key_path, left, right++ if len(left_keys) != len(right_keys):+ extra_key = (+ left_keys[len(right_keys)]+ if len(left_keys) > len(right_keys)+ else right_keys[len(left_keys)]+ )+ key_path = _append_dict_path(path, extra_key)+ left_value = left_dict.get(extra_key)+ right_value = right_dict.get(extra_key)+ return key_path, cast(JSONValue, left_value), cast(JSONValue, right_value)++ for key in left_keys:+ nested = _find_first_value_difference(+ left_dict[key],+ right_dict[key],+ _append_dict_path(path, key),+ )+ if nested is not None:+ return nested+ return None++ if isinstance(left, list):+ left_list = _as_json_list(left)+ right_list = _as_json_list(right)+ for index in range(min(len(left_list), len(right_list))):+ nested = _find_first_value_difference(+ left_list[index],+ right_list[index],+ _append_list_path(path, index),+ )+ if nested is not None:+ return nested++ if len(left_list) != len(right_list):+ index = min(len(left_list), len(right_list))+ item_path = _append_list_path(path, index)+ left_value = left_list[index] if index < len(left_list) else None+ right_value = right_list[index] if index < len(right_list) else None+ return item_path, left_value, right_value+ return None++ if left != right:+ return path, left, right++ return None+++def compare_openai_inputs(+ left_payload: Any,+ right_payload: Any,+) -> OpenAIInputComparison:+ left_items = _extract_input_items(left_payload)+ right_items = _extract_input_items(right_payload)++ common_prefix_items = 0+ for index in range(min(len(left_items), len(right_items))):+ left_item = left_items[index]+ right_item = right_items[index]+ if left_item == right_item:+ common_prefix_items += 1+ continue++ nested_difference = _find_first_value_difference(left_item, right_item)+ nested_path = "" if nested_difference is None else nested_difference[0]+ path = f"input[{index}]"+ if nested_path:+ if nested_path.startswith("["):+ path = f"{path}{nested_path}"+ else:+ path = f"{path}.{nested_path}"++ left_value = left_item if nested_difference is None else nested_difference[1]+ right_value = right_item if nested_difference is None else nested_difference[2]++ return OpenAIInputComparison(+ common_prefix_items=common_prefix_items,+ left_item_count=len(left_items),+ right_item_count=len(right_items),+ difference=OpenAIInputDifference(+ item_index=index,+ path=path,+ left_summary=summarize_responses_input_item(index, left_item),+ right_summary=summarize_responses_input_item(index, right_item),+ left_value=left_value,+ right_value=right_value,+ ),+ )++ if len(left_items) != len(right_items):+ index = min(len(left_items), len(right_items))+ left_item = left_items[index] if index < len(left_items) else None+ right_item = right_items[index] if index < len(right_items) else None+ return OpenAIInputComparison(+ common_prefix_items=common_prefix_items,+ left_item_count=len(left_items),+ right_item_count=len(right_items),+ difference=OpenAIInputDifference(+ item_index=index,+ path=f"input[{index}]",+ left_summary=(+ summarize_responses_input_item(index, left_item)+ if left_item is not None+ else f"{index:02d} <missing>"+ ),+ right_summary=(+ summarize_responses_input_item(index, right_item)+ if right_item is not None+ else f"{index:02d} <missing>"+ ),+ left_value=left_item,+ right_value=right_item,+ ),+ )++ return OpenAIInputComparison(+ common_prefix_items=common_prefix_items,+ left_item_count=len(left_items),+ right_item_count=len(right_items),+ difference=None,+ )+++def format_openai_input_comparison(comparison: OpenAIInputComparison) -> str:+ lines = [+ "OpenAI input comparison",+ f"common_prefix_items={comparison.common_prefix_items}",+ f"left_item_count={comparison.left_item_count}",+ f"right_item_count={comparison.right_item_count}",+ ]++ difference = comparison.difference+ if difference is None:+ lines.append("difference=none")+ return "\n".join(lines)++ lines.extend(+ [+ f"first_different_item_index={difference.item_index}",+ f"first_different_path={difference.path}",+ f"left_summary={difference.left_summary}",+ f"right_summary={difference.right_summary}",+ "left_value=" + json.dumps(difference.left_value, indent=2, ensure_ascii=False),+ "right_value=" + json.dumps(+ difference.right_value,+ indent=2,+ ensure_ascii=False,+ ),+ ]+ )+ return "\n".join(lines)+++def compare_openai_input_json_strings(+ left_json: str,+ right_json: str,+) -> OpenAIInputComparison:+ left_payload = json.loads(left_json)+ right_payload = json.loads(right_json)+ return compare_openai_inputs(left_payload, right_payload)diff --git a/backend/fs_logging/openai_input_formatting.py b/backend/fs_logging/openai_input_formatting.pynew file mode 100644index 00000000..62aadb33--- /dev/null+++ b/backend/fs_logging/openai_input_formatting.py@@ -0,0 +1,226 @@+# pyright: reportUnknownVariableType=false+import json+from typing import Any++from agent.state import ensure_str+++def truncate_for_log(value: Any, max_len: int = 120) -> str:+ text = ensure_str(value).replace("\n", "\\n")+ if len(text) <= max_len:+ return text+ return f"{text[:max_len]}..."+++def as_dict(value: Any) -> dict[str, Any] | None:+ if isinstance(value, dict):+ return value++ model_dump = getattr(value, "model_dump", None)+ if callable(model_dump):+ dumped = model_dump()+ if isinstance(dumped, dict):+ return dumped++ to_dict = getattr(value, "to_dict", None)+ if callable(to_dict):+ dumped = to_dict()+ if isinstance(dumped, dict):+ return dumped++ dict_method = getattr(value, "dict", None)+ if callable(dict_method):+ dumped = dict_method()+ if isinstance(dumped, dict):+ return dumped++ raw_dict = getattr(value, "__dict__", None)+ if isinstance(raw_dict, dict):+ normalized = {k: v for k, v in raw_dict.items() if not k.startswith("_")}+ if normalized:+ return normalized++ return None+++def to_serializable(value: Any) -> Any:+ if value is None or isinstance(value, (bool, int, float, str)):+ return value++ if isinstance(value, dict):+ return {ensure_str(k): to_serializable(v) for k, v in value.items()}++ if isinstance(value, (list, tuple)):+ return [to_serializable(v) for v in value]++ value_as_dict = as_dict(value)+ if value_as_dict is not None:+ return to_serializable(value_as_dict)++ return ensure_str(value)+++def summarize_content_part(part: Any) -> str:+ part_dict = as_dict(part)+ if part_dict is None:+ return f"{type(part).__name__}"++ part_type = part_dict.get("type", "unknown")++ if part_type in ("input_text", "text", "output_text", "summary_text"):+ text = ensure_str(part_dict.get("text", ""))+ return (+ f"{part_type}(chars={len(text)} "+ f"preview='{truncate_for_log(text, max_len=80)}')"+ )++ if part_type in ("input_image", "image_url"):+ image_url_value: Any = part_dict.get("image_url", "")+ detail: str | None = None+ if isinstance(image_url_value, dict):+ detail = ensure_str(image_url_value.get("detail", ""))+ image_url_value = image_url_value.get("url", "")+ else:+ detail = ensure_str(part_dict.get("detail", ""))++ url_text = ensure_str(image_url_value)+ detail_text = detail or "-"+ return (+ f"{part_type}(detail={detail_text} "+ f"url='{truncate_for_log(url_text, max_len=80)}')"+ )++ return f"{part_type}(keys={sorted(part_dict.keys())})"+++def summarize_function_call_output_payload(output_text: str) -> str:+ try:+ parsed = json.loads(output_text)+ except json.JSONDecodeError:+ return (+ f"output_chars={len(output_text)} "+ f"preview='{truncate_for_log(output_text)}'"+ )++ if not isinstance(parsed, dict):+ return (+ f"output_type={type(parsed).__name__} "+ f"preview='{truncate_for_log(parsed)}'"+ )++ if "error" in parsed:+ error_text = ensure_str(parsed.get("error"))+ return f"error='{truncate_for_log(error_text)}'"++ summary_parts: list[str] = []++ content_text = ensure_str(parsed.get("content"))+ if content_text:+ summary_parts.append(f"content='{truncate_for_log(content_text, max_len=80)}'")++ details = parsed.get("details")+ if isinstance(details, dict):+ path = ensure_str(details.get("path"))++ diff_text = details.get("diff")+ if (not path) and isinstance(diff_text, str) and diff_text:+ for line in diff_text.splitlines():+ if line.startswith("--- "):+ path = line.removeprefix("--- ").strip()+ break++ if path:+ summary_parts.append(f"path={path}")++ edits = details.get("edits")+ if isinstance(edits, list):+ summary_parts.append(f"edits={len(edits)}")++ content_length = details.get("contentLength")+ if isinstance(content_length, int):+ summary_parts.append(f"content_length={content_length}")++ first_changed_line = details.get("firstChangedLine")+ if isinstance(first_changed_line, int):+ summary_parts.append(f"first_changed_line={first_changed_line}")++ if isinstance(diff_text, str) and diff_text:+ diff_lines = diff_text.count("\n")+ summary_parts.append(f"diff_chars={len(diff_text)}")+ summary_parts.append(f"diff_lines={diff_lines}")++ if not summary_parts:+ summary_parts.append(f"keys={sorted(parsed.keys())}")++ return " ".join(summary_parts)+++def summarize_responses_input_item(index: int, item: Any) -> str:+ item_dict = as_dict(item)+ if item_dict is None:+ return f"{index:02d} item_type={type(item).__name__}"++ if "role" in item_dict:+ role = ensure_str(item_dict.get("role", "unknown"))+ content = item_dict.get("content", "")+ if isinstance(content, str):+ return (+ f"{index:02d} role={role} content=str chars={len(content)} "+ f"preview='{truncate_for_log(content)}'"+ )+ if isinstance(content, list):+ part_summaries = [summarize_content_part(part) for part in content]+ return (+ f"{index:02d} role={role} content_parts={len(content)} "+ f"[{'; '.join(part_summaries)}]"+ )+ return f"{index:02d} role={role} content_type={type(content).__name__}"++ item_type = ensure_str(item_dict.get("type", "unknown"))++ if item_type in ("function_call", "custom_tool_call"):+ raw_args = (+ item_dict.get("input")+ if item_type == "custom_tool_call"+ else item_dict.get("arguments")+ )+ args_text = ensure_str(raw_args or "")+ call_id = item_dict.get("call_id") or item_dict.get("id")+ return (+ f"{index:02d} type={item_type} name={item_dict.get('name')} "+ f"call_id={call_id} args_chars={len(args_text)} "+ f"preview='{truncate_for_log(args_text)}'"+ )++ if item_type == "function_call_output":+ output_text = ensure_str(item_dict.get("output", ""))+ return (+ f"{index:02d} type=function_call_output call_id={item_dict.get('call_id')} "+ f"{summarize_function_call_output_payload(output_text)}"+ )++ if item_type == "message":+ role = ensure_str(item_dict.get("role", "unknown"))+ content = item_dict.get("content", [])+ if isinstance(content, list):+ part_summaries = [summarize_content_part(part) for part in content]+ return (+ f"{index:02d} type=message role={role} parts={len(content)} "+ f"[{'; '.join(part_summaries)}]"+ )+ return (+ f"{index:02d} type=message role={role} "+ f"content_type={type(content).__name__}"+ )++ if item_type == "reasoning":+ summary = item_dict.get("summary")+ if isinstance(summary, list):+ summary_parts = [summarize_content_part(part) for part in summary]+ return (+ f"{index:02d} type=reasoning summary_parts={len(summary)} "+ f"[{'; '.join(summary_parts)}]"+ )+ return f"{index:02d} type=reasoning summary_type={type(summary).__name__}"++ return f"{index:02d} type={item_type} keys={sorted(item_dict.keys())}"diff --git a/backend/fs_logging/openai_turn_inputs.py b/backend/fs_logging/openai_turn_inputs.pyindex 8902f30c..fe497af3 100644--- a/backend/fs_logging/openai_turn_inputs.py+++ b/backend/fs_logging/openai_turn_inputs.py@@ -10,159 +10,13 @@ from typing import Any, Sequencefrom agent.providers.pricing import MODEL_PRICINGfrom agent.providers.token_usage import TokenUsagefrom agent.state import ensure_str+from fs_logging.openai_input_formatting import (+ summarize_responses_input_item,+ to_serializable,+)from llm import Llm, get_openai_api_name-def _truncate_for_log(value: Any, max_len: int = 120) -> str:- text = ensure_str(value).replace("\n", "\\n")- if len(text) <= max_len:- return text- return f"{text[:max_len]}..."---def _as_dict(value: Any) -> dict[str, Any] | None:- if isinstance(value, dict):- return value-- model_dump = getattr(value, "model_dump", None)- if callable(model_dump):- dumped = model_dump()- if isinstance(dumped, dict):- return dumped-- to_dict = getattr(value, "to_dict", None)- if callable(to_dict):- dumped = to_dict()- if isinstance(dumped, dict):- return dumped-- dict_method = getattr(value, "dict", None)- if callable(dict_method):- dumped = dict_method()- if isinstance(dumped, dict):- return dumped-- raw_dict = getattr(value, "__dict__", None)- if isinstance(raw_dict, dict):- normalized = {k: v for k, v in raw_dict.items() if not k.startswith("_")}- if normalized:- return normalized-- return None---def _to_serializable(value: Any) -> Any:- if value is None or isinstance(value, (bool, int, float, str)):- return value-- if isinstance(value, dict):- return {ensure_str(k): _to_serializable(v) for k, v in value.items()}-- if isinstance(value, (list, tuple)):- return [_to_serializable(v) for v in value]-- as_dict = _as_dict(value)- if as_dict is not None:- return _to_serializable(as_dict)-- return ensure_str(value)---def _summarize_content_part(part: Any) -> str:- part_dict = _as_dict(part)- if part_dict is None:- return f"{type(part).__name__}"-- part_type = part_dict.get("type", "unknown")-- if part_type in ("input_text", "text", "output_text", "summary_text"):- text = ensure_str(part_dict.get("text", ""))- return (- f"{part_type}(chars={len(text)} "- f"preview='{_truncate_for_log(text, max_len=80)}')"- )-- if part_type in ("input_image", "image_url"):- image_url_value: Any = part_dict.get("image_url", "")- detail: str | None = None- if isinstance(image_url_value, dict):- detail = ensure_str(image_url_value.get("detail", ""))- image_url_value = image_url_value.get("url", "")- else:- detail = ensure_str(part_dict.get("detail", ""))-- url_text = ensure_str(image_url_value)- detail_text = detail or "-"- return (- f"{part_type}(detail={detail_text} "- f"url='{_truncate_for_log(url_text, max_len=80)}')"- )-- return f"{part_type}(keys={sorted(part_dict.keys())})"---def _summarize_function_call_output_payload(output_text: str) -> str:- try:- parsed = json.loads(output_text)- except json.JSONDecodeError:- return (- f"output_chars={len(output_text)} "- f"preview='{_truncate_for_log(output_text)}'"- )-- if not isinstance(parsed, dict):- return (- f"output_type={type(parsed).__name__} "- f"preview='{_truncate_for_log(parsed)}'"- )-- if "error" in parsed:- error_text = ensure_str(parsed.get("error"))- return f"error='{_truncate_for_log(error_text)}'"-- summary_parts: list[str] = []-- content_text = ensure_str(parsed.get("content"))- if content_text:- summary_parts.append(f"content='{_truncate_for_log(content_text, max_len=80)}'")-- details = parsed.get("details")- if isinstance(details, dict):- path = ensure_str(details.get("path"))-- diff_text = details.get("diff")- if (not path) and isinstance(diff_text, str) and diff_text:- for line in diff_text.splitlines():- if line.startswith("--- "):- path = line.removeprefix("--- ").strip()- break-- if path:- summary_parts.append(f"path={path}")-- edits = details.get("edits")- if isinstance(edits, list):- summary_parts.append(f"edits={len(edits)}")-- content_length = details.get("contentLength")- if isinstance(content_length, int):- summary_parts.append(f"content_length={content_length}")-- first_changed_line = details.get("firstChangedLine")- if isinstance(first_changed_line, int):- summary_parts.append(f"first_changed_line={first_changed_line}")-- if isinstance(diff_text, str) and diff_text:- diff_lines = diff_text.count("\n")- summary_parts.append(f"diff_chars={len(diff_text)}")- summary_parts.append(f"diff_lines={diff_lines}")-- if not summary_parts:- summary_parts.append(f"keys={sorted(parsed.keys())}")-- return " ".join(summary_parts)--def _render_json_scalar(value: Any) -> str:if value is None:return "<span class='json-null'>null</span>"@@ -223,76 +77,15 @@ def _render_json_node(value: Any, label: str | None = None) -> str:)-def _summarize_responses_input_item(index: int, item: Any) -> str:- item_dict = _as_dict(item)- if item_dict is None:- return f"{index:02d} item_type={type(item).__name__}"-- if "role" in item_dict:- role = ensure_str(item_dict.get("role", "unknown"))- content = item_dict.get("content", "")- if isinstance(content, str):- return (- f"{index:02d} role={role} content=str chars={len(content)} "- f"preview='{_truncate_for_log(content)}'"- )- if isinstance(content, list):- part_summaries = [_summarize_content_part(part) for part in content]- return (- f"{index:02d} role={role} content_parts={len(content)} "- f"[{'; '.join(part_summaries)}]"- )- return f"{index:02d} role={role} content_type={type(content).__name__}"-- item_type = ensure_str(item_dict.get("type", "unknown"))-- if item_type in ("function_call", "custom_tool_call"):- raw_args = (- item_dict.get("input")- if item_type == "custom_tool_call"- else item_dict.get("arguments")- )- args_text = ensure_str(raw_args or "")- call_id = item_dict.get("call_id") or item_dict.get("id")- return (- f"{index:02d} type={item_type} name={item_dict.get('name')} "- f"call_id={call_id} args_chars={len(args_text)} "- f"preview='{_truncate_for_log(args_text)}'"- )-- if item_type == "function_call_output":- output_text = ensure_str(item_dict.get("output", ""))- return (- f"{index:02d} type=function_call_output call_id={item_dict.get('call_id')} "- f"{_summarize_function_call_output_payload(output_text)}"- )-- if item_type == "message":- role = ensure_str(item_dict.get("role", "unknown"))- content = item_dict.get("content", [])- if isinstance(content, list):- part_summaries = [_summarize_content_part(part) for part in content]- return (- f"{index:02d} type=message role={role} parts={len(content)} "- f"[{'; '.join(part_summaries)}]"- )- return (- f"{index:02d} type=message role={role} "- f"content_type={type(content).__name__}"- )-- if item_type == "reasoning":- summary = item_dict.get("summary")- if isinstance(summary, list):- summary_parts = [_summarize_content_part(part) for part in summary]- return (- f"{index:02d} type=reasoning summary_parts={len(summary)} "- f"[{'; '.join(summary_parts)}]"- )- return f"{index:02d} type=reasoning summary_type={type(summary).__name__}"-- return f"{index:02d} type={item_type} keys={sorted(item_dict.keys())}"-+def _render_copy_controls(copy_target_id: str, button_label: str) -> str:+ return (+ "<div class='copy-controls'>"+ f"<button type='button' class='copy-button' data-copy-target='{escape(copy_target_id)}'>"+ f"{escape(button_label)}"+ "</button>"+ "<span class='copy-status' aria-live='polite'></span>"+ "</div>"+ )def _log_openai_turn_input(model: Llm, turn_index: int, input_items: Sequence[Any]) -> None:model_name = get_openai_api_name(model)@@ -303,7 +96,7 @@ def _log_openai_turn_input(model: Llm, turn_index: int, input_items: Sequence[Anfor index, item in enumerate(input_items):print(f"[OPENAI TURN INPUT] "- f"{_summarize_responses_input_item(index, item)}"+ f"{summarize_responses_input_item(index, item)}")@@ -361,8 +154,8 @@ class OpenAITurnInputLogger:turn_items = [OpenAITurnInputItem(index=index,- summary=_summarize_responses_input_item(index, item),- payload=_to_serializable(item),+ summary=summarize_responses_input_item(index, item),+ payload=to_serializable(item),)for index, item in enumerate(input_items)]@@ -370,7 +163,7 @@ class OpenAITurnInputLogger:OpenAITurnInputReport(turn_index=self._turn_index,items=turn_items,- request_payload=_to_serializable(request_payload),+ request_payload=to_serializable(request_payload),))@@ -446,6 +239,11 @@ class OpenAITurnInputLogger:" .json-type { color: #2563eb; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; }"," .json-number, .json-bool, .json-null { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; color: #0f766e; }"," .json-string { white-space: pre-wrap; overflow-wrap: anywhere; }",+ " .copy-controls { display: flex; align-items: center; gap: 8px; margin-top: 10px; }",+ " .copy-button { border: 1px solid #cbd5e1; background: #fff; color: #111827; border-radius: 6px; padding: 6px 10px; cursor: pointer; font-size: 12px; }",+ " .copy-button:hover { background: #f8fafc; }",+ " .copy-status { color: #2563eb; font-size: 12px; min-height: 16px; }",+ " .copy-source { display: none; }"," </style>","</head>","<body>",@@ -469,8 +267,25 @@ class OpenAITurnInputLogger:indent=2,ensure_ascii=False,)+ request_input_json: str | None = None+ if isinstance(turn.request_payload, dict) and "input" in turn.request_payload:+ request_input_json = json.dumps(+ turn.request_payload["input"],+ indent=2,+ ensure_ascii=False,+ )html_parts.append(" <details class='payload-wrap' open>")html_parts.append(" <summary>Request payload</summary>")+ if request_input_json is not None:+ request_input_id = f"request-input-turn-{turn.turn_index}"+ html_parts.append(+ " "+ + _render_copy_controls(request_input_id, "Copy input JSON")+ )+ html_parts.append(+ f" <pre id='{escape(request_input_id)}' class='copy-source'>"+ f"{escape(request_input_json)}</pre>"+ )html_parts.append(" <div class='json-view'>")html_parts.append(_render_json_node(turn.request_payload, "root"))html_parts.append(" </div>")@@ -558,5 +373,37 @@ class OpenAITurnInputLogger:html_parts.append(" </details>")html_parts.append(" </section>")- html_parts.extend(["</body>", "</html>"])+ html_parts.extend(+ [+ " <script>",+ " document.addEventListener('click', async (event) => {",+ " const target = event.target;",+ " if (!(target instanceof HTMLButtonElement)) {",+ " return;",+ " }",+ " const copyTargetId = target.dataset.copyTarget;",+ " if (!copyTargetId) {",+ " return;",+ " }",+ " const source = document.getElementById(copyTargetId);",+ " const status = target.parentElement?.querySelector('.copy-status');",+ " if (!source) {",+ " if (status) { status.textContent = 'Missing source'; }",+ " return;",+ " }",+ " try {",+ " await navigator.clipboard.writeText(source.textContent || '');",+ " if (status) { status.textContent = 'Copied'; }",+ " } catch (_error) {",+ " if (status) { status.textContent = 'Copy failed'; }",+ " }",+ " window.setTimeout(() => {",+ " if (status) { status.textContent = ''; }",+ " }, 1600);",+ " });",+ " </script>",+ "</body>",+ "</html>",+ ]+ )return "\n".join(html_parts)diff --git a/backend/routes/evals.py b/backend/routes/evals.pyindex fc5cd5ed..0f5d4a68 100644--- a/backend/routes/evals.py+++ b/backend/routes/evals.py@@ -12,6 +12,10 @@ from typing import List, Dictfrom llm import Llmfrom prompts.prompt_types import Stackfrom pathlib import Path+from fs_logging.openai_input_compare import (+ compare_openai_inputs,+ format_openai_input_comparison,+)router = APIRouter()@@ -183,6 +187,76 @@ class RunEvalsRequest(BaseModel):diff_mode: bool = False+class OpenAIInputCompareRequest(BaseModel):+ left_json: str+ right_json: str+++class OpenAIInputCompareDifferenceResponse(BaseModel):+ item_index: int+ path: str+ left_summary: str+ right_summary: str+ left_value: object | None+ right_value: object | None+++class OpenAIInputCompareResponse(BaseModel):+ common_prefix_items: int+ left_item_count: int+ right_item_count: int+ difference: OpenAIInputCompareDifferenceResponse | None+ formatted: str+++def _load_openai_input_compare_payload(raw_json: str, side: str) -> object:+ try:+ payload = json.loads(raw_json)+ except json.JSONDecodeError as error:+ raise HTTPException(+ status_code=400,+ detail=(+ f"Invalid {side} JSON: {error.msg} "+ f"(line {error.lineno}, column {error.colno})"+ ),+ )++ try:+ compare_openai_inputs(payload, payload)+ except ValueError as error:+ raise HTTPException(status_code=400, detail=f"Invalid {side} payload: {error}")++ return payload++[email protected]("/openai-input-compare", response_model=OpenAIInputCompareResponse)+async def compare_openai_inputs_for_evals(+ request: OpenAIInputCompareRequest,+) -> OpenAIInputCompareResponse:+ left_payload = _load_openai_input_compare_payload(request.left_json, "left")+ right_payload = _load_openai_input_compare_payload(request.right_json, "right")+ comparison = compare_openai_inputs(left_payload, right_payload)++ difference = None+ if comparison.difference is not None:+ difference = OpenAIInputCompareDifferenceResponse(+ item_index=comparison.difference.item_index,+ path=comparison.difference.path,+ left_summary=comparison.difference.left_summary,+ right_summary=comparison.difference.right_summary,+ left_value=comparison.difference.left_value,+ right_value=comparison.difference.right_value,+ )++ return OpenAIInputCompareResponse(+ common_prefix_items=comparison.common_prefix_items,+ left_item_count=comparison.left_item_count,+ right_item_count=comparison.right_item_count,+ difference=difference,+ formatted=format_openai_input_comparison(comparison),+ )++@router.post("/run_evals", response_model=List[str])async def run_evals(request: RunEvalsRequest) -> List[str]:"""Run evaluations on selected images in the inputs directory for multiple models"""diff --git a/backend/tests/test_evals_openai_input_compare.py b/backend/tests/test_evals_openai_input_compare.pynew file mode 100644index 00000000..799288f2--- /dev/null+++ b/backend/tests/test_evals_openai_input_compare.py@@ -0,0 +1,42 @@+import pytest+from fastapi import HTTPException++from routes.evals import OpenAIInputCompareRequest, compare_openai_inputs_for_evals+++async def test_compare_openai_inputs_for_evals_returns_first_difference() -> None:+ response = await compare_openai_inputs_for_evals(+ OpenAIInputCompareRequest(+ left_json=(+ '{"input":[{"role":"system","content":"A"},'+ '{"role":"user","content":"Build dashboard"}]}'+ ),+ right_json=(+ '{"input":[{"role":"system","content":"A"},'+ '{"role":"user","content":"Build landing page"}]}'+ ),+ )+ )++ assert response.common_prefix_items == 1+ assert response.left_item_count == 2+ assert response.right_item_count == 2+ assert response.difference is not None+ assert response.difference.path == "input[1].content"+ assert response.difference.left_value == "Build dashboard"+ assert response.difference.right_value == "Build landing page"+++async def test_compare_openai_inputs_for_evals_rejects_invalid_json() -> None:+ with pytest.raises(HTTPException) as error_info:+ await compare_openai_inputs_for_evals(+ OpenAIInputCompareRequest(+ left_json='{"input": [',+ right_json='{"input": []}',+ )+ )++ assert error_info.value.status_code == 400+ assert "Invalid left JSON" in error_info.value.detaildiff --git a/backend/tests/test_openai_input_compare.py b/backend/tests/test_openai_input_compare.pynew file mode 100644index 00000000..6b9a3537--- /dev/null+++ b/backend/tests/test_openai_input_compare.py@@ -0,0 +1,86 @@+from typing import Any++from fs_logging.openai_input_compare import (+ compare_openai_inputs,+ format_openai_input_comparison,+)+++def test_compare_openai_inputs_returns_none_for_identical_inputs() -> None:+ payload: dict[str, Any] = {+ "input": [+ {"role": "system", "content": "You are a coding agent."},+ {"role": "user", "content": "Build a dashboard."},+ ]+ }++ comparison = compare_openai_inputs(payload, payload)++ assert comparison.common_prefix_items == 2+ assert comparison.left_item_count == 2+ assert comparison.right_item_count == 2+ assert comparison.difference is None+ assert "difference=none" in format_openai_input_comparison(comparison)+++def test_compare_openai_inputs_finds_first_different_block_and_field() -> None:+ left_payload: dict[str, Any] = {+ "input": [+ {"role": "system", "content": "You are a coding agent."},+ {+ "role": "user",+ "content": [+ {"type": "input_text", "text": "Build a dashboard."},+ {+ "type": "input_image",+ "image_url": "data:image/png;base64,left",+ "detail": "original",+ },+ ],+ },+ ]+ }+ right_payload: dict[str, Any] = {+ "input": [+ {"role": "system", "content": "You are a coding agent."},+ {+ "role": "user",+ "content": [+ {"type": "input_text", "text": "Build a dashboard."},+ {+ "type": "input_image",+ "image_url": "data:image/png;base64,right",+ "detail": "original",+ },+ ],+ },+ ]+ }++ comparison = compare_openai_inputs(left_payload, right_payload)++ assert comparison.common_prefix_items == 1+ assert comparison.difference is not None+ assert comparison.difference.item_index == 1+ assert comparison.difference.path == "input[1].content[1].image_url"+ assert comparison.difference.left_value == "data:image/png;base64,left"+ assert comparison.difference.right_value == "data:image/png;base64,right"+++def test_compare_openai_inputs_accepts_raw_input_arrays() -> None:+ left_input: list[dict[str, Any]] = [+ {"role": "system", "content": "You are a coding agent."},+ {"role": "user", "content": "Build a dashboard."},+ ]+ right_input: list[dict[str, Any]] = [+ {"role": "system", "content": "You are a coding agent."},+ {"role": "user", "content": "Build a landing page."},+ ]++ comparison = compare_openai_inputs(left_input, right_input)+ formatted = format_openai_input_comparison(comparison)++ assert comparison.difference is not None+ assert comparison.difference.path == "input[1].content"+ assert "first_different_item_index=1" in formatted+ assert "first_different_path=input[1].content" in formatteddiff --git a/backend/tests/test_openai_provider_session.py b/backend/tests/test_openai_provider_session.pyindex 6117e2aa..92bc89bb 100644--- a/backend/tests/test_openai_provider_session.py+++ b/backend/tests/test_openai_provider_session.py@@ -57,7 +57,7 @@ def _test_tools() -> list[dict[str, Any]]:@pytest.mark.asyncio-async def test_openai_provider_session_reuses_prompt_cache_key_across_turns() -> None:+async def test_openai_provider_session_omits_prompt_cache_key_across_turns() -> None:client = _FakeOpenAIClient()session = OpenAIProviderSession(client=client, # type: ignore[arg-type]@@ -108,9 +108,8 @@ async def test_openai_provider_session_reuses_prompt_cache_key_across_turns() ->first_input = first_call["input"]second_input = second_call["input"]- assert first_call["prompt_cache_key"] == second_call["prompt_cache_key"]- assert isinstance(first_call["prompt_cache_key"], str)- assert str(first_call["prompt_cache_key"]).startswith("s2c-openai-session-v1-")+ assert "prompt_cache_key" not in first_call+ assert "prompt_cache_key" not in second_callassert "prompt_cache_retention" not in first_callassert "prompt_cache_retention" not in second_callassert isinstance(first_input, list)@@ -119,7 +118,7 @@ async def test_openai_provider_session_reuses_prompt_cache_key_across_turns() ->@pytest.mark.asyncio-async def test_openai_provider_session_prompt_cache_key_is_deterministic() -> None:+async def test_openai_provider_session_omits_prompt_cache_key_for_all_prompts() -> None:first_client = _FakeOpenAIClient()second_client = _FakeOpenAIClient()different_prompt_client = _FakeOpenAIClient()@@ -147,12 +146,9 @@ async def test_openai_provider_session_prompt_cache_key_is_deterministic() -> Noawait second_session.stream_turn(_noop_event_sink)await different_prompt_session.stream_turn(_noop_event_sink)- first_key = first_client.responses.calls[0]["prompt_cache_key"]- second_key = second_client.responses.calls[0]["prompt_cache_key"]- different_prompt_key = different_prompt_client.responses.calls[0]["prompt_cache_key"]-- assert first_key == second_key- assert first_key != different_prompt_key+ assert "prompt_cache_key" not in first_client.responses.calls[0]+ assert "prompt_cache_key" not in second_client.responses.calls[0]+ assert "prompt_cache_key" not in different_prompt_client.responses.calls[0]@pytest.mark.asynciodiff --git a/backend/tests/test_openai_turn_input_logging.py b/backend/tests/test_openai_turn_input_logging.pyindex 96840163..da0cf6a6 100644--- a/backend/tests/test_openai_turn_input_logging.py+++ b/backend/tests/test_openai_turn_input_logging.py@@ -94,7 +94,6 @@ def test_openai_turn_input_logger_includes_request_payload(],request_payload={"model": "gpt-5.2-codex",- "prompt_cache_key": "s2c-openai-session-v1-abc123","input": [{"role": "user", "content": "Build this page"}],},)@@ -104,8 +103,8 @@ def test_openai_turn_input_logger_includes_request_payload(assert report_path is not Nonehtml = Path(report_path).read_text(encoding="utf-8")assert "Request payload" in html- assert "prompt_cache_key" in html- assert "s2c-openai-session-v1-abc123" in html+ assert "Copy input JSON" in html+ assert "request-input-turn-1" in htmldef test_openai_turn_input_logger_disabled_writes_nothing(tmp_path, monkeypatch) -> None:diff --git a/frontend/src/components/evals/AllEvalsPage.tsx b/frontend/src/components/evals/AllEvalsPage.tsxindex 835d718a..76b8c4dd 100644--- a/frontend/src/components/evals/AllEvalsPage.tsx+++ b/frontend/src/components/evals/AllEvalsPage.tsx@@ -57,6 +57,18 @@ function AllEvalsPage() {</h2><p className="text-gray-600">Score outputs from a single model</p></Link>++ <Link+ to="/evals/openai-input-compare"+ className="block w-full p-4 bg-white rounded-lg shadow hover:shadow-md transition-shadow border border-gray-200"+ >+ <h2 className="text-xl font-semibold text-gray-800">+ OpenAI Input Compare+ </h2>+ <p className="text-gray-600">+ Find the first diverging input block between two requests+ </p>+ </Link></div></div></div>diff --git a/frontend/src/components/evals/EvalNavigation.tsx b/frontend/src/components/evals/EvalNavigation.tsxindex 5e82d269..060729fa 100644--- a/frontend/src/components/evals/EvalNavigation.tsx+++ b/frontend/src/components/evals/EvalNavigation.tsx@@ -40,6 +40,13 @@ function EvalNavigation() {>Single</Link>++ <Link+ to="/evals/openai-input-compare"+ className="hover:text-blue-300 transition-colors"+ >+ Input Compare+ </Link></div><Linkdiff --git a/frontend/src/components/evals/OpenAIInputComparePage.tsx b/frontend/src/components/evals/OpenAIInputComparePage.tsxnew file mode 100644index 00000000..9ed78499--- /dev/null+++ b/frontend/src/components/evals/OpenAIInputComparePage.tsx@@ -0,0 +1,241 @@+import { useState } from "react";++import { HTTP_BACKEND_URL } from "../../config";+import EvalNavigation from "./EvalNavigation";++interface OpenAIInputDifference {+ item_index: number;+ path: string;+ left_summary: string;+ right_summary: string;+ left_value: unknown;+ right_value: unknown;+}++interface OpenAIInputCompareResponse {+ common_prefix_items: number;+ left_item_count: number;+ right_item_count: number;+ difference: OpenAIInputDifference | null;+ formatted: string;+}++function formatJson(value: unknown): string {+ const formatted = JSON.stringify(value, null, 2);+ return formatted ?? String(value);+}++function OpenAIInputComparePage() {+ const [leftJson, setLeftJson] = useState("");+ const [rightJson, setRightJson] = useState("");+ const [result, setResult] = useState<OpenAIInputCompareResponse | null>(null);+ const [error, setError] = useState("");+ const [isLoading, setIsLoading] = useState(false);++ const handleCompare = async () => {+ if (!leftJson.trim() || !rightJson.trim()) {+ setError("Paste both JSON payloads before comparing.");+ return;+ }++ setIsLoading(true);+ setError("");++ try {+ const response = await fetch(`${HTTP_BACKEND_URL}/openai-input-compare`, {+ method: "POST",+ headers: {+ "Content-Type": "application/json",+ },+ body: JSON.stringify({+ left_json: leftJson,+ right_json: rightJson,+ }),+ });++ const data = await response.json();+ if (!response.ok) {+ setResult(null);+ setError(data.detail || "Compare request failed.");+ return;+ }++ setResult(data);+ } catch (requestError) {+ console.error("Error comparing OpenAI inputs", requestError);+ setResult(null);+ setError("Compare request failed.");+ } finally {+ setIsLoading(false);+ }+ };++ return (+ <div className="min-h-screen bg-zinc-950 text-white">+ <EvalNavigation />+ <div className="mx-auto flex w-full max-w-7xl flex-col gap-6 px-4 py-6">+ <div className="rounded-2xl border border-zinc-800 bg-zinc-900/80 p-6 shadow-2xl shadow-black/20">+ <h1 className="text-3xl font-semibold tracking-tight">+ OpenAI Input Compare+ </h1>+ <p className="mt-2 max-w-3xl text-sm leading-6 text-zinc-300">+ Paste either a full OpenAI request payload or just the raw{" "}+ <code className="rounded bg-zinc-800 px-1.5 py-0.5 text-zinc-100">+ input+ </code>{" "}+ array on each side. The compare view finds the first input block+ that diverges and the first nested field path where that happens.+ </p>+ <p className="mt-2 text-sm text-zinc-400">+ The OpenAI Turn Input Report now has a{" "}+ <span className="rounded bg-zinc-800 px-1.5 py-0.5 text-zinc-100">+ Copy input JSON+ </span>{" "}+ button you can paste here directly.+ </p>+ </div>++ <div className="grid gap-6 xl:grid-cols-2">+ <section className="rounded-2xl border border-emerald-900/60 bg-emerald-950/30 p-4">+ <div className="mb-3 flex items-center justify-between">+ <h2 className="text-lg font-semibold text-emerald-100">Left JSON</h2>+ <span className="text-xs uppercase tracking-[0.18em] text-emerald-300/80">+ Request A+ </span>+ </div>+ <textarea+ value={leftJson}+ onChange={(event) => setLeftJson(event.target.value)}+ placeholder='{"input":[{"role":"system","content":"..."}]}'+ className="min-h-[360px] w-full rounded-xl border border-emerald-900/60 bg-zinc-950 px-4 py-3 font-mono text-sm text-zinc-100 outline-none transition focus:border-emerald-500"+ spellCheck={false}+ />+ </section>++ <section className="rounded-2xl border border-sky-900/60 bg-sky-950/30 p-4">+ <div className="mb-3 flex items-center justify-between">+ <h2 className="text-lg font-semibold text-sky-100">Right JSON</h2>+ <span className="text-xs uppercase tracking-[0.18em] text-sky-300/80">+ Request B+ </span>+ </div>+ <textarea+ value={rightJson}+ onChange={(event) => setRightJson(event.target.value)}+ placeholder='{"input":[{"role":"system","content":"..."}]}'+ className="min-h-[360px] w-full rounded-xl border border-sky-900/60 bg-zinc-950 px-4 py-3 font-mono text-sm text-zinc-100 outline-none transition focus:border-sky-500"+ spellCheck={false}+ />+ </section>+ </div>++ <div className="flex items-center gap-4">+ <button+ type="button"+ onClick={handleCompare}+ disabled={isLoading}+ className="rounded-full bg-white px-5 py-2 text-sm font-semibold text-zinc-950 transition hover:bg-zinc-200 disabled:cursor-not-allowed disabled:bg-zinc-500"+ >+ {isLoading ? "Comparing..." : "Compare Inputs"}+ </button>+ {error ? <p className="text-sm text-rose-300">{error}</p> : null}+ </div>++ {result ? (+ <div className="grid gap-6">+ <section className="grid gap-4 md:grid-cols-3">+ <div className="rounded-2xl border border-zinc-800 bg-zinc-900 p-4">+ <div className="text-xs uppercase tracking-[0.18em] text-zinc-400">+ Shared Prefix+ </div>+ <div className="mt-2 text-3xl font-semibold">+ {result.common_prefix_items}+ </div>+ <p className="mt-1 text-sm text-zinc-400">+ Top-level input items that match exactly before divergence.+ </p>+ </div>+ <div className="rounded-2xl border border-zinc-800 bg-zinc-900 p-4">+ <div className="text-xs uppercase tracking-[0.18em] text-zinc-400">+ Left Items+ </div>+ <div className="mt-2 text-3xl font-semibold">+ {result.left_item_count}+ </div>+ </div>+ <div className="rounded-2xl border border-zinc-800 bg-zinc-900 p-4">+ <div className="text-xs uppercase tracking-[0.18em] text-zinc-400">+ Right Items+ </div>+ <div className="mt-2 text-3xl font-semibold">+ {result.right_item_count}+ </div>+ </div>+ </section>++ <section className="rounded-2xl border border-zinc-800 bg-zinc-900 p-5">+ <h2 className="text-xl font-semibold">First Difference</h2>+ {result.difference ? (+ <div className="mt-4 grid gap-4">+ <div className="rounded-xl border border-amber-900/60 bg-amber-950/30 p-4">+ <div className="text-xs uppercase tracking-[0.18em] text-amber-300/80">+ Path+ </div>+ <div className="mt-2 font-mono text-sm text-amber-50">+ {result.difference.path}+ </div>+ </div>++ <div className="grid gap-4 xl:grid-cols-2">+ <div className="rounded-xl border border-emerald-900/60 bg-emerald-950/30 p-4">+ <div className="text-xs uppercase tracking-[0.18em] text-emerald-300/80">+ Left Summary+ </div>+ <pre className="mt-2 whitespace-pre-wrap break-words rounded-lg bg-zinc-950 p-3 font-mono text-xs text-zinc-100">+ {result.difference.left_summary}+ </pre>+ <div className="mt-3 text-xs uppercase tracking-[0.18em] text-emerald-300/80">+ Left Value+ </div>+ <pre className="mt-2 max-h-[320px] overflow-auto whitespace-pre-wrap break-words rounded-lg bg-zinc-950 p-3 font-mono text-xs text-zinc-100">+ {formatJson(result.difference.left_value)}+ </pre>+ </div>++ <div className="rounded-xl border border-sky-900/60 bg-sky-950/30 p-4">+ <div className="text-xs uppercase tracking-[0.18em] text-sky-300/80">+ Right Summary+ </div>+ <pre className="mt-2 whitespace-pre-wrap break-words rounded-lg bg-zinc-950 p-3 font-mono text-xs text-zinc-100">+ {result.difference.right_summary}+ </pre>+ <div className="mt-3 text-xs uppercase tracking-[0.18em] text-sky-300/80">+ Right Value+ </div>+ <pre className="mt-2 max-h-[320px] overflow-auto whitespace-pre-wrap break-words rounded-lg bg-zinc-950 p-3 font-mono text-xs text-zinc-100">+ {formatJson(result.difference.right_value)}+ </pre>+ </div>+ </div>+ </div>+ ) : (+ <p className="mt-4 text-zinc-300">+ No difference found. Both inputs match exactly.+ </p>+ )}+ </section>++ <section className="rounded-2xl border border-zinc-800 bg-zinc-900 p-5">+ <h2 className="text-xl font-semibold">Formatted Summary</h2>+ <pre className="mt-4 max-h-[420px] overflow-auto whitespace-pre-wrap break-words rounded-xl bg-zinc-950 p-4 font-mono text-xs text-zinc-100">+ {result.formatted}+ </pre>+ </section>+ </div>+ ) : null}+ </div>+ </div>+ );+}++export default OpenAIInputComparePage;diff --git a/frontend/src/main.tsx b/frontend/src/main.tsxindex 0df92c9a..f1f7da89 100644--- a/frontend/src/main.tsx+++ b/frontend/src/main.tsx@@ -9,6 +9,7 @@ import PairwiseEvalsPage from "./components/evals/PairwiseEvalsPage";import RunEvalsPage from "./components/evals/RunEvalsPage.tsx";import BestOfNEvalsPage from "./components/evals/BestOfNEvalsPage.tsx";import AllEvalsPage from "./components/evals/AllEvalsPage.tsx";+import OpenAIInputComparePage from "./components/evals/OpenAIInputComparePage.tsx";ReactDOM.createRoot(document.getElementById("root")!).render(<React.StrictMode>@@ -20,6 +21,10 @@ ReactDOM.createRoot(document.getElementById("root")!).render(<Route path="/evals/pairwise" element={<PairwiseEvalsPage />} /><Route path="/evals/best-of-n" element={<BestOfNEvalsPage />} /><Route path="/evals/run" element={<RunEvalsPage />} />+ <Route+ path="/evals/openai-input-compare"+ element={<OpenAIInputComparePage />}+ /></Routes></Router><Toaster toastOptions={{ className: "dark:bg-zinc-950 dark:text-white" }} />