union-app-chat-stream 1.0.8__tar.gz

union_app_chat_stream-1.0.8/MANIFEST.in

@@ -0,0 +1,13 @@
+include PROJECT_OVERVIEW.md
+include requirements.txt
+include ci.yml
+include package.json
+recursive-include app *.py
+recursive-include deploy *.yml *.yaml *.txt *.sh *.j2
+recursive-include tools *.yml *.yaml
+recursive-include knowledge *.md
+recursive-exclude deploy/offline-packages *
+recursive-exclude app .env*
+global-exclude *.py[cod]
+global-exclude __pycache__
+global-exclude .DS_Store

union_app_chat_stream-1.0.8/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: union-app-chat-stream
+Version: 1.0.8
+Summary: Union operations chat stream Flask application package.
+License-Expression: LicenseRef-Proprietary
+Requires-Python: >=3.12
+Requires-Dist: annotated-types==0.7.0
+Requires-Dist: anyio==4.6.2
+Requires-Dist: blinker==1.8.2
+Requires-Dist: certifi==2025.8.3
+Requires-Dist: charset-normalizer==3.4.4
+Requires-Dist: click==8.1.8
+Requires-Dist: concurrent-log-handler==0.9.28
+Requires-Dist: curlify==3.0.0
+Requires-Dist: distro==1.9.0
+Requires-Dist: dnspython==2.6.1
+Requires-Dist: exceptiongroup==1.3.0
+Requires-Dist: Flask==3.0.3
+Requires-Dist: Flask-Cors==5.0.0
+Requires-Dist: h11==0.16.0
+Requires-Dist: h2==4.1.0
+Requires-Dist: hpack==4.0.0
+Requires-Dist: httpcore==1.0.9
+Requires-Dist: httpx==0.28.1
+Requires-Dist: Hypercorn==0.17.3
+Requires-Dist: hyperframe==6.0.1
+Requires-Dist: idna==3.10
+Requires-Dist: itsdangerous==2.2.0
+Requires-Dist: Jinja2==3.1.6
+Requires-Dist: jiter==0.9.1
+Requires-Dist: loguru==0.7.3
+Requires-Dist: lxml==6.0.1
+Requires-Dist: MarkupSafe==2.1.5
+Requires-Dist: numpy<2.5.0,>=2.0.0
+Requires-Dist: opencv-python>=4.13.0.90
+Requires-Dist: openai==1.107.3
+Requires-Dist: packaging==25.0
+Requires-Dist: portalocker==3.0.0
+Requires-Dist: priority==2.0.0
+Requires-Dist: PyJWT==2.9.0
+Requires-Dist: python-dateutil==2.9.0.post0
+Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: pytz==2025.2
+Requires-Dist: requests==2.32.5
+Requires-Dist: six==1.17.0
+Requires-Dist: sniffio==1.3.1
+Requires-Dist: tqdm==4.67.3
+Requires-Dist: typing_extensions==4.15.0
+Requires-Dist: tzdata==2025.2
+Requires-Dist: urllib3==1.26.20
+Requires-Dist: Werkzeug==3.0.6
+Requires-Dist: wsproto==1.2.0
+Requires-Dist: zipp==3.20.2
+Requires-Dist: pydantic==2.13.4
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: zai-sdk==0.2.2
+Requires-Dist: chromadb==1.5.9
+Requires-Dist: pysqlite3-binary==0.5.4
+Requires-Dist: typer==0.15.1

union_app_chat_stream-1.0.8/PROJECT_OVERVIEW.md

@@ -0,0 +1,203 @@
+# Project Overview
+
+## Purpose
+
+This repository contains a Python 3.12 Flask application for Union operations
+chat and RAG-assisted troubleshooting. It exposes streaming chat APIs, runtime
+management APIs, and a health check endpoint. The app is intended to run behind
+Hypercorn in Linux x86_64 deployment environments.
+
+## Stack
+
+- Language: Python 3.12
+- Web framework: Flask running through Hypercorn ASGI
+- LLM SDK: zai-sdk
+- Vector database: ChromaDB
+- Validation: Pydantic v2
+- Logging: Loguru
+- Runtime target: Linux x86_64
+
+## Repository Layout
+
+```text
+union-py-app/
+├── app/                         # Flask application package
+│   ├── __init__.py              # create_app() factory and blueprint setup
+│   ├── wsgi.py                  # Application entrypoint
+│   ├── authenticated_user.py    # Session authentication middleware
+│   ├── config/                  # Configuration and logging
+│   ├── manager/                 # Business orchestration layer
+│   ├── models/                  # Pydantic schemas
+│   ├── service/                 # Core services: chat, RAG, LLM, union logic
+│   ├── utils/                   # Shared utility functions
+│   └── views/                   # Flask blueprints and HTTP routes
+├── knowledge/                   # RAG knowledge source files
+├── tools/                       # Tool definitions for model tool calling
+├── scripts/                     # Environment-specific launcher scripts
+├── deploy/                      # Deployment config, templates, and scripts
+├── requirements.txt             # Python dependencies
+├── ci.yml                       # CI configuration
+└── .gitignore
+```
+
+Project-specific context belongs in this file. Do not add a repository-root
+`AGENTS.md`; global working rules are provided outside the repo.
+
+## Important Modules
+
+- `app/__init__.py`: Builds the Flask app, loads configuration, initializes
+  managers in `app.extensions`, and registers blueprints.
+- `app/wsgi.py`: Imports `create_app()` and exposes `app` for Hypercorn.
+- `app/authenticated_user.py`: Validates login identity before requests.
+- `app/config/env_config.py`: Defines Flask configuration values.
+- `app/config/logger_config.py`: Initializes application logging.
+- `app/manager/chatstream_manager.py`: Orchestrates chatstream routes, including
+  chat streaming and RAG status/rebuild operations.
+- `app/manager/runtime_manager.py`: Handles runtime management behavior.
+- `app/manager/prompts.py`: Stores prompt templates.
+- `app/models/schemas.py`: Defines request and response schemas.
+- `app/service/chat_service.py`: Implements streaming chat and tool-call loops.
+- `app/service/rag_service.py`: Manages RAG indexing and retrieval.
+- `app/service/llm_service.py`: Wraps LLM provider behavior.
+- `app/service/union_service.py`: Contains Union operations business services.
+- `app/utils/function_utils.py`: Loads YAML tool definitions and dispatches
+  tool calls.
+- `app/views/view_chatstream.py`: Chatstream and RAG HTTP endpoints.
+- `app/views/view_runtime.py`: Runtime HTTP endpoints.
+- `app/views/view_healthcheck.py`: Health check HTTP endpoint.
+
+## API Surface
+
+| Method | Path | Blueprint | Purpose |
+|---|---|---|---|
+| POST | `/chatstream/v1/chat/stream` | chatstream | SSE streaming chat with RAG and tool calls |
+| GET | `/chatstream/v1/rag/check` | chatstream | RAG knowledge and vector database status |
+| POST | `/chatstream/v1/rag/force-rebuild` | chatstream | Force rebuild of the RAG knowledge base |
+| GET | `/healthcheck.html` | healthcheck | Service health check |
+
+## Environment Loading
+
+Environment-specific launch scripts under `scripts/` contain the target
+environment name on the first line:
+
+- `scripts/start-BJ11.sh`: `prod.bj11`
+- `scripts/start-BJ12.sh`: `test.bj12`
+- `scripts/start-SH20.sh`: `prod.sh20`
+- `scripts/start-SZ31.sh`: `prod.sz31`
+
+The deploy launcher at `deploy/scripts/start.sh` reads that environment name,
+exports `FLASK_ENV`, and starts the app through Hypercorn.
+
+Environment files live under `app/` and are intentionally ignored by Git:
+
+- `app/.env`
+- `app/.env.dev`
+- `app/.env.prod.bj11`
+- `app/.env.prod.sh20`
+- `app/.env.prod.sz31`
+- `app/.env.test.bj12`
+
+Treat all environment files, credentials, tokens, and production configuration
+as sensitive. Do not commit them.
+
+## Deployment
+
+Deployment files are organized under `deploy/`:
+
+- `deploy/autoconf.yml`: Autoconf mapping for deployment environments.
+- `deploy/autoconf/templates/env.j2`: Template used to render environment
+  variables.
+- `deploy/scripts/start.sh`: Creates or uses a virtual environment, installs
+  dependencies, and starts Hypercorn.
+- `deploy/scripts/stop.sh`: Stops the Hypercorn process.
+- `deploy/scripts/healthcheck.sh`: Deployment health check entrypoint.
+- `deploy/scripts/requirements.txt`: Deployment dependency file. It should stay
+  in sync with root `requirements.txt`.
+- `deploy/offline-packages/`: Expected location for offline wheel packages when
+  building a fully offline deployment bundle.
+
+## Development Notes
+
+- Read this file before changing project code.
+- Keep changes scoped to the requested behavior.
+- Prefer existing package boundaries: views call managers or services; services
+  contain core business logic; utils stay generic.
+- Keep RAG knowledge content under `knowledge/`. The directory is tracked using
+  `.gitkeep`; knowledge documents are managed separately and ignored by default.
+- Keep tool-call schema changes in `tools/tool_definitions.yaml` aligned with
+  `app/utils/function_utils.py` and the services that implement tools.
+- Avoid committing generated caches, virtual environments, local environment
+  files, or machine-specific artifacts.
+- Before publishing this project to npm, bump the package version forward and
+  verify the packed artifact includes the full `app/`, `tools/`, and
+  `knowledge/` directories plus `deploy/` excluding `deploy/offline-packages/`;
+  keep the existing `.gitignore` rule that ignores local `knowledge/` files.
+- npm publishes must include `app/.env*` environment files, but only after
+  temporarily masking every sensitive value in those files, including keys,
+  URLs, tokens, secrets, cookies, passwords, and values that expose business
+  terms such as `网联`, `网联清算`, `nucc`, `uops`, or `联合运维`. After the npm
+  publish finishes, restore the local `.env*` files back to their original
+  plaintext values and remove the temporary masking changes.
+- Keep `app/.env*` files human-editable: preserve their key order, comments,
+  and blank-line grouping when normalizing, masking, or restoring them.
+
+## GLM Model Capability Reference
+
+- Use `/Users/simon/Documents/glm-model-doc.md` as the local long-term reference
+  for GLM model capabilities. When a change or design decision depends on GLM
+  behavior such as Thinking, Interleaved Thinking, Preserved Thinking,
+  turn-level thinking, streaming, function calling, tool streaming, or agent
+  loops, read that document before assuming API behavior.
+- For complex chat, RAG, or tool-call work, prefer designs that match GLM's
+  native tool-calling and thinking model instead of adding ad hoc orchestration
+  first. In particular, RAG can be exposed as a normal tool when the model needs
+  to decide search intent from conversation history.
+- When using GLM Thinking with tools, preserve the model's `reasoning_content`
+  according to the document's requirements. Interleaved thinking allows the
+  model to continue reasoning between tool calls and after tool results; for
+  preserved thinking, pass complete, unmodified reasoning content back in later
+  messages and use `clear_thinking: false` where applicable.
+- Do not rely on prompt text alone for critical tool hierarchy or evidence
+  policy. Keep executable tool definitions in `tools/tool_definitions.yaml`, and
+  treat knowledge-base "related functions" as routing hints unless code
+  explicitly promotes them to executable tools.
+
+## Streaming Tool-Call Contract
+
+- External tool calls may run for minutes or longer because some tools query
+  large data platforms such as Hive. Do not treat a long-running tool call as a
+  timeout by default.
+- During tool execution, `/chatstream/v1/chat/stream` emits SSE `heartbeat`
+  events every `TOOL_CALL_HEARTBEAT_INTERVAL` seconds. The payload is the normal
+  chat response JSON with a `heartbeat` object, including `type`, `tool`,
+  `elapsedSeconds`, and `message`.
+- Frontends should listen for both `message` and `heartbeat` SSE events.
+  Heartbeat events mean the stream is alive and the current tool is still
+  running; they are not model content and should not be rendered as answer text.
+- Tool execution failures return a `message` event with `finish_reason="error"`
+  and `errorMsg`. If tool-calling reaches `TOOLS_MAX_ROUNDS`, return
+  `finish_reason="error"` and `errorMsg="工具调用轮数达到上限（N轮）"`.
+
+## Validation
+
+Use the smallest reliable checks that cover the change:
+
+- Syntax check: `python3 -m compileall app`
+- RAG smoke check when touching RAG code:
+  `python3 -c "from app import create_app; app = create_app(); print(app.extensions['chatstream_manager'].check_rag())"`
+- Endpoint smoke checks should cover `/healthcheck.html` and the relevant
+  `/chatstream/v1/*` route when route behavior changes.
+- When dependency files change, verify root `requirements.txt` and
+  `deploy/scripts/requirements.txt` stay aligned.
+
+## Known Structure Gaps To Confirm
+
+These are structure differences observed during the initial repository check:
+
+- `deploy/offline-packages/` is expected by the original structure but is not
+  currently present.
+- Shell scripts are present but may need executable permissions for deployment.
+- `tools/tool_definitions.yaml` currently exists but may need project-specific
+  tool definitions populated.
+- `scripts/healthcheck.sh` and `deploy/scripts/healthcheck.sh` currently exist
+  but may need health check logic populated.

union_app_chat_stream-1.0.8/app/__init__.py

@@ -0,0 +1,42 @@
+import os
+
+from flask import Flask
+from dotenv import load_dotenv
+
+
+def _load_dotenv_for_env():
+    config_name = os.getenv("FLASK_ENV", "dev")
+    dotenv_file = os.path.join(os.path.dirname(__file__), f".env.{config_name}")
+    load_dotenv(dotenv_file, override=True, verbose=True)
+
+
+def create_app():
+    _load_dotenv_for_env()
+
+    app = Flask(__name__)
+    from app.config.env_config import Config
+    app.config.from_object(Config)
+
+    from .authenticated_user import FlaskSessionClient
+    FlaskSessionClient(app)
+
+    from app.manager.chatstream_manager import ChatstreamManager
+    from app.manager.runtime_manager import RuntimeManager
+    from app.service.chat_service import ChatService
+    from app.service.llm_service import llm_service
+    from app.service.rag_service import RagService
+    from app.service.union_service import union_service
+
+    llm_service.initialize(app.config)
+    union_service.initialize(app.config)
+    rag_service = RagService(app.config)
+    chat_service = ChatService(app.config, rag_service, union_service)
+
+    app.extensions["chatstream_manager"] = ChatstreamManager(app.config, chat_service, rag_service)
+    app.extensions["runtime_manager"] = RuntimeManager(union_service, llm_service)
+
+    from .views import blueprints
+
+    for bp in blueprints:
+        app.register_blueprint(bp)
+    return app

union_app_chat_stream-1.0.8/app/authenticated_user.py

@@ -0,0 +1,74 @@
+from flask import Flask, request, jsonify, g, has_request_context
+from werkzeug.exceptions import HTTPException
+from loguru import logger
+from app.utils import common_utils
+from app.config.logger_config import setup_logger
+from contextvars import ContextVar
+
+_current_ip: ContextVar[str] = ContextVar("current_ip", default="unknown_ip")
+
+logger = setup_logger()
+
+
+class FlaskSessionClient:
+    def __init__(self, app):
+        self.auth_user_server = app.config['GET_USE_INFO_URL']
+        self.permissions = app.config['PERMISSIONS']
+        self.init_app(app)
+
+    def init_app(self, app: Flask):
+        def patcher(record):
+            record["extra"]["ip"] = _current_ip.get()
+
+        logger.configure(patcher=patcher)
+
+        @app.before_request
+        def require_auth():
+            try:
+                if has_request_context():
+                    ip = common_utils.get_client_ip()
+            except LookupError:
+                ip = "unknown_context-lost"
+            _current_ip.set(ip)
+
+            if request.method == 'OPTIONS':
+                return
+
+            public_paths = [
+                '/healthcheck.html',
+                '/favicon.ico'
+            ]
+            if any(request.path == path or request.path.startswith(path) for path in public_paths):
+                return
+
+            jsessionid = request.headers.get('Cookie')
+
+            if not jsessionid:
+                logger.error("未登录")
+                return jsonify({"error": "auth error"}), 401
+
+            try:
+                response = common_utils.call_https_api(url=self.auth_user_server,
+                                                       headers={'Cookie': 'CASSESSIONID=' + jsessionid},
+                                                       method='GET', verify_ssl=False)
+                if response.get('status_code') != 200 or not response.get('data'):
+                    logger.error("验证失败")
+                    return jsonify({"error": "auth error"}), 401
+                user = response.get('data')
+                if user['loginName'] and self.permissions and self.permissions not in user['permissions']:
+                    return jsonify({"error": "auth error"}), 401
+                g.current_user = response.get('data')
+                g.current_user['jsessionid'] = jsessionid
+
+                return
+            except Exception as e:
+                logger.error(f"auth 验证失败: {str(e)}，路径: {request.path}")
+                return jsonify({"error": "auth error"}), 401
+
+        @app.errorhandler(Exception)
+        def handle_exception(e):
+            if isinstance(e, HTTPException):
+                return e
+
+            logger.error(f"未处理的异常: {str(e)}")
+            return jsonify({"error": "Internal Server Error"}), 500

union_app_chat_stream-1.0.8/app/config/env_config.py

@@ -0,0 +1,102 @@
+import os
+
+
+def _env_bool(name, default=False):
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.lower() in {"1", "true", "yes", "on"}
+
+
+def _env_int(name, default):
+    value = os.getenv(name)
+    if value is None:
+        return default
+    try:
+        return int(value)
+    except ValueError:
+        return default
+
+
+def _env_float(name, default):
+    value = os.getenv(name)
+    if value is None:
+        return default
+    try:
+        return float(value)
+    except ValueError:
+        return default
+
+
+def _env_list(name, default=None):
+    value = os.getenv(name)
+    if value is None:
+        return default or []
+    return [item.strip() for item in value.split(",") if item.strip()]
+
+
+class Config:
+    SECRET_KEY = os.getenv('SECRET_KEY')
+    GET_USE_INFO_URL = os.getenv('GET_USE_INFO_URL')
+    GET_ORG_INFO_URL = os.getenv('GET_ORG_INFO_URL')
+    GET_JIRA_INFO_URL = os.getenv('GET_JIRA_INFO_URL')
+    GET_BIGDATA_URL = os.getenv('GET_BIGDATA_URL')
+    GET_UNION_BASE_URL = os.getenv('GET_UNION_BASE_URL')
+    GET_ORG_INFO_URL_TOKEN = os.getenv('GET_ORG_INFO_URL_TOKEN')
+    GET_JIRA_INFO_URL_TOKEN = os.getenv('GET_JIRA_INFO_URL_TOKEN')
+    PERMISSIONS = os.getenv('PERMISSIONS')
+    LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
+    CONSOLE_STDOUT = os.getenv("CONSOLE_STDOUT", "FALSE")
+    LOG_DIR = os.getenv("LOG_DIR", "/data/appLogs")
+    FLASK_ENV = os.getenv("FLASK_ENV", "prod")
+    JWT_SECRET_KEY = os.getenv("JWT_SECRET_KEY", f"union-fall-back-secret-for-{FLASK_ENV}")
+    JWT_EXPIRATION_SECOND = os.getenv("JWT_EXPIRATION_SECOND", 900)
+    JWT_RENEW_SECOND = os.getenv("JWT_RENEW_SECOND", 120)
+
+    # 大模型地址
+    LLM_URL = os.getenv('LLM_URL')
+    LLM_KEY = os.getenv('LLM_KEY')
+    LLM_MODEL = os.getenv('LLM_MODEL')  # 默认模型名称
+    LLM_MAX_TOKENS = _env_int("LLM_MAX_TOKENS", 4096)
+    LLM_TEMPERATURE = _env_float("LLM_TEMPERATURE", 0.7)
+    LLM_TOP_P = _env_float("LLM_TOP_P", 0.9)
+
+    SYSTEM_PROMPT = os.getenv("SYSTEM_PROMPT", "")
+
+    FILTER_ENABLED = _env_bool("FILTER_ENABLED", False)
+    FILTER_ALLOWED_KEYWORDS = _env_list("FILTER_ALLOWED_KEYWORDS")
+    FILTER_REJECTION_MESSAGE = os.getenv(
+        "FILTER_REJECTION_MESSAGE",
+        "抱歉，我是联合运维智能客服，只能回答与联合运维相关的问题。",
+    )
+
+    TOOLS_MAX_ROUNDS = _env_int("TOOLS_MAX_ROUNDS", 5)
+    TOOL_CALL_HEARTBEAT_INTERVAL = _env_float("TOOL_CALL_HEARTBEAT_INTERVAL", 15.0)
+    CHAT_OPENING_QUESTIONS = _env_list("CHAT_OPENING_QUESTIONS", [
+        "上周全链路运行质量如何",
+        "最近有哪些成员机构交易异常",
+        "当前系统运行风险点有哪些",
+    ])
+
+    CONVERSATION_MAX_HISTORY = _env_int("CONVERSATION_MAX_HISTORY", 20)
+    CONVERSATION_TTL = _env_int("CONVERSATION_TTL", 3600)
+
+    RAG_ENABLED = _env_bool("RAG_ENABLED", True)
+    RAG_KNOWLEDGE_DIR = os.getenv("RAG_KNOWLEDGE_DIR", "knowledge")
+    RAG_PERSIST_DIR = os.getenv("RAG_PERSIST_DIR", ".chroma")
+    RAG_COLLECTION = os.getenv("RAG_COLLECTION", "ops_knowledge")
+    RAG_EMBEDDING_MODEL = os.getenv("RAG_EMBEDDING_MODEL", "embedding-3")
+    RAG_EMBEDDING_MAX_CHARS = _env_int("RAG_EMBEDDING_MAX_CHARS", 6000)
+    RAG_EMBEDDING_BATCH_SIZE = _env_int("RAG_EMBEDDING_BATCH_SIZE", 8)
+    RAG_TOP_K = _env_int("RAG_TOP_K", 5)
+    RAG_SEMANTIC_CANDIDATE_K = _env_int("RAG_SEMANTIC_CANDIDATE_K", 40)
+    RAG_CONTEXT_K = _env_int("RAG_CONTEXT_K", 8)
+    RAG_EXACT_CONTEXT_K = _env_int("RAG_EXACT_CONTEXT_K", 6)
+    RAG_EXACT_PER_FILE_CONTEXT_K = _env_int("RAG_EXACT_PER_FILE_CONTEXT_K", 1)
+    RAG_PER_FILE_CONTEXT_K = _env_int("RAG_PER_FILE_CONTEXT_K", 2)
+    RAG_CHUNK_SIZE = _env_int("RAG_CHUNK_SIZE", 1200)
+    RAG_REBUILD_ON_STARTUP = _env_bool("RAG_REBUILD_ON_STARTUP", False)
+
+    @classmethod
+    def init_app(cls, app):
+        pass

union_app_chat_stream-1.0.8/app/config/logger_config.py

@@ -0,0 +1,46 @@
+from loguru import logger
+import os
+
+
+def setup_logger():
+
+
+    env = os.getenv("FLASK_ENV", "prod")
+    log_level = os.getenv("LOG_LEVEL", "INFO")
+    console_stdout = os.getenv("CONSOLE_STDOUT", "FALSE")
+    log_dir = os.getenv("LOG_DIR", "/data/appLogs")
+    os.makedirs(log_dir, exist_ok=True)
+    app_log_path = os.path.join(log_dir, "union-py-app.log")
+    error_log_path = os.path.join(log_dir, "union-py-error.log")
+    logger.remove()
+
+    logger.configure(extra={"ip": "unknown_ip"})
+    log_format = "{time:YYYY-MM-DD HH:mm:ss}|{level:8}|{extra[ip]}|{name}:{function}:{line}|{message}"
+
+    logger.add(
+        app_log_path,
+        rotation="500 MB",
+        retention="30 days",
+        compression="gz",
+        level=log_level,
+        format=log_format,
+        enqueue=True,
+        encoding="utf=8"
+    )
+    logger.add(
+        error_log_path,
+        rotation="500 MB",
+        retention="30 days",
+        compression="gz",
+        level="ERROR",
+        encoding="utf=8"
+    )
+    if console_stdout:
+        logger.add(
+            sink=lambda msg: print(msg, end=""),
+            level=log_level,
+            format=log_format,
+            enqueue=True
+        )
+
+    return logger

union_app_chat_stream-1.0.8/app/manager/chatstream_manager.py

@@ -0,0 +1,122 @@
+import threading
+import time
+from typing import Dict, Generator, List, Optional
+from uuid import uuid4
+
+from app.models.schemas import ChatResponse
+from app.service.chat_service import ChatService
+from app.service.rag_service import RagService
+from app.utils.function_utils import tools
+
+
+class ChatstreamManager:
+    def __init__(self, config, chat_service: ChatService, rag_service: RagService):
+        self._chat_service = chat_service
+        self._rag_service = rag_service
+        self._conversations: Dict[str, Dict] = {}
+        # ponytail: process-local guard; use shared storage only if workers need cross-process cancellation.
+        self._active_streams: Dict[str, Dict] = {}
+        self._max_history = config["CONVERSATION_MAX_HISTORY"]
+        self._ttl = config["CONVERSATION_TTL"]
+        self._lock = threading.Lock()
+
+    @staticmethod
+    def normalize_conversation_id(conversation_id: Optional[str]) -> str:
+        normalized = (conversation_id or "").strip()
+        return normalized or f"conv-{uuid4().hex}"
+
+    def check_rag(self) -> Dict:
+        return self._rag_service.check()
+
+    def force_rebuild_rag(self) -> Dict:
+        return self._rag_service.force_rebuild()
+
+    def _cleanup_expired(self):
+        now = time.time()
+        expired = [cid for cid, c in self._conversations.items() if now - c["last_active"] > self._ttl]
+        for cid in expired:
+            del self._conversations[cid]
+
+    def _ensure_conversation(self, conversation_id: str):
+        if conversation_id not in self._conversations:
+            self._conversations[conversation_id] = {
+                "messages": [],
+                "created_at": time.time(),
+                "last_active": time.time(),
+            }
+
+    def _get_history(self, conversation_id: str) -> List[Dict[str, str]]:
+        with self._lock:
+            self._cleanup_expired()
+            self._ensure_conversation(conversation_id)
+            return list(self._conversations[conversation_id]["messages"])
+
+    def _append_exchange(self, conversation_id: str, user_question: str, assistant_answer: str):
+        with self._lock:
+            self._ensure_conversation(conversation_id)
+            conversation = self._conversations[conversation_id]
+            conversation["messages"].extend([
+                {"role": "user", "content": user_question},
+                {"role": "assistant", "content": assistant_answer},
+            ])
+            conversation["last_active"] = time.time()
+            max_messages = self._max_history * 2
+            if len(conversation["messages"]) > max_messages:
+                conversation["messages"] = conversation["messages"][-max_messages:]
+
+    def _start_stream(self, jsessionid: str, conversation_id: str) -> threading.Event:
+        abort_event = threading.Event()
+        with self._lock:
+            active = self._active_streams.get(jsessionid)
+            if active and active["conversation_id"] != conversation_id:
+                active["abort_event"].set()
+            self._active_streams[jsessionid] = {
+                "conversation_id": conversation_id,
+                "abort_event": abort_event,
+            }
+        return abort_event
+
+    def _finish_stream(self, jsessionid: str, abort_event: threading.Event):
+        with self._lock:
+            active = self._active_streams.get(jsessionid)
+            if active and active["abort_event"] is abort_event:
+                del self._active_streams[jsessionid]
+
+    def chat_stream(
+        self,
+        conversation_id: Optional[str],
+        question: str,
+        jsessionid: str,
+    ) -> Generator[ChatResponse, None, None]:
+        normalized_conversation_id = self.normalize_conversation_id(conversation_id)
+        abort_event = self._start_stream(jsessionid, normalized_conversation_id)
+        history = self._get_history(normalized_conversation_id)
+        answer_parts: List[str] = []
+        saved = False
+
+        try:
+            for chunk in self._chat_service.tool_call_stream(
+                normalized_conversation_id,
+                question,
+                tools,
+                history,
+                jsessionid,
+            ):
+                if abort_event.is_set():
+                    yield ChatResponse(
+                        conversationId=normalized_conversation_id,
+                        content="当前对话已被新的对话替换，已停止。",
+                        finish_reason="abort",
+                    )
+                    return
+                if chunk.content:
+                    answer_parts.append(chunk.content)
+                if chunk.finish_reason and answer_parts and not saved:
+                    self._append_exchange(normalized_conversation_id, question, "".join(answer_parts))
+                    saved = True
+                yield chunk
+
+            if answer_parts and not saved:
+                self._append_exchange(normalized_conversation_id, question, "".join(answer_parts))
+        finally:
+            self._finish_stream(jsessionid, abort_event)