Agent Zero AI framework
Preserve native Responses history within prepared prompts
Alessandro32aa95e8ddc3
diff --git a/AGENTS.md b/AGENTS.mdindex a822b69f2..1165e958d 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -16,6 +16,7 @@- `agent.py` owns `Agent`, `AgentContext`, and loop data.- `Agent.hist_add_ai_response` owns Responses-API state advancement: it calls `_remember_llm_result_state` internally. Model turns pass an `LLMResult`; omitted results and legacy positional string IDs use the non-LLM sentinel. Callers must not invoke `_remember_llm_result_state` manually.+- Prepared local Responses input may project intact native history through `helpers/responses_history.py`; retain original Chat/fallback messages, current protocol/extras, summaries and masking. Durable capability metadata stores only a stable-prefix digest for eligibility.- Native function calls use canonical call content for history and repeat comparison, even when accompanied by commentary. The canonical content passes through the normal history template/masking hook; provider output metadata remains intact.- `initialize.py` owns framework initialization.- `models.py` owns model-provider configuration and LiteLLM integration.diff --git a/agent.py b/agent.pyindex 8b34c2e75..7088b21f6 100644--- a/agent.py+++ b/agent.py@@ -12,6 +12,7 @@ from helpers import (files,errors,history,+ responses_history,tokens,context as context_helper,dirty_json,@@ -343,6 +344,8 @@ class LoopData:self.iteration = -1self.system = []self.responses_prompt_replacements: dict[str, str] = {}+ self.responses_prepared_text = ""+ self.responses_history_prefix: list[BaseMessage] = []self.user_message: history.Message | None = Noneself.history_output: list[history.OutputMessage] = []self.protocol_temporary: OrderedDict[str, history.MessageContent] = OrderedDict()@@ -612,6 +615,11 @@ class Agent:*history_langchain,]full_text = ChatPromptTemplate.from_messages(full_prompt).format()+ loop_data.responses_prepared_text = full_text+ loop_data.responses_history_prefix = [+ SystemMessage(content=system_text),+ *history.output_langchain(protocol + loop_data.history_output),+ ]# store as last context window contentself.set_data(@@ -970,6 +978,9 @@ class Agent:"chat_model_call_before", self, call_data=call_data)+ call_data["responses_history_context"] = self._responses_history_context(+ call_data["model"], call_data["messages"]+ )turn_kwargs = {"a0_responses_function_tools": call_data.get("a0_responses_function_tools"@@ -979,6 +990,7 @@ class Agent:),}for key in (+ "responses_history_context","responses_prompt_replacements","responses_builtin_tools","responses_state",@@ -1064,6 +1076,31 @@ class Agent:converted = model._convert_messages(messages)return ResponsesTransport.input_from_messages(converted)+ def _responses_history_context(self, model: Any, messages: list[BaseMessage]):+ prepared = getattr(self.loop_data, "responses_prepared_text", "")+ if (+ not prepared or not hasattr(model, "_convert_messages")+ or any(message.additional_kwargs or getattr(message, "tool_calls", None) for message in messages)+ or ChatPromptTemplate.from_messages(messages).format() != prepared+ ):+ return None+ from helpers.secrets import get_secrets_manager++ def render(record):+ rendered = self._responses_prompt_input_items(+ model, history.output_langchain([{**record, "ai": False}])+ )+ return rendered[0].get("content") if len(rendered) == 1 else None++ return {+ "prompt": self._responses_prompt_input_items(model, messages),+ "prefix": self._responses_prompt_input_items(model, self.loop_data.responses_history_prefix),+ "groups": responses_history.prepare_groups(+ self.loop_data.history_output, render,+ get_secrets_manager(self.context).mask_values,+ ),+ }+def _remember_llm_result_state(self, llm_result: LLMResult, history_message: history.Message) -> None:diff --git a/extensions/python/_functions/AGENTS.md b/extensions/python/_functions/AGENTS.mdindex 0b7954fdb..5ba2a7f5d 100644--- a/extensions/python/_functions/AGENTS.md+++ b/extensions/python/_functions/AGENTS.md@@ -15,7 +15,7 @@- Do not flatten nested qualname paths into retired legacy folder names.- Extension functions must match the implicit hook's supplied arguments.- Preserve ordering prefixes where exception handling, watchdog registration, or cleanup depends on them.-- Hooks that mirror persisted AI responses into UI logs must reuse existing stream log items and avoid duplicating live response-tool logs.+- Hooks that mirror persisted AI responses into UI logs must reuse existing stream log items and avoid duplicating live response-tool logs. Native-call commentary must not be finalized as a plain response; canonical calls keep their tool-step log ownership.- The `AgentContext.run_task/end` hook attaches integration callbacks to the returned `DeferredTask`; keep terminal side effects out of `agent.py`.- Recovery-loop circuit breakers must stop at the General Settings limit and render their user-visible cost warning from a core framework prompt.- Prompt settings snapshots must be task-local, accessed through `get_settings_for_prompt()`, and end with the matching `Agent.prepare_prompt` call, including exceptional exits.diff --git a/extensions/python/_functions/agent/Agent/hist_add_ai_response/end/_10_log_plain_responses.py b/extensions/python/_functions/agent/Agent/hist_add_ai_response/end/_10_log_plain_responses.pyindex 28c80e77c..69ff9131d 100644--- a/extensions/python/_functions/agent/Agent/hist_add_ai_response/end/_10_log_plain_responses.py+++ b/extensions/python/_functions/agent/Agent/hist_add_ai_response/end/_10_log_plain_responses.py@@ -14,7 +14,7 @@ class LogPlainResponses(Extension):call_kwargs = {}llm_result = call_kwargs.get("llm_result")- if getattr(llm_result, "mode", "") != "responses":+ if getattr(llm_result, "mode", "") != "responses" or getattr(llm_result, "function_calls", None):returnmessage = call_kwargs.get("message")diff --git a/helpers/litellm_transport.py b/helpers/litellm_transport.pyindex a3dd758d5..fd2928262 100644--- a/helpers/litellm_transport.py+++ b/helpers/litellm_transport.py@@ -16,7 +16,7 @@ from litellm import (responses,)-from helpers import images+from helpers import images, responses_historyfrom helpers.llm_result import LLMResultfrom helpers.responses_tools import project_system_prompt@@ -184,6 +184,8 @@ class LiteLLMTransport:last_result: LLMResult | None = field(init=False, default=None)last_request_state: str = field(init=False, default=RESPONSES_STATE_PROVIDER)explicit_prompt_caching: bool = field(init=False, default=False)+ history_prefix_hash: str = field(init=False, default="")+ native_history_calls: int = field(init=False, default=0)def __post_init__(self) -> None:self.kwargs = _without_stream_kwarg(dict(self.kwargs))@@ -390,6 +392,27 @@ class LiteLLMTransport:self.last_request_state = _normalize_responses_state(self.kwargs.get("responses_state"))+ self.history_prefix_hash = ""+ self.native_history_calls = 0+ context = self.kwargs.get("responses_history_context")+ if (+ self.last_request_state == RESPONSES_STATE_LOCAL+ and _has_tools(self.kwargs.get("a0_responses_function_tools"))+ and isinstance(context, dict)+ and all(isinstance(context.get(key), list) for key in ("prompt", "prefix", "groups"))+ ):+ replacements = self.kwargs.get("responses_prompt_replacements")+ prompt = project_system_prompt(context.get("prompt", []), replacements)+ if response_kwargs.get("input") == prompt:+ prefix = project_system_prompt(context.get("prefix", []), replacements)+ scope = {"affinity": self.policy.cache_key, "tools": response_kwargs.get("tools")}+ self.history_prefix_hash = responses_history.prefix_hashes(prefix, scope)[-1]+ response_kwargs["input"] = responses_history.project_history(+ prompt, context.get("groups", []), scope,+ )+ self.native_history_calls = sum(+ item.get("type") == "function_call" for item in response_kwargs["input"]+ )return {"model": self.model,"stream": stream,@@ -433,10 +456,30 @@ class LiteLLMTransport:return Noneresponse = _object_to_dict(parser.completed_response)output = _as_list(response.get("output"))- if parser.function_calls and not any(- _get_value(item, "type") == "function_call" for item in output- ):- response["output"] = [*output, *parser.function_calls.values()]+ has_terminal_output = bool(output)+ positions = {key: int(index) for index, key in parser.output_index_keys.items()}+ streamed = sorted(+ enumerate(parser.output_items.items()),+ key=lambda entry: positions.get(entry[1][0], entry[0]),+ )+ for fallback_index, (key, item) in streamed:+ if has_terminal_output and not item.get("id") and not item.get("call_id"):+ continue # An unidentified stream fragment cannot add another terminal call.+ match = next((+ index for index, final in enumerate(output)+ if _get_value(final, "type") == item.get("type") and any(+ item.get(field) and item[field] == _get_value(final, field)+ for field in ("id", "call_id")+ )+ ), None)+ if match is None:+ output.insert(min(positions.get(key, fallback_index), len(output)), dict(item))+ else:+ output[match] = {+ **item,+ **{field: value for field, value in _object_to_dict(output[match]).items() if value is not None},+ }+ response["output"] = outputreturn self._llm_result_from_response(response, request)def _stream_result_from_chat_parser(@@ -459,6 +502,11 @@ class LiteLLMTransport:"mode": self.policy.mode.value,"state": self.policy.state,"cache_key": self.policy.cache_key,+ **(+ {responses_history.PREFIX_HASH: self.history_prefix_hash,+ "native_history_calls": self.native_history_calls}+ if self.policy.using_responses and self.history_prefix_hash else {}+ ),"fallback_error": _exception_text(self.policy.fallback_error)if self.policy.fallback_errorelse "",@@ -1195,6 +1243,7 @@ class ResponsesEventParser:def __init__(self) -> None:self.function_calls: dict[str, dict[str, Any]] = {}+ self.output_items: dict[str, dict[str, Any]] = {}self.output_index_keys: dict[str, str] = {}self.emitted_function_calls: set[str] = set()self.streamed_function_calls: dict[str, str] = {}@@ -1220,7 +1269,7 @@ class ResponsesEventParser:}:reasoning_delta = str(_get_value(event, "delta") or "")elif event_type == "response.output_item.added":- self._remember_function_call(_get_value(event, "item"), event)+ self._remember_output_item(_get_value(event, "item"), event)elif event_type == "response.function_call_arguments.delta":response_delta = self._append_function_call_arguments(event)elif event_type == "response.function_call_arguments.done":@@ -1245,15 +1294,18 @@ class ResponsesEventParser:return {"reasoning_delta": reasoning_delta, "response_delta": response_delta}- def _remember_function_call(self, item: Any, event: Any) -> str:- if _get_value(item, "type") != "function_call":+ def _remember_output_item(self, item: Any, event: Any) -> str:+ item_type = _get_value(item, "type")+ if not item_type:return ""key = self._event_key(event, item)if not key:return ""- current = self.function_calls.get(key, {})- merged = {**current, **_object_to_dict(item)}- self.function_calls[key] = merged+ current = self.output_items.get(key, self.function_calls.get(key, {}))+ merged = {**current, **{field: value for field, value in _object_to_dict(item).items() if value is not None}}+ self.output_items[key] = merged+ if item_type == "function_call":+ self.function_calls[key] = mergedoutput_index = _get_value(event, "output_index")if output_index is not None:self.output_index_keys[str(output_index)] = key@@ -1264,6 +1316,7 @@ class ResponsesEventParser:if not key:return ""current = self.function_calls.setdefault(key, {"type": "function_call"})+ self.output_items.setdefault(key, current)delta = str(_get_value(event, "delta") or "")current["arguments"] = str(current.get("arguments") or "") + deltaif (@@ -1287,6 +1340,7 @@ class ResponsesEventParser:if not key:return ""current = self.function_calls.setdefault(key, {"type": "function_call"})+ self.output_items.setdefault(key, current)if _get_value(event, "arguments") is not None:current["arguments"] = _get_value(event, "arguments")if _get_value(event, "name"):@@ -1296,8 +1350,8 @@ class ResponsesEventParser:return self._emit_function_call(key, current)def _complete_output_item(self, item: Any, event: Any) -> str:- key = self._remember_function_call(item, event)- if not key:+ key = self._remember_output_item(item, event)+ if key not in self.function_calls:return ""if key in self.streamed_function_calls:return self._finish_function_call(key, self.function_calls[key])@@ -1420,6 +1474,7 @@ def _drop_responses_only_kwargs(kwargs: dict[str, Any]) -> None:kwargs.pop("responses_input_items", None)kwargs.pop("responses_local_input_items", None)kwargs.pop("responses_prompt_replacements", None)+ kwargs.pop("responses_history_context", None)kwargs.pop("previous_response_id", None)kwargs.pop("_a0_responses_builtin_downgrades", None)diff --git a/helpers/litellm_transport.py.dox.md b/helpers/litellm_transport.py.dox.mdindex 3d4311a5d..4367fb0f2 100644--- a/helpers/litellm_transport.py.dox.md+++ b/helpers/litellm_transport.py.dox.md@@ -24,6 +24,7 @@- Keep provider selection and provider-specific defaults outside this helper; callers pass a resolved LiteLLM model name and kwargs.- Strip Agent Zero internal kwargs before sending requests to LiteLLM.+- Validate internal `responses_history_context` against selected prepared local input, bind its stable-prefix digest to actual affinity/tool schemas, and project eligible groups through `responses_history`. Strip the control on every provider path and omit its digest from Chat/fallback result metadata.- Apply `responses_prompt_replacements` only to Responses input when generated A0 functions are present; preserve original Chat/fallback messages and strip this internal control before either provider call.- Do not send orphan tool controls when no tools are present; strict OpenAI-compatible servers can reject empty `tools` arrays.- When Agent Zero function tools are present, default Responses requests to one required native call; explicit request-level `tool_choice` and `parallel_tool_calls` values still win.@@ -35,7 +36,7 @@- Fall back to Chat Completions when LiteLLM's Responses mock streaming path tries to JSON-decode a real SSE stream before any output.- Preserve Chat Completions tool calls from both non-streaming responses and streaming deltas as canonical `LLMResult` function-call items.- Preserve provider usage and LiteLLM response cost for both transports only when the response or stream actually supplies them; do not synthesize unavailable provider accounting.-- Preserve Responses function calls collected from stream events when a terminal completed event omits them.+- Recover all Responses output items from stream events when a terminal completed envelope omits them, including encrypted reasoning. Merge by item/call identity in output-index order; terminal non-null fields win without duplicating calls.- Stream named native function arguments through canonical tool envelopes for display. Buffer interleaved calls until the active envelope closes; preserve independent original call metadata. Native execution still waits for the completed model turn.- Fail incomplete Responses generations and native-call streams that end without completion; never promote partial call previews to a Chat result.- Serialize synthesized Responses function-call JSON with literal Unicode so streamed raw-response logs preserve tool arguments.diff --git a/helpers/responses_history.py b/helpers/responses_history.pynew file mode 100644index 000000000..252b15a22--- /dev/null+++ b/helpers/responses_history.py@@ -0,0 +1,144 @@+"""Conservative native projection of already-prepared local Responses history."""++from copy import deepcopy+import hashlib+import json+from typing import Any, Callable++from helpers.llm_result import result_from_metadata+++PREFIX_HASH = "history_prefix_hash"+++def _json_bytes(value: Any) -> bytes:+ return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode()+++def prefix_hashes(items: list[dict], scope: dict) -> list[str]:+ digest = hashlib.sha256(_json_bytes(scope))+ hashes = [digest.hexdigest()]+ for item in items:+ digest.update(b"\n" + _json_bytes(item))+ hashes.append(digest.hexdigest())+ return hashes+++def _json_object(text: Any) -> dict | None:+ if not isinstance(text, str):+ return None+ try:+ value = json.loads(text)+ except (TypeError, ValueError):+ return None+ return value if isinstance(value, dict) else None+++def _contains_secret(value: Any, mask: Callable[[str], str]) -> bool:+ if isinstance(value, str):+ return mask(value) != value+ if isinstance(value, dict):+ return any(_contains_secret(item, mask) for item in value.values())+ if isinstance(value, list):+ return any(_contains_secret(item, mask) for item in value)+ return False+++def prepare_groups(+ records: list[dict], render: Callable[[dict], Any], mask: Callable[[str], str]+) -> list[dict]:+ groups = []+ for index, record in enumerate(records):+ if not record.get("ai"):+ continue+ result = result_from_metadata(record.get("metadata"))+ if not result or result.mode != "responses" or result.state != "local":+ continue+ prefix_hash = result.capability.get(PREFIX_HASH)+ calls = result.function_calls+ if not prefix_hash or not calls:+ continue+ output = [item.to_dict() for item in result.output_items]+ if any(item.get("type") not in {"function_call", "reasoning"} for item in output):+ continue+ if any(+ item.get("type") == "reasoning"+ and (not isinstance(item.get("encrypted_content"), str) or not item["encrypted_content"])+ for item in output+ ):+ continue+ if any(+ _json_object(item.get("arguments")) is None+ for item in output if item.get("type") == "function_call"+ ):+ continue+ try:+ if _contains_secret(output, mask) or _contains_secret([call.arguments for call in calls], mask):+ continue+ except Exception:+ continue # Keep prepared text when secret masking cannot be checked.+ call_ids = [call.call_id for call in calls]+ if not all(call_ids) or len(set(call_ids)) != len(call_ids):+ continue+ assistant = render(record)+ if _json_object(assistant) != _json_object(result.function_calls_text()):+ continue+ results = []+ for call_id, following in zip(call_ids, records[index + 1:index + 1 + len(calls)]):+ metadata = result_from_metadata(following.get("metadata"))+ items = metadata.input_items if metadata else []+ text = render(following)+ if (+ following.get("ai") or not isinstance(text, str)+ or len(items) != 1 or not isinstance(items[0], dict)+ or items[0].get("type") != "function_call_output"+ or items[0].get("call_id") != call_id+ ):+ break+ results.append({"type": "function_call_output", "call_id": call_id, "output": text})+ if len(results) == len(calls):+ groups.append({+ PREFIX_HASH: prefix_hash, "assistant": assistant,+ "output": deepcopy(output), "results": results,+ })+ return groups+++def project_history(items: list[dict], groups: list[dict], scope: dict) -> list[dict]:+ indices = {value: index for index, value in enumerate(prefix_hashes(items, scope))}+ replacements = {}+ used_calls, used_items = set(), set()+ for group in groups:+ index = indices.get(group.get(PREFIX_HASH))+ if index is None or index + 1 >= len(items):+ continue+ assistant, following = items[index:index + 2]+ if assistant.get("role") != "assistant" or assistant.get("content") != group["assistant"]:+ continue+ content = following.get("content")+ expected = "\n".join(result["output"] for result in group["results"])+ if following.get("role") != "user" or not isinstance(content, str):+ continue+ if content != expected and not content.startswith(expected + "\n"):+ continue+ call_ids = {item["call_id"] for item in group["results"]}+ item_ids = [item["id"] for item in group["output"] if item.get("id")]+ if call_ids & used_calls or set(item_ids) & used_items or len(set(item_ids)) != len(item_ids):+ continue+ used_calls.update(call_ids)+ used_items.update(item_ids)+ suffix = content[len(expected):]+ replacement = [*group["output"], *group["results"]]+ if suffix:+ replacement.append({**following, "content": suffix[1:]})+ replacements[index] = replacement+ result = []+ index = 0+ while index < len(items):+ if index in replacements:+ result.extend(deepcopy(replacements[index]))+ index += 2+ else:+ result.append(deepcopy(items[index]))+ index += 1+ return resultdiff --git a/helpers/responses_history.py.dox.md b/helpers/responses_history.py.dox.mdnew file mode 100644index 000000000..1b7cbeb75--- /dev/null+++ b/helpers/responses_history.py.dox.md@@ -0,0 +1,19 @@+# responses_history.py DOX++## Purpose and Ownership++- Project eligible local Responses call/result groups within complete prepared input. Agent owns rendering and secret masking; the transport owns affinity, tool scope and request selection.+- `prepare_groups` reads visible rendered records and durable result metadata without changing stored history. `project_history` replaces only exact prepared spans. `prefix_hashes` binds stable visible prefixes to transport/tool scope in linear input size.++## Contracts++- Persist `history_prefix_hash` and the derived `native_history_calls` count in existing result capability metadata, never copies of old prompt inputs. The count reports what the actual request projected, for cache/continuation diagnosis. Hash system, protocol and prepared history; retain freshly prepared extras in each request.+- Require canonical visible arguments, original unique call IDs, immediately paired result records, compatible local Responses state and unchanged prefix/scope. Legacy records without digests stay as text.+- Replay only function calls and encrypted reasoning, with original provider items. Reject known unmasked secrets, textual follow-ups, unsupported items, incomplete pairs and non-text result layouts.+- Build tool outputs from visible rendered result content, preserving additional fields. Never restore raw tool output metadata or invent a final response-tool result.+- Preserve summaries, unmatched/custom layouts, attachments and all remaining prepared input. No execution or policy authorization occurs here.+- Internal history context is removed before every provider request; Chat and fallback messages remain untouched.++## Verification++- Run native history, Responses architecture/transport, prompt protocol, history and tool-policy tests. Verify named Codex and Venice presets live after integration changes.diff --git a/tests/test_plain_response_logging.py b/tests/test_plain_response_logging.pyindex df43c8088..7a0756f09 100644--- a/tests/test_plain_response_logging.py+++ b/tests/test_plain_response_logging.py@@ -244,3 +244,17 @@ async def test_stream_aliases_reach_all_consumers_canonically(monkeypatch, tool_monkeypatch.setattr(extension, "call_extensions_async", consume)await agent.handle_response_stream(json.dumps(tool_request))assert agent.loop_data.params_temporary["log_item_generating"].kvps["step"] == "Writing Python code... (8)"+++def test_native_tool_commentary_keeps_generating_step():+ from helpers.llm_result import LLMResult+ agent, item = _agent_with_generating_log()+ result = LLMResult.from_response({+ "output_text": "Running the lookup now.",+ "output": [{"type": "function_call", "name": "lookup", "call_id": "call_1", "arguments": '{"q":"a0"}'}],+ })+ LogPlainResponses(agent=agent).execute(data={+ "args": (agent, result.response), "kwargs": {"llm_result": result},+ })+ assert item.type == "agent"+ assert "log_item_response" not in agent.loop_data.params_temporarydiff --git a/tests/test_responses_history.py b/tests/test_responses_history.pynew file mode 100644index 000000000..3f5e509e1--- /dev/null+++ b/tests/test_responses_history.py@@ -0,0 +1,204 @@+from copy import deepcopy+import json++import pytest++from helpers import responses_history as history+from helpers.llm_result import LLMResult+from helpers.litellm_transport import LiteLLMTransport, clear_transport_capability_cache+++TOOLS = [{"type": "function", "name": "lookup", "parameters": {"type": "object", "properties": {}}}]+BASE = [{"role": "system", "content": "Rules"}, {"role": "user", "content": "Question"}]++[email protected](autouse=True)+def clear_capabilities():+ clear_transport_capability_cache()+++def render(record):+ value = record["content"]+ return json.dumps(value, separators=(",", ":")) if isinstance(value, dict) else value+++def transport(prompt, prefix, records=(), **kwargs):+ return LiteLLMTransport(model=kwargs.pop("model", "openai/test"), messages=prompt, kwargs={+ "a0_api_mode": "responses", "responses_state": "local",+ "a0_responses_function_tools": TOOLS,+ "responses_history_context": {+ "prompt": prompt, "prefix": prefix,+ "groups": history.prepare_groups(list(records), render, lambda text: text),+ }, **kwargs,+ })+++def completed_call(source, call_id="call_1", name="lookup"):+ request = source._responses_request(stream=False)+ return source._llm_result_from_response({"id": "resp_1", "output": [+ {"type": "reasoning", "id": "rs_" + call_id, "encrypted_content": "opaque", "summary": []},+ {"type": "function_call", "id": "fc_" + call_id, "call_id": call_id, "name": name, "arguments": '{"q":"a0"}'},+ ]}, request)+++def records_for(result):+ return [+ {"ai": True, "content": result.function_calls_text(), "metadata": result.metadata()},+ {"ai": False, "content": {"tool_name": "lookup", "tool_result": "Found", "file": "/visible/file.txt"}, "metadata": {+ "responses": {"input_items": [{"type": "function_call_output", "call_id": result.function_calls[0].call_id, "output": "DO NOT REPLAY RAW OUTPUT"}]},+ }},+ ]+++def prompt_for(records, base=None):+ return [*(base or BASE), {"role": "assistant", "content": render(records[0])},+ {"role": "user", "content": render(records[1]) + "\nCurrent extras"}]+++def test_native_replay_uses_visible_results_and_retains_current_extras():+ source = transport([BASE[0], {"role": "user", "content": "Question\nOld extras"}], BASE)+ result = completed_call(source)+ records = records_for(result)+ original = deepcopy(records)+ prompt = prompt_for(records)+ replay = transport(prompt, prompt, records)+ request = replay._responses_request(stream=False)+ assert request["input"][:2] == BASE+ assert request["input"][2:4] == [item.to_dict() for item in result.output_items]+ assert request["input"][4] == {"type": "function_call_output", "call_id": "call_1", "output": render(records[1])}+ assert request["input"][5] == {"role": "user", "content": "Current extras"}+ assert "DO NOT REPLAY RAW OUTPUT" not in json.dumps(request)+ assert "Old extras" not in json.dumps(request)+ assert "responses_history_context" not in request+ assert replay._capability_metadata()["native_history_calls"] == 1+ assert records == original+ assert prompt == prompt_for(records)++[email protected]("change", ["summary", "arguments", "missing_output", "wrong_id", "attachments", "commentary", "unencrypted", "legacy", "secret"])+def test_ineligible_history_stays_in_prepared_text(change):+ result = completed_call(transport(BASE, BASE))+ records = records_for(result)+ base = deepcopy(BASE)+ mask = lambda text: text+ if change == "summary":+ base[1]["content"] = "Compressed question"+ elif change == "arguments":+ records[0]["content"] = records[0]["content"].replace('a0', 'MASKED')+ elif change == "missing_output":+ records[1]["metadata"] = {}+ elif change == "wrong_id":+ records[1]["metadata"]["responses"]["input_items"][0]["call_id"] = "other"+ elif change == "attachments":+ records[1]["content"] = [{"type": "input_image", "image_url": "data:image/png;base64,AAAA"}]+ elif change == "commentary":+ records[0]["metadata"]["responses"]["output_items"].append({"type": "message", "content": [{"type": "output_text", "text": "second tool call"}]})+ elif change == "unencrypted":+ records[0]["metadata"]["responses"]["output_items"][0].pop("encrypted_content")+ elif change == "legacy":+ records[0]["metadata"]["responses"]["capability"].pop(history.PREFIX_HASH)+ elif change == "secret":+ mask = lambda text: text.replace("opaque", "MASKED")+ prompt = [*base, {"role": "assistant", "content": render(records[0])}, {"role": "user", "content": render(records[1])}]+ groups = history.prepare_groups(records, render, mask)+ replay = transport(prompt, prompt)+ replay.kwargs["responses_history_context"]["groups"] = groups+ assert replay._responses_request(stream=False)["input"] == prompt+ assert replay.native_history_calls == 0++[email protected]("kwargs", [+ {"model": "openai/other"}, {"api_base": "https://other.invalid"},+ {"a0_responses_function_tools": [{**TOOLS[0], "description": "new policy"}]},+])+def test_replay_is_bound_to_current_model_endpoint_and_tool_scope(kwargs):+ records = records_for(completed_call(transport(BASE, BASE)))+ prompt = prompt_for(records)+ replay = transport(prompt, prompt, records, **kwargs)+ assert replay._responses_request(stream=False)["input"] == prompt+ assert replay.native_history_calls == 0+++def test_final_response_call_without_result_is_never_fabricated():+ result = completed_call(transport(BASE, BASE), name="response")+ assert history.prepare_groups(records_for(result)[:1], render, lambda text: text) == []+++def test_chat_request_drops_replay_control_and_keeps_text_examples():+ records = records_for(completed_call(transport(BASE, BASE)))+ prompt = prompt_for(records)+ replay = transport(prompt, prompt, records, a0_api_mode="chat")+ request = replay._chat_request(stream=False)+ assert request["messages"] == prompt+ assert "responses_history_context" not in request+ assert "tools" not in request+ assert history.PREFIX_HASH not in replay._capability_metadata()+++def test_changed_selected_input_cannot_acquire_a_history_digest():+ replay = transport(BASE, BASE, responses_local_input_items=[{"role": "user", "content": "override"}])+ assert replay._responses_request(stream=False)["input"] == [{"role": "user", "content": "override"}]+ assert history.PREFIX_HASH not in replay._capability_metadata()++[email protected]("duplicate", [False, True])+def test_multiple_groups_preserve_history_order_without_duplicate_native_ids(duplicate):+ first = records_for(completed_call(transport(BASE, BASE)))+ second_prompt = prompt_for(first)+ second_prefix = deepcopy(second_prompt)+ second_prefix[-1]["content"] = render(first[1])+ second = records_for(completed_call(transport(second_prompt, second_prefix, first), call_id="call_1" if duplicate else "call_2"))+ records = first + second+ prompt = [*second_prefix, *prompt_for(second)[len(BASE):]]+ replay = transport(prompt, prompt, records)+ request = replay._responses_request(stream=False)+ calls = [item for item in request["input"] if item.get("type") == "function_call"]+ assert [item["call_id"] for item in calls] == (["call_1"] if duplicate else ["call_1", "call_2"])+ assert replay.native_history_calls == len(calls)+ assert request["input"][-1]["content"].endswith("Current extras")+++def test_masking_failure_disables_native_projection():+ records = records_for(completed_call(transport(BASE, BASE)))+ def unavailable(text):+ raise OSError("masking unavailable")+ assert history.prepare_groups(records, render, unavailable) == []+++async def test_automatic_chat_fallback_keeps_text_and_drops_history_controls(monkeypatch):+ from helpers import litellm_transport+ records = records_for(completed_call(transport(BASE, BASE)))+ prompt = prompt_for(records)+ calls = []+ class BadRequestError(RuntimeError):+ pass+ async def responses(**kwargs):+ calls.append("responses")+ assert any(item.get("type") == "function_call" for item in kwargs["input"])+ assert "responses_history_context" not in kwargs+ raise BadRequestError("Cannot determine type of item")+ async def chat(**kwargs):+ calls.append("chat")+ assert kwargs["messages"] == prompt+ assert "responses_history_context" not in kwargs+ assert "tools" not in kwargs+ return {"choices": [{"message": {"content": "fallback"}}]}+ monkeypatch.setattr(litellm_transport, "aresponses", responses)+ monkeypatch.setattr(litellm_transport, "acompletion", chat)+ replay = transport(prompt, prompt, records)+ await replay.acomplete()+ assert calls == ["responses", "chat"]+ assert history.PREFIX_HASH not in replay.last_result.capability+ assert replay.last_result.mode == "chat_completions"+++def test_tool_result_summary_is_replayed_as_visible_summary_only():+ records = records_for(completed_call(transport(BASE, BASE)))+ records[1]["content"] = "Condensed tool result"+ prompt = prompt_for(records)+ replay = transport(prompt, prompt, records)+ request = replay._responses_request(stream=False)+ output = next(item for item in request["input"] if item.get("type") == "function_call_output")+ assert output["output"] == "Condensed tool result"+ assert "DO NOT REPLAY RAW OUTPUT" not in json.dumps(request)diff --git a/tests/test_stream_tool_early_stop.py b/tests/test_stream_tool_early_stop.pyindex ec356542e..987b52bb8 100644--- a/tests/test_stream_tool_early_stop.py+++ b/tests/test_stream_tool_early_stop.py@@ -1942,3 +1942,37 @@ async def test_interrupted_native_argument_stream_cannot_become_a_text_tool(monkpassassert transport.last_result is Noneassert stream.closed+++def test_stream_metadata_recovers_reasoning_and_partial_terminal_call_lists():+ parser = litellm_transport.ResponsesEventParser()+ reasoning = {"type": "reasoning", "id": "rs_1", "encrypted_content": "encrypted", "summary": []}+ first = {"type": "function_call", "id": "fc_1", "call_id": "call_1", "name": "lookup", "arguments": '{"q":"first"}'}+ second = {"type": "function_call", "id": "fc_2", "call_id": "call_2", "name": "lookup", "arguments": '{"q":"second"}'}+ for index, item in reversed(list(enumerate([reasoning, first, second]))):+ parser.parse({"type": "response.output_item.done", "output_index": index, "item": item})+ parser.parse({"type": "response.completed", "response": {"id": "resp_1", "output": [{**second, "status": "completed"}]}})+ transport = litellm_transport.LiteLLMTransport(model="openai/test", messages=[], kwargs={"a0_api_mode": "responses"})+ result = transport._stream_result_from_parser(parser, {})+ assert [item.to_dict() for item in result.output_items] == [reasoning, first, {**second, "status": "completed"}]+ assert [call.call_id for call in result.function_calls] == ["call_1", "call_2"]+++def test_terminal_reasoning_null_does_not_erase_streamed_ciphertext():+ parser = litellm_transport.ResponsesEventParser()+ reasoning = {"type": "reasoning", "id": "rs_1", "encrypted_content": "encrypted", "summary": []}+ parser.parse({"type": "response.output_item.done", "output_index": 0, "item": reasoning})+ parser.parse({"type": "response.completed", "response": {"output": [{**reasoning, "encrypted_content": None}]}})+ transport = litellm_transport.LiteLLMTransport(model="openai/test", messages=[], kwargs={"a0_api_mode": "responses"})+ result = transport._stream_result_from_parser(parser, {})+ assert [item.to_dict() for item in result.output_items] == [reasoning]+++def test_unidentified_stream_fragment_cannot_duplicate_terminal_call():+ parser = litellm_transport.ResponsesEventParser()+ item = {"type": "function_call", "name": "lookup", "arguments": '{"q":"a0"}'}+ parser.parse({"type": "response.output_item.done", "output_index": 0, "item": item})+ parser.parse({"type": "response.completed", "response": {"output": [item]}})+ transport = litellm_transport.LiteLLMTransport(model="openai/test", messages=[], kwargs={"a0_api_mode": "responses"})+ result = transport._stream_result_from_parser(parser, {})+ assert len(result.function_calls) == 1