response = agent.invoke(
    {"messages": [{"role": "user", "content": "把今天的订单退款情况汇总一下"}]},
    config={
        # tags：用于归类和筛选（建议用枚举风格，别塞长文本）
        "tags": ["production", "refund-agent", "ab:route-v2"],
        # metadata：用于关联/追责（建议放可索引字段）
        "metadata": {
            "tenant_id": "t_001",
            "user_id": "u_123",
            "thread_id": "thread_20251214_0001",
            "release": "2025.12.14",
        },
    },
)

from langsmith import Client
from langsmith.anonymizer import create_anonymizer

# 1) 定义脱敏规则：用正则匹配敏感模式，然后替换为占位符
anonymizer = create_anonymizer(
    [
        # 示例：把疑似 SSN 的格式打成 <ssn>
        {"pattern": r"\\b\\d{3}-?\\d{2}-?\\d{4}\\b", "replace": "<ssn>"},
        # 你也可以加：API Key 前缀、Bearer token、cookie 键名等规则
    ]
)

# 2) 用带 anonymizer 的 client 构建 tracer（只要接入 callbacks，就会自动应用脱敏）
tracer_client = Client(anonymizer=anonymizer)

from __future__ import annotations

import json
import time
from typing import Any, Callable

from langchain.agents.middleware import (
    after_agent,
    before_agent,
    wrap_model_call,
    ModelRequest,
    ModelResponse,
)

def _redact(value: Any) -> Any:
    # 统一的脱敏入口：别把“怎么脱敏”散落到每个 hook 里
    if value is None:
        return None
    return "<redacted>"

@before_agent
def obs_start(state: dict[str, Any], runtime: Any) -> dict[str, Any] | None:
    # before_agent：适合做“本次运行”的起始打点（一次 invocation 只会触发一次）
    runtime.metadata = getattr(runtime, "metadata", {})  # 防御式写法：避免 runtime 结构差异
    runtime.metadata["obs_start_ms"] = int(time.time() * 1000)
    return None

@wrap_model_call
def obs_model(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse],
) -> ModelResponse:
    # wrap_model_call：适合记录模型调用耗时、失败原因、选用模型等（每次模型调用都会触发）
    t0 = time.time()
    try:
        response = handler(request)
        ok = True
        err = None
        return response
    except Exception as e:  # noqa: BLE001
        ok = False
        err = repr(e)
        raise
    finally:
        cost_ms = int((time.time() - t0) * 1000)

        # 注意：千万别把 runtime.context 原样打出去（里面可能有密钥/Token/Cookie）
        event = {
            "type": "model_call",
            "ok": ok,
            "cost_ms": cost_ms,
            "model": str(request.model),
            # 你可以从 request.state / request.runtime 拿到 thread_id / tenant_id 等
            "tenant_id": request.runtime.context.tenant_id if hasattr(request.runtime, "context") else None,
            # 对敏感字段做脱敏或直接不记录
            "credentials": _redact(getattr(getattr(request.runtime, "context", None), "api_key", None)),
        }

        print(json.dumps(event, ensure_ascii=False))

@after_agent
def obs_end(state: dict[str, Any], runtime: Any) -> dict[str, Any] | None:
    # after_agent：适合做“本次运行”的收口打点（一次 invocation 只会触发一次）
    start_ms = getattr(getattr(runtime, "metadata", {}), "get", lambda _k, _d=None: _d)("obs_start_ms")
    end_ms = int(time.time() * 1000)
    event = {
        "type": "agent_done",
        "cost_ms": (end_ms - start_ms) if start_ms else None,
        # 示例：记录 messages 的规模（注意别把内容原样打出去）
        "message_count": len(state.get("messages", [])),
    }
    print(json.dumps(event, ensure_ascii=False))
    return None