agent-session-monitor

Original source / Raw SKILL.md

---
name: agent-session-monitor
description: Real-time agent conversation monitoring - monitors Higress access logs, aggregates conversations by session, tracks token usage. Supports web interface for viewing complete conversation history and costs. Use when users ask about current session token consumption, conversation history, or cost statistics.

---

## Overview

Real-time monitoring of Higress access logs, extracting ai_log JSON, grouping multi-turn conversations by session_id, and calculating token costs with visualization.

### Core Features

- **Real-time Log Monitoring**: Monitors Higress access log files, parses new ai_log entries in real-time
- **Log Rotation Support**: Full logrotate support, automatically tracks access.log.1~5 etc.
- **Incremental Parsing**: Inode-based tracking, processes only new content, no duplicates
- **Session Grouping**: Associates multi-turn conversations by session_id (each turn is a separate request)
- **Complete Conversation Tracking**: Records messages, question, answer, reasoning, tool_calls for each turn
- **Token Usage Tracking**: Distinguishes input/output/reasoning/cached tokens
- **Web Visualization**: Browser-based UI with overview and session drill-down
- **Real-time URL Generation**: Clawdbot can generate observation links based on current session ID
- **Background Processing**: Independent process, continuously parses access logs
- **State Persistence**: Maintains parsing progress and session data across runs

## Usage

### 1. Background Monitoring (Continuous)

```bash
# Parse Higress access logs (with log rotation support)
python3 main.py --log-path /var/log/proxy/access.log --output-dir ./sessions

# Filter by session key
python3 main.py --log-path /var/log/proxy/access.log --session-key <session-id>

# Scheduled task (incremental parsing every minute)
* * * * * python3 /path/to/main.py --log-path /var/log/proxy/access.log --output-dir /var/lib/sessions
```

### 2. Start Web UI (Recommended)

```bash
# Start web server
python3 scripts/webserver.py --data-dir ./sessions --port 8888

# Access in browser
open http://localhost:8888
```

Web UI features:
- 📊 Overview: View all session statistics and group by model
- 🔍 Session Details: Click session ID to drill down into complete conversation history
- 💬 Conversation Log: Display messages, question, answer, reasoning, tool_calls for each turn
- 💰 Cost Statistics: Real-time token usage and cost calculation
- 🔄 Auto Refresh: Updates every 30 seconds

### 3. Use in Clawdbot Conversations

When users ask about current session token consumption or conversation history:

1. Get current session_id (from runtime or context)
2. Generate web UI URL and return to user

Example response:

```
Your current session statistics:
- Session ID: agent:main:discord:channel:1465367993012981988
- View details: http://localhost:8888/session?id=agent:main:discord:channel:1465367993012981988

Click the link to see:
✅ Complete conversation history
✅ Token usage breakdown per turn
✅ Tool call records
✅ Cost statistics
```

### 4. CLI Queries (Optional)

```bash
# View specific session details
python3 scripts/cli.py show <session-id>

# List all sessions
python3 scripts/cli.py list --sort-by cost --limit 10

# Statistics by model
python3 scripts/cli.py stats-model

# Statistics by date (last 7 days)
python3 scripts/cli.py stats-date --days 7

# Export reports
python3 scripts/cli.py export finops-report.json
```

## Configuration

### main.py (Background Monitor)

| Parameter | Description | Required | Default |
|-----------|-------------|----------|---------|
| `--log-path` | Higress access log file path | Yes | /var/log/higress/access.log |
| `--output-dir` | Session data storage directory | No | ./sessions |
| `--session-key` | Monitor only specified session key | No | Monitor all sessions |
| `--state-file` | State file path (records read offsets) | No | <output-dir>/.state.json |
| `--refresh-interval` | Log refresh interval (seconds) | No | 1 |

### webserver.py (Web UI)

| Parameter | Description | Required | Default |
|-----------|-------------|----------|---------|
| `--data-dir` | Session data directory | No | ./sessions |
| `--port` | HTTP server port | No | 8888 |
| `--host` | HTTP server address | No | 0.0.0.0 |

## Output Examples

### 1. Real-time Monitor

```
🔍 Session Monitor - Active
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 Active Sessions: 3

┌──────────────────────────┬─────────┬──────────┬───────────┐
│ Session ID               │ Msgs    │ Input    │ Output    │
├──────────────────────────┼─────────┼──────────┼───────────┤
│ sess_abc123              │       5 │    1,250 │       800 │
│ sess_xyz789              │       3 │      890 │       650 │
│ sess_def456              │       8 │    2,100 │     1,200 │
└──────────────────────────┴─────────┴──────────┴───────────┘

📈 Token Statistics
  Total Input:   4240 tokens
  Total Output:  2650 tokens
  Total Cached:  0 tokens
  Total Cost:    $0.00127
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

### 2. CLI Session Details

```bash
$ python3 scripts/cli.py show agent:main:discord:channel:1465367993012981988

======================================================================
📊 Session Detail: agent:main:discord:channel:1465367993012981988
======================================================================

🕐 Created:  2026-02-01T09:30:00+08:00
🕑 Updated:  2026-02-01T10:35:12+08:00
🤖 Model:    Qwen3-rerank
💬 Messages: 5

📈 Token Statistics:
   Input:           1,250 tokens
   Output:            800 tokens
   Reasoning:         150 tokens
   Total:           2,200 tokens

💰 Estimated Cost: $0.00126000 USD

📝 Conversation Rounds (5):
──────────────────────────────────────────────────────────────────────

  Round 1 @ 2026-02-01T09:30:15+08:00
    Tokens: 250 in → 160 out
    🔧 Tool calls: Yes
    Messages (2):
      [user] Check Beijing weather
    ❓ Question: Check Beijing weather
    ✅ Answer: Checking Beijing weather for you...
    🧠 Reasoning: User wants to know Beijing weather, I need to call weather API.
    🛠️  Tool Calls:
       - get_weather({"location":"Beijing"})
```

### 3. Statistics by Model

```bash
$ python3 scripts/cli.py stats-model

================================================================================
📊 Statistics by Model
================================================================================

Model                Sessions   Input           Output          Cost (USD)  
────────────────────────────────────────────────────────────────────────────
Qwen3-rerank         12         15,230          9,840           $  0.016800
DeepSeek-R1          5          8,450           6,200           $  0.010600
Qwen-Max             3          4,200           3,100           $  0.008300
GPT-4                2          2,100           1,800           $  0.017100
────────────────────────────────────────────────────────────────────────────
TOTAL                22         29,980          20,940          $  0.052800

================================================================================
```

### 4. Statistics by Date

```bash
$ python3 scripts/cli.py stats-date --days 7

================================================================================
📊 Statistics by Date (Last 7 days)
================================================================================

Date         Sessions   Input           Output          Cost (USD)   Models              
────────────────────────────────────────────────────────────────────────────
2026-01-26   3          2,100           1,450           $  0.0042   Qwen3-rerank
2026-01-27   5          4,850           3,200           $  0.0096   Qwen3-rerank, GPT-4
2026-01-28   4          3,600           2,800           $  0.0078   DeepSeek-R1, Qwen
────────────────────────────────────────────────────────────────────────────
TOTAL        22         29,980          20,940          $  0.0528

================================================================================
```

### 5. Web UI (Recommended)

Access `http://localhost:8888` to see:

**Home Page:**
- 📊 Total sessions, token consumption, cost cards
- 📋 Recent sessions list (clickable for details)
- 📈 Statistics by model table

**Session Detail Page:**
- 💬 Complete conversation log (messages, question, answer, reasoning, tool_calls per turn)
- 🔧 Tool call history
- 💰 Token usage breakdown and costs

**Features:**
- 🔄 Auto-refresh every 30 seconds
- 📱 Responsive design, mobile-friendly
- 🎨 Clean UI, easy to read

## Session Data Structure

Each session is stored as an independent JSON file with complete conversation history and token statistics:

```json
{
  "session_id": "agent:main:discord:channel:1465367993012981988",
  "created_at": "2026-02-01T10:30:00Z",
  "updated_at": "2026-02-01T10:35:12Z",
  "messages_count": 5,
  "total_input_tokens": 1250,
  "total_output_tokens": 800,
  "total_reasoning_tokens": 150,
  "total_cached_tokens": 0,
  "model": "Qwen3-rerank",
  "rounds": [
    {
      "round": 1,
      "timestamp": "2026-02-01T10:30:15Z",
      "input_tokens": 250,
      "output_tokens": 160,
      "reasoning_tokens": 0,
      "cached_tokens": 0,
      "model": "Qwen3-rerank",
      "has_tool_calls": true,
      "response_type": "normal",
      "messages": [
        {
          "role": "system",
          "content": "You are a helpful assistant..."
        },
        {
          "role": "user",
          "content": "Check Beijing weather"
        }
      ],
      "question": "Check Beijing weather",
      "answer": "Checking Beijing weather for you...",
      "reasoning": "User wants to know Beijing weather, need to call weather API.",
      "tool_calls": [
        {
          "index": 0,
          "id": "call_abc123",
          "type": "function",
          "function": {
            "name": "get_weather",
            "arguments": "{\"location\":\"Beijing\"}"
          }
        }
      ],
      "input_token_details": {"cached_tokens": 0},
      "output_token_details": {}
    }
  ]
}
```

### Field Descriptions

**Session Level:**
- `session_id`: Unique session identifier (from ai_log's session_id field)
- `created_at`: Session creation time
- `updated_at`: Last update time
- `messages_count`: Number of conversation turns
- `total_input_tokens`: Cumulative input tokens
- `total_output_tokens`: Cumulative output tokens
- `total_reasoning_tokens`: Cumulative reasoning tokens (DeepSeek, o1, etc.)
- `total_cached_tokens`: Cumulative cached tokens (prompt caching)
- `model`: Current model in use

**Round Level (rounds):**
- `round`: Turn number
- `timestamp`: Current turn timestamp
- `input_tokens`: Input tokens for this turn
- `output_tokens`: Output tokens for this turn
- `reasoning_tokens`: Reasoning tokens (o1, etc.)
- `cached_tokens`: Cached tokens (prompt caching)
- `model`: Model used for this turn
- `has_tool_calls`: Whether includes tool calls
- `response_type`: Response type (normal/error, etc.)
- `messages`: Complete conversation history (OpenAI messages format)
- `question`: User's question for this turn (last user message)
- `answer`: AI's answer for this turn
- `reasoning`: AI's thinking process (if model supports)
- `tool_calls`: Tool call list (if any)
- `input_token_details`: Complete input token details (JSON)
- `output_token_details`: Complete output token details (JSON)

## Log Format Requirements

Higress access logs must include ai_log field (JSON format). Example:

```json
{
  "__file_offset__": "1000",
  "timestamp": "2026-02-01T09:30:15Z",
  "ai_log": "{\"session_id\":\"sess_abc\",\"messages\":[...],\"question\":\"...\",\"answer\":\"...\",\"input_token\":250,\"output_token\":160,\"model\":\"Qwen3-rerank\"}"
}
```

Supported ai_log attributes:
- `session_id`: Session identifier (required)
- `messages`: Complete conversation history
- `question`: Question for current turn
- `answer`: AI answer
- `reasoning`: Thinking process (DeepSeek, o1, etc.)
- `reasoning_tokens`: Reasoning token count (from PR #3424)
- `cached_tokens`: Cached token count (from PR #3424)
- `tool_calls`: Tool call list
- `input_token`: Input token count
- `output_token`: Output token count
- `input_token_details`: Complete input token details (JSON)
- `output_token_details`: Complete output token details (JSON)
- `model`: Model name
- `response_type`: Response type

## Implementation

### Technology Stack

- **Log Parsing**: Direct JSON parsing, no regex needed
- **File Monitoring**: Polling-based (no watchdog dependency)
- **Session Management**: In-memory + disk hybrid storage
- **Token Calculation**: Model-specific pricing for GPT-4, Qwen, Claude, o1, etc.

### Privacy and Security

- ✅ Does not record conversation content in logs, only token statistics
- ✅ Session data stored locally, not uploaded to external services
- ✅ Supports log file path allowlist
- ✅ Session key access control

### Performance Optimization

- Incremental log parsing, avoids full scans
- In-memory session data with periodic persistence
- Optimized log file reading (offset tracking)
- Inode-based file identification (handles rotation efficiently)


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### scripts/webserver.py

```python
#!/usr/bin/env python3
"""
Agent Session Monitor - Web Server
提供浏览器访问的观测界面
"""

import argparse
import json
import sys
from pathlib import Path
from http.server import HTTPServer, BaseHTTPRequestHandler
from urllib.parse import urlparse, parse_qs
from collections import defaultdict
from datetime import datetime, timedelta
import re

# 添加父目录到path以导入cli模块
sys.path.insert(0, str(Path(__file__).parent.parent))

try:
    from scripts.cli import SessionAnalyzer, TOKEN_PRICING
except ImportError:
    # 如果导入失败，定义简单版本
    TOKEN_PRICING = {
        "Qwen3-rerank": {"input": 0.0003, "output": 0.0012},
        "DeepSeek-R1": {"input": 0.004, "output": 0.012, "reasoning": 0.002},
    }


class SessionMonitorHandler(BaseHTTPRequestHandler):
    """HTTP请求处理器"""
    
    def __init__(self, *args, data_dir=None, **kwargs):
        self.data_dir = Path(data_dir) if data_dir else Path("./sessions")
        super().__init__(*args, **kwargs)
    
    def do_GET(self):
        """处理GET请求"""
        parsed_path = urlparse(self.path)
        path = parsed_path.path
        query = parse_qs(parsed_path.query)
        
        if path == '/' or path == '/index.html':
            self.serve_index()
        elif path == '/session':
            session_id = query.get('id', [None])[0]
            if session_id:
                self.serve_session_detail(session_id)
            else:
                self.send_error(400, "Missing session id")
        elif path == '/api/sessions':
            self.serve_api_sessions()
        elif path == '/api/session':
            session_id = query.get('id', [None])[0]
            if session_id:
                self.serve_api_session(session_id)
            else:
                self.send_error(400, "Missing session id")
        elif path == '/api/stats':
            self.serve_api_stats()
        else:
            self.send_error(404, "Not Found")
    
    def serve_index(self):
        """首页 - 总览"""
        html = self.generate_index_html()
        self.send_html(html)
    
    def serve_session_detail(self, session_id: str):
        """Session详情页"""
        html = self.generate_session_html(session_id)
        self.send_html(html)
    
    def serve_api_sessions(self):
        """API: 获取所有session列表"""
        sessions = self.load_all_sessions()
        
        # 简化数据
        data = []
        for session in sessions:
            data.append({
                'session_id': session['session_id'],
                'model': session.get('model', 'unknown'),
                'messages_count': session.get('messages_count', 0),
                'total_tokens': session['total_input_tokens'] + session['total_output_tokens'],
                'updated_at': session.get('updated_at', ''),
                'cost': self.calculate_cost(session)
            })
        
        # 按更新时间降序排序
        data.sort(key=lambda x: x['updated_at'], reverse=True)
        
        self.send_json(data)
    
    def serve_api_session(self, session_id: str):
        """API: 获取指定session的详细数据"""
        session = self.load_session(session_id)
        if session:
            session['cost'] = self.calculate_cost(session)
            self.send_json(session)
        else:
            self.send_error(404, "Session not found")
    
    def serve_api_stats(self):
        """API: 获取统计数据"""
        sessions = self.load_all_sessions()
        
        # 按模型统计
        by_model = defaultdict(lambda: {
            'count': 0,
            'input_tokens': 0,
            'output_tokens': 0,
            'cost': 0.0
        })
        
        # 按日期统计
        by_date = defaultdict(lambda: {
            'count': 0,
            'input_tokens': 0,
            'output_tokens': 0,
            'cost': 0.0,
            'models': set()
        })
        
        total_cost = 0.0
        
        for session in sessions:
            model = session.get('model', 'unknown')
            cost = self.calculate_cost(session)
            total_cost += cost
            
            # 按模型
            by_model[model]['count'] += 1
            by_model[model]['input_tokens'] += session['total_input_tokens']
            by_model[model]['output_tokens'] += session['total_output_tokens']
            by_model[model]['cost'] += cost
            
            # 按日期
            created_at = session.get('created_at', '')
            date_key = created_at[:10] if len(created_at) >= 10 else 'unknown'
            by_date[date_key]['count'] += 1
            by_date[date_key]['input_tokens'] += session['total_input_tokens']
            by_date[date_key]['output_tokens'] += session['total_output_tokens']
            by_date[date_key]['cost'] += cost
            by_date[date_key]['models'].add(model)
        
        # 转换sets为lists
        for date in by_date:
            by_date[date]['models'] = list(by_date[date]['models'])
        
        stats = {
            'total_sessions': len(sessions),
            'total_cost': total_cost,
            'by_model': dict(by_model),
            'by_date': dict(sorted(by_date.items(), reverse=True))
        }
        
        self.send_json(stats)
    
    def load_session(self, session_id: str):
        """加载指定session"""
        session_file = self.data_dir / f"{session_id}.json"
        if session_file.exists():
            with open(session_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        return None
    
    def load_all_sessions(self):
        """加载所有session"""
        sessions = []
        for session_file in self.data_dir.glob("*.json"):
            try:
                with open(session_file, 'r', encoding='utf-8') as f:
                    sessions.append(json.load(f))
            except Exception as e:
                print(f"Warning: Failed to load {session_file}: {e}", file=sys.stderr)
        return sessions
    
    def calculate_cost(self, session: dict) -> float:
        """计算session成本"""
        model = session.get('model', 'unknown')
        pricing = TOKEN_PRICING.get(model, TOKEN_PRICING.get("GPT-4", {"input": 0.003, "output": 0.006}))
        
        input_tokens = session['total_input_tokens']
        output_tokens = session['total_output_tokens']
        reasoning_tokens = session.get('total_reasoning_tokens', 0)
        cached_tokens = session.get('total_cached_tokens', 0)
        
        # 区分regular input和cached input
        regular_input_tokens = input_tokens - cached_tokens
        
        input_cost = regular_input_tokens * pricing.get('input', 0) / 1000000
        output_cost = output_tokens * pricing.get('output', 0) / 1000000
        
        reasoning_cost = 0
        if 'reasoning' in pricing and reasoning_tokens > 0:
            reasoning_cost = reasoning_tokens * pricing['reasoning'] / 1000000
        
        cached_cost = 0
        if 'cached' in pricing and cached_tokens > 0:
            cached_cost = cached_tokens * pricing['cached'] / 1000000
        
        return input_cost + output_cost + reasoning_cost + cached_cost
    
    def send_html(self, html: str):
        """发送HTML响应"""
        self.send_response(200)
        self.send_header('Content-type', 'text/html; charset=utf-8')
        self.end_headers()
        self.wfile.write(html.encode('utf-8'))
    
    def send_json(self, data):
        """发送JSON响应"""
        self.send_response(200)
        self.send_header('Content-type', 'application/json; charset=utf-8')
        self.send_header('Access-Control-Allow-Origin', '*')
        self.end_headers()
        self.wfile.write(json.dumps(data, ensure_ascii=False, indent=2).encode('utf-8'))
    
    def generate_index_html(self) -> str:
        """生成首页HTML"""
        return '''<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Agent Session Monitor</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body {
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            background: #f5f5f5;
            padding: 20px;
        }
        .container { max-width: 1400px; margin: 0 auto; }
        header {
            background: white;
            padding: 30px;
            border-radius: 8px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
            margin-bottom: 20px;
        }
        h1 { color: #333; margin-bottom: 10px; }
        .subtitle { color: #666; font-size: 14px; }
        
        .stats-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
            gap: 20px;
            margin-bottom: 20px;
        }
        .stat-card {
            background: white;
            padding: 20px;
            border-radius: 8px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
        }
        .stat-label { color: #666; font-size: 14px; margin-bottom: 8px; }
        .stat-value { color: #333; font-size: 32px; font-weight: bold; }
        .stat-unit { color: #999; font-size: 16px; margin-left: 4px; }
        
        .section {
            background: white;
            padding: 30px;
            border-radius: 8px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
            margin-bottom: 20px;
        }
        h2 { color: #333; margin-bottom: 20px; font-size: 20px; }
        
        table { width: 100%; border-collapse: collapse; }
        thead { background: #f8f9fa; }
        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #e9ecef; }
        th { font-weight: 600; color: #666; font-size: 14px; }
        td { color: #333; }
        tbody tr:hover { background: #f8f9fa; }
        
        .session-link {
            color: #007bff;
            text-decoration: none;
            font-family: monospace;
            font-size: 13px;
        }
        .session-link:hover { text-decoration: underline; }
        
        .badge {
            display: inline-block;
            padding: 4px 8px;
            border-radius: 4px;
            font-size: 12px;
            font-weight: 500;
        }
        .badge-qwen { background: #e3f2fd; color: #1976d2; }
        .badge-deepseek { background: #f3e5f5; color: #7b1fa2; }
        .badge-gpt { background: #e8f5e9; color: #388e3c; }
        .badge-claude { background: #fff3e0; color: #f57c00; }
        
        .loading { text-align: center; padding: 40px; color: #666; }
        .error { color: #d32f2f; padding: 20px; }
        
        .refresh-btn {
            background: #007bff;
            color: white;
            border: none;
            padding: 10px 20px;
            border-radius: 4px;
            cursor: pointer;
            font-size: 14px;
        }
        .refresh-btn:hover { background: #0056b3; }
    </style>
</head>
<body>
    <div class="container">
        <header>
            <h1>🔍 Agent Session Monitor</h1>
            <p class="subtitle">实时观测Clawdbot对话过程和Token开销</p>
        </header>
        
        <div class="stats-grid" id="stats-grid">
            <div class="stat-card">
                <div class="stat-label">总会话数</div>
                <div class="stat-value">-</div>
            </div>
            <div class="stat-card">
                <div class="stat-label">总Token消耗</div>
                <div class="stat-value">-</div>
            </div>
            <div class="stat-card">
                <div class="stat-label">总成本</div>
                <div class="stat-value">-</div>
            </div>
        </div>
        
        <div class="section">
            <h2>📊 最近会话</h2>
            <button class="refresh-btn" onclick="loadSessions()">🔄 刷新</button>
            <div id="sessions-table">
                <div class="loading">加载中...</div>
            </div>
        </div>
        
        <div class="section">
            <h2>📈 按模型统计</h2>
            <div id="model-stats">
                <div class="loading">加载中...</div>
            </div>
        </div>
    </div>
    
    <script>
        function loadSessions() {
            fetch('/api/sessions')
                .then(r => r.json())
                .then(sessions => {
                    const html = `
                        <table>
                            <thead>
                                <tr>
                                    <th>Session ID</th>
                                    <th>模型</th>
                                    <th>消息数</th>
                                    <th>总Token</th>
                                    <th>成本</th>
                                    <th>更新时间</th>
                                </tr>
                            </thead>
                            <tbody>
                                ${sessions.slice(0, 50).map(s => `
                                    <tr>
                                        <td><a href="/session?id=${encodeURIComponent(s.session_id)}" class="session-link">${s.session_id}</a></td>
                                        <td>${getModelBadge(s.model)}</td>
                                        <td>${s.messages_count}</td>
                                        <td>${s.total_tokens.toLocaleString()}</td>
                                        <td>$${s.cost.toFixed(6)}</td>
                                        <td>${new Date(s.updated_at).toLocaleString()}</td>
                                    </tr>
                                `).join('')}
                            </tbody>
                        </table>
                    `;
                    document.getElementById('sessions-table').innerHTML = html;
                })
                .catch(err => {
                    document.getElementById('sessions-table').innerHTML = `<div class="error">加载失败: ${err.message}</div>`;
                });
        }
        
        function loadStats() {
            fetch('/api/stats')
                .then(r => r.json())
                .then(stats => {
                    // 更新顶部统计卡片
                    const cards = document.querySelectorAll('.stat-card');
                    cards[0].querySelector('.stat-value').textContent = stats.total_sessions;
                    
                    const totalTokens = Object.values(stats.by_model).reduce((sum, m) => sum + m.input_tokens + m.output_tokens, 0);
                    cards[1].querySelector('.stat-value').innerHTML = totalTokens.toLocaleString() + '<span class="stat-unit">tokens</span>';
                    
                    cards[2].querySelector('.stat-value').innerHTML = '$' + stats.total_cost.toFixed(4);
                    
                    // 模型统计表格
                    const modelHtml = `
                        <table>
                            <thead>
                                <tr>
                                    <th>模型</th>
                                    <th>会话数</th>
                                    <th>输入Token</th>
                                    <th>输出Token</th>
                                    <th>成本</th>
                                </tr>
                            </thead>
                            <tbody>
                                ${Object.entries(stats.by_model).map(([model, data]) => `
                                    <tr>
                                        <td>${getModelBadge(model)}</td>
                                        <td>${data.count}</td>
                                        <td>${data.input_tokens.toLocaleString()}</td>
                                        <td>${data.output_tokens.toLocaleString()}</td>
                                        <td>$${data.cost.toFixed(6)}</td>
                                    </tr>
                                `).join('')}
                            </tbody>
                        </table>
                    `;
                    document.getElementById('model-stats').innerHTML = modelHtml;
                })
                .catch(err => {
                    console.error('Failed to load stats:', err);
                });
        }
        
        function getModelBadge(model) {
            let cls = 'badge';
            if (model.includes('Qwen')) cls += ' badge-qwen';
            else if (model.includes('DeepSeek')) cls += ' badge-deepseek';
            else if (model.includes('GPT')) cls += ' badge-gpt';
            else if (model.includes('Claude')) cls += ' badge-claude';
            return `<span class="${cls}">${model}</span>`;
        }
        
        // 初始加载
        loadSessions();
        loadStats();
        
        // 每30秒自动刷新
        setInterval(() => {
            loadSessions();
            loadStats();
        }, 30000);
    </script>
</body>
</html>'''
    
    def generate_session_html(self, session_id: str) -> str:
        """生成Session详情页HTML"""
        session = self.load_session(session_id)
        if not session:
            return f'<html><body><h1>Session not found: {session_id}</h1></body></html>'
        
        cost = self.calculate_cost(session)
        
        # 生成对话轮次HTML
        rounds_html = []
        for r in session.get('rounds', []):
            messages_html = ''
            if r.get('messages'):
                messages_html = '<div class="messages">'
                for msg in r['messages'][-5:]:  # 最多显示5条
                    role = msg.get('role', 'unknown')
                    content = msg.get('content', '')
                    messages_html += f'<div class="message message-{role}"><strong>[{role}]</strong> {self.escape_html(content)}</div>'
                messages_html += '</div>'
            
            tool_calls_html = ''
            if r.get('tool_calls'):
                tool_calls_html = '<div class="tool-calls"><strong>🛠️ Tool Calls:</strong><ul>'
                for tc in r['tool_calls']:
                    func_name = tc.get('function', {}).get('name', 'unknown')
                    tool_calls_html += f'<li>{func_name}()</li>'
                tool_calls_html += '</ul></div>'
            
            # Token详情显示
            token_details_html = ''
            if r.get('input_token_details') or r.get('output_token_details'):
                token_details_html = '<div class="token-details"><strong>📊 Token Details:</strong><ul>'
                if r.get('input_token_details'):
                    token_details_html += f'<li>Input: {r["input_token_details"]}</li>'
                if r.get('output_token_details'):
                    token_details_html += f'<li>Output: {r["output_token_details"]}</li>'
                token_details_html += '</ul></div>'
            
            # Token类型标签
            token_badges = ''
            if r.get('cached_tokens', 0) > 0:
                token_badges += f' <span class="token-badge token-badge-cached">📦 {r["cached_tokens"]:,} cached</span>'
            if r.get('reasoning_tokens', 0) > 0:
                token_badges += f' <span class="token-badge token-badge-reasoning">🧠 {r["reasoning_tokens"]:,} reasoning</span>'
            
            rounds_html.append(f'''
                <div class="round">
                    <div class="round-header">
                        <span class="round-number">Round {r['round']}</span>
                        <span class="round-time">{r['timestamp']}</span>
                        <span class="round-tokens">{r['input_tokens']:,} in → {r['output_tokens']:,} out{token_badges}</span>
                    </div>
                    {messages_html}
                    {f'<div class="question"><strong>❓ Question:</strong> {self.escape_html(r.get("question", ""))}</div>' if r.get('question') else ''}
                    {f'<div class="answer"><strong>✅ Answer:</strong> {self.escape_html(r.get("answer", ""))}</div>' if r.get('answer') else ''}
                    {f'<div class="reasoning"><strong>🧠 Reasoning:</strong> {self.escape_html(r.get("reasoning", ""))}</div>' if r.get('reasoning') else ''}
                    {tool_calls_html}
                    {token_details_html}
                </div>
            ''')
        
        return f'''<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{session_id} - Session Monitor</title>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        body {{
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            background: #f5f5f5;
            padding: 20px;
        }}
        .container {{ max-width: 1200px; margin: 0 auto; }}
        
        header {{
            background: white;
            padding: 30px;
            border-radius: 8px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
            margin-bottom: 20px;
        }}
        h1 {{ color: #333; margin-bottom: 10px; font-size: 24px; }}
        .back-link {{ color: #007bff; text-decoration: none; margin-bottom: 10px; display: inline-block; }}
        .back-link:hover {{ text-decoration: underline; }}
        
        .info-grid {{
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 15px;
            margin-top: 20px;
        }}
        .info-item {{ padding: 10px 0; }}
        .info-label {{ color: #666; font-size: 14px; }}
        .info-value {{ color: #333; font-size: 18px; font-weight: 600; margin-top: 4px; }}
        
        .section {{
            background: white;
            padding: 30px;
            border-radius: 8px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
            margin-bottom: 20px;
        }}
        h2 {{ color: #333; margin-bottom: 20px; font-size: 20px; }}
        
        .round {{
            border-left: 3px solid #007bff;
            padding: 20px;
            margin-bottom: 20px;
            background: #f8f9fa;
            border-radius: 4px;
        }}
        .round-header {{
            display: flex;
            justify-content: space-between;
            margin-bottom: 15px;
            font-size: 14px;
        }}
        .round-number {{ font-weight: 600; color: #007bff; }}
        .round-time {{ color: #666; }}
        .round-tokens {{ color: #333; }}
        
        .messages {{ margin: 15px 0; }}
        .message {{
            padding: 10px;
            margin: 5px 0;
            border-radius: 4px;
            font-size: 14px;
            line-height: 1.6;
        }}
        .message-system {{ background: #fff3cd; }}
        .message-user {{ background: #d1ecf1; }}
        .message-assistant {{ background: #d4edda; }}
        .message-tool {{ background: #e2e3e5; }}
        
        .question, .answer, .reasoning, .tool-calls {{
            margin: 10px 0;
            padding: 10px;
            background: white;
            border-radius: 4px;
            font-size: 14px;
            line-height: 1.6;
        }}
        .question {{ border-left: 3px solid #ffc107; }}
        .answer {{ border-left: 3px solid #28a745; }}
        .reasoning {{ border-left: 3px solid #17a2b8; }}
        .tool-calls {{ border-left: 3px solid #6c757d; }}
        .tool-calls ul {{ margin-left: 20px; margin-top: 5px; }}
        
        .token-details {{
            margin: 10px 0;
            padding: 10px;
            background: white;
            border-radius: 4px;
            font-size: 13px;
            border-left: 3px solid #17a2b8;
        }}
        .token-details ul {{ margin-left: 20px; margin-top: 5px; color: #666; }}
        
        .token-badge {{
            display: inline-block;
            padding: 2px 6px;
            border-radius: 3px;
            font-size: 11px;
            margin-left: 5px;
        }}
        .token-badge-cached {{
            background: #d4edda;
            color: #155724;
        }}
        .token-badge-reasoning {{
            background: #cce5ff;
            color: #004085;
        }}
        
        .badge {{
            display: inline-block;
            padding: 4px 8px;
            border-radius: 4px;
            font-size: 12px;
            font-weight: 500;
            background: #e3f2fd;
            color: #1976d2;
        }}
    </style>
</head>
<body>
    <div class="container">
        <header>
            <a href="/" class="back-link">← 返回列表</a>
            <h1>📊 Session Detail</h1>
            <p style="color: #666; font-family: monospace; font-size: 14px; margin-top: 10px;">{session_id}</p>
            
            <div class="info-grid">
                <div class="info-item">
                    <div class="info-label">模型</div>
                    <div class="info-value"><span class="badge">{session.get('model', 'unknown')}</span></div>
                </div>
                <div class="info-item">
                    <div class="info-label">消息数</div>
                    <div class="info-value">{session.get('messages_count', 0)}</div>
                </div>
                <div class="info-item">
                    <div class="info-label">总Token</div>
                    <div class="info-value">{session['total_input_tokens'] + session['total_output_tokens']:,}</div>
                </div>
                <div class="info-item">
                    <div class="info-label">成本</div>
                    <div class="info-value">${cost:.6f}</div>
                </div>
            </div>
        </header>
        
        <div class="section">
            <h2>💬 对话记录 ({len(session.get('rounds', []))} 轮)</h2>
            {"".join(rounds_html) if rounds_html else '<p style="color: #666;">暂无对话记录</p>'}
        </div>
    </div>
</body>
</html>'''
    
    def escape_html(self, text: str) -> str:
        """转义HTML特殊字符"""
        return (text.replace('&', '&amp;')
                   .replace('<', '&lt;')
                   .replace('>', '&gt;')
                   .replace('"', '&quot;')
                   .replace("'", '&#39;'))
    
    def log_message(self, format, *args):
        """重写日志方法，简化输出"""
        pass  # 不打印每个请求


def create_handler(data_dir):
    """创建带数据目录的处理器"""
    def handler(*args, **kwargs):
        return SessionMonitorHandler(*args, data_dir=data_dir, **kwargs)
    return handler


def main():
    parser = argparse.ArgumentParser(
        description="Agent Session Monitor - Web Server",
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    
    parser.add_argument(
        '--data-dir',
        default='./sessions',
        help='Session数据目录（默认: ./sessions）'
    )
    
    parser.add_argument(
        '--port',
        type=int,
        default=8888,
        help='HTTP服务器端口（默认: 8888）'
    )
    
    parser.add_argument(
        '--host',
        default='0.0.0.0',
        help='HTTP服务器地址（默认: 0.0.0.0）'
    )
    
    args = parser.parse_args()
    
    # 检查数据目录是否存在
    data_dir = Path(args.data_dir)
    if not data_dir.exists():
        print(f"❌ Error: Data directory not found: {data_dir}")
        print(f"   Please run main.py first to generate session data.")
        sys.exit(1)
    
    # 创建HTTP服务器
    handler_class = create_handler(args.data_dir)
    server = HTTPServer((args.host, args.port), handler_class)
    
    print(f"{'=' * 60}")
    print(f"🌐 Agent Session Monitor - Web Server")
    print(f"{'=' * 60}")
    print()
    print(f"📂 Data directory: {args.data_dir}")
    print(f"🌍 Server address: http://{args.host}:{args.port}")
    print()
    print(f"✅ Server started. Press Ctrl+C to stop.")
    print(f"{'=' * 60}")
    print()
    
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\n\n👋 Shutting down server...")
        server.shutdown()


if __name__ == '__main__':
    main()

```

### scripts/cli.py

```python
#!/usr/bin/env python3
"""
Agent Session Monitor CLI - 查询和分析agent对话数据
支持：
1. 实时查询指定session的完整llm请求和响应
2. 按模型统计token开销
3. 按日期统计token开销
4. 生成FinOps报表
"""

import argparse
import json
import sys
from collections import defaultdict
from datetime import datetime, timedelta
from pathlib import Path
from typing import Dict, List, Optional
import re

# Token定价（单位：美元/1M tokens）
TOKEN_PRICING = {
    "Qwen": {
        "input": 0.0002,  # $0.2/1M
        "output": 0.0006,
        "cached": 0.0001,  # cached tokens通常是input的50%
    },
    "Qwen3-rerank": {
        "input": 0.0003,
        "output": 0.0012,
        "cached": 0.00015,
    },
    "Qwen-Max": {
        "input": 0.0005,
        "output": 0.002,
        "cached": 0.00025,
    },
    "GPT-4": {
        "input": 0.003,
        "output": 0.006,
        "cached": 0.0015,
    },
    "GPT-4o": {
        "input": 0.0025,
        "output": 0.01,
        "cached": 0.00125,  # GPT-4o prompt caching: 50% discount
    },
    "GPT-4-32k": {
        "input": 0.01,
        "output": 0.03,
        "cached": 0.005,
    },
    "o1": {
        "input": 0.015,
        "output": 0.06,
        "cached": 0.0075,
        "reasoning": 0.06,  # o1 reasoning tokens same as output
    },
    "o1-mini": {
        "input": 0.003,
        "output": 0.012,
        "cached": 0.0015,
        "reasoning": 0.012,
    },
    "Claude": {
        "input": 0.015,
        "output": 0.075,
        "cached": 0.0015,  # Claude prompt caching: 90% discount
    },
    "DeepSeek-R1": {
        "input": 0.004,
        "output": 0.012,
        "reasoning": 0.002,
        "cached": 0.002,
    }
}


class SessionAnalyzer:
    """Session数据分析器"""
    
    def __init__(self, data_dir: str):
        self.data_dir = Path(data_dir)
        if not self.data_dir.exists():
            raise FileNotFoundError(f"Session data directory not found: {data_dir}")
    
    def load_session(self, session_id: str) -> Optional[dict]:
        """加载指定session的完整数据"""
        session_file = self.data_dir / f"{session_id}.json"
        if not session_file.exists():
            return None
        
        with open(session_file, 'r', encoding='utf-8') as f:
            return json.load(f)
    
    def load_all_sessions(self) -> List[dict]:
        """加载所有session数据"""
        sessions = []
        for session_file in self.data_dir.glob("*.json"):
            try:
                with open(session_file, 'r', encoding='utf-8') as f:
                    session = json.load(f)
                    sessions.append(session)
            except Exception as e:
                print(f"Warning: Failed to load {session_file}: {e}", file=sys.stderr)
        return sessions
    
    def display_session_detail(self, session_id: str, show_messages: bool = True):
        """显示session的详细信息"""
        session = self.load_session(session_id)
        if not session:
            print(f"❌ Session not found: {session_id}")
            return
        
        print(f"\n{'='*70}")
        print(f"📊 Session Detail: {session_id}")
        print(f"{'='*70}\n")
        
        # 基本信息
        print(f"🕐 Created:  {session['created_at']}")
        print(f"🕑 Updated:  {session['updated_at']}")
        print(f"🤖 Model:    {session['model']}")
        print(f"💬 Messages: {session['messages_count']}")
        print()
        
        # Token统计
        print(f"📈 Token Statistics:")
        
        total_input = session['total_input_tokens']
        total_output = session['total_output_tokens']
        total_reasoning = session.get('total_reasoning_tokens', 0)
        total_cached = session.get('total_cached_tokens', 0)
        
        # 区分regular input和cached input
        regular_input = total_input - total_cached
        
        if total_cached > 0:
            print(f"   Input:      {regular_input:>10,} tokens (regular)")
            print(f"   Cached:     {total_cached:>10,} tokens (from cache)")
            print(f"   Total Input:{total_input:>10,} tokens")
        else:
            print(f"   Input:      {total_input:>10,} tokens")
        
        print(f"   Output:     {total_output:>10,} tokens")
        
        if total_reasoning > 0:
            print(f"   Reasoning:  {total_reasoning:>10,} tokens")
        
        # 总计（不重复计算cached）
        total_tokens = total_input + total_output + total_reasoning
        print(f"   ────────────────────────")
        print(f"   Total:      {total_tokens:>10,} tokens")
        print()
        
        # 成本计算
        cost = self._calculate_cost(session)
        print(f"💰 Estimated Cost: ${cost:.8f} USD")
        print()
        
        # 对话轮次
        if show_messages and 'rounds' in session:
            print(f"📝 Conversation Rounds ({len(session['rounds'])}):")
            print(f"{'─'*70}")
            
            for i, round_data in enumerate(session['rounds'], 1):
                timestamp = round_data.get('timestamp', 'N/A')
                input_tokens = round_data.get('input_tokens', 0)
                output_tokens = round_data.get('output_tokens', 0)
                has_tool_calls = round_data.get('has_tool_calls', False)
                response_type = round_data.get('response_type', 'normal')
                
                print(f"\n  Round {i} @ {timestamp}")
                print(f"    Tokens: {input_tokens:,} in → {output_tokens:,} out")
                
                if has_tool_calls:
                    print(f"    🔧 Tool calls: Yes")
                
                if response_type != 'normal':
                    print(f"    Type: {response_type}")
                
                # 显示完整的messages（如果有）
                if 'messages' in round_data:
                    messages = round_data['messages']
                    print(f"    Messages ({len(messages)}):")
                    for msg in messages[-3:]:  # 只显示最后3条
                        role = msg.get('role', 'unknown')
                        content = msg.get('content', '')
                        content_preview = content[:100] + '...' if len(content) > 100 else content
                        print(f"      [{role}] {content_preview}")
                
                # 显示question/answer/reasoning（如果有）
                if 'question' in round_data:
                    q = round_data['question']
                    q_preview = q[:150] + '...' if len(q) > 150 else q
                    print(f"    ❓ Question: {q_preview}")
                
                if 'answer' in round_data:
                    a = round_data['answer']
                    a_preview = a[:150] + '...' if len(a) > 150 else a
                    print(f"    ✅ Answer: {a_preview}")
                
                if 'reasoning' in round_data and round_data['reasoning']:
                    r = round_data['reasoning']
                    r_preview = r[:150] + '...' if len(r) > 150 else r
                    print(f"    🧠 Reasoning: {r_preview}")
                
                if 'tool_calls' in round_data and round_data['tool_calls']:
                    print(f"    🛠️  Tool Calls:")
                    for tool_call in round_data['tool_calls']:
                        func_name = tool_call.get('function', {}).get('name', 'unknown')
                        args = tool_call.get('function', {}).get('arguments', '')
                        print(f"       - {func_name}({args[:80]}...)")
                
                # 显示token details（如果有）
                if round_data.get('input_token_details'):
                    print(f"    📊 Input Token Details: {round_data['input_token_details']}")
                
                if round_data.get('output_token_details'):
                    print(f"    📊 Output Token Details: {round_data['output_token_details']}")
            
            print(f"\n{'─'*70}")
        
        print(f"\n{'='*70}\n")
    
    def _calculate_cost(self, session: dict) -> float:
        """计算session的成本"""
        model = session.get('model', 'unknown')
        pricing = TOKEN_PRICING.get(model, TOKEN_PRICING.get("GPT-4", {}))
        
        input_tokens = session['total_input_tokens']
        output_tokens = session['total_output_tokens']
        reasoning_tokens = session.get('total_reasoning_tokens', 0)
        cached_tokens = session.get('total_cached_tokens', 0)
        
        # 区分regular input和cached input
        regular_input_tokens = input_tokens - cached_tokens
        
        input_cost = regular_input_tokens * pricing.get('input', 0) / 1000000
        output_cost = output_tokens * pricing.get('output', 0) / 1000000
        
        reasoning_cost = 0
        if 'reasoning' in pricing and reasoning_tokens > 0:
            reasoning_cost = reasoning_tokens * pricing['reasoning'] / 1000000
        
        cached_cost = 0
        if 'cached' in pricing and cached_tokens > 0:
            cached_cost = cached_tokens * pricing['cached'] / 1000000
        
        return input_cost + output_cost + reasoning_cost + cached_cost
    
    def stats_by_model(self) -> Dict[str, dict]:
        """按模型统计token开销"""
        sessions = self.load_all_sessions()
        
        stats = defaultdict(lambda: {
            'session_count': 0,
            'total_input': 0,
            'total_output': 0,
            'total_reasoning': 0,
            'total_cost': 0.0
        })
        
        for session in sessions:
            model = session.get('model', 'unknown')
            stats[model]['session_count'] += 1
            stats[model]['total_input'] += session['total_input_tokens']
            stats[model]['total_output'] += session['total_output_tokens']
            stats[model]['total_reasoning'] += session.get('total_reasoning_tokens', 0)
            stats[model]['total_cost'] += self._calculate_cost(session)
        
        return dict(stats)
    
    def stats_by_date(self, days: int = 30) -> Dict[str, dict]:
        """按日期统计token开销（最近N天）"""
        sessions = self.load_all_sessions()
        
        stats = defaultdict(lambda: {
            'session_count': 0,
            'total_input': 0,
            'total_output': 0,
            'total_reasoning': 0,
            'total_cost': 0.0,
            'models': set()
        })
        
        cutoff_date = datetime.now() - timedelta(days=days)
        
        for session in sessions:
            created_at = datetime.fromisoformat(session['created_at'])
            if created_at < cutoff_date:
                continue
            
            date_key = created_at.strftime('%Y-%m-%d')
            stats[date_key]['session_count'] += 1
            stats[date_key]['total_input'] += session['total_input_tokens']
            stats[date_key]['total_output'] += session['total_output_tokens']
            stats[date_key]['total_reasoning'] += session.get('total_reasoning_tokens', 0)
            stats[date_key]['total_cost'] += self._calculate_cost(session)
            stats[date_key]['models'].add(session.get('model', 'unknown'))
        
        # 转换sets为lists以便JSON序列化
        for date_key in stats:
            stats[date_key]['models'] = list(stats[date_key]['models'])
        
        return dict(stats)
    
    def display_model_stats(self):
        """显示按模型的统计"""
        stats = self.stats_by_model()
        
        print(f"\n{'='*80}")
        print(f"📊 Statistics by Model")
        print(f"{'='*80}\n")
        
        print(f"{'Model':<20} {'Sessions':<10} {'Input':<15} {'Output':<15} {'Cost (USD)':<12}")
        print(f"{'─'*80}")
        
        # 按成本降序排列
        sorted_models = sorted(stats.items(), key=lambda x: x[1]['total_cost'], reverse=True)
        
        for model, data in sorted_models:
            print(f"{model:<20} "
                  f"{data['session_count']:<10} "
                  f"{data['total_input']:>12,}  "
                  f"{data['total_output']:>12,}  "
                  f"${data['total_cost']:>10.6f}")
        
        # 总计
        total_sessions = sum(d['session_count'] for d in stats.values())
        total_input = sum(d['total_input'] for d in stats.values())
        total_output = sum(d['total_output'] for d in stats.values())
        total_cost = sum(d['total_cost'] for d in stats.values())
        
        print(f"{'─'*80}")
        print(f"{'TOTAL':<20} "
              f"{total_sessions:<10} "
              f"{total_input:>12,}  "
              f"{total_output:>12,}  "
              f"${total_cost:>10.6f}")
        
        print(f"\n{'='*80}\n")
    
    def display_date_stats(self, days: int = 30):
        """显示按日期的统计"""
        stats = self.stats_by_date(days)
        
        print(f"\n{'='*80}")
        print(f"📊 Statistics by Date (Last {days} days)")
        print(f"{'='*80}\n")
        
        print(f"{'Date':<12} {'Sessions':<10} {'Input':<15} {'Output':<15} {'Cost (USD)':<12} {'Models':<20}")
        print(f"{'─'*80}")
        
        # 按日期升序排列
        sorted_dates = sorted(stats.items())
        
        for date, data in sorted_dates:
            models_str = ', '.join(data['models'][:3])  # 最多显示3个模型
            if len(data['models']) > 3:
                models_str += f" +{len(data['models'])-3}"
            
            print(f"{date:<12} "
                  f"{data['session_count']:<10} "
                  f"{data['total_input']:>12,}  "
                  f"{data['total_output']:>12,}  "
                  f"${data['total_cost']:>10.4f}  "
                  f"{models_str}")
        
        # 总计
        total_sessions = sum(d['session_count'] for d in stats.values())
        total_input = sum(d['total_input'] for d in stats.values())
        total_output = sum(d['total_output'] for d in stats.values())
        total_cost = sum(d['total_cost'] for d in stats.values())
        
        print(f"{'─'*80}")
        print(f"{'TOTAL':<12} "
              f"{total_sessions:<10} "
              f"{total_input:>12,}  "
              f"{total_output:>12,}  "
              f"${total_cost:>10.4f}")
        
        print(f"\n{'='*80}\n")
    
    def list_sessions(self, limit: int = 20, sort_by: str = 'updated'):
        """列出所有session"""
        sessions = self.load_all_sessions()
        
        # 排序
        if sort_by == 'updated':
            sessions.sort(key=lambda s: s.get('updated_at', ''), reverse=True)
        elif sort_by == 'cost':
            sessions.sort(key=lambda s: self._calculate_cost(s), reverse=True)
        elif sort_by == 'tokens':
            sessions.sort(key=lambda s: s['total_input_tokens'] + s['total_output_tokens'], reverse=True)
        
        print(f"\n{'='*100}")
        print(f"📋 Sessions (sorted by {sort_by}, showing {min(limit, len(sessions))} of {len(sessions)})")
        print(f"{'='*100}\n")
        
        print(f"{'Session ID':<30} {'Updated':<20} {'Model':<15} {'Msgs':<6} {'Tokens':<12} {'Cost':<10}")
        print(f"{'─'*100}")
        
        for session in sessions[:limit]:
            session_id = session['session_id'][:28] + '..' if len(session['session_id']) > 30 else session['session_id']
            updated = session.get('updated_at', 'N/A')[:19]
            model = session.get('model', 'unknown')[:13]
            msg_count = session.get('messages_count', 0)
            total_tokens = session['total_input_tokens'] + session['total_output_tokens']
            cost = self._calculate_cost(session)
            
            print(f"{session_id:<30} {updated:<20} {model:<15} {msg_count:<6} {total_tokens:>10,}  ${cost:>8.4f}")
        
        print(f"\n{'='*100}\n")
    
    def export_finops_report(self, output_file: str, format: str = 'json'):
        """导出FinOps报表"""
        model_stats = self.stats_by_model()
        date_stats = self.stats_by_date(30)
        
        report = {
            'generated_at': datetime.now().isoformat(),
            'summary': {
                'total_sessions': sum(d['session_count'] for d in model_stats.values()),
                'total_input_tokens': sum(d['total_input'] for d in model_stats.values()),
                'total_output_tokens': sum(d['total_output'] for d in model_stats.values()),
                'total_cost_usd': sum(d['total_cost'] for d in model_stats.values()),
            },
            'by_model': model_stats,
            'by_date': date_stats,
        }
        
        output_path = Path(output_file)
        
        if format == 'json':
            with open(output_path, 'w', encoding='utf-8') as f:
                json.dump(report, f, ensure_ascii=False, indent=2)
            print(f"✅ FinOps report exported to: {output_path}")
        
        elif format == 'csv':
            import csv
            
            # 按模型导出CSV
            model_csv = output_path.with_suffix('.model.csv')
            with open(model_csv, 'w', newline='', encoding='utf-8') as f:
                writer = csv.writer(f)
                writer.writerow(['Model', 'Sessions', 'Input Tokens', 'Output Tokens', 'Cost (USD)'])
                for model, data in model_stats.items():
                    writer.writerow([
                        model,
                        data['session_count'],
                        data['total_input'],
                        data['total_output'],
                        f"{data['total_cost']:.6f}"
                    ])
            
            # 按日期导出CSV
            date_csv = output_path.with_suffix('.date.csv')
            with open(date_csv, 'w', newline='', encoding='utf-8') as f:
                writer = csv.writer(f)
                writer.writerow(['Date', 'Sessions', 'Input Tokens', 'Output Tokens', 'Cost (USD)', 'Models'])
                for date, data in sorted(date_stats.items()):
                    writer.writerow([
                        date,
                        data['session_count'],
                        data['total_input'],
                        data['total_output'],
                        f"{data['total_cost']:.6f}",
                        ', '.join(data['models'])
                    ])
            
            print(f"✅ FinOps report exported to:")
            print(f"   Model stats: {model_csv}")
            print(f"   Date stats:  {date_csv}")


def main():
    parser = argparse.ArgumentParser(
        description="Agent Session Monitor CLI - 查询和分析agent对话数据",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Commands:
  show <session-id>      显示session的详细信息
  list                   列出所有session
  stats-model            按模型统计token开销
  stats-date             按日期统计token开销（默认30天）
  export                 导出FinOps报表

Examples:
  # 查看特定session的详细对话
  %(prog)s show agent:main:discord:channel:1465367993012981988
  
  # 列出最近20个session（按更新时间）
  %(prog)s list
  
  # 列出token开销最高的10个session
  %(prog)s list --sort-by cost --limit 10
  
  # 按模型统计token开销
  %(prog)s stats-model
  
  # 按日期统计token开销（最近7天）
  %(prog)s stats-date --days 7
  
  # 导出FinOps报表（JSON格式）
  %(prog)s export finops-report.json
  
  # 导出FinOps报表（CSV格式）
  %(prog)s export finops-report --format csv
        """
    )
    
    parser.add_argument(
        'command',
        choices=['show', 'list', 'stats-model', 'stats-date', 'export'],
        help='命令'
    )
    
    parser.add_argument(
        'args',
        nargs='*',
        help='命令参数（例如：session-id或输出文件名）'
    )
    
    parser.add_argument(
        '--data-dir',
        default='./sessions',
        help='Session数据目录（默认: ./sessions）'
    )
    
    parser.add_argument(
        '--limit',
        type=int,
        default=20,
        help='list命令的结果限制（默认: 20）'
    )
    
    parser.add_argument(
        '--sort-by',
        choices=['updated', 'cost', 'tokens'],
        default='updated',
        help='list命令的排序方式（默认: updated）'
    )
    
    parser.add_argument(
        '--days',
        type=int,
        default=30,
        help='stats-date命令的天数（默认: 30）'
    )
    
    parser.add_argument(
        '--format',
        choices=['json', 'csv'],
        default='json',
        help='export命令的输出格式（默认: json）'
    )
    
    parser.add_argument(
        '--no-messages',
        action='store_true',
        help='show命令：不显示对话内容'
    )
    
    args = parser.parse_args()
    
    try:
        analyzer = SessionAnalyzer(args.data_dir)
        
        if args.command == 'show':
            if not args.args:
                parser.error("show命令需要session-id参数")
            session_id = args.args[0]
            analyzer.display_session_detail(session_id, show_messages=not args.no_messages)
        
        elif args.command == 'list':
            analyzer.list_sessions(limit=args.limit, sort_by=args.sort_by)
        
        elif args.command == 'stats-model':
            analyzer.display_model_stats()
        
        elif args.command == 'stats-date':
            analyzer.display_date_stats(days=args.days)
        
        elif args.command == 'export':
            if not args.args:
                parser.error("export命令需要输出文件名参数")
            output_file = args.args[0]
            analyzer.export_finops_report(output_file, format=args.format)
    
    except FileNotFoundError as e:
        print(f"❌ Error: {e}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(f"❌ Unexpected error: {e}", file=sys.stderr)
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == '__main__':
    main()

```