bizyengine 1.2.50__py3-none-any.whl → 1.2.51__py3-none-any.whl

bizyengine/bizy_server/errno.py

@@ -201,6 +201,27 @@ class errnos:
         400, 400150, None, {"en": "Invalid prompt", "zh": "工作流错误"}
     )
 
+    # 聊天输入相关
+    MISSING_MESSAGE_OR_HISTORY = ErrorNo(
+        400,
+        400151,
+        None,
+        {
+            "en": "Missing message or conversation_history",
+            "zh": "缺少 message 或 conversation_history",
+        },
+    )
+
+    INVALID_CONVERSATION_HISTORY = ErrorNo(
+        400,
+        400152,
+        None,
+        {
+            "en": "Invalid conversation_history format",
+            "zh": "conversation_history 格式无效",
+        },
+    )
+
     INVALID_API_KEY = ErrorNo(
         401, 401000, None, {"en": "Invalid API key", "zh": "无效的API密钥"}
     )

bizyengine/bizy_server/server.py

@@ -1,11 +1,7 @@
 import asyncio
-import configparser
 import json
 import logging
-import os
-import random
 import re
-import shutil
 import threading
 import time
 import urllib.parse
@@ -13,11 +9,11 @@ import uuid
 
 import aiohttp
 import execution
-import openai
 from server import PromptServer
 
-from bizyengine.core.common.env_var import BIZYAIR_SERVER_ADDRESS, BIZYAIR_SERVER_MODE
-from bizyengine.core.configs.conf import ModelRule, config_manager
+from bizyengine.bizybot.config import Config, LLMConfig, MCPServerConfig
+from bizyengine.bizybot.coordinator import Coordinator
+from bizyengine.core.common.env_var import BIZYAIR_DEBUG, BIZYAIR_SERVER_MODE
 
 from .api_client import APIClient
 from .errno import ErrorNo, errnos
@@ -45,6 +41,10 @@ BIZYAIR_DATA_DICT = {}
 BIZYAIR_DATA_DICT_UPDATED_AT = 0.0
 
 logging.basicConfig(level=logging.DEBUG)
+# 禁用MCP与OpenAI使用的httpx等相关的DEBUG,INFO日志, 仅在BIZYAIR_DEBUG模式下启用
+if not BIZYAIR_DEBUG:
+    logging.getLogger("mcp").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
 
 
 def _get_request_api_key(request_headers):
@@ -818,177 +818,137 @@ class BizyAirServer:
                 return ErrResponse(err)
 
         @self.prompt_server.routes.post(f"/{MODEL_API}/chat")
-        async def chat_completions(request):
-            request_api_key, err = _get_request_api_key(request.headers)
-            if err:
-                return ErrResponse(err)
-
-            response = None  # 确保变量在退出前定义
-            resp = None  # 响应对象引用
-            req_id = f"req-{id(request)}"  # 为请求生成唯一ID
-
+        async def chat(request):
             try:
+                # 获取API密钥
+                request_api_key, err = _get_request_api_key(request.headers)
+                if err:
+                    return ErrResponse(err)
+
                 # 解析请求数据
                 request_data = await request.json()
 
-                # 转发请求到模型服务
-                with self.api_client.forward_model_request(
-                    request_data, request_api_key
-                ) as response:
-                    # 创建并准备流式响应
-                    resp = aiohttp.web.StreamResponse(
+                # 提取参数
+                current_message = request_data.get("message")
+                conversation_history = request_data.get("conversation_history", [])
+                model_config = request_data.get("model_config", {})
+
+                # 验证输入
+                if not current_message and not conversation_history:
+                    return ErrResponse(errnos.MISSING_MESSAGE_OR_HISTORY)
+
+                # 验证对话历史格式
+                if conversation_history:
+                    from bizyengine.bizybot.models import Conversation
+
+                    if not Conversation.validate_conversation_history(
+                        conversation_history
+                    ):
+                        return ErrResponse(errnos.INVALID_CONVERSATION_HISTORY)
+
+                if request_api_key:
+                    api_key = request_api_key
+                if not BIZYAIR_SERVER_MODE:
+                    from bizyengine.core.common.client import get_api_key
+
+                    api_key = get_api_key()
+
+                if not api_key:
+                    return ErrResponse(errnos.INVALID_API_KEY)
+
+                # 创建LLM配置
+                llm_config = LLMConfig(api_key=api_key, timeout=30.0)
+                config = Config(
+                    llm=llm_config,
+                    mcp_servers={
+                        "bizyair-mcp": MCPServerConfig(
+                            transport="streamable_http",
+                            url="https://api.bizyair.cn/w/v1/mcp/32",
+                            headers={
+                                "Authorization": "Bearer " + api_key,
+                                "X-BizyBot-Client": "bizybot",
+                            },
+                        ),
+                        "bizyait-image-gen": MCPServerConfig(
+                            transport="streamable_http",
+                            url="https://api.bizyair.cn/w/v1/mcp/33",
+                            headers={
+                                "Authorization": "Bearer " + api_key,
+                                "X-BizyBot-Client": "bizybot",
+                            },
+                        ),
+                        "bizyait-image-edit": MCPServerConfig(
+                            transport="streamable_http",
+                            url="https://api.bizyair.cn/w/v1/mcp/34",
+                            headers={
+                                "Authorization": "Bearer " + api_key,
+                                "X-BizyBot-Client": "bizybot",
+                            },
+                        ),
+                    },
+                )
+
+                coordinator = Coordinator(config)
+                try:
+                    await coordinator.initialize()
+
+                    response = aiohttp.web.StreamResponse(
                         status=200,
-                        reason="OK",
                         headers={
                             "Content-Type": "text/event-stream",
                             "Cache-Control": "no-cache",
                             "Connection": "keep-alive",
-                            "X-Accel-Buffering": "no",  # 禁用Nginx缓冲
                         },
                     )
-                    await resp.prepare(request)
+                    await response.prepare(request)
 
-                    # 开始流式传输
-                    any_chunk_sent = False  # 跟踪是否发送了任何数据块
                     try:
-                        for bytes in response.iter_bytes(1024):
-                            if bytes:
-                                await resp.write(bytes)
-                                any_chunk_sent = True
-                                await resp.drain()  # 确保数据被立即发送
-                    except Exception as e:
-                        print(
-                            f"\033[31m[聊天请求-{req_id}]\033[0m 流式传输错误: {str(e)}"
+                        import uuid
+
+                        temp_conversation_id = str(uuid.uuid4())
+                        conversation_event = {
+                            "type": "conversation_started",
+                            "conversation_id": temp_conversation_id,
+                        }
+                        await response.write(
+                            f"data: {json.dumps(conversation_event, ensure_ascii=False)}\n\n".encode(
+                                "utf-8"
+                            )
                         )
-                        # 如果尚未发送任何数据块，尝试发送错误信息
-                        if not any_chunk_sent and not resp.prepared:
-                            return ErrResponse(errnos.MODEL_API_ERROR)
-                        elif not any_chunk_sent:
-                            try:
-                                error_msg = json.dumps(
-                                    {"error": f"流式传输错误: {str(e)}"}
-                                )
-                                await resp.write(
-                                    f"data: {error_msg}\n\n".encode("utf-8")
-                                )
-                                await resp.write(b"data: [DONE]\n\n")
-                            except Exception as write_err:
-                                print(
-                                    f"\033[31m[聊天请求-{req_id}]\033[0m 写入错误消息时出错: {str(write_err)}"
+
+                        async for event in coordinator.process_message(
+                            message=current_message,
+                            conversation_history=conversation_history,
+                            llm_config_override=model_config,
+                        ):
+                            formatted_event = coordinator.format_streaming_event(event)
+                            await response.write(
+                                f"data: {json.dumps(formatted_event, ensure_ascii=False)}\n\n".encode(
+                                    "utf-8"
                                 )
+                            )
 
-                    try:
-                        await resp.write_eof()
+                        await response.write(b"data: [DONE]\n\n")
                     except Exception as e:
-                        print(
-                            f"\033[31m[聊天请求-{req_id}]\033[0m 结束响应时出错: {str(e)}"
-                        )
-
-                    return resp
+                        error_event = {"type": "error", "error": str(e)}
+                        try:
+                            await response.write(
+                                f"data: {json.dumps(error_event, ensure_ascii=False)}\n\n".encode(
+                                    "utf-8"
+                                )
+                            )
+                        except Exception:
+                            pass
 
-            except openai.APIConnectionError as e:
-                print("The server could not be reached")
-                print(
-                    e.__cause__
-                )  # an underlying Exception, likely raised within httpx.
-            except openai.RateLimitError:
-                print("A 429 status code was received; we should back off a bit.")
-            except openai.APIStatusError as e:
-                print("Another non-200-range status code was received")
-                print(e.status_code)
-                print(e.response)
-            except Exception as e:
-                print(
-                    f"\033[31m[聊天请求-{req_id}]\033[0m 处理请求时发生错误: {str(e)}"
-                )
-                # 如果响应已经准备好，尝试发送错误信息
-                if resp and resp.prepared:
+                    return response
+                finally:
                     try:
-                        error_msg = json.dumps({"error": f"服务器错误: {str(e)}"})
-                        await resp.write(f"data: {error_msg}\n\n".encode("utf-8"))
-                        await resp.write(b"data: [DONE]\n\n")
-                        await resp.write_eof()
-                    except:
-                        pass
-                    return resp
-
-                return ErrResponse(errnos.MODEL_API_ERROR)
+                        await coordinator.cleanup()
+                    except Exception:
+                        logging.exception("Coordinator cleanup failed")
 
-        @self.prompt_server.routes.post(f"/{MODEL_API}/image-edit")
-        async def image_edit(request):
-            try:
-                request_api_key, err = _get_request_api_key(request.headers)
-                if err:
-                    return ErrResponse(err)
-                auth_header = request.headers.get("Authorization", "")
-                cookie_str = request.headers.get("Cookie", "")
-                cookie_api_key = _get_api_key_from_cookie(cookie_str)
-                request_data = await request.json()
-                target_url = f"{BIZYAIR_SERVER_ADDRESS}{config_manager.get_rules('comfyagent-flux1-kontext')[0].route}"
-                forward_payload = {
-                    "prompt": request_data.get("prompt", "请编辑这张图片"),
-                    "image": request_data.get("image", ""),
-                    "seed": request_data.get("seed", random.randint(1, 9999999999)),
-                    "num_inference_steps": request_data.get("num_inference_steps", 20),
-                    "guidance_scale": request_data.get("guidance_scale", 2.5),
-                }
-                async with aiohttp.ClientSession() as session:
-                    headers = {
-                        "Content-Type": "application/json",
-                        "User-Agent": "BizyAir Server",
-                        "x-bizyair-client-version": "1.2.21",
-                    }
-                    if request_api_key:
-                        headers["Authorization"] = f"Bearer {request_api_key}"
-                    elif cookie_api_key:
-                        headers["Authorization"] = f"Bearer {cookie_api_key}"
-                    elif auth_header:
-                        if not auth_header.startswith("Bearer "):
-                            headers["Authorization"] = f"Bearer {auth_header}"
-                        else:
-                            headers["Authorization"] = auth_header
-                    else:
-                        from bizyengine.core.common.env_var import load_api_key
-
-                        has_key, file_api_key = load_api_key()
-                        if has_key and file_api_key:
-                            headers["Authorization"] = f"Bearer {file_api_key}"
-                            logging.debug("Using API key from api_key.ini file")
-                    async with session.post(
-                        target_url, headers=headers, json=forward_payload, timeout=120
-                    ) as response:
-                        response_data = await response.json()
-                        logging.debug(response_data)
-
-                        if response.status == 200:
-                            return OKResponse(response_data)
-                        else:
-                            return ErrResponse(errnos.MODEL_API_ERROR)
-
-            except Exception:
-                return ErrResponse(errnos.MODEL_API_ERROR)
-
-        @self.prompt_server.routes.post(f"/{MODEL_API}/images")
-        async def image_generations(request):
-            try:
-                request_api_key, err = _get_request_api_key(request.headers)
-                if err:
-                    return ErrResponse(err)
-
-                # 解析请求数据
-                request_data = await request.json()
-
-                # 转发图像生成请求
-                result, err = await self.api_client.forward_image_request(
-                    request_data, request_api_key
-                )
-                if err is not None:
-                    return ErrResponse(err)
-
-                # 返回结果
-                return OKResponse(result)
-
-            except Exception:
+            except Exception as e:
+                print(f"\033[31m[BizyAir]\033[0m Chat request failed: {str(e)}")
                 return ErrResponse(errnos.MODEL_API_ERROR)
 
         # 服务器模式独占
@@ -1000,7 +960,7 @@ class BizyAirServer:
         async def list_share_model_files(request):
             shareId = request.match_info["shareId"]
             if not is_string_valid(shareId):
-                return ErrResponse("INVALID_SHARE_ID")
+                return ErrResponse(errnos.INVALID_SHARE_ID)
             payload = {}
             query_params = ["type", "name", "ext_name"]
             for param in query_params:

bizyengine/bizybot/__init__.py

@@ -0,0 +1,12 @@
+"""
+MCP Coordinator - A lightweight AI application coordinator
+"""
+
+__version__ = "0.1.0"
+
+from .config import Config, LLMConfig
+
+# Import main modules to make them available
+from .coordinator import Coordinator
+
+__all__ = ["Coordinator", "Config", "LLMConfig"]