def read_file(path: str, start_line: int = 1, limit: int = 200) -> str:
    try:
        target = safe_path(path)
        if not target.exists():
            return f"Error: file does not exist - {path}"
        if not target.is_file():
            return f"Error: path is not a file - {path}"

        lines = target.read_text(encoding="utf-8").splitlines()
        start = max(1, start_line)
        end = min(len(lines), start + limit - 1)

        selected = lines[start - 1 : end]
        rendered = [f"{line_no}: {line}" for line_no, line in enumerate(selected, start)]

        if end < len(lines):
            rendered.append(f"... ({len(lines) - end} more lines)")

        return "\n".join(rendered)[:50000]
    except Exception as exc:
        return f"Error: {exc}"

MAX_TOOL_OUTPUT_CHARS = 50000


def trim_tool_output(output: str) -> str:
    if len(output) <= MAX_TOOL_OUTPUT_CHARS:
        return output

    head = output[:20000]
    tail = output[-8000:]
    omitted = len(output) - len(head) - len(tail)

    return f"""
{head}

... ({omitted} characters omitted) ...

{tail}
""".strip()

import hashlib
from dataclasses import dataclass, field
from typing import Any


@dataclass
class ContextState:
    summary: str = ""
    tool_artifacts: dict[str, str] = field(default_factory=dict)
    token_budget: int = 24000
    recent_messages_to_keep: int = 12

def compact_tool_message(
    message: dict[str, Any],
    state: ContextState,
    limit: int = 3000,
) -> dict[str, Any]:
    if message.get("role") != "tool":
        return message

    content = str(message.get("content") or "")
    if len(content) <= limit:
        return message

    digest = hashlib.sha256(content.encode("utf-8")).hexdigest()[:12]
    artifact_id = f"tool-result-{digest}"
    state.tool_artifacts[artifact_id] = content

    compacted = f"""
[large tool result compacted]
artifact_id: {artifact_id}
original_chars: {len(content)}
sha256: {digest}

head:
{content[:1200]}

tail:
{content[-800:]}
""".strip()

    return {**message, "content": compacted}

def estimate_tokens(text: str) -> int:
    return max(1, len(text) // 4)


def message_to_text(message: dict[str, Any]) -> str:
    parts = [
        f"role: {message.get('role')}",
        f"content: {message.get('content') or ''}",
    ]

    if message.get("tool_calls"):
        parts.append(f"tool_calls: {message['tool_calls']}")

    return "\n".join(parts)


def estimate_messages_tokens(messages: list[dict[str, Any]]) -> int:
    return sum(estimate_tokens(message_to_text(message)) for message in messages)

context_state = ContextState(
    token_budget=24000,
    recent_messages_to_keep=12,
)

SUMMARY_PROMPT = """
你负责压缩 Agent Harness 的历史上下文。

请保留：
1. 用户当前目标和明确要求；
2. 已经完成的重要步骤；
3. 当前仍然有效的约束；
4. 修改过、读取过、需要继续关注的文件；
5. 工具调用得到的关键结论；
6. 失败过的命令、错误原因和已排除路径；
7. 当前 Todo 状态和下一步建议。

请丢弃：
1. 大段原始工具输出；
2. 重复日志；
3. 已经失效的中间尝试；
4. 和当前任务无关的细节。
"""


def update_context_summary(
    state: ContextState,
    old_messages: list[dict[str, Any]],
) -> None:
    payload = {
        "existing_summary": state.summary,
        "old_messages": old_messages,
    }

    response = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": SUMMARY_PROMPT},
            {
                "role": "user",
                "content": json.dumps(payload, ensure_ascii=False, indent=2),
            },
        ],
    )

    summary = response.choices[0].message.content or ""
    state.summary = summary.strip()[:8000]

def split_for_compaction(
    messages: list[dict[str, Any]],
    keep_recent: int,
) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
    if len(messages) <= keep_recent:
        return [], messages

    cutoff = len(messages) - keep_recent
    return messages[:cutoff], messages[cutoff:]


def compact_messages_if_needed(
    messages: list[dict[str, Any]],
    state: ContextState,
) -> list[dict[str, Any]]:
    compacted = [compact_tool_message(message, state) for message in messages]

    if estimate_messages_tokens(compacted) <= state.token_budget:
        return compacted

    old_messages, recent_messages = split_for_compaction(
        compacted,
        keep_recent=state.recent_messages_to_keep,
    )

    if old_messages:
        update_context_summary(state, old_messages)

    return recent_messages

def build_model_messages(
    messages: list[dict[str, Any]],
    state: ContextState,
) -> list[dict[str, Any]]:
    working_messages = compact_messages_if_needed(messages, state)

    model_messages = [{"role": "system", "content": SYSTEM_PROMPT}]

    if state.summary:
        model_messages.append(
            {
                "role": "system",
                "content": f"下面是被压缩的历史上下文摘要：\n{state.summary}",
            }
        )

    model_messages.extend(working_messages)
    return model_messages

def run_loop(user_message: str, max_steps: int = 8) -> str:
    messages: list[dict[str, Any]] = [{"role": "user", "content": user_message}]
    state = ContextState(token_budget=24000, recent_messages_to_keep=12)

    for step in range(max_steps):
        response = client.chat.completions.create(
            model=MODEL,
            messages=build_model_messages(messages, state),
            tools=TOOLS,
        )

        # 后面的工具调用处理逻辑继续沿用前几篇

def hard_compact_messages(
    messages: list[dict[str, Any]],
    state: ContextState,
) -> list[dict[str, Any]]:
    if not messages:
        return []

    old_messages, recent_messages = split_for_compaction(messages, keep_recent=6)
    if old_messages:
        update_context_summary(state, old_messages)

    latest_user = next(
        (message for message in reversed(messages) if message.get("role") == "user"),
        None,
    )

    if latest_user and latest_user not in recent_messages:
        return [latest_user] + recent_messages

    return recent_messages