先看那张"模型→窗口大小"的静态表和两个常量（llm.py:168 与 llm.py:325）：

# llm.py:168
LLM_CONTEXT_WINDOW_SIZES: Final[dict[str, int]] = {
    "gpt-4": 8192,
    "gpt-4o": 128000,
    "gpt-4o-mini": 200000,
    "gpt-4.1": 1047576,          # 官方文档值
    "o1-preview": 128000,
    "o3-mini": 200000,
    ...
    "mistral/mistral-large-latest": 32768,
}

# llm.py:325
DEFAULT_CONTEXT_WINDOW_SIZE: Final[int] = 8192     # 不认识的模型给个保守下限
CONTEXT_WINDOW_USAGE_RATIO: Final[float] = 0.85    # ★只用 85%，留 15% 余量

把表和系数结合起来算出实际可用窗口（llm.py:2443）：

# llm.py:2443
def get_context_window_size(self) -> int:
    """Returns 75% of the maximum to avoid cutting off messages mid-thread."""
    if self.context_window_size != 0:
        return self.context_window_size        # ★已算过 → 直接返回缓存
    min_context = 1024
    max_context = 2097152                       # gemini-1.5-pro 的上限
    for key, value in LLM_CONTEXT_WINDOW_SIZES.items():
        if value < min_context or value > max_context:
            raise ValueError(f"Context window for {key} must be between ...")  # 表自检
    self.context_window_size = int(DEFAULT_CONTEXT_WINDOW_SIZE * CONTEXT_WINDOW_USAGE_RATIO)
    for key, value in LLM_CONTEXT_WINDOW_SIZES.items():
        if self.model.startswith(key):          # ★前缀匹配模型名
            self.context_window_size = int(value * CONTEXT_WINDOW_USAGE_RATIO)
    return self.context_window_size

真超长时各家 API 报错文案五花八门，用一张关键词表统一识别（utilities/exceptions/context_window_exceeding_exception.py）：

# context_window_exceeding_exception.py
CONTEXT_LIMIT_ERRORS: Final[list[str]] = [
    "expected a string with maximum length",
    "maximum context length",
    "context length exceeded",
    "context_length_exceeded",
    "context window full",
    "too many tokens",
    "input is too long",
    "exceeds token limit",
]

class LLMContextLengthExceededError(Exception):
    @staticmethod
    def _is_context_limit_error(error_message: str) -> bool:
        return any(phrase.lower() in error_message.lower()
                   for phrase in CONTEXT_LIMIT_ERRORS)   # ★任一关键词命中就算超长

上层用一个薄封装调它（utilities/agent_utils.py:698）：

# agent_utils.py:698
def is_context_length_exceeded(exception: Exception) -> bool:
    return LLMContextLengthExceededError(str(exception))._is_context_limit_error(str(exception))

认出超长后，按用户配置的 respect_context_window 分流（utilities/agent_utils.py:712）：

# agent_utils.py:712
def handle_context_length(respect_context_window, printer, messages, llm, callbacks, verbose=True):
    """Handle context length exceeded by either summarizing or raising an error."""
    if respect_context_window:                       # ① 用户允许自动处理
        if verbose:
            printer.print("Context length exceeded. Summarizing content to fit ...", color="yellow")
        summarize_messages(messages=messages, llm=llm, callbacks=callbacks, verbose=verbose)  # 压缩
    else:                                            # ② 用户不允许
        if verbose:
            printer.print("Context length exceeded. Consider ... RAG tools ...", color="red")
        raise SystemExit(                            # ★直接退出，不硬撞
            "Context length exceeded and user opted not to summarize. "
            "Consider using smaller text or RAG tools from crewai_tools.")

压缩的核心思路是"切成小块、各自摘要、拼回去"（utilities/agent_utils.py:920，配合辅助函数）：

# agent_utils.py:752 —— token 估算（保守启发式）
def _estimate_token_count(text: str) -> int:
    return len(text) // 4                    # ★经验值：约 4 个字符 ≈ 1 token

# agent_utils.py:819 —— 按消息边界切块
def _split_messages_into_chunks(messages, max_tokens):
    non_system = [m for m in messages if m.get("role") != "system"]   # system 不参与切块
    chunks, current_chunk, current_tokens = [], [], 0
    for msg in non_system:
        msg_tokens = _estimate_token_count(str(msg.get("content") or ""))
        if current_chunk and (current_tokens + msg_tokens) > max_tokens:
            chunks.append(current_chunk); current_chunk = []; current_tokens = 0  # 满了另起一块
        current_chunk.append(msg); current_tokens += msg_tokens
    if current_chunk: chunks.append(current_chunk)
    return chunks

# agent_utils.py:867 —— 从模型输出里抠摘要
def _extract_summary_tags(text: str) -> str:
    match = re.search(r"<summary>(.*?)</summary>", text, re.DOTALL)
    return match.group(1).strip() if match else text   # 有标签取标签内，否则取全文

回到 Day 08 的执行循环，超长处理就挂在 except 里（agents/crew_agent_executor.py:447）：

# crew_agent_executor.py:447（文本 ReAct 循环的异常分支）
if is_context_length_exceeded(e):                 # ① 认出是超长错误
    handle_context_length(                        # ② 分流：压缩 or 报错
        respect_context_window=self.respect_context_window,
        printer=self._printer,
        messages=self.messages,                   # 把当前对话历史传进去
        llm=self.llm,
        callbacks=self.callbacks,
    )
    continue                                      # ③ ★压缩完 continue，接着转下一圈

原生工具调用循环里也有对称的一处（crew_agent_executor.py:582），逻辑相同。