Function _split_body_if_oversized

tools/adapters/codex.py:275–322

If body exceeds cap, return (head, overflow). Otherwise (body, None). Two-stage split: 1. Walk `## ` section boundaries (skipping headings inside fenced code blocks); accumulate sections into `head` while we fit. 2. If `head` itself still exceeds cap (e.g. the H1 + intro is alrea

(body: str, cap_bytes: int)

def _split_body_if_oversized(body: str, cap_bytes: int) -> tuple[str, str | None]:
    """If body exceeds cap, return (head, overflow). Otherwise (body, None).

    Two-stage split:
    1. Walk `## ` section boundaries (skipping headings inside fenced code blocks);
       accumulate sections into `head` while we fit.
    2. If `head` itself still exceeds cap (e.g. the H1 + intro is already huge), hard-cut
       at a UTF-8 codepoint boundary (preferring a newline) to guarantee output ≤ cap
       without dropping multibyte chars.

    The pointer note appended to `head` is accounted for in the effective cap.
    """
    encoded = body.encode("utf-8")
    if len(encoded) <= cap_bytes:
        return body, None

    # Reserve room for the pointer note we'll append.
    effective_cap = cap_bytes - _POINTER_BYTES

    # _split_body_fence_aware returns sections WITH the leading `## ` already in place
    # for every section after the first; the first section is the pre-heading head.
    # Joining is just `head + "\n" + section` (no re-prepend of `## `).
    sections = _split_body_fence_aware(body) if body else [body]
    head = sections[0] if sections else body
    overflow_parts: list[str] = []
    running = head
    for section in sections[1:]:
        candidate = running.rstrip("\n") + "\n\n" + section
        if len(candidate.encode("utf-8")) > effective_cap:
            overflow_parts.append(section)
        else:
            running = candidate

    # If running is still over cap (the head/H1 intro itself is too big), UTF-8-safe hard cut.
    if len(running.encode("utf-8")) > effective_cap:
        running_encoded = running.encode("utf-8")
        head_bytes, tail_bytes = _utf8_safe_cut(running_encoded, effective_cap)
        truncated_overflow = tail_bytes.decode("utf-8")
        overflow_parts.insert(0, truncated_overflow.lstrip("\n"))
        running = head_bytes.decode("utf-8")

    if not overflow_parts:
        # Edge case: hit the cap exactly. Fall back to a UTF-8-safe hard cut.
        head_bytes, tail_bytes = _utf8_safe_cut(encoded, effective_cap)
        running = head_bytes.decode("utf-8")
        overflow_parts = [tail_bytes.decode("utf-8")]

    return running + _POINTER, "\n".join(overflow_parts)


# ── Adapter ──────────────────────────────────────────────────────────────────