@agentunion/kite 1.4.0 → 1.5.0

package/extensions/services/proxy/agentcp/llm_agent_utils.py

@@ -0,0 +1,249 @@
+# -*- coding:utf-8 -*-
+# Copyright 2025 AgentUnion Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import asyncio
+import json
+import time
+import traceback
+import urllib.parse
+
+import requests
+from flask import Response
+
+from agentcp.base.log import log_error, log_exception, log_info
+
+
+class AttrDict(dict):
+    """使用属性方式读取字典兼容 openai响应格式"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # 递归转换所有字典类型子项
+        for key, value in self.items():
+            if isinstance(value, dict):
+                self[key] = AttrDict(value)
+            elif isinstance(value, list):
+                self[key] = [AttrDict(v) if isinstance(v, dict) else v for v in value]
+
+    def __getattr__(self, key):
+        if key in self:
+            return self[key]
+        raise AttributeError(f"{self.__class__.__name__}对象无属性{key}")
+
+    def model_dump(self, exclude_none: bool = True, **kwargs) -> dict:
+        """兼容openai响应的 model_dump"""
+
+        def _serialize(obj):
+            if isinstance(obj, AttrDict):
+                return {k: _serialize(v) for k, v in obj.items() if not (exclude_none and v is None)}
+            elif isinstance(obj, list):
+                return [_serialize(item) for item in obj]
+            else:
+                return obj
+
+        return _serialize(self)
+
+
+def format_date() -> str:
+    """获取当前格式化时间"""
+    ts = time.time()
+    # 格式化输出（带毫秒）
+    formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts))
+    millis = int(ts * 1000) % 1000
+    return f"{formatted_time}.{millis:03d}"
+
+
+def get_message_type(messages: list) -> str:
+    """获取消息类型"""
+    if len(messages) > 0:
+        msg = messages[0]
+        msg_type = msg.get("type")
+        return msg_type
+    return None
+
+
+def parse_stream_url(url0: str) -> tuple:
+    """
+    解析消息中流地址
+    如:
+    https://ts.agentunion.cn/api/text_stream/pull_text_stream?session_id=1831992075507204096&message_id=6
+    解析出独立的url和参数字典
+    """
+    args = {}
+    array = url0.split("?")
+    if len(array) != 2:
+        return url0, args
+    url, args_str = array
+    for kv in args_str.split("&"):
+        arr = kv.split("=")
+        if len(arr) != 2:
+            continue
+        args[arr[0]] = arr[1]
+    return url, args
+
+
+def get_vaild_json(text):
+    try:
+        json_data = json.loads(text)
+        return json_data
+    except Exception:
+        return None
+
+
+def fail_response(content) -> AttrDict:
+    # 构造失败默认结果(是否流式只是delta和message的区别)
+    return AttrDict(
+        {
+            "status": "error",
+            "code": 400,
+            "message": content,
+        }
+    )
+
+
+class LLMAgent:
+    def __init__(self, llm_agent, aid):
+        self.llm_agent_name = llm_agent  # 大模型agent名称
+        self.aid = aid  # 当前agent主体
+        self.msg = None  # 当前agent主体
+        self.result = None
+        self.session_id = None  # 当前会话id
+        self.result_type = (
+            None  # 结果类型，如text, image, audio, video, file, form, add_friend, create_order, error, empt
+        )
+
+    async def chat_create(self, open_ai_message_body, trace_id: str = ""):
+        """大模型agent对话"""
+        # 结果值为空
+        self.result = AttrDict({})
+        llm_message = {
+            "type": "llm",
+            "status": "success",
+            "timestamp": int(time.time() * 1000),
+            "content": open_ai_message_body,
+            "trace_id": trace_id,
+        }
+
+        # 3、发送消息并异步接收结果
+        async def reply_message_handler(reply_msg):
+            try:
+                # 解析大模型返回结果
+                msg_type, response = self.parse_message(reply_msg=reply_msg)
+                log_info(
+                    f"[{format_date()}]: llm agent message parse result msg_type = {msg_type}, response = {response}"
+                )
+                self.result_type = msg_type
+                if msg_type == "error":
+                    self.result = fail_response(response)
+                else:
+                    self.result = response
+            except Exception as e:
+                self.result = fail_response(f"消息解析失败{str(e)}")
+                self.result_type = "error"
+            self.session_id = reply_msg.get("session_id", "")
+
+        try:
+            # 3-1、向大模型agent发送消息
+            if self.session_id is None:
+                returned_session_id = self.aid.quick_send_message(
+                    self.llm_agent_name, llm_message, lambda reply_msg: reply_message_handler(reply_msg)
+                )
+                # 捕获返回的session_id
+                if returned_session_id:
+                    self.session_id = returned_session_id
+            else:
+                self.aid.add_message_handler(reply_message_handler, session_id=self.session_id)
+                self.aid.send_message(self.session_id, [self.llm_agent_name], llm_message)
+            # 3-2、异步等待结果（带超时）
+            # 4-2、轮询解析结果(最长等待10分钟)
+            timeout = 600  # 10分钟超时
+            start_time = time.time()
+            while len(self.result) == 0:
+                # log_info(f'reply_result = {self.result[1]}')
+                await asyncio.sleep(0.1)  # 每0.1s检查一次
+                if time.time() - start_time > timeout:
+                    return fail_response(f"服务商{self.aid.id}未响应，请检查网络或重启ModelGate客户端，如果问题依旧，请联系客服")
+            # 流式响应
+            if self.result_type == "text/event-stream":
+                return self.read_stream(self.result)
+        except Exception as e:
+            log_exception(f"{format_date()}消息处理异常: {str(e)}")
+            traceback.format_exc()
+            return fail_response(f"消息处理异常{str(e)}")
+        return self.result
+
+    def read_stream(self, content):
+        url = ""
+        try:
+            # 增加URL参数验证
+            url = content + "&agent_id=" + self.aid.id
+            target_response = requests.get(url, stream=True, verify=False, timeout=(60, 600), proxies={})  # 连接超时60秒，读取超时10分钟
+
+            def generate():
+                try:
+                    for line in target_response.iter_lines():
+                        if line:
+                            # 检查是否为合法 SSE 格式（避免污染数据流）
+                            chunk = urllib.parse.unquote_plus(line.decode("utf-8"))
+                            # chunk = get_vaild_json(decoded_url)
+                            key, value = chunk.split(":", 1)
+                            key = key.strip()
+                            value = value.strip()
+                            if key == "event" and value == "done":
+                                break
+                                # yield f"event: done\n\n".encode('utf-8')
+                            else:
+                                json_data = get_vaild_json(value)
+                                if json_data is None:
+                                    continue
+                                # print(f"[llm agent message] {json_data}")
+                                yield f"data: {json.dumps(json_data)}\n\n".encode("utf-8")
+                except requests.exceptions.Timeout:
+                    # 返回超时错误（SSE 格式）
+                    error_msg = {"status": "error", "message": json.dumps({"error": "目标服务器响应超时"})}
+                    yield f"data: {error_msg}\n\n".encode("utf-8")  # 编码为字节流
+                except requests.exceptions.RequestException as e:
+                    # 返回其他请求错误（SSE 格式）
+                    error_msg = {"status": "error", "message": json.dumps({"error": f"目标服务器请求失败: {str(e)}"})}
+                    yield f"data: {error_msg}\n\n".encode("utf-8")  # 编码为字节流
+                except Exception as e:
+                    # 捕获其他异常并返回错误（SSE 格式）
+                    error_msg = {"status": "error", "message": json.dumps({"error": f"处理过程中发生错误: {str(e)}"})}
+                    yield f"data: {error_msg}\n\n".encode("utf-8")
+
+            # 返回流式响应
+            return Response(generate(), content_type="text/event-stream", status=target_response.status_code)
+        except requests.exceptions.Timeout:
+            log_error(f"请求超时: {url}")
+            return fail_response("流连接超时")
+        except requests.exceptions.RequestException as e:
+            log_error(f"{format_date()}连接异常: {str(e)}")
+            import traceback
+            traceback.format_exc()
+            return fail_response(f"连接异常{traceback.format_exc()}")
+
+    def parse_message(self, reply_msg) -> tuple:
+        """解析llm agent消息结果"""
+        # 读取消息中的llm响应体
+        msg_type = get_message_type(messages=self.aid.get_content_array_from_message(reply_msg))
+        content = self.aid.get_content_from_message(reply_msg, message_type=msg_type)
+        if msg_type == "error":
+            return msg_type, content
+
+        if msg_type == "text/event-stream":
+            return msg_type, content
+
+        # 解析大模型返回
+        content_dict = json.loads(content)
+        return msg_type, AttrDict(content_dict)

package/extensions/services/proxy/agentcp/llm_server.py

@@ -0,0 +1,172 @@
+# 在Python文件开头明确指定编码声明
+# -*- coding: utf-8 -*-
+# Copyright 2025 AgentUnion Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# from flask import Flask, request, Response, jsonify
+# import threading
+# import socket
+# import time
+
+# from .llm_agent_utils import LLMAgent,AttrDict
+# from flask import jsonify, make_response
+# import logging
+# log = logging.getLogger('werkzeug')
+# log.setLevel(logging.ERROR)
+# app = Flask(__name__)
+# # app.logger.disabled = True
+# actual_port = 0
+
+# llm_aid_app_key_map = {}
+# llm_app_key_aid_map = {}
+# is_running = False
+
+# @app.route('/<llm_aid>/chat/completions', methods=['POST'])  # 添加methods参数指定POST方法
+# async def llm_request(llm_aid):
+#     # 获取请求头并打印
+#     headers = dict(request.headers)
+#     if request.is_json:
+#         body = request.get_json()
+#     else:
+#         body = request.form.to_dict()
+#     global llm_app_key_aid_map
+#     auth_str:str = headers.get("Authorization")
+#     llm_app_key = auth_str.replace("Bearer ","")
+#     aid = llm_app_key_aid_map.get(llm_app_key)
+#     if aid is None:
+#         return make_response(jsonify({"error": "Unauthorized"}), 401)
+#     llm_agent = LLMAgent(llm_agent=llm_aid, aid = aid)
+#     response = await llm_agent.chat_create(body)
+#     # print(response.get("status",""))
+#     if isinstance(response, AttrDict) and response.get("status","") == 'error':
+#         # 如果是错误状态，可以进行特殊处理，例如记录日志或返回自定义错误信息
+#         return make_response(jsonify({"error": response.get('message', "未知错误")}), response.get('code', 400))
+#     return response
+
+# @app.route('/', defaults={'path': ''}, methods=['OPTIONS', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH'])
+# @app.route('/<path:path>', methods=['OPTIONS', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH'])
+# async def proxy(path):
+#     try:
+#         if request.method == 'OPTIONS':
+#             # 返回 CORS 预检响应头
+#             response = Response()
+#             response.headers['Access-Control-Allow-Origin'] = '*'
+#             response.headers['Access-Control-Allow-Methods'] = 'POST, OPTIONS'
+#             response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
+#             return response
+#         elif request.method == 'POST':
+#             # 这个最终来自路由服务器,即模型名称对应一个地址和key
+#             # 校验请求数据
+#             # data = request.get_json()
+#             try:
+#                 #return llm_request(llm_aid)
+#                 llm_aid = path.split('/')[0]
+#                 return await llm_request(llm_aid)
+#             except Exception as e:
+#                 return jsonify({"error": f"{path}"}), 502
+#         elif request.method == 'GET':
+#             return jsonify({"result": "服务访问正常"}), 200
+#         else:
+#             return jsonify({"error": "Method not allowed"}), 405
+
+#     except Exception as e:
+#         return jsonify({"error": "Internal server error", "details": str(e)}), 500
+
+
+def add_llm_aid(aid):
+    # global llm_aid_app_key_map, llm_app_key_aid_map
+    # import hashlib
+    # if aid.id in llm_aid_app_key_map:
+    #     llm_app_key = llm_aid_app_key_map[aid.id]
+    # else:
+    #     llm_app_key = str(int(time.time())+actual_port)
+    #     llm_app_key = hashlib.sha256(llm_app_key.encode()).hexdigest()
+    #     llm_aid_app_key_map[aid.id] = llm_app_key
+    # llm_app_key_aid_map[llm_app_key] = aid
+    return True
+
+
+def add_llm_api_key(aid,llm_app_key):
+    # global llm_aid_app_key_map, llm_app_key_aid_map
+    # llm_aid_app_key_map[aid.id] = llm_app_key
+    # llm_app_key_aid_map[llm_app_key] = aid
+    return True
+    
+
+def get_base_url(aid,llm_aid):
+    # global actual_port
+    # # 获取实际分配的端口号
+    # return "http://127.0.0.1:"+str(actual_port)+"/"+llm_aid
+    pass
+
+def get_llm_api_key(aid_str:str):
+    # 获取实际分配的端口号
+    pass
+    # global llm_aid_app_key_map,llm_app_key_aid_map
+    # if aid_str not in llm_aid_app_key_map:
+    #     import secrets,hashlib
+    #     llm_app_key = secrets.token_hex(16)
+    #     llm_app_key = hashlib.sha256(llm_app_key.encode()).hexdigest()
+    #     llm_aid_app_key_map[aid_str] = llm_app_key
+    # return llm_aid_app_key_map[aid_str]
+
+def llm_server_is_running():
+    # global is_running
+    # return is_running
+    pass
+
+def __run_server():
+    # 端口设为0让系统自动分配
+    pass
+    # try:
+    #     global actual_port
+    #     if actual_port == 0:
+    #         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    #         sock.bind(('', 0))
+    #         actual_port = sock.getsockname()[1]
+    #         sock.close()
+    #         app.run(host='127.0.0.1', port = actual_port, debug=False)
+    #     else:
+    #         app.run(host='127.0.0.1', port = actual_port, debug=False)
+
+    #     global is_running
+    #     is_running = True
+    # except Exception as e:
+    #     is_running = False
+    #     #print(f"Flask服务启动失败,请检查端口占用后，重启服务")
+
+def run_server(debug:bool = False,port:int = 0,llm_aid_app_key_map_h = {},llm_app_key_aid_map_h = {}):
+    # 创建并启动子线程运行Flask服务
+    pass
+    # app.logger.disabled = (not debug)
+    # global actual_port,llm_aid_app_key_map,llm_app_key_aid_map
+    # try:
+    #     actual_port = int(port)
+    # except (ValueError, TypeError):
+    #     actual_port = 0  # 如果转换失败，设置为默认值0
+    # llm_aid_app_key_map = llm_aid_app_key_map_h
+    # llm_app_key_aid_map = llm_app_key_aid_map_h
+    # server_thread = threading.Thread(target=__run_server)
+    # server_thread.daemon = True  # 设置为守护线程，主线程退出时会自动结束
+    # server_thread.start()
+    # 主线程可以继续执行其他任务
+
+# 添加一个关闭服务器的路由
+# @app.route('/shutdown', methods=['POST'])
+def shutdown_server():
+    pass
+    # func = request.environ.get('werkzeug.server.shutdown')
+    # if func is None:
+    #     return jsonify({"status": "error", "message": "Not running with Werkzeug Server"})
+    # func()
+    # return jsonify({"status": "success", "message": "Server shutting down..."})

package/extensions/services/proxy/agentcp/mermaid.py

@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+# Copyright 2025 AgentUnion Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+
+from agentcp.base.log import log_error, log_info
+
+
+class Mermaid:
+    def __init__(self, content):
+        self.mermaid_code = content
+        self.graph_type = None
+        self.graph_direction = None  # 新增：存储图的方向
+        self.nodes = []
+        self.node_dict = {}
+        self.node_styles = {}
+        self.edges = []
+        self.parse_mermaid()
+
+        log_info(f"图类型:{self.graph_type}")
+        log_info(f"总共{len(self.nodes)}个节点,节点列表如下:\n\t{self.nodes}")
+        for node in self.node_dict.items():
+            log_info(f"节点映射:{node}")
+        for edge in self.edges:
+            log_info(f"边关系:{edge}")
+
+
+    @classmethod
+    def from_file(cls, dir_path, file_name):
+        return cls(cls.read_mermaid_code(dir_path, file_name))
+    def read_mermaid_code(dir_path: str, file_name: str):
+        file_path = Path(dir_path) / f"{file_name}.mmd"
+        absolute_path = file_path.absolute()
+        log_info(f"读取Mermaid文件，绝对路径: {absolute_path}")
+        if file_path.is_file():
+            try:
+                with file_path.open('r', encoding='utf-8') as f:
+                    content = f.read()
+                    content = content.replace(' ', '').replace(u'\xa0', u'')
+                    return content
+            except Exception as e:
+                log_error(f"读取文件错误: {e}")
+                return ""
+        else:
+            log_error(f"文件 {file_path} 未找到")
+            return ""
+
+    def parse_mermaid(self):
+        if not self.mermaid_code:
+            return
+
+        # 检查图类型和方向
+        for line in self.mermaid_code.split('\n'):
+            line = line.strip()
+            if not line or line.startswith('%'):
+                continue
+
+            if line.startswith('graph'):
+                parts = line.split()
+                if len(parts) >= 2:
+                    self.graph_type = 'graph'
+                    self.graph_direction = parts[1]  # 存储方向 (TD, LR, BT, RL等)
+                break
+            elif line.startswith(('pie', 'sequenceDiagram', 'gantt', 'classDiagram', 'stateDiagram')):
+                self.graph_type = line.split()[0]
+                log_error(f"不支持 {self.graph_type} 类型的图")
+                return
+            else:
+                log_error("无法识别的图类型")
+                return
+
+        if self.graph_type != 'graph':
+            return
+
+        # 解析内容
+        for line in self.mermaid_code.split('\n'):
+            line = line.strip()
+            if not line or line.startswith(('%', 'classDef', 'linkStyle', 'style', 'graph')):
+                continue
+
+            # 解析节点
+            if (any(x in line for x in ['[', '(', '{']) and
+                not any(x in line for x in ['-->', '--', '->'])) or \
+                    (not any(x in line for x in ['-->', '--', '->']) and
+                     line not in self.node_dict and
+                     not line.startswith('graph')):
+                self.parse_node(line)
+
+            # 解析边关系
+            if any(x in line for x in ['-->', '--', '->']):
+                self.parse_edge(line)
+
+    def parse_node(self, line):
+        """解析节点定义"""
+        node_name = ''
+        node_desc = ''
+        style_class = ''
+
+        # 提取样式类 (:::xxx)
+        if ':::' in line:
+            parts = line.split(':::')
+            line = parts[0].strip()
+            style_class = parts[1].strip()
+
+        # 花括号格式: A{描述}
+        if '{' in line and '}' in line:
+            start = line.find('{')
+            end = line.find('}')
+            node_name = line[:start].strip()
+            node_desc = line[start + 1:end].strip('" ')
+
+        # 方括号格式: A["描述"]
+        elif '[' in line and ']' in line:
+            start = line.find('[')
+            end = line.find(']')
+            node_name = line[:start].strip()
+            node_desc = line[start + 1:end].strip('" ')
+
+        # 圆括号格式: A(描述)
+        elif '(' in line and ')' in line:
+            start = line.find('(')
+            end = line.find(')')
+            node_name = line[:start].strip()
+            node_desc = line[start + 1:end].strip('" ')
+
+        # 无描述节点: A
+        else:
+            node_name = line.strip()
+            node_desc = node_name
+
+        if node_name and node_name not in self.node_dict:
+            self.node_dict[node_name] = node_desc or node_name
+            self.nodes.append(self.node_dict[node_name])
+            if style_class:
+                self.node_styles[node_name] = style_class
+
+    def parse_edge(self, line):
+        """解析边关系"""
+        line = line.replace(' ', '')
+
+        # 处理 A-->|描述|B 格式
+        if '-->|' in line and '|' in line[line.find('-->|') + 3:]:
+            arrow_pos = line.find('-->|')
+            desc_start = arrow_pos + 4
+            desc_end = line.find('|', desc_start)
+            source = line[:arrow_pos]
+            target = line[desc_end + 1:]
+            description = line[desc_start:desc_end]
+            self.edges.append((source, description, target))
+            return
+
+        # 处理 A-->B 格式
+        if '-->' in line:
+            parts = line.split('-->')
+            if len(parts) == 2:
+                self.edges.append((parts[0], '', parts[1]))
+            return
+
+        # 处理 A--描述-->B 格式
+        if '--' in line and '-->' in line:
+            arrow_pos = line.find('-->')
+            source = line[:line.find('--')]
+            target = line[arrow_pos + 3:]
+            description = line[line.find('--') + 2:arrow_pos]
+            self.edges.append((source, description, target))
+            return
+
+        # 处理 A->B 格式
+        if '->' in line:
+            parts = line.split('->')
+            if len(parts) == 2:
+                self.edges.append((parts[0], '', parts[1]))
+            return
+# 示例使用
+if __name__ == "__main__":
+    #mermaid = Mermaid.from_file('.', 'workflow')
+    mmd = """
+    graph TD
+    %% ===== 节点定义 =====
+    Z[用户交互层User]:::user
+    A[任务拆解/推进/退出]:::Planner 
+    B(个人助手):::PA
+    D[Agent选择 AgentSelector]:::selector
+    F[协作Agents]:::action
+    G[单步任务执行]:::process
+    Z -->|自然语言任务| B
+    A -->|任务推进| D
+    B -->|简单任务直接执行交付或复杂任务执行完成交付| Z
+    B -->|复杂任务| A
+    A -->|复杂任务完成所有步骤或者达成退出条件,交付| B
+    D -->|任务推进|G
+    G -->|调用| F
+    F -->|成功/失败| G
+    G -->|有失败任务未达到交付条件,重选Agent| D
+    G -->|执行成功后交付|A
+    """
+
+    mermaid2 = Mermaid(mmd)