bizyengine 1.2.49__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/bizyair_extras/nodes_gemini.py

@@ -1,11 +1,15 @@
 import base64
 import io
 import json
+import logging
 import re
 
 import numpy as np
 import torch
-from comfy_api_nodes.apinode_utils import tensor_to_base64_string
+from comfy_api_nodes.apinode_utils import (
+    bytesio_to_image_tensor,
+    tensor_to_base64_string,
+)
 from PIL import Image, ImageOps
 
 from bizyengine.core import BizyAirBaseNode, pop_api_key_and_prompt_id
@@ -58,6 +62,94 @@ def base64_to_image(base64_string):
     return image
 
 
+def get_parts_from_response(
+    response: dict,
+):
+    return response["candidates"][0]["content"]["parts"]
+
+
+def get_parts_by_type(response: dict, part_type: str):
+    parts = []
+    for part in get_parts_from_response(response):
+        if part_type == "text" and part.get("text", None):
+            parts.append(part)
+        elif (
+            part.get("inlineData", None) and part["inlineData"]["mimeType"] == part_type
+        ):
+            parts.append(part)
+        # Skip parts that don't match the requested type
+    return parts
+
+
+def get_text_from_response(response: dict) -> str:
+    parts = get_parts_by_type(response, "text")
+    logging.debug(f"Text parts: {parts}")
+    return "\n".join([part["text"] for part in parts])
+
+
+def get_image_from_response(response: dict) -> torch.Tensor:
+    image_tensors: list[torch.Tensor] = []
+    parts = get_parts_by_type(response, "image/png")
+    for part in parts:
+        b64_data = part["inlineData"]["data"]
+        if b64_data:
+            image_data = base64.b64decode(b64_data)
+            returned_image = bytesio_to_image_tensor(io.BytesIO(image_data))
+            image_tensors.append(returned_image)
+    if len(image_tensors) == 0:
+        return torch.zeros((1, 1024, 1024, 4))
+    return torch.cat(image_tensors, dim=0)
+
+
+# FROM: https://github.com/ShmuelRonen/ComfyUI-NanoBanano/blob/9eeb8f2411fd0ff08791bdf5e24eec347456c8b8/nano_banano.py#L191
+def build_prompt_for_operation(
+    prompt,
+    operation,
+    has_references=False,
+    aspect_ratio="1:1",
+    character_consistency=True,
+):
+    """Build optimized prompt based on operation type"""
+
+    aspect_instructions = {
+        "1:1": "square format",
+        "16:9": "widescreen landscape format",
+        "9:16": "portrait format",
+        "4:3": "standard landscape format",
+        "3:4": "standard portrait format",
+    }
+
+    base_quality = "Generate a high-quality, photorealistic image"
+    format_instruction = f"in {aspect_instructions.get(aspect_ratio, 'square format')}"
+
+    if operation == "generate":
+        if has_references:
+            final_prompt = f"{base_quality} inspired by the style and elements of the reference images. {prompt}. {format_instruction}."
+        else:
+            final_prompt = f"{base_quality} of: {prompt}. {format_instruction}."
+
+    elif operation == "edit":
+        if not has_references:
+            return "Error: Edit operation requires reference images"
+        # No aspect ratio for edit - preserve original image dimensions
+        final_prompt = f"Edit the provided reference image(s). {prompt}. Maintain the original composition and quality while making the requested changes."
+
+    elif operation == "style_transfer":
+        if not has_references:
+            return "Error: Style transfer requires reference images"
+        final_prompt = f"Apply the style from the reference images to create: {prompt}. Blend the stylistic elements naturally. {format_instruction}."
+
+    elif operation == "object_insertion":
+        if not has_references:
+            return "Error: Object insertion requires reference images"
+        final_prompt = f"Insert or blend the following into the reference image(s): {prompt}. Ensure natural lighting, shadows, and perspective. {format_instruction}."
+
+    if character_consistency and has_references:
+        final_prompt += " Maintain character consistency and visual identity from the reference images."
+
+    return final_prompt
+
+
 class NanoBanana(BizyAirBaseNode):
     def __init__(self):
         pass
@@ -73,6 +165,13 @@ class NanoBanana(BizyAirBaseNode):
                         "default": "",
                     },
                 ),
+                "operation": (
+                    ["generate", "edit", "style_transfer", "object_insertion"],
+                    {
+                        "default": "generate",
+                        "tooltip": "Choose the type of image operation",
+                    },
+                ),
                 "temperature": (
                     "FLOAT",
                     {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05},
@@ -90,73 +189,123 @@ class NanoBanana(BizyAirBaseNode):
                 "image3": ("IMAGE",),
                 "image4": ("IMAGE",),
                 "image5": ("IMAGE",),
+                "quality": (
+                    ["standard", "high"],
+                    {"default": "high", "tooltip": "Image generation quality"},
+                ),
+                "aspect_ratio": (
+                    ["1:1", "16:9", "9:16", "4:3", "3:4"],
+                    {"default": "1:1", "tooltip": "Output image aspect ratio"},
+                ),
+                "character_consistency": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "Maintain character consistency across edits",
+                    },
+                ),
             },
         }
 
-    RETURN_TYPES = ("IMAGE",)
+    RETURN_TYPES = ("IMAGE", "STRING")
     FUNCTION = "execute"
     OUTPUT_NODE = False
     CATEGORY = "☁️BizyAir/External APIs/Gemini"
 
-    def execute(self, prompt, temperature, top_p, seed, max_tokens, **kwargs):
-        url = f"{BIZYAIR_SERVER_ADDRESS}/proxy_inference/VertexAI/gemini-2.5-flash-image-preview"
-        extra_data = pop_api_key_and_prompt_id(kwargs)
-        parts = [{"text": prompt}]
-        for _, img in enumerate(
-            [
-                kwargs.get("image", None),
-                kwargs.get("image2", None),
-                kwargs.get("image3", None),
-                kwargs.get("image4", None),
-                kwargs.get("image5", None),
-            ],
-            1,
-        ):
-            if img is not None:
-                parts.append(
-                    {
-                        "inline_data": {
-                            "mime_type": "image/png",
-                            "data": tensor_to_base64_string(img),
+    def execute(
+        self,
+        prompt,
+        operation,
+        temperature,
+        top_p,
+        seed,
+        max_tokens,
+        quality=None,
+        aspect_ratio=None,
+        character_consistency=None,
+        **kwargs,
+    ):
+        try:
+            url = f"{BIZYAIR_SERVER_ADDRESS}/proxy_inference/VertexAI/gemini-2.5-flash-image-preview"
+            extra_data = pop_api_key_and_prompt_id(kwargs)
+
+            parts = []
+            for _, img in enumerate(
+                [
+                    kwargs.get("image", None),
+                    kwargs.get("image2", None),
+                    kwargs.get("image3", None),
+                    kwargs.get("image4", None),
+                    kwargs.get("image5", None),
+                ],
+                1,
+            ):
+                if img is not None:
+                    parts.append(
+                        {
+                            "inline_data": {
+                                "mime_type": "image/png",
+                                "data": tensor_to_base64_string(img),
+                            }
                         }
-                    }
+                    )
+
+            prompt = build_prompt_for_operation(
+                prompt,
+                operation,
+                has_references=len(parts) > 0,
+                aspect_ratio=aspect_ratio,
+                character_consistency=character_consistency,
+            )
+            if quality == "high":
+                prompt += " Use the highest quality settings available."
+            parts.append({"text": prompt})
+
+            data = {
+                "contents": {
+                    "parts": parts,
+                    "role": "user",
+                },
+                "generationConfig": {
+                    "seed": seed,
+                    "responseModalities": ["TEXT", "IMAGE"],
+                    "temperature": temperature,
+                    "topP": top_p,
+                    "maxOutputTokens": max_tokens,
+                },
+            }
+            json_payload = json.dumps(data).encode("utf-8")
+            headers = client.headers(api_key=extra_data["api_key"])
+            headers["X-BIZYAIR-PROMPT-ID"] = extra_data[
+                "prompt_id"
+            ]  # 额外参数vertexai会拒绝，所以用请求头传
+            resp = client.send_request(
+                url=url,
+                data=json_payload,
+                headers=headers,
+            )
+            # 解析潜在错误
+            prompt_feedback = resp.get("promptFeedback", None)
+            if prompt_feedback:
+                logging.error(f"Response: {resp}")
+                raise ValueError(f"Prompt blocked: {prompt_feedback}")
+            if len(resp["candidates"]) == 0:
+                logging.error(f"Response: {resp}")
+                raise ValueError("No candidates found in response")
+            if resp["candidates"][0]["finishReason"] != "STOP":
+                logging.error(f"Response: {resp}")
+                raise ValueError(
+                    f"Erroneous finish reason: {resp['candidates'][0]['finishReason']}"
                 )
-        data = {
-            "contents": {
-                "parts": parts,
-                "role": "user",
-            },
-            "generationConfig": {
-                "seed": seed,
-                "responseModalities": ["TEXT", "IMAGE"],
-                "temperature": temperature,
-                "topP": top_p,
-                "maxOutputTokens": max_tokens,
-            },
-        }
-        json_payload = json.dumps(data).encode("utf-8")
-        headers = client.headers(api_key=extra_data["api_key"])
-        headers["X-BIZYAIR-PROMPT-ID"] = extra_data[
-            "prompt_id"
-        ]  # 额外参数vertexai会拒绝，所以用请求头传
-        resp = client.send_request(
-            url=url,
-            data=json_payload,
-            headers=headers,
-        )
-        # 解析base64图片
-        b64_data = None
-        for part in resp["candidates"][0]["content"]["parts"]:
-            if part.get("inlineData", None):
-                b64_data = part["inlineData"]["data"]
-                break
-        if b64_data:
-            i = base64_to_image(b64_data)
-            # 下面代码参考LoadImage
-            i = ImageOps.exif_transpose(i)
-            image = i.convert("RGB")
-            image = np.array(image).astype(np.float32) / 255.0
-            image = torch.from_numpy(image)[None,]
-            return (image,)
-        else:
-            raise ValueError("No image found in response")
+
+            # 解析文本
+            text = get_text_from_response(resp)
+
+            # 解析base64图片
+            image = get_image_from_response(resp)
+
+            return (image, text)
+
+        except Exception as e:
+            logging.error(f"Gemini API error: {e}")
+            raise e