@agentunion/kite 1.4.0 → 1.6.0

package/extensions/services/proxy/agentcp/samples/wrapper_agently_to_agent/main.py

@@ -0,0 +1,44 @@
+import agentcp
+import Agently
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+if __name__ == "__main__":
+    agent_id = 'your_agent_id_from_profile'
+    acp = agentcp.AgentCP('.', seed_password='')
+    aid = acp.load_aid(agent_id)
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    model_url = os.getenv("BASE_URL")
+    model_name = os.getenv("MODEL")
+    agent = (
+        Agently.create_agent()
+            .set_settings("current_model", "OAIClient")
+            .set_settings("model.OAIClient.auth", {'api_key': openai_api_key})
+            .set_settings("model.OAIClient.url", model_url)
+            .set_settings("model.OAIClient.options", {'model': model_name})
+    )
+    
+    @aid.message_handler()  #消息处理函数
+    async def sync_message_handler(msg):
+        receiver = aid.get_receiver_from_message(msg)  # 获取接收者 
+        if aid.id not in receiver:
+            return
+        session_id = aid.get_session_id_from_message(msg)
+        sender = aid.get_sender_from_message(msg)  # 获取发送者
+        sender_content = aid.get_content_from_message(msg)
+        result = (
+            agent
+                .general("输出规定", "必须使用中文进行输出")
+                .role({
+                    "姓名": "ACP小助手",
+                    "任务": "使用自己的知识为用户解答常见问题",
+                })
+                .input(sender_content)
+                .instruct(["你需要根据用户的问题提供相关的回答", "你可以适当的有点幽默"])
+                .start()
+        )
+        aid.send_message_content(to_aid_list=[sender], session_id=session_id, llm_content=result)
+        return True
+    aid.online()
+    acp.serve_forever()

package/extensions/services/proxy/agentcp/utils/__init__.py

@@ -0,0 +1,15 @@
+# -*- 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 . import file_util

package/extensions/services/proxy/agentcp/utils/file_util.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+import os
+def get_file_info(file_path: str) -> dict:
+    """
+    通过文件路径读取文件信息
+    
+    Args:
+        file_path (str): 文件的完整路径
+        
+    Returns:
+        dict: 包含文件信息的字典，格式为：
+              {
+                  'file_name': str,     # 文件名
+                  'file_size': int,     # 文件大小（字节）
+                  'file_type': str,     # 文件类型/扩展名
+                  'exists': bool,       # 文件是否存在
+                  'error': str          # 错误信息（如果有）
+              }
+    """
+    try:
+        # 检查文件是否存在
+        if not os.path.exists(file_path):
+            return {
+                'file_name': '',
+                'file_size': 0,
+                'file_type': '',
+                'exists': False,
+                'error': '文件不存在'
+            }
+        
+        # 检查是否为文件（而不是目录）
+        if not os.path.isfile(file_path):
+            return {
+                'file_name': '',
+                'file_size': 0,
+                'file_type': '',
+                'exists': False,
+                'error': '路径不是文件'
+            }
+        
+        # 获取文件信息
+        file_stats = os.stat(file_path)
+        file_name = os.path.basename(file_path)
+        file_size = file_stats.st_size
+        
+        # 获取文件扩展名作为文件类型
+        file_type = os.path.splitext(file_path)[1].lower()
+        if file_type.startswith('.'):
+            file_type = file_type[1:]  # 移除开头的点
+        
+        # 如果没有扩展名，尝试根据文件内容判断类型
+        if not file_type:
+            file_type = _detect_file_type(file_path)
+        
+        return {
+            'file_name': file_name,
+            'file_size': file_size,
+            'file_type': file_type,
+            'exists': True,
+            'error': ''
+        }
+        
+    except PermissionError:
+        return {
+            'file_name': '',
+            'file_size': 0,
+            'file_type': '',
+            'exists': False,
+            'error': '没有权限访问文件'
+        }
+    except Exception as e:
+        return {
+            'file_name': '',
+            'file_size': 0,
+            'file_type': '',
+            'exists': False,
+            'error': f'读取文件信息时发生错误: {str(e)}'
+        }
+
+def _detect_file_type(file_path: str) -> str:
+    """
+    当文件没有扩展名时，尝试检测文件类型
+    
+    Args:
+        file_path (str): 文件路径
+        
+    Returns:
+        str: 检测到的文件类型
+    """
+    try:
+        with open(file_path, 'rb') as f:
+            # 读取文件头部字节来判断文件类型
+            header = f.read(16)
+            
+            # 常见文件类型的魔数检测
+            if header.startswith(b'\x89PNG\r\n\x1a\n'):
+                return 'png'
+            elif header.startswith(b'\xff\xd8\xff'):
+                return 'jpg'
+            elif header.startswith(b'GIF8'):
+                return 'gif'
+            elif header.startswith(b'%PDF'):
+                return 'pdf'
+            elif header.startswith(b'PK\x03\x04'):
+                return 'zip'
+            elif header.startswith(b'\x50\x4b\x03\x04'):
+                return 'zip'
+            else:
+                # 尝试作为文本文件读取
+                try:
+                    f.seek(0)
+                    f.read().decode('utf-8')
+                    return 'txt'
+                except UnicodeDecodeError:
+                    return 'binary'
+    except Exception:
+        return 'unknown'

package/extensions/services/proxy/agentcp/utils/proxy_bypass.py

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+import os
+from contextlib import contextmanager
+from urllib.parse import urlparse
+
+
+_LOCAL_HOSTS = ("localhost", "127.0.0.1", "::1", "0.0.0.0")
+_LOCAL_NO_PROXY = "localhost,127.0.0.1,::1"
+LOCAL_NO_PROXY_LIST = ["localhost", "127.0.0.1", "::1"]
+
+
+def ensure_no_proxy_for_local_env() -> None:
+    """Ensure NO_PROXY/no_proxy includes localhost, as a safety net against global proxies."""
+    for key in ("NO_PROXY", "no_proxy"):
+        existing = (os.environ.get(key) or "").strip()
+        if not existing:
+            os.environ[key] = _LOCAL_NO_PROXY
+            continue
+
+        existing_parts = [p.strip() for p in existing.replace(";", ",").split(",") if p.strip()]
+        existing_lower = {p.lower() for p in existing_parts}
+        for host in _LOCAL_NO_PROXY.split(","):
+            if host.lower() not in existing_lower:
+                existing_parts.append(host)
+        os.environ[key] = ",".join(existing_parts)
+
+
+def is_local_url(url: str) -> bool:
+    """Return True when URL hostname is localhost/loopback."""
+    try:
+        parsed = urlparse(url)
+        host = parsed.hostname
+        if not host:
+            return False
+        host = host.strip("[]").lower()
+        return host in _LOCAL_HOSTS
+    except Exception:
+        return False
+
+
+def get_requests_proxies(use_system_proxy: bool, url: str):
+    """
+    For requests:
+      - {} disables proxy
+      - None uses env/system proxy
+    """
+    return {}
+
+
+def get_trust_env(use_system_proxy: bool, url: str) -> bool:
+    """For httpx/aiohttp trust_env: never trust env proxy for any URL."""
+    return False
+
+
+def pop_proxy_env():
+    """Remove proxy env vars and return the saved mapping for restoration."""
+    keys = (
+        "HTTP_PROXY",
+        "HTTPS_PROXY",
+        "ALL_PROXY",
+        "FTP_PROXY",
+        "SOCKS_PROXY",
+        "http_proxy",
+        "https_proxy",
+        "all_proxy",
+        "ftp_proxy",
+        "socks_proxy",
+    )
+    saved = {k: os.environ.get(k) for k in keys}
+    for k in keys:
+        os.environ.pop(k, None)
+    return saved
+
+
+def restore_proxy_env(saved) -> None:
+    if not saved:
+        return
+    for k, v in saved.items():
+        if v is None:
+            os.environ.pop(k, None)
+        else:
+            os.environ[k] = v
+
+
+@contextmanager
+def without_proxy_env(enabled: bool = True):
+    """
+    Temporarily remove proxy env vars (HTTP(S)_PROXY/ALL_PROXY and lowercase variants).
+    Useful for websocket libraries that consult env proxies.
+    """
+    if not enabled:
+        yield
+        return
+
+    saved = pop_proxy_env()
+    try:
+        yield
+    finally:
+        restore_proxy_env(saved)

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

@@ -0,0 +1,203 @@
+# -*- 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.
+
+"""
+我们来详细实现Workflow:
+1.Mermaid类是mermaid语法的解析器,类构造实例的时候传入mermaid语法的文本,得到流程图的节点和边.目前只支持graph
+2.Workflow类是用来处理任意工作流,在构造实例的时候传入一个Mermaid的实例作为整个工作流参考的基础
+3.各节点类通过装饰器output_port和input_port来定义节点的输入输出端口
+4.节点通过Workflow的addnode方法加入工作流,工作流在调用start方法的时候,根据mermaid的节点和边的关系建立各节点实例输入输出端口之间的绑定关系
+5.在定义Agent的时候, 不同的Agent需要有不同Agent的类
+6.每个Agent类, 他有具体的输入输出端口, 这些输入输出端口是通过装饰器来定义
+7.装饰器做两件事:
+    1.完成参数的传递
+    2.完成端口函数名字和端口注解的绑定(可以在函数定义里面的注释部分来描述这个端口是做什么用的,
+                                 他应该与mermaid里面的流程里面的描述词一样)
+8.通过workflow.start的时候, 首先将已经通过addmode加入的节点之间, 让输入输出端口之间根据描述词建立绑定关系.
+这样, 当一个输出端口执行完毕后, 将自动开始调用其指向的下一个Agent的输入端口函数
+"""
+
+# 引入acp的库
+# import time
+import threading
+
+from inspect import iscoroutinefunction
+import asyncio
+
+from .mermaid import Mermaid
+from functools import wraps
+from collections import defaultdict
+
+from agentcp.base.log import log_error, log_info, log_warning
+
+
+class Workflow:
+    _workflow_lock = threading.Lock()
+    _workflow_storage = dict()
+
+    def output_port(description: str):
+        """
+            输出端口的函数参数定义无限制,只要他的调用者(通常就是当前节点自己的输入端口函数中)正确的传递参数即可
+            输入端口的函数参数定义,是一个字符串,其实原则上也是没有限制的,只要调用者参数传递争取即可
+
+        :return:
+        """
+
+        # 输出端口的函数定义是随便的,只要他的调用者正确的传递参数即可
+        #
+        def decorator(func):
+            func.is_output_port = True
+            func.output_port_desc = description
+
+            @wraps(func)
+            def wrapper(self, *args, **kwargs):
+                try:
+                    result = func(self, *args, **kwargs)
+
+                    workflow = self._workflow
+
+                    output_port_name = f"{self.__class__.__name__}:{func.__name__}"
+                    target_port, target_port_name = workflow.port_mapping.get(output_port_name, (None, None))
+                    if target_port:
+                        # 判断是否为异步方法并处理
+                        if iscoroutinefunction(target_port):
+                            # 获取或创建事件循环
+                            try:
+                                loop = asyncio.get_running_loop()
+                            except RuntimeError:
+                                loop = asyncio.new_event_loop()
+                                asyncio.set_event_loop(loop)
+                            # 异步调用（支持同步/异步上下文）
+                            loop.run_until_complete(target_port(result))
+                        else:
+                            # 同步调用
+                            target_port(result)
+                    else:
+                        log_error(f"{output_port_name}没有找到绑定的输入端口")
+
+                    return result
+                except Exception as e:
+                    log_error(f"Error in output port {func.__name__}: {e}")
+                    raise
+
+            return wrapper
+
+        return decorator
+
+    def input_port(param: str):
+        def decorator(func):
+            func.is_input_port = True
+            func.input_port_desc = param
+
+            @wraps(func)
+            def wrapper(self, *args, **kwargs):
+                try:
+                    return func(self, *args, **kwargs)
+                except Exception as e:
+                    log_error(f"输入端口异常 {func.__name__}: {e}")
+                    raise
+
+            return wrapper
+
+        return decorator
+
+    def __init__(self, mermaid: Mermaid):
+        self.nodes = {}
+        self.port_mapping = defaultdict()
+        self.mermaid = mermaid  # 保存 Mermaid 实例
+
+    def addnode(self, agent, node_name):
+        agent._workflow = self
+        self.nodes[node_name] = agent
+        return self  # 返回 self 以支持链式调用
+
+    @classmethod
+    def getstorage(cls, key=None, default=None, caller: str = "") -> dict:
+        # 不同的工作流调用者得到不同的存储对象,默认是一个线程一个对象
+        if not caller or len(caller) == 0:
+            threadid = threading.get_ident()
+            caller = f"workflow_caller_{threadid}"
+        with cls._workflow_lock:
+            if caller not in cls._workflow_storage:
+                cls._workflow_storage[caller] = dict()
+
+            storage = cls._workflow_storage[caller]
+            if key:
+                return storage.setdefault(key, default)
+            return storage
+
+    @classmethod
+    def clearstorage(cls, caller: str = "") -> None:
+        """
+        清除指定调用者的存储数据
+
+        :param caller: 调用者标识，默认为当前线程生成的标识
+        """
+        if not caller or len(caller) == 0:
+            threadid = threading.get_ident()
+            caller = f"workflow_caller_{threadid}"
+        with cls._workflow_lock:
+            if caller in cls._workflow_storage:
+                del cls._workflow_storage[caller]
+
+    def start(self):
+        self._build_port_mapping()
+
+    def _build_port_mapping(self):
+        mermaid_edges = self.mermaid.edges  # 从 Mermaid 实例获取边数据
+        for edge in mermaid_edges:
+            source_node, description, target_node = edge
+            source_node_desc = self.mermaid.node_dict.get(source_node, "")
+            target_node_desc = self.mermaid.node_dict.get(target_node, "")
+            source_agent = self.nodes.get(source_node_desc, None)
+            target_agent = self.nodes.get(target_node_desc, None)
+            if not source_agent:
+                log_warning(
+                    f'"{source_node} -->|{description}|{target_node}"\t{source_node}[{source_node_desc}]没有找到'
+                )
+            if not target_agent:
+                log_warning(
+                    f'"{source_node} -->|{description}|{target_node}"\t{target_node}[{target_node_desc}]没有找到'
+                )
+            if source_agent and target_agent:
+                output_port = self._find_output_port(source_agent, description)
+                input_port = self._find_input_port(target_agent, description)
+                if not output_port:
+                    log_warning(f'"{source_node_desc}"没有发现输出端口:{description}')
+                if not input_port:
+                    log_warning(f'"{target_node_desc}"没有发现输入端口:{description}')
+                if input_port and output_port:
+                    self.port_mapping[f"{source_agent.__class__.__name__}:{output_port.__name__}"] = (
+                        input_port,
+                        f"{target_agent.__class__.__name__}:{input_port.__name__}",
+                    )
+                    log_info(
+                        f"[{source_node_desc}  -> |{description}| {target_node_desc}]"
+                        f"\n\t调用链: {source_agent.__class__.__name__}:{output_port.__name__} >> {target_agent.__class__.__name__}:{input_port.__name__}"
+                    )
+
+    def _find_output_port(self, agent, desc):
+        for method_name in dir(agent):
+            method = getattr(agent, method_name)
+            if hasattr(method, "is_output_port") and method.output_port_desc == desc:
+                return method
+        return None
+
+    def _find_input_port(self, agent, desc):
+        for method_name in dir(agent):
+            method = getattr(agent, method_name)
+            if hasattr(method, "is_input_port") and method.input_port_desc == desc:
+                return method
+        return None