Свой middleware: хуки, прыжки и своё состояние | Курс LangChain урок 16

"""Общая сборка модели для примеров урока 16.

Тот же модуль, что course_model.py прежних уроков, без изменений. У build_model есть
необязательный первый аргумент с именем модели, а рядом лежит gateway_kwargs()
для примеров, которые собирают модель сами.

Файл .env берётся тот же, что в уроке 0. Положите его рядом с этой папкой или
выше по дереву: load_dotenv() ищет файл начиная с папки этого модуля и поднимается
вверх.
"""

import os

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model

load_dotenv()


def gateway_kwargs():
    """Возвращает аргументы доступа к провайдеру: имя, адрес, ключ.

    Нужны примерам, которые вызывают init_chat_model сами. У настраиваемой модели
    имени модели при создании нет, поэтому build_model ей не подходит.
    """
    base_url = os.getenv("MODEL_BASE_URL")

    if base_url:
        return {
            "model_provider": "openai",
            "base_url": base_url,
            "api_key": os.environ["OPENAI_API_KEY"],
        }

    return {}


def build_model(model_name=None, **kwargs):
    """Собирает модель курса.

    model_name без значения означает модель из переменной MODEL_NAME. Явное имя
    нужно примерам, где моделей в приложении больше одной.

    Все именованные аргументы уходят в init_chat_model как есть: temperature,
    max_tokens, timeout, max_retries, rate_limiter, profile и прочее из раздела
    Parameters.
    """
    model_name = model_name or os.environ["MODEL_NAME"]
    access = gateway_kwargs()

    if access:
        # Путь для любого адреса, совместимого с OpenAI Chat Completions API.
        return init_chat_model(model=model_name, **access, **kwargs)

    # Путь напрямую к провайдеру.
    return init_chat_model(model_name, **kwargs)

"""Пример 1 урока 16: свой middleware двумя декораторами.

Хук-узел before_model считает вызовы модели и печатает, сколько сообщений
истории она получает. Хук-обёртка wrap_tool_call охватывает вызов инструмента:
замеряет время и печатает имя вместе с аргументами.

Обе функции становятся middleware и уходят в create_agent обычным
списком middleware.
"""

import time
from collections.abc import Callable

from langchain.agents import create_agent
from langchain.agents.middleware import (
    AgentState,
    ToolCallRequest,
    before_model,
    wrap_tool_call,
)
from langchain.messages import ToolMessage
from langgraph.runtime import Runtime
from langgraph.types import Command

from course_model import build_model

MODULES = {
    "/src/reports": 7305,
    "/src/billing": 2140,
    "/src/auth": 860,
}

turns = {"count": 0}


def module_size(path: str) -> str:
    """Возвращает число строк модуля репозитория по пути."""
    lines = MODULES.get(path)
    if lines is None:
        return f"модуля {path} в репозитории нет"
    return f"{path}: {lines} строк"


@before_model
def count_turns(state: AgentState, runtime: Runtime) -> dict | None:
    """Перед вызовом модели печатает его номер и длину истории."""
    turns["count"] += 1
    print(
        f"[before_model] вызов модели {turns['count']}, "
        f"сообщений в истории: {len(state['messages'])}"
    )
    return None


@wrap_tool_call
def time_tool(
    request: ToolCallRequest,
    handler: Callable[[ToolCallRequest], ToolMessage | Command],
) -> ToolMessage | Command:
    """Замеряет время вызова инструмента и печатает имя с аргументами."""
    started = time.perf_counter()
    result = handler(request)
    spent_ms = (time.perf_counter() - started) * 1000
    print(
        f"[wrap_tool_call] {request.tool_call['name']}"
        f"({request.tool_call['args']}) за {spent_ms:.1f} мс"
    )
    return result


agent = create_agent(
    model=build_model(temperature=0, max_tokens=256),
    tools=[module_size],
    system_prompt=(
        "Вы помощник по разбору легаси. Размеры модулей узнавайте инструментом. "
        "Отвечайте по-русски одной фразой."
    ),
    middleware=[count_turns, time_tool],
)

result = agent.invoke(
    {
        "messages": [
            {
                "role": "user",
                "content": "Что больше по числу строк, /src/reports или /src/auth?",
            }
        ]
    }
)

print()
print("имя middleware у декоратора:", count_turns.name, "и", time_tool.name)
print("ответ:", result["messages"][-1].text)

# Вывод:
# [before_model] вызов модели 1, сообщений в истории: 1
# [wrap_tool_call] module_size({'path': '/src/reports'}) за 0.4 мс
# [wrap_tool_call] module_size({'path': '/src/auth'}) за 0.3 мс
# [before_model] вызов модели 2, сообщений в истории: 4
#
# имя middleware у декоратора: count_turns и time_tool
# ответ: Модуль `/src/reports` (7305 строк) значительно больше модуля `/src/auth` (860 строк).

"""Пример 2 урока 16: один класс со всеми шестью хуками.

Middleware ничего не меняет, он только записывает в журнал каждое своё срабатывание.
По журналу видно, какие хуки срабатывают один раз за запуск, какие при каждом
вызове модели и как обёртки охватывают вызовы изнутри.

Внизу печатаются узлы собранного графа: хуки-узлы там есть, хуки-обёртки нет.
"""

from collections.abc import Callable

from langchain.agents import create_agent
from langchain.agents.middleware import (
    AgentMiddleware,
    AgentState,
    ModelRequest,
    ModelResponse,
    ToolCallRequest,
)
from langchain.messages import ToolMessage
from langgraph.runtime import Runtime
from langgraph.types import Command

from course_model import build_model

OWNERS = {"/src/reports": "нет", "/src/billing": "Ирина", "/src/auth": "Павел"}


def module_owner(path: str) -> str:
    """Возвращает владельца модуля репозитория по пути."""
    return f"{path}: владелец {OWNERS.get(path, 'неизвестен')}"


class AuditMiddleware(AgentMiddleware):
    """Пишет строку журнала на каждое срабатывание своих хуков."""

    def __init__(self) -> None:
        super().__init__()
        self.journal: list[str] = []

    def before_agent(self, state: AgentState, runtime: Runtime) -> dict | None:
        self.journal.append("before_agent")
        return None

    def before_model(self, state: AgentState, runtime: Runtime) -> dict | None:
        self.journal.append(f"before_model, сообщений {len(state['messages'])}")
        return None

    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ModelResponse:
        self.journal.append(f"wrap_model_call: вход, инструментов {len(request.tools)}")
        response = handler(request)
        self.journal.append(f"wrap_model_call: выход, сообщений {len(response.result)}")
        return response

    def wrap_tool_call(
        self,
        request: ToolCallRequest,
        handler: Callable[[ToolCallRequest], ToolMessage | Command],
    ) -> ToolMessage | Command:
        name = request.tool_call["name"]
        self.journal.append(f"wrap_tool_call: вход, {name}")
        result = handler(request)
        self.journal.append(f"wrap_tool_call: выход, {name}")
        return result

    def after_model(self, state: AgentState, runtime: Runtime) -> dict | None:
        last = state["messages"][-1]
        calls = len(getattr(last, "tool_calls", []) or [])
        self.journal.append(f"after_model, запрошено вызовов инструмента {calls}")
        return None

    def after_agent(self, state: AgentState, runtime: Runtime) -> dict | None:
        self.journal.append("after_agent")
        return None


audit = AuditMiddleware()

agent = create_agent(
    model=build_model(temperature=0, max_tokens=256),
    tools=[module_owner],
    system_prompt=(
        "Вы помощник по разбору легаси. Владельцев узнавайте инструментом. "
        "Отвечайте по-русски одной фразой."
    ),
    middleware=[audit],
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Кто владелец модуля /src/billing?"}]}
)

print("ЖУРНАЛ MIDDLEWARE")
for number, line in enumerate(audit.journal, start=1):
    print(f"  {number:>2}. {line}")

print()
print("узлы собранного графа:")
for node in agent.get_graph().nodes:
    print(f"  {node}")

print()
print("ответ:", result["messages"][-1].text)

# Вывод:
# ЖУРНАЛ MIDDLEWARE
#    1. before_agent
#    2. before_model, сообщений 1
#    3. wrap_model_call: вход, инструментов 1
#    4. wrap_model_call: выход, сообщений 1
#    5. after_model, запрошено вызовов инструмента 1
#    6. wrap_tool_call: вход, module_owner
#    7. wrap_tool_call: выход, module_owner
#    8. before_model, сообщений 3
#    9. wrap_model_call: вход, инструментов 1
#   10. wrap_model_call: выход, сообщений 1
#   11. after_model, запрошено вызовов инструмента 0
#   12. after_agent
#
# узлы собранного графа:
#   __start__
#   model
#   tools
#   AuditMiddleware.before_agent
#   AuditMiddleware.before_model
#   AuditMiddleware.after_model
#   AuditMiddleware.after_agent
#   __end__
#
# ответ: Владелец модуля `/src/billing` — Ирина.

"""Пример 3 урока 16: своё поле состояния у middleware.

Middleware объявляет подкласс AgentState с двумя своими полями и ставит его
атрибутом state_schema. Поля хранятся в состоянии агента наравне с messages:
их можно передать при вызове, прочитать в хуке и увидеть в результате.

Печать показывает, какие поля попали в результат: поля jump_to среди них нет.
"""

from typing_extensions import NotRequired

from langchain.agents import create_agent
from langchain.agents.middleware import AgentMiddleware, AgentState
from langgraph.runtime import Runtime

from course_model import build_model

TESTS = {"/src/reports": 0, "/src/billing": 41, "/src/auth": 12}


def module_tests(path: str) -> str:
    """Возвращает число тестов модуля репозитория по пути."""
    count = TESTS.get(path)
    if count is None:
        return f"модуля {path} в репозитории нет"
    return f"{path}: тестов {count}"


class BudgetState(AgentState):
    """Состояние агента плюс два счётчика middleware."""

    model_calls: NotRequired[int]
    tool_calls: NotRequired[int]


class BudgetMiddleware(AgentMiddleware[BudgetState]):
    """Считает вызовы модели и запрошенные ею вызовы инструментов."""

    state_schema = BudgetState

    def before_model(self, state: BudgetState, runtime: Runtime) -> dict | None:
        print(
            f"[before_model] сделано вызовов модели: {state.get('model_calls', 0)}, "
            f"заказано вызовов инструмента: {state.get('tool_calls', 0)}"
        )
        return None

    def after_model(self, state: BudgetState, runtime: Runtime) -> dict | None:
        last = state["messages"][-1]
        return {
            "model_calls": state.get("model_calls", 0) + 1,
            "tool_calls": state.get("tool_calls", 0)
            + len(getattr(last, "tool_calls", []) or []),
        }


agent = create_agent(
    model=build_model(temperature=0, max_tokens=256),
    tools=[module_tests],
    system_prompt=(
        "Вы помощник по разбору легаси. Число тестов узнавайте инструментом, "
        "по одному модулю за вызов. Отвечайте по-русски одной фразой."
    ),
    middleware=[BudgetMiddleware()],
)

result = agent.invoke(
    {
        "messages": [
            {
                "role": "user",
                "content": "Сколько тестов в /src/reports и сколько в /src/auth?",
            }
        ],
        "model_calls": 0,
        "tool_calls": 0,
    }
)

print()
print("поля результата:", ", ".join(sorted(result)))
print("вызовов модели:", result["model_calls"])
print("вызовов инструмента:", result["tool_calls"])
print("ответ:", result["messages"][-1].text)

# Вывод:
# [before_model] сделано вызовов модели: 0, заказано вызовов инструмента: 0
# [before_model] сделано вызовов модели: 1, заказано вызовов инструмента: 2
#
# поля результата: messages, model_calls, tool_calls
# вызовов модели: 2
# вызовов инструмента: 2
# ответ: В `/src/reports` тестов 0, а в `/src/auth` — 12.
# (формулировка ответа меняется от запуска к запуску, у читателя она может быть другой)

"""Пример 4 урока 16: прыжок к концу запуска и прыжок без объявления.

Middleware считает вызовы модели и после первого вызова возвращает
jump_to="end". Один и тот же код запускается дважды: в первом middleware хук
помечен hook_config(can_jump_to=["end"]), во втором пометки нет.

Пометка задаёт условное ребро в графе. Без неё узел соединён обычным ребром,
и jump_to из before_model никто не читает.
"""

from typing_extensions import NotRequired

from langchain.agents import create_agent
from langchain.agents.middleware import AgentMiddleware, AgentState, hook_config
from langchain.messages import AIMessage
from langgraph.runtime import Runtime

from course_model import build_model

OWNERS = {
    "/src/reports": "нет",
    "/src/billing": "Ирина",
    "/src/auth": "Павел",
    "/src/gateway": "Сергей",
}


def module_owner(path: str) -> str:
    """Возвращает владельца модуля репозитория по пути."""
    return f"{path}: владелец {OWNERS.get(path, 'неизвестен')}"


class TurnState(AgentState):
    """Состояние агента плюс счётчик вызовов модели."""

    turns: NotRequired[int]


class TurnLimitMiddleware(AgentMiddleware[TurnState]):
    """Завершает запуск после заданного числа вызовов модели."""

    state_schema = TurnState

    def __init__(self, max_turns: int) -> None:
        super().__init__()
        self.max_turns = max_turns

    def _verdict(self, state: TurnState) -> dict | None:
        """Общее тело хука: решение об остановке по числу сделанных вызовов модели."""
        if state.get("turns", 0) >= self.max_turns:
            print(f"  [{self.name}] запрошен прыжок к концу запуска")
            return {
                "messages": [
                    AIMessage("Лимит вызовов модели исчерпан, отвечаю тем, что успел собрать.")
                ],
                "jump_to": "end",
            }
        return None

    @hook_config(can_jump_to=["end"])
    def before_model(self, state: TurnState, runtime: Runtime) -> dict | None:
        return self._verdict(state)

    def after_model(self, state: TurnState, runtime: Runtime) -> dict | None:
        return {"turns": state.get("turns", 0) + 1}


class SilentTurnLimitMiddleware(TurnLimitMiddleware):
    """Тот же middleware, у которого хук не объявил, что умеет прыгать."""

    def before_model(self, state: TurnState, runtime: Runtime) -> dict | None:
        return self._verdict(state)


QUESTION = (
    "Назовите владельцев модулей /src/reports, /src/billing, /src/auth и "
    "/src/gateway."
)

model = build_model(temperature=0, max_tokens=256)


def run(label: str, layer: AgentMiddleware) -> None:
    """Запускает агента с одним middleware и печатает, чем кончился запуск."""
    agent = create_agent(
        model=model,
        tools=[module_owner],
        system_prompt=(
            "Вы помощник по разбору легаси. Владельцев узнавайте инструментом. "
            "Отвечайте по-русски одной фразой."
        ),
        middleware=[layer],
    )
    print(label)
    for edge in agent.get_graph().edges:
        if edge.source.endswith(".before_model"):
            kind = "условное" if edge.conditional else "обычное"
            print(f"  ребро {kind}: {edge.source} -> {edge.target}")

    result = agent.invoke({"messages": [{"role": "user", "content": QUESTION}], "turns": 0})
    ai = sum(1 for message in result["messages"] if message.type == "ai")
    tools = sum(1 for message in result["messages"] if message.type == "tool")
    print(f"  записано вызовов модели: {result['turns']}")
    print(f"  сообщений AI: {ai}, ответов инструмента: {tools}")
    print(f"  последнее сообщение: {result['messages'][-1].text}")
    print()


run("MIDDLEWARE С hook_config(can_jump_to=['end'])", TurnLimitMiddleware(max_turns=1))
run("ТОТ ЖЕ MIDDLEWARE БЕЗ ПОМЕТКИ", SilentTurnLimitMiddleware(max_turns=1))

# Вывод:
# MIDDLEWARE С hook_config(can_jump_to=['end'])
#   ребро условное: TurnLimitMiddleware.before_model -> __end__
#   ребро условное: TurnLimitMiddleware.before_model -> model
#   [TurnLimitMiddleware] запрошен прыжок к концу запуска
#   записано вызовов модели: 1
#   сообщений AI: 2, ответов инструмента: 4
#   последнее сообщение: Лимит вызовов модели исчерпан, отвечаю тем, что успел собрать.
#
# ТОТ ЖЕ MIDDLEWARE БЕЗ ПОМЕТКИ
#   ребро обычное: SilentTurnLimitMiddleware.before_model -> model
#   [SilentTurnLimitMiddleware] запрошен прыжок к концу запуска
#   записано вызовов модели: 2
#   сообщений AI: 3, ответов инструмента: 4
#   последнее сообщение: # У владельцев модулей
#
# Модули:
# - `/src/billing` — владелец **Ирина**
# - `/src/auth` — владелец **Павел**
# - `/src/gateway` — владелец **Сергей**
# - `/src/reports` — владелец не указан
# (последнее сообщение второго запуска пишет модель, у вас текст будет другим)

"""Пример 5 урока 16: обёртка вокруг инструмента, отвечающая без запуска.

Хук wrap_tool_call решает, вызывать ли handler. Если такой вызов уже был,
middleware возвращает готовый ToolMessage и тело инструмента не выполняется.

Агент вызывается дважды с одним и тем же вопросом. Счётчик внутри инструмента
показывает, сколько раз тело инструмента выполнилось на самом деле.
"""

import json
from collections.abc import Callable

from langchain.agents import create_agent
from langchain.agents.middleware import ToolCallRequest, wrap_tool_call
from langchain.messages import ToolMessage
from langgraph.types import Command

from course_model import build_model

OWNERS = {"/src/reports": "нет", "/src/billing": "Ирина", "/src/auth": "Павел"}

runs = {"count": 0}
CACHE: dict[tuple[str, str], str] = {}


def module_owner(path: str) -> str:
    """Возвращает владельца модуля репозитория по пути."""
    runs["count"] += 1
    return f"{path}: владелец {OWNERS.get(path, 'неизвестен')}"


@wrap_tool_call
def cache_tool_calls(
    request: ToolCallRequest,
    handler: Callable[[ToolCallRequest], ToolMessage | Command],
) -> ToolMessage | Command:
    """Отдаёт прежний ответ инструмента, если вызов повторяется дословно."""
    key = (
        request.tool_call["name"],
        json.dumps(request.tool_call["args"], sort_keys=True, ensure_ascii=False),
    )

    if key in CACHE:
        print(f"[кеш] {key[0]}{key[1]}: ответ из кеша, инструмент не вызывается")
        return ToolMessage(
            content=CACHE[key],
            tool_call_id=request.tool_call["id"],
            name=request.tool_call["name"],
        )

    result = handler(request)

    if isinstance(result, ToolMessage) and result.status == "success":
        CACHE[key] = result.text

    return result


agent = create_agent(
    model=build_model(temperature=0, max_tokens=256),
    tools=[module_owner],
    system_prompt=(
        "Вы помощник по разбору легаси. Владельцев узнавайте инструментом. "
        "Отвечайте по-русски одной фразой."
    ),
    middleware=[cache_tool_calls],
)

QUESTION = "Кто владелец модуля /src/billing?"

for number in (1, 2):
    print(f"ВЫЗОВ АГЕНТА {number}")
    result = agent.invoke({"messages": [{"role": "user", "content": QUESTION}]})
    print(f"  запусков тела инструмента всего: {runs['count']}")
    print(f"  записей в кеше: {len(CACHE)}")
    print(f"  ответ: {result['messages'][-1].text}")
    print()

# Вывод:
# ВЫЗОВ АГЕНТА 1
#   запусков тела инструмента всего: 1
#   записей в кеше: 1
#   ответ: Владелец модуля /src/billing — Ирина.
#
# ВЫЗОВ АГЕНТА 2
# [кеш] module_owner{"path": "/src/billing"}: ответ из кеша, инструмент не вызывается
#   запусков тела инструмента всего: 1
#   записей в кеше: 1
#   ответ: Владелец модуля /src/billing — Ирина.

"""Пример 6 урока 16: свой контекст и правка состояния из обёртки.

Middleware читает конфигурацию запуска из request.runtime.context и дописывает
к системному сообщению правило тарифа. После ответа модели он считает
потраченные токены и записывает их в состояние, возвращая ExtendedModelResponse
с Command: у хука-обёртки других способов записать в состояние нет.

Тип контекста объявлен параметром класса: AgentMiddleware[UsageState,
SupportContext]. Сам класс контекста уходит в create_agent аргументом
context_schema, а значение приходит при вызове аргументом context.
"""

from collections.abc import Callable
from dataclasses import dataclass

from typing_extensions import NotRequired

from langchain.agents import create_agent
from langchain.agents.middleware import (
    AgentMiddleware,
    AgentState,
    ExtendedModelResponse,
    ModelRequest,
    ModelResponse,
)
from langchain.messages import SystemMessage
from langgraph.types import Command

from course_model import build_model

OWNERS = {"/src/reports": "нет", "/src/billing": "Ирина", "/src/auth": "Павел"}

PLAN_RULES = {
    "free": "Тариф free: отвечайте одним предложением, без пояснений.",
    "pro": "Тариф pro: после ответа добавьте абзац с рекомендацией, что делать дальше.",
}


def module_owner(path: str) -> str:
    """Возвращает владельца модуля репозитория по пути."""
    return f"{path}: владелец {OWNERS.get(path, 'неизвестен')}"


@dataclass
class SupportContext:
    """Конфигурация запуска: кто спрашивает и по какому тарифу."""

    user_id: str
    plan: str


class UsageState(AgentState):
    """Состояние агента плюс расход токенов, накопленный middleware."""

    spent_tokens: NotRequired[int]


class PlanMiddleware(AgentMiddleware[UsageState, SupportContext]):
    """Правило тарифа в системном сообщении и счёт токенов в состоянии."""

    state_schema = UsageState

    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ExtendedModelResponse:
        plan = request.runtime.context.plan
        blocks = list(request.system_message.content_blocks) if request.system_message else []
        blocks.append({"type": "text", "text": PLAN_RULES[plan]})

        response = handler(request.override(system_message=SystemMessage(content=blocks)))

        usage = getattr(response.result[-1], "usage_metadata", None) or {}
        spent = request.state.get("spent_tokens", 0) + usage.get("total_tokens", 0)

        return ExtendedModelResponse(
            model_response=response,
            command=Command(update={"spent_tokens": spent}),
        )


agent = create_agent(
    model=build_model(temperature=0, max_tokens=512),
    tools=[module_owner],
    system_prompt=(
        "Вы помощник по разбору легаси. Владельцев узнавайте инструментом. "
        "Отвечайте по-русски."
    ),
    middleware=[PlanMiddleware()],
    context_schema=SupportContext,
)

QUESTION = "Кто владелец модуля /src/reports?"

for plan in ("free", "pro"):
    result = agent.invoke(
        {"messages": [{"role": "user", "content": QUESTION}]},
        context=SupportContext(user_id="u-101", plan=plan),
    )
    print(f"ТАРИФ {plan.upper()}")
    print(f"  токенов за запуск: {result['spent_tokens']}")
    print(f"  ответ: {result['messages'][-1].text}")
    print()

# Вывод:
# ТАРИФ FREE
#   токенов за запуск: 812
#   ответ: Владелец модуля /src/reports не назначен.
#
# ТАРИФ PRO
#   токенов за запуск: 888
#   ответ: Владелец модуля `/src/reports` не назначен (не указан в системе).
#
# **Рекомендация:** Обратитесь к тимлиду команды разработки или в отдел управления конфигурациями, чтобы уточнить актуального ответственного за этот модуль, и при необходимости зарегистрировать владельца в системе.
# (числа и текст рекомендации у читателя будут свои)

# Иллюстрация: код не запускается отдельным файлом.
from langchain.agents.middleware import AgentMiddleware, TracePolicy, omit_payload


class QuietAudit(AgentMiddleware):
    """Участок в трассировке остаётся, история сообщений в него не попадает."""

    trace_policy = TracePolicy(process_inputs=omit_payload)

    def after_model(self, state, runtime):
        return None

# Неправильно: оба экземпляра называются AuditMiddleware
agent = create_agent(
    model=model,
    tools=[module_owner],
    middleware=[AuditMiddleware("вход"), AuditMiddleware("выход")],
)

# Правильно: имя включает отличающий параметр
class AuditMiddleware(AgentMiddleware):
    def __init__(self, tag):
        super().__init__()
        self.tag = tag

    @property
    def name(self):
        return f"{self.__class__.__name__}[{self.tag}]"

# Неправильно: у функции нет второго параметра
@before_model
def only_state(state):
    return None

# Неправильно: результат получен и потерян
@wrap_model_call
def log_call(request, handler):
    response = handler(request)
    print(f"сообщений в ответе: {len(response.result)}")