e27f16365d
A model that declines mid-stream delivers the explanation on the structured refusal channel (chat_completions delta.refusal; Responses response.refusal.delta / refusal content parts) and leaves content empty. The streaming accumulators dropped that channel entirely, so a streamed refusal assembled into an empty message and fell into the empty/invalid-response retry loops - burning paid retries reproducing a deterministic refusal - while the non-streaming path had already fixed this class in #46013. - chat_completions streaming: accumulate delta.refusal (incl. model_extra), expose message.refusal on the assembled mock response so ChatCompletionsTransport.normalize_response applies the existing sole-payload -> content_filter promotion; count refusal deltas in the zero-chunk guard; carry refusal in the Relay final-response dict. - Codex Responses stream consumer: collect response.refusal.delta as answer text so a refusal-only stream no longer raises 'did not emit a terminal response' with zero usable content. - Responses normalizer: read type=refusal content parts in _extract_responses_message_text (attr and dict shapes). Sabotage-verified: each new test fails with its wiring line disabled. E2E: refusal-only stream -> terminal content_filter with explanation; refusal-alongside-content stays a normal usable turn; plain-text streams unchanged.
80 lines
3.6 KiB
Python
80 lines
3.6 KiB
Python
"""Relay-side accumulator for the chat_completions streaming wire.
|
|
|
|
Relay invokes its collector for every post-intercept chunk and then its finalizer as soon
|
|
as the provider stream ends — concurrently with Hermes' consumer thread, which may not have
|
|
read the last chunk yet. The finalizer therefore builds Relay's recorded response from
|
|
collector-observed state only, never from the consumer loop's closures. Sibling of
|
|
``relay_llm.AnthropicStreamAccumulator``; Bedrock and Codex follow the same contract.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from types import SimpleNamespace
|
|
from typing import Any
|
|
|
|
from agent.chat_completion_helpers import _ToolCallAccumulator
|
|
from agent.message_content import flatten_message_text
|
|
from agent.reasoning_summaries import separate_glued_reasoning_blocks
|
|
|
|
|
|
def _tool_call_delta_view(tc_delta: Any) -> Any:
|
|
"""Attribute view of a JSON tool-call delta for ``_ToolCallAccumulator.feed`` (written
|
|
against SDK objects). Only ``function`` is wrapped: ``feed`` passes ``extra_content``
|
|
(a dict) straight through ``_dump_if_model``, so a recursive view would corrupt it."""
|
|
if not isinstance(tc_delta, dict):
|
|
return tc_delta
|
|
function = tc_delta.get("function")
|
|
return SimpleNamespace(**{**tc_delta,
|
|
"function": SimpleNamespace(**function) if isinstance(function, dict) else function})
|
|
|
|
|
|
class RelayChatAccumulator:
|
|
"""Rebuild a chat.completion from Relay's post-intercept chunk dicts."""
|
|
|
|
def __init__(self) -> None:
|
|
self._content: list[str] = []
|
|
self._reasoning: list[str] = []
|
|
self._refusal: list[str] = [] # OpenAI ``delta.refusal`` — a refusal is content, not an empty stream
|
|
self._tool_calls = _ToolCallAccumulator()
|
|
self._model = self._usage = self._finish_reason = None
|
|
self._role = "assistant"
|
|
|
|
def observe(self, chunk: Any) -> None:
|
|
if not isinstance(chunk, dict):
|
|
return
|
|
self._model = chunk.get("model") or self._model
|
|
if chunk.get("usage"):
|
|
self._usage = chunk["usage"]
|
|
choices = chunk.get("choices") or []
|
|
choice = choices[0] if choices else None # Hermes never requests n>1
|
|
if not isinstance(choice, dict):
|
|
return
|
|
self._finish_reason = choice.get("finish_reason") or self._finish_reason
|
|
delta = choice.get("delta")
|
|
if not isinstance(delta, dict):
|
|
return
|
|
if delta.get("role"):
|
|
self._role = delta["role"]
|
|
text = flatten_message_text(delta.get("content"), sep="")
|
|
if text:
|
|
self._content.append(text)
|
|
reasoning = delta.get("reasoning_content") or delta.get("reasoning")
|
|
if reasoning:
|
|
self._reasoning.append(separate_glued_reasoning_blocks(
|
|
self._reasoning[-1] if self._reasoning else "", reasoning))
|
|
refusal = delta.get("refusal")
|
|
if isinstance(refusal, str) and refusal:
|
|
self._refusal.append(refusal)
|
|
for tc_delta in delta.get("tool_calls") or []:
|
|
self._tool_calls.feed(_tool_call_delta_view(tc_delta))
|
|
|
|
def finalize(self) -> dict[str, Any]:
|
|
acc = self._tool_calls.materialize()
|
|
message = {"role": self._role, "content": "".join(self._content) or None,
|
|
"reasoning_content": "".join(self._reasoning) or None,
|
|
"refusal": "".join(self._refusal) or None,
|
|
"tool_calls": [acc[i] for i in sorted(acc)] or None}
|
|
# "stop" also covers Nous Portal ``lastOne`` usage frames, which carry no finish_reason.
|
|
return {"model": self._model, "usage": self._usage,
|
|
"choices": [{"message": message, "finish_reason": self._finish_reason or "stop"}]}
|