"""Helper function for pretty-printing content strings."""

import json

def _format_tool_call(args_str: str) -> str:

    """Format tool call arguments, extracting command if it's a bash call."""

    try:

        args = json.loads(args_str) if isinstance(args_str, str) else args_str

        if isinstance(args, dict) and "command" in args:

            return f"```\n{args['command']}\n```"

    except Exception:

        pass

    return f"```\n{args_str}\n```"

def _format_observation(content: str) -> str | None:

    """Try to format an observation JSON as key-value pairs."""

    try:

        data = json.loads(content)

        if isinstance(data, dict) and "returncode" in data:

            lines = []

            for key, value in data.items():

                lines.append(f"<{key}>")

                lines.append(str(value))

            return "\n".join(lines)

        return content

    except Exception:

        return content

def get_content_string(message: dict) -> str:

    """Extract text content from any message format for display.

    Handles:

    - Traditional chat: {"content": "text"}

    - Multimodal chat: {"content": [{"type": "text", "text": "..."}]}

    - Observation messages: {"content": "{\"returncode\": 0, \"output\": \"...\"}"}

    - Traditional tool calls: {"tool_calls": [{"function": {"name": "...", "arguments": "..."}}]}

    - Responses API: {"output": [{"type": "message", "content": [...]}]}

    """

    texts = []

    # Extract content (string or multimodal list)

    content = message.get("content")

    if isinstance(content, str):

        texts.append(_format_observation(content))

    elif isinstance(content, list):

        texts.append("\n".join(item.get("text", "") for item in content if isinstance(item, dict)))

    # Handle traditional tool_calls format (OpenAI/LiteLLM style)

    if tool_calls := message.get("tool_calls"):

        for tc in tool_calls:

            func = tc.get("function", {}) if isinstance(tc, dict) else getattr(tc, "function", None)

            if func:

                args = func.get("arguments", "{}") if isinstance(func, dict) else getattr(func, "arguments", "{}")

                texts.append(_format_tool_call(args))

    # Handle Responses API format (output array)

    if output := message.get("output"):

        if isinstance(output, str):

            texts.append(_format_observation(output))

        elif isinstance(output, list):

            for item in output:

                if not isinstance(item, dict):

                    continue

                if item.get("type") == "message":

                    for c in item.get("content", []):

                        if isinstance(c, dict) and (text := c.get("text")):

                            texts.append(text)

                elif item.get("type") == "function_call":

                    texts.append(_format_tool_call(item.get("arguments", "{}")))

    return "\n\n".join(t for t in texts if t)