llmproxy-withlog 1.0.0__py3-none-any.whl

llmproxy/__init__.py

@@ -0,0 +1,3 @@
+"""LLM Proxy - OpenAI-compatible LLM reverse proxy with real-time analytics."""
+
+__version__ = "1.0.0"

llmproxy/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as: python -m llmproxy"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

llmproxy/analyzer.py

@@ -0,0 +1,283 @@
+"""Offline log analysis tool for LLM Proxy."""
+
+import json
+import os
+import re
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+def find_log_files(paths: Optional[list[str]] = None, log_dir: str = "logs") -> list[Path]:
+    if paths:
+        return sorted(Path(p) for p in paths if Path(p).exists())
+    return sorted(Path(log_dir).glob("*.log"))
+
+
+def parse_streaming_chunks(raw_body: str) -> dict:
+    content_parts = []
+    tool_calls: dict[int, dict] = {}
+    usage = None
+    model = None
+    finish_reason = None
+    for line in raw_body.strip().splitlines():
+        line = line.strip()
+        if not line or line == "data: [DONE]":
+            continue
+        if not line.startswith("data: "):
+            continue
+        try:
+            chunk = json.loads(line[6:])
+        except json.JSONDecodeError:
+            continue
+        if not chunk:
+            continue
+        if chunk.get("model"):
+            model = chunk.get("model")
+        if chunk.get("lastOne"):
+            usage = chunk.get("usage")
+        for choice in chunk.get("choices", []):
+            delta = choice.get("delta", {})
+            c = delta.get("content")
+            if c:
+                content_parts.append(c)
+            for tc in delta.get("tool_calls", []):
+                idx = tc.get("index", 0)
+                if idx not in tool_calls:
+                    tool_calls[idx] = {"id": "", "type": "function",
+                                       "function": {"name": "", "arguments": ""}}
+                if tc.get("id"):
+                    tool_calls[idx]["id"] = tc["id"]
+                if tc.get("type"):
+                    tool_calls[idx]["type"] = tc["type"]
+                fn = tc.get("function", {})
+                if fn.get("name"):
+                    tool_calls[idx]["function"]["name"] = fn["name"]
+                if fn.get("arguments"):
+                    tool_calls[idx]["function"]["arguments"] += fn["arguments"]
+            fr = choice.get("finish_reason")
+            if fr:
+                finish_reason = fr
+    merged_tc = [tool_calls[i] for i in sorted(tool_calls.keys())] if tool_calls else None
+    result = {"content": "".join(content_parts), "tool_calls": merged_tc,
+              "finish_reason": finish_reason, "model": model}
+    if usage:
+        result["usage"] = usage
+    return result
+
+
+def extract_user_messages(body_str: str) -> list[dict]:
+    try:
+        data = json.loads(body_str)
+    except json.JSONDecodeError:
+        return []
+    messages = data.get("messages", [])
+    result = []
+    for msg in messages:
+        role = msg.get("role", "")
+        content = msg.get("content", "")
+        if isinstance(content, list):
+            text_parts = [item.get("text", "") for item in content
+                          if isinstance(item, dict) and item.get("type") == "text"]
+            content = "\n".join(text_parts)
+        result.append({"role": role, "content": content})
+    return result
+
+
+def parse_log_file(filepath: Path, no_system: bool = False,
+                   only_user: bool = False) -> list[dict]:
+    records = []
+    with open(filepath, "r", encoding="utf-8", errors="replace") as f:
+        text = f.read()
+    pattern = re.compile(r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3})  INFO  (>>>|<<<) (\w+)")
+    matches = list(pattern.finditer(text))
+    for i, m in enumerate(matches):
+        timestamp = m.group(1)
+        direction = m.group(2)
+        record_type = m.group(3)
+        start = m.end()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        block = text[start:end].strip()
+        if direction == ">>>":
+            body_match = re.match(r"\s*MODEL=(\S+)\s+BODY=(.*)", block, re.DOTALL)
+            if not body_match:
+                continue
+            model = body_match.group(1)
+            body_str = body_match.group(2).strip()
+            messages = extract_user_messages(body_str)
+            user_contents = []
+            for msg in messages:
+                if msg["role"] == "user":
+                    user_contents.append(msg["content"])
+                elif msg["role"] == "system" and not no_system:
+                    content = msg["content"]
+                    if len(content) > 200 and only_user:
+                        continue
+                    user_contents.append(f"[SYSTEM] {content[:500]}..." if len(content) > 500 else f"[SYSTEM] {content}")
+            if only_user:
+                user_contents = [c for c in user_contents if not c.startswith("[SYSTEM]")]
+            if not user_contents and only_user:
+                continue
+            records.append({
+                "timestamp": timestamp, "model": model, "direction": "input",
+                "user_input": "\n".join(user_contents) if user_contents else "(no user message)",
+                "assistant_output": None, "tool_calls": None,
+                "finish_reason": None, "usage": None, "status": None,
+            })
+        elif direction == "<<<":
+            body_match = re.match(r"\s*MODEL=(\S+)\s+STATUS=(\d+)\s+BODY=(.*)", block, re.DOTALL)
+            if not body_match:
+                error_match = re.match(r"\s*MODEL=(\S+)\s+REASON=(.*)", block, re.DOTALL)
+                if error_match:
+                    records.append({
+                        "timestamp": timestamp, "model": error_match.group(1),
+                        "direction": "error", "user_input": None,
+                        "assistant_output": None, "tool_calls": None,
+                        "finish_reason": "error", "usage": None,
+                        "status": "error", "error_reason": error_match.group(2).strip(),
+                    })
+                continue
+            model = body_match.group(1)
+            status = int(body_match.group(2))
+            body_str = body_match.group(3).strip()
+            if body_str.startswith("data:"):
+                parsed = parse_streaming_chunks(body_str)
+                assistant_output = parsed["content"]
+                tool_calls = parsed.get("tool_calls")
+                finish_reason = parsed.get("finish_reason")
+                usage = parsed.get("usage")
+            else:
+                try:
+                    data = json.loads(body_str)
+                    assistant_output = ""
+                    tool_calls = None
+                    finish_reason = None
+                    for choice in data.get("choices", []):
+                        msg = choice.get("message", {})
+                        if msg.get("content"):
+                            assistant_output += msg["content"]
+                        if msg.get("tool_calls"):
+                            tool_calls = msg["tool_calls"]
+                        if choice.get("finish_reason"):
+                            finish_reason = choice["finish_reason"]
+                    usage = data.get("usage")
+                except json.JSONDecodeError:
+                    assistant_output = body_str[:500]
+                    tool_calls = None
+                    finish_reason = None
+                    usage = None
+            records.append({
+                "timestamp": timestamp, "model": model, "direction": "output",
+                "user_input": None, "assistant_output": assistant_output,
+                "tool_calls": tool_calls, "finish_reason": finish_reason,
+                "usage": usage, "status": status,
+            })
+    return records
+
+
+def pair_conversations(records: list[dict]) -> list[dict]:
+    conversations = []
+    current_input = None
+    for rec in records:
+        if rec["direction"] == "input":
+            current_input = rec
+        elif rec["direction"] == "output" and current_input:
+            conversations.append({
+                "timestamp": current_input["timestamp"],
+                "model": current_input["model"],
+                "user_input": current_input["user_input"],
+                "assistant_output": rec["assistant_output"],
+                "tool_calls": rec["tool_calls"],
+                "finish_reason": rec["finish_reason"],
+                "usage": rec["usage"],
+                "status": rec["status"],
+            })
+            current_input = None
+        elif rec["direction"] == "error" and current_input:
+            conversations.append({
+                "timestamp": current_input["timestamp"],
+                "model": current_input["model"],
+                "user_input": current_input["user_input"],
+                "assistant_output": None, "tool_calls": None,
+                "finish_reason": "error", "usage": None,
+                "status": "error", "error_reason": rec.get("error_reason", ""),
+            })
+            current_input = None
+    return conversations
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="LLM Proxy log analyzer")
+    parser.add_argument("files", nargs="*", help="Log file paths")
+    parser.add_argument("--all", action="store_true", help="Analyze all logs in logs/ dir")
+    parser.add_argument("--format", choices=["text", "json"], default="text")
+    parser.add_argument("--output", "-o", help="Output file path")
+    parser.add_argument("--no-system", action="store_true", help="Skip system messages")
+    parser.add_argument("--only-user", action="store_true", help="Only user role input")
+    parser.add_argument("--stats", action="store_true", help="Only output statistics")
+    args = parser.parse_args()
+
+    if args.files:
+        log_files = find_log_files(args.files)
+    else:
+        log_files = find_log_files()
+
+    if not log_files:
+        print("No log files found", file=sys.stderr)
+        sys.exit(1)
+
+    all_conversations = []
+    for log_file in log_files:
+        records = parse_log_file(log_file, no_system=args.no_system, only_user=args.only_user)
+        conversations = pair_conversations(records)
+        all_conversations.extend(conversations)
+
+    if args.stats:
+        total = len(all_conversations)
+        errors = sum(1 for c in all_conversations if c.get("status") == "error")
+        total_input_tokens = sum((c.get("usage") or {}).get("prompt_tokens", 0) or 0 for c in all_conversations)
+        total_output_tokens = sum((c.get("usage") or {}).get("completion_tokens", 0) or 0 for c in all_conversations)
+        models = {}
+        for c in all_conversations:
+            m = c.get("model", "unknown")
+            models[m] = models.get(m, 0) + 1
+        print(json.dumps({
+            "total_conversations": total, "errors": errors,
+            "total_input_tokens": total_input_tokens,
+            "total_output_tokens": total_output_tokens,
+            "models": models,
+        }, ensure_ascii=False, indent=2))
+        return
+
+    if args.format == "json":
+        report = json.dumps(all_conversations, ensure_ascii=False, indent=2)
+    else:
+        lines = ["=" * 80, "LLM Proxy Log Analysis Report",
+                 f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+                 f"Conversations: {len(all_conversations)}", "=" * 80]
+        for i, conv in enumerate(all_conversations, 1):
+            lines += ["", f"--- #{i} | {conv['timestamp']} | {conv['model']} ---", "",
+                       f"[User]\n{conv['user_input'] or '(empty)'}", "",
+                       f"[Assistant] finish={conv.get('finish_reason', 'N/A')}\n{conv['assistant_output'] or '(empty)'}"]
+            if conv.get("tool_calls"):
+                lines.append(f"\n[Tool Calls] {len(conv['tool_calls'])}")
+                for j, tc in enumerate(conv["tool_calls"]):
+                    fn = tc.get("function", {})
+                    lines.append(f"  [{j+1}] {fn.get('name', '?')}({fn.get('arguments', '')[:200]})")
+            if conv.get("usage"):
+                u = conv["usage"]
+                lines.append(f"\n[Token] prompt={u.get('prompt_tokens','?')} completion={u.get('completion_tokens','?')} total={u.get('total_tokens','?')}")
+            lines.append("-" * 80)
+        report = "\n".join(lines)
+
+    if args.output:
+        with open(args_output, "w", encoding="utf-8") as f:
+            f.write(report)
+    else:
+        print(report)
+
+
+if __name__ == "__main__":
+    main()

llmproxy/cli.py

@@ -0,0 +1,33 @@
+"""CLI entry point for llmproxy."""
+
+import sys
+
+
+def main():
+    """Run the LLM Proxy server."""
+    import argparse
+    import uvicorn
+    from .server import create_app
+
+    parser = argparse.ArgumentParser(description="LLM Proxy server")
+    parser.add_argument("--config", default=None, help="Path to config.ini")
+    parser.add_argument("--host", default=None, help="Override bind host")
+    parser.add_argument("--port", type=int, default=None, help="Override bind port")
+    args = parser.parse_args()
+
+    app = create_app(config_path=args.config)
+
+    # Read host/port from config if not overridden
+    import configparser
+    import os
+    config_path = args.config or os.environ.get("LLMPROXY_CONFIG", "config.ini")
+    cfg = configparser.ConfigParser()
+    cfg.read(config_path)
+    host = args.host or cfg.get("proxy", "host", fallback="0.0.0.0")
+    port = args.port or cfg.getint("proxy", "port", fallback=8000)
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

llmproxy/server.py

@@ -0,0 +1,269 @@
+"""Core proxy server module."""
+
+import json
+import logging
+import os
+from datetime import datetime
+from threading import Lock
+from typing import Optional
+
+import httpx
+from fastapi import FastAPI, HTTPException, Request, Response
+from fastapi.responses import JSONResponse, StreamingResponse
+
+REPORT_DIR = "reports"
+os.makedirs(REPORT_DIR, exist_ok=True)
+
+_log = logging.getLogger("llmproxy")
+_log.setLevel(logging.INFO)
+if not _log.handlers:
+    _log.addHandler(logging.StreamHandler())
+
+_report_write_lock = Lock()
+
+
+def _extract_user_input(req_json: dict) -> str:
+    messages = req_json.get("messages", [])
+    parts = []
+    for msg in messages:
+        if msg.get("role") == "user":
+            content = msg.get("content", "")
+            if isinstance(content, list):
+                text_parts = [
+                    item.get("text", "")
+                    for item in content
+                    if isinstance(item, dict) and item.get("type") == "text"
+                ]
+                content = "\n".join(text_parts)
+            parts.append(content)
+    return "\n".join(parts) if parts else "(no user message)"
+
+
+def _parse_output(output_text: str) -> dict:
+    result: dict = {"content": "", "tool_calls": None, "finish_reason": None, "usage": None}
+    if output_text.lstrip().startswith("data:"):
+        content_parts: list[str] = []
+        tc_map: dict[int, dict] = {}
+        for line in output_text.strip().splitlines():
+            line = line.strip()
+            if not line or line == "data: [DONE]":
+                continue
+            if not line.startswith("data: "):
+                continue
+            try:
+                chunk = json.loads(line[6:])
+            except json.JSONDecodeError:
+                continue
+            if not chunk:
+                continue
+            if chunk.get("lastOne"):
+                result["usage"] = chunk.get("usage")
+            for choice in chunk.get("choices", []):
+                delta = choice.get("delta", {})
+                c = delta.get("content")
+                if c:
+                    content_parts.append(c)
+                for tc in delta.get("tool_calls", []):
+                    idx = tc.get("index", 0)
+                    if idx not in tc_map:
+                        tc_map[idx] = {"id": "", "type": "function",
+                                       "function": {"name": "", "arguments": ""}}
+                    if tc.get("id"):
+                        tc_map[idx]["id"] = tc["id"]
+                    if tc.get("type"):
+                        tc_map[idx]["type"] = tc["type"]
+                    fn = tc.get("function", {})
+                    if fn.get("name"):
+                        tc_map[idx]["function"]["name"] = fn["name"]
+                    if fn.get("arguments"):
+                        tc_map[idx]["function"]["arguments"] += fn["arguments"]
+                fr = choice.get("finish_reason")
+                if fr:
+                    result["finish_reason"] = fr
+        result["content"] = "".join(content_parts)
+        if tc_map:
+            result["tool_calls"] = [tc_map[i] for i in sorted(tc_map)]
+    else:
+        try:
+            data = json.loads(output_text)
+        except json.JSONDecodeError:
+            result["content"] = output_text[:500]
+            return result
+        for choice in data.get("choices", []):
+            msg = choice.get("message", {})
+            if msg.get("content"):
+                result["content"] += msg["content"]
+            if msg.get("tool_calls"):
+                result["tool_calls"] = msg["tool_calls"]
+            if choice.get("finish_reason"):
+                result["finish_reason"] = choice["finish_reason"]
+        result["usage"] = data.get("usage")
+    return result
+
+
+def _format_tool_calls(tool_calls: list[dict]) -> str:
+    lines = []
+    for i, tc in enumerate(tool_calls):
+        fn = tc.get("function", {})
+        args = fn.get("arguments", "")
+        try:
+            args_str = json.dumps(json.loads(args), ensure_ascii=False)
+        except (json.JSONDecodeError, TypeError):
+            args_str = args
+        lines.append(f"  [{i+1}] {fn.get('name', '?')}({args_str[:300]})")
+    return "\n".join(lines)
+
+
+def append_report(now: datetime, model_name: str, req_json: dict,
+                  output_text: str, status_code: int) -> None:
+    ymd = now.strftime("%Y%m%d")
+    report_path = os.path.join(REPORT_DIR, f"{ymd}-analysis.txt")
+    user_input = _extract_user_input(req_json)
+    parsed = _parse_output(output_text)
+    _report_write_lock.acquire()
+    try:
+        with open(report_path, "a", encoding="utf-8") as f:
+            f.write(f"\n{'─'*70}\n")
+            f.write(f"时间: {now.strftime('%Y-%m-%d %H:%M:%S')}  ")
+            f.write(f"模型: {model_name}  ")
+            f.write(f"状态: {status_code}  ")
+            f.write(f"finish: {parsed.get('finish_reason') or 'N/A'}\n\n")
+            f.write(f"[用户输入]\n{user_input}\n\n")
+            if parsed.get("tool_calls"):
+                f.write(f"[工具调用] {len(parsed['tool_calls'])} 个\n")
+                f.write(_format_tool_calls(parsed["tool_calls"]))
+                f.write("\n\n")
+            f.write(f"[LLM 输出]\n{parsed['content']}\n")
+            if parsed.get("usage"):
+                u = parsed["usage"]
+                f.write(f"\n[Token] prompt={u.get('prompt_tokens','?')} "
+                        f"completion={u.get('completion_tokens','?')} "
+                        f"total={u.get('total_tokens','?')}\n")
+    finally:
+        _report_write_lock.release()
+
+
+def create_app(config_path: Optional[str] = None) -> FastAPI:
+    """Create and configure the FastAPI application."""
+    import configparser
+
+    if config_path is None:
+        config_path = os.environ.get("LLMPROXY_CONFIG", "config.ini")
+
+    cfg = configparser.ConfigParser()
+    cfg.read(config_path)
+
+    models: dict[str, tuple[str, str, str]] = {}
+    for name, val in cfg["models"].items():
+        if "|" in val:
+            key, base, model = val.split("|", 2)
+            models[name] = (key.strip(), base.strip(), model.strip())
+
+    proxy_host = cfg.get("proxy", "host", fallback="0.0.0.0")
+    proxy_port = cfg.getint("proxy", "port", fallback=8000)
+    proxy_api_key = cfg.get("auth", "proxy_api_key", fallback="")
+
+    log_dir = "logs"
+    os.makedirs(log_dir, exist_ok=True)
+
+    def get_logger(ymd: str) -> logging.Logger:
+        fh = logging.FileHandler(os.path.join(log_dir, f"{ymd}.log"), encoding="utf-8")
+        fh.setFormatter(logging.Formatter("%(asctime)s  %(levelname)s  %(message)s"))
+        _log.handlers = [h for h in _log.handlers if not isinstance(h, logging.FileHandler)]
+        _log.addHandler(fh)
+        return _log
+
+    def verify_auth(auth_header: Optional[str]):
+        if not proxy_api_key:
+            return
+        if not auth_header:
+            raise HTTPException(401, "Missing Authorization header")
+        if auth_header.removeprefix("Bearer ").strip() != proxy_api_key:
+            raise HTTPException(403, "Invalid proxy API key")
+
+    app = FastAPI(title="LLM Proxy", version="1.0.0")
+
+    @app.get("/v1/version")
+    async def get_version(request: Request):
+        verify_auth(request.headers.get("Authorization"))
+        return JSONResponse({"version": "1.0.0", "name": "llmproxy"})
+
+    @app.get("/v1/props")
+    async def get_props(request: Request):
+        verify_auth(request.headers.get("Authorization"))
+        return JSONResponse({
+            "models": list(models.keys()),
+            "host": proxy_host,
+            "port": proxy_port,
+            "auth_enabled": bool(proxy_api_key),
+        })
+
+    @app.get("/v1/models")
+    async def list_models(request: Request):
+        verify_auth(request.headers.get("Authorization"))
+        data = [{"id": m, "object": "model",
+                 "created": int(datetime.now().timestamp()),
+                 "owned_by": "llmproxy"} for m in models]
+        return JSONResponse({"object": "list", "data": data})
+
+    @app.api_route("/v1/{path:path}", methods=["POST", "GET", "PUT", "DELETE", "PATCH"])
+    async def proxy(request: Request, path: str):
+        verify_auth(request.headers.get("Authorization"))
+        body_bytes = await request.body()
+        try:
+            req_json = json.loads(body_bytes) if body_bytes else {}
+        except json.JSONDecodeError:
+            raise HTTPException(400, "Invalid JSON body")
+
+        model_name = req_json.get("model", "").lower()
+        if not model_name or model_name not in models:
+            raise HTTPException(400, f"Unsupported model '{model_name}'. Available: {list(models.keys())}")
+
+        api_key, base_url, model = models[model_name]
+        req_json["model"] = model
+        target_url = f"{base_url.rstrip('/')}/{path}"
+        headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+        input_text = json.dumps(req_json)
+        now = datetime.now()
+        ymd = now.strftime("%Y%m%d")
+        log = get_logger(ymd)
+        log.info(">>> INPUT  MODEL=%(model)s  BODY=%(body)s",
+                 {"name": model_name, "model": model, "body": input_text})
+
+        async with httpx.AsyncClient(timeout=300) as client:
+            try:
+                resp = await client.request(method=request.method, url=target_url,
+                                            headers=headers, content=input_text)
+                content_type = resp.headers.get("content-type", "")
+
+                if "text/event-stream" in content_type:
+                    output_chunks: list[bytes] = []
+
+                    async def stream_with_capture():
+                        async for chunk in resp.aiter_bytes():
+                            output_chunks.append(chunk)
+                            yield chunk
+                        output_text = b"".join(output_chunks).decode("utf-8", errors="replace")
+                        append_report(now, model_name, req_json, output_text, resp.status_code)
+
+                    log.info("<<< OUTPUT MODEL=%(model)s  STATUS=%(status)d  STREAMING=true",
+                             {"model": model_name, "status": resp.status_code})
+                    return StreamingResponse(
+                        stream_with_capture(), status_code=resp.status_code,
+                        media_type="text/event-stream",
+                        headers={k: v for k, v in resp.headers.items() if k.lower() != "content-encoding"},
+                    )
+                else:
+                    output_text = resp.text
+                    log.info("<<< OUTPUT MODEL=%(model)s  STATUS=%(status)d  BODY=%(body)s",
+                             {"model": model_name, "status": resp.status_code, "body": output_text})
+                    append_report(now, model_name, req_json, output_text, resp.status_code)
+                    return Response(content=output_text, status_code=resp.status_code,
+                                    media_type=content_type)
+
+            except httpx.RequestError as e:
+                log.error("<<< ERROR  MODEL=%(model)s  REASON=%(reason)s",
+                          {"model": model_name, "reason": str(e)})
+                raise HTTPException(502, f"Upstream request failed: {e}")
+
+    return app

llmproxy_withlog-1.0.0.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: llmproxy-withlog
+Version: 1.0.0
+Summary: OpenAI-compatible LLM reverse proxy with real-time conversation analytics
+Author-email: william <william@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/hkjgvugkjh/llmproxy
+Project-URL: Repository, https://github.com/hkjgvugkjh/llmproxy
+Project-URL: Issues, https://github.com/hkjgvugkjh/llmproxy/issues
+Keywords: llm,proxy,openai,api,analytics,chatbot
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: uvicorn[standard]>=0.29
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+
+# LLM Proxy
+
+OpenAI 兼容的 LLM 反向代理，支持多模型路由、请求日志记录和实时对话分析报告。
+
+## 功能特性
+
+- **多模型路由**：通过 `config.ini` 配置多个上游 LLM 客户端，统一用 OpenAI 格式调用
+- **请求日志**：每次请求/响应自动记录到 `logs/YYYYMMDD.log`
+- **实时分析报告**：每个请求完成后自动追加到 `reports/YYYYMMDD-analysis.txt`，包含：
+  - 用户输入（仅 user 角色）
+  - LLM 完整输出（流式响应自动合并 SSE chunk）
+  - 工具调用详情
+  - Token 用量
+- **流式响应支持**：边转发边收集，不改变流式行为
+- **并发安全**：多请求并发写入报告时自动加锁
+- **独立日志分析工具**：`analyze_logs.py` 支持对历史日志做离线分析和统计
+
+## 环境要求
+
+- Python 3.10+
+- 依赖：`fastapi` `httpx` `uvicorn`
+
+## 快速开始
+
+### 1. 安装依赖
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. 配置
+
+编辑 `config.ini`，填入你的上游 LLM 信息：
+
+```ini
+[models]
+my-model = YOUR_API_KEY|https://api.openai.com/v1|gpt-4o
+
+[proxy]
+host = 0.0.0.0
+port = 8000
+
+[auth]
+proxy_api_key = my-secret-key   # 可选，留空不校验
+```
+
+### 3. 启动
+
+```bash
+# 前台启动
+python3 llm_proxy.py
+
+# 后台启动
+./start.sh
+
+# systemd 服务
+sudo cp llmproxy.service /etc/systemd/system/
+sudo systemctl enable --now llmproxy
+```
+
+### 4. 调用示例
+
+```bash
+# 列出可用模型
+curl -s http://localhost:8000/v1/models \
+  -H "Authorization: Bearer my-secret-key" | jq
+
+# 对话
+curl -s http://localhost:8000/v1/chat/completions \
+  -H "Authorization: Bearer my-secret-key" \
+  -H "Content-Type: application/json" \
+  -d '{"model":"my-model","messages":[{"role":"user","content":"你好"}]}'
+```
+
+## API 端点
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| GET | `/v1/version` | 版本信息 |
+| GET | `/v1/props` | 配置信息（模型列表等） |
+| GET | `/v1/models` | 模型列表（OpenAI 格式） |
+| ALL | `/v1/{path}` | 透传到上游（支持 POST/GET/PUT/DELETE/PATCH） |
+
+## 文件结构
+
+```
+llmproxy/
+├── llm_proxy.py          # 主程序（代理 + 实时报告）
+├── analyze_logs.py       # 离线日志分析工具
+├── daily_analyze.sh      # 每日分析定时脚本
+├── config.ini            # 配置文件（需自行填写）
+├── requirements.txt      # Python 依赖
+├── start.sh              # 后台启动脚本
+├── llmproxy.service      # systemd 服务文件
+├── README.md             # 本文件
+├── logs/                 # 请求日志（自动生成）
+│   └── YYYYMMDD.log
+└── reports/              # 对话分析报告（自动生成）
+    └── YYYYMMDD-analysis.txt
+```
+
+## 日志分析工具
+
+`analyze_logs.py` 支持对历史日志做离线分析：
+
+```bash
+# 分析指定文件，输出文本报告
+python3 analyze_logs.py logs/20260523.log --only-user
+
+# 输出 JSON 格式
+python3 analyze_logs.py logs/20260523.log --format json -o result.json
+
+# 仅统计信息
+python3 analyze_logs.py logs/20260523.log --stats
+
+# 分析所有日志
+python3 analyze_logs.py --all --stats
+```
+
+## 报告格式示例
+
+```
+──────────────────────────────────────────────────────────────────────
+时间: 2026-05-23 15:00:00  模型: my-model  状态: 200  finish: stop
+
+[用户输入]
+你好，请介绍一下你自己
+
+[LLM 输出]
+你好！我是一个 AI 助手，可以帮你完成各种任务...
+
+[Token] prompt=128 completion=64 total=192
+```
+
+## License
+
+MIT

llmproxy_withlog-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+llmproxy/__init__.py,sha256=mQU3InoddrvbgN25ZNipN7M_tQgBtECwmor4fWjmzDE,103
+llmproxy/__main__.py,sha256=J4sjpF3UFAL_-7fnknWRrQxqwBYMK3WpWqeHt5KqiTY,105
+llmproxy/analyzer.py,sha256=i80cxKAVvmXCY0v5EgA_ZLn6_hLqoH99RgBixoE04rE,12161
+llmproxy/cli.py,sha256=bgLndus-fhYxMyR8iJa5Ym3SAmN9S_S48fUZFe90eJ4,1012
+llmproxy/server.py,sha256=GvQDQ9aamatOYx3m5n8G4-Okq68wRd5ygkzn7P1XXCQ,11223
+llmproxy_withlog-1.0.0.dist-info/METADATA,sha256=e88LjkA-g6Ag416wvo4Im1gQvrHkK_Id1Sid-0VThmM,4915
+llmproxy_withlog-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+llmproxy_withlog-1.0.0.dist-info/entry_points.txt,sha256=fDGSPH4tcc0o-IfOe0HzNxvNKblMDL5C-87MTsJtJdw,47
+llmproxy_withlog-1.0.0.dist-info/top_level.txt,sha256=4cSfjBrXRgldvKNBqhAGPfmwvXGCrIag84jA8yzUars,9
+llmproxy_withlog-1.0.0.dist-info/RECORD,,

llmproxy_withlog-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

llmproxy_withlog-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+llmproxy = llmproxy.cli:main

llmproxy_withlog-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+llmproxy