| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475 |
- """Boundary repair for providers that stream reasoning as discrete summary parts.
- Reasoning-summary models (OpenAI gpt-5.x and Responses-API relays onto the chat wire) emit one
- ``reasoning_content`` delta per *completed* summary part, each opening with a bold heading.
- The chat wire lacks the Responses API's ``summary_index`` delimiter (verified live on Nous
- Portal ``openai/gpt-5.6-sol``), so plain concatenation glues ``**One****Two**`` into one
- half-bold paragraph. The boundary is re-derived from a delta opening a bold heading, matching
- the blank-line join Hermes' own Responses adapter does.
- """
- from __future__ import annotations
- from typing import Any
- from agent.message_content import flatten_message_text
- __all__ = ["append_streamed_reasoning_detail", "separate_glued_reasoning_blocks"]
- def separate_glued_reasoning_blocks(previous: str, delta: Any) -> str:
- """Return *delta*, prefixed with a paragraph break when it glues onto *previous*.
- A break is inserted when *delta* opens a *closed* bold heading and *previous* is mid-line
- (heading butting heading, or prose butting heading). Token-streamed reasoning is left
- alone: its deltas carry their own whitespace, and a fragment that merely opens emphasis
- (``**`` alone) is not a part boundary — summary parts carry the whole heading in one delta.
- """
- # Relays also emit content-part lists/dicts; fragments carry their own whitespace.
- delta = flatten_message_text(delta, sep="")
- glued = previous and delta and not previous[-1].isspace() and delta.startswith("**") and "**" in delta[2:]
- return f"\n\n{delta}" if glued else delta
- # reasoning_details entry types whose consecutive fragments are ONE logical block.
- _MERGEABLE_DETAIL_TEXT_KEYS = {"reasoning.text": "text", "reasoning.summary": "summary"}
- _BACKFILL_DETAIL_KEYS = ("signature", "id", "format", "index")
- def streamed_reasoning_detail_text(detail: Any) -> str:
- """Readable text from a detail delta; never expose opaque replay material."""
- dtype = detail.get("type") if isinstance(detail, dict) else getattr(detail, "type", None)
- key = _MERGEABLE_DETAIL_TEXT_KEYS.get(dtype) if isinstance(dtype, str) else None
- if key is None:
- return ""
- text = detail.get(key) if isinstance(detail, dict) else getattr(detail, key, None)
- return text if isinstance(text, str) else ""
- def append_streamed_reasoning_detail(details_acc: list, detail: Any) -> None:
- """Accumulate one streamed ``reasoning_details`` delta entry into *details_acc*.
- OpenRouter streams ``reasoning_details`` as word-level deltas: consecutive
- ``reasoning.text`` / ``reasoning.summary`` entries are fragments of one logical
- block and are merged (later fragments backfill ``signature``/``id`` the first
- omitted); encrypted/opaque entries stay discrete. Unmerged, a long thought
- replays as hundreds of one-word entries and providers that validate the
- sequence shape on the next turn reject it. SDK objects are normalized to dicts.
- """
- if not isinstance(detail, dict):
- if hasattr(detail, "model_dump"):
- detail = detail.model_dump(warnings=False)
- elif hasattr(detail, "__dict__"):
- detail = dict(detail.__dict__)
- else:
- return
- dtype = detail.get("type")
- merge_key = _MERGEABLE_DETAIL_TEXT_KEYS.get(dtype)
- last = details_acc[-1] if details_acc else None
- if last is not None and merge_key and last.get("type") == dtype and isinstance(detail.get(merge_key), str):
- last[merge_key] = (last.get(merge_key) or "") + detail[merge_key]
- for k in _BACKFILL_DETAIL_KEYS:
- if last.get(k) in (None, "") and detail.get(k) not in (None, ""):
- last[k] = detail[k]
- return
- details_acc.append(dict(detail))
|