Skip to content

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.py
index 571ef411..980db4d0 100644
--- a/backend/agent/providers/openai.py
+++ b/backend/agent/providers/openai.py
@@ -1,6 +1,5 @@
# pyright: reportUnknownVariableType=false
import copy
-import hashlib
import json
import uuid
from 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}"
-
-
@dataclass
class 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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, Sequence
from agent.providers.pricing import MODEL_PRICING
from agent.providers.token_usage import TokenUsage
from 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[An
for 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.py
index fc5cd5ed..0f5d4a68 100644
--- a/backend/routes/evals.py
+++ b/backend/routes/evals.py
@@ -12,6 +12,10 @@ from typing import List, Dict
from llm import Llm
from prompts.prompt_types import Stack
from 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.py
new file mode 100644
index 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.detail
diff --git a/backend/tests/test_openai_input_compare.py b/backend/tests/test_openai_input_compare.py
new file mode 100644
index 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 formatted
diff --git a/backend/tests/test_openai_provider_session.py b/backend/tests/test_openai_provider_session.py
index 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_call
assert "prompt_cache_retention" not in first_call
assert "prompt_cache_retention" not in second_call
assert 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() -> No
await 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.asyncio
diff --git a/backend/tests/test_openai_turn_input_logging.py b/backend/tests/test_openai_turn_input_logging.py
index 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 None
html = 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 html
def 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.tsx
index 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.tsx
index 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>
<Link
diff --git a/frontend/src/components/evals/OpenAIInputComparePage.tsx b/frontend/src/components/evals/OpenAIInputComparePage.tsx
new file mode 100644
index 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.tsx
index 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" }} />