{"type": "thinking", "thinking": "...", "signature": ""}

---

{
  "type": "output_text",
  "text": "**THINKING MESSAGE**"
}

---

{
  "input": [
    {
      "content": [
        {
          "text": "Some user message",
          "type": "input_text"
        }
      ],
      "role": "user",
      "type": "message"
    },
    {
      "content": [
        {
          "text": "**THINKING MESSAGE**",
          "type": "output_text"
        },
        {
          "text": "Some other AI message",
          "type": "output_text"
        }
      ],
      "role": "assistant",
      "type": "message"
    },
    {
      "content": [
        {
          "text": "Another user message",
          "type": "input_text"
        }
      ],
      "role": "user",
      "type": "message"
    }
  ],
  "instructions": "Some system prompt",
  "max_output_tokens": 1024,
  "model": "gpt-5.5",
  "reasoning": {
    "effort": "medium",
    "summary": "detailed"
  }
}

---

from __future__ import annotations

import asyncio
import json
from importlib.metadata import version as package_version
from typing import Any

import httpx
import litellm
from litellm import anthropic_messages
from litellm.types.llms.anthropic_messages.anthropic_response import AnthropicResponseThinkingBlock

_CAPTURED_BODY: object | None = None


class CapturedRequestError(RuntimeError):
    """Stops the request after LiteLLM has serialized the OpenAI body."""


async def _request_body(request: httpx.Request) -> bytes:
    try:
        return request.content
    except httpx.RequestNotRead:
        return await request.aread()


def _install_httpx_capture() -> None:
    original_send = httpx.AsyncClient.send

    async def hooked_send(client: httpx.AsyncClient, request: httpx.Request, *args: Any, **kwargs: Any):
        global _CAPTURED_BODY  # noqa: PLW0603 -- script-level capture state
        if request.url.path.rstrip("/").endswith(("/messages", "/responses")):
            body = await _request_body(request)
            try:
                _CAPTURED_BODY = json.loads(body.decode("utf-8", errors="replace"))
            except json.JSONDecodeError:
                _CAPTURED_BODY = body.decode("utf-8", errors="replace")
            raise CapturedRequestError("captured OpenAI /responses request")
        return await original_send(client, request, *args, **kwargs)

    httpx.AsyncClient.send = hooked_send  # ty: ignore[invalid-assignment] -- intentional request capture hook


async def main() -> None:
    litellm.suppress_debug_info = True  # ty: ignore[invalid-assignment] -- litellm annotates this as Literal[False]
    _install_httpx_capture()

    system = "Some system prompt"
    messages = [
        {
            "role": "user",
            "content": "Some user message",
        },
        {
            "role": "assistant",
            "content": [
                # This simulates a response block from a previous call to `anthropic_messages`
                AnthropicResponseThinkingBlock(thinking="**THINKING MESSAGE**", type="thinking"),
                {
                    "type": "text",
                    "text": "Some other AI message",
                },
            ],
        },
        {
            "role": "user",
            "content": "Another user message",
        },
    ]

    print(f"litellm {package_version('litellm')}")

    print("ANTHROPIC MODEL: WORKS -> thinking block is sent as a thinking block")
    global _CAPTURED_BODY  # noqa: PLW0603 -- script-level capture state
    _CAPTURED_BODY = None
    try:
        await anthropic_messages(
            model="anthropic/claude-sonnet-4-6",
            api_key="sk-capture-only",
            system=system,
            messages=messages,
            max_tokens=1024,
            thinking={"type": "enabled", "budget_tokens": 5000, "summary": "detailed"},
        )
    except Exception:
        if _CAPTURED_BODY is None:
            raise
        print(json.dumps(_CAPTURED_BODY, indent=2, sort_keys=True))

    print("GPT MODEL: DOES NOT WORK -> thinking block is sent as a text block instead of OpenAI reasoning block")
    _CAPTURED_BODY = None
    try:
        await anthropic_messages(
            model="openai/gpt-5.5",
            api_key="sk-capture-only",
            system=system,
            messages=messages,
            max_tokens=1024,
            thinking={"type": "enabled", "budget_tokens": 5000, "summary": "detailed"},
        )
    except Exception:
        if _CAPTURED_BODY is None:
            raise
        print(json.dumps(_CAPTURED_BODY, indent=2, sort_keys=True))


if __name__ == "__main__":
    asyncio.run(main())

---